Classe para arquivos log com cache automática

{############################################################################
#
#   DOCUMENTAÇÃO DA UNIDADE UARQUIVOLOG (UArquivoLog.pas)
#
#   Autor: Ricardo Erick Rebêlo
#   Última Modificação: 29/03/05
#
#############################################################################


USES
====

Tipos: TArquivoDireto

Classes:


CLASSES
=======

TArquivoLog

    Descrição: Arquivo de log com uso mínimo de recursos de arquivo,
               com cache e criptografia "mochila" simples.
               Verifica a integridade dos dados.

    Autor: Ricardo Erick Rebêlo

    Portabilidade: pelo uso de TArquivoDireto (1.4), ver última documentação deste

    Versão Atual: 1.3

    Alterada em: 29/03/05

    Alterações:
        • as entradas geradas pelo próprio objeto estão mais claras
        • as propriedades AutoLog e LogTudo acrescentadas, permitindo o
          controle das entradas geradas pelo próprio objeto

    Versões Anteriores:
        • 1.2: 13/03/05 • Ricardo Erick Rebêlo
          • uso de UArquivoDireto para reduzir a complexidade do código e
            permitir criptografia "mochila" simples (aumentando a segurança)
          • Código e Nível alterados para tipos string (aumentando a flexibilidade)

        • 1.1: 19/12/03 • Ricardo Erick Rebêlo
          • modificado para usar cache de memória
            (agora, entradas anteriores à criação do arquivo de log podem ser criadas!)
          • função DataHoraPraString alterada para compatibilidade da ordenação em Paradox

        • 1.0: 18/12/03 • Ricardo Erick Rebêlo

    Métodos:
    Abre: tenta abrir o arquivo para inclusão. Se não conseguir e estiver habilitado
          para sobrescrever, cria um arquivo novo e gera um aviso - retorna erro
Const   Cria: cria o objeto, sem nome de arquivo (overload)
Const   Cria( Pnome): cria o objeto, com nome de arquivo (overload)
    Despeja: despeja a cache de memória (se houver) no arquivo log - retorna erro - versão 1.1 em diante
Destr   Destroi: destrói o objeto, fechando o arquivo, se estiver aberto
             despeja a cache se habilitado (versão 1.1 em diante)
    Fecha: fecha o arquivo, se estiver aberto - retorna erro
           despeja a cache se habilitado (versão 1.1 em diante)
    Grava( PCod, PNiv, PComent): gera uma entrada no arquivo log com a hora atual (overload)
    Grava( PDataHora, PCod, PNiv, PComent): idem, mas a hora pode ser qualquer uma (overload)
    Reseta: Exclui todas as entradas no arquivo log e gera um aviso - retorna erro
    ResetaCache: Destrói a cache de memória - versão 1.1 em diante

    Propriedades:
    Aberto (r): boolean que indica se o arquivo está aberto
    AutoLog (rw): boolean que indica se os erros do próprio uso do objeto gerarão entradas no log (publicada)
    Cached (rw): boolean que indica se a cache está habilitada - versão 1.1 em diante (publicada)
    CacheDespeja (rw): boolean que indica se a cache vai ser automaticamente despejada. - versão 1.1 em diante (publicada)
                       Quando True, sempre que houver oportunidade, a cache será despejada no arquivo!
                       (só funciona quando Cached for True)
    Debug (rw): boolean que indica se está em modo Debug. (publicada)
                No modo debug, todo log gerado automaticamente por ArquivoLog também gera uma mensagem na tela
    LiberaCache (rw): boolean que indica se a cache pode ser descartada à revelia do aplicativo. - versão 1.1 em diante (publicada)
                      Quando True é possível que se perca todos os dados da cache, se ela não for despejada em tempo!
                      (só funciona quando Cached for True)
    LogTudo (rw): boolean que indica se até as operações comuns do objeto gerarão entradas no log (publicada)
                  (só funciona quando AutoLog for True)
    Nome (rw): nome do arquivo (publicada)
    Sobrescreve (rw): boolean que indica se o arquivo log pode ser automaticamente re-criado. (publicada)
                      Se esta propriedade for False, ArquivoLog só funciona em arquivos já existentes!
    UsaCache (r): boolean que indica se a cache está sendo usada - versão 1.1 em diante

    Privados:
        function AbreApp: função interna que abre o arquivo para inclusão - retorna erro
        function DataHoraPraString( PDataHora): função interna que retorna a conversão de Data+Hora em string.
                                                Mude esta função caso a forma de conversão não seja apropriada!
        procedure GravaEmCache( PDataHora, PCod, PNiv, PComent): procedimento interno de uso da cache - versão 1.1 em diante
        procedure SetNome( Pnome): modifica o nome do arquivo (escrita da propriedade Nome)
        procedure SetCached( PCached): modifica o uso da cache (escrita da propriedade Cached) - versão 1.1 em diante
        procedure Zera: procedimento interno que "zera" as variáveis internas na criação do objeto.
                        Veja neste procedimento os valores iniciais de cada propriedade de TArquivoLog!
        SAberto (boolean): interno de Aberto
        SArquivo (TArquivoDireto): objeto que simplifica o código e permite a criptografia "mochila" simples - versão 1.2 em diante
        SAutoLog (boolean): interno de AutoLog - versão 1.3 em diante
        SCache (TStringList): objeto interno que guarda a cache de memória - versão 1.1 em diante
        SCached (boolean): interno de Cached - versão 1.1 em diante
        SCacheDespeja (boolean): interno de CacheDespeja - versão 1.1 em diante
        SDebug (boolean): interno de Debug
        SLiberaCache (boolean): interno de LiberaCache - versão 1.1 em diante
        SLogTudo (boolean): interno de LogTudo - versão 1.3 em diante
        SNome (string): nome interno do arquivo, privado por causa da escrita
        SSobrescreve (boolean): interno de Sobrescreve
        STotCache (integer): indica o número de entradas de log na cache - versão 1.2 em diante
        SUsaCache (boolean): interno de UsaCache - versão 1.1 em diante

    Exemplo de Uso:
    (veja TesteLog -- e visualize seus logs com LogViewer 1.1b)

    Outras Informações:
        • O arquivo gerado por TArquivoLog é estruturado e protegido contra alterações
          (a partir da versão 1.2, usando TArquivoDireto 1.4).

        • Embora teoricamente seja possível gravar mensagens de até 2GB, tente não usar
          strings muito maiores que 64KB, por questões de eficiência e uso de memória.
          Tente ser conciso nas mensagens - eventos em lote acontecem regularmente!

        • As funções obsoletas NomeLogCod e NomeLogNiv dão algumas idéias para PCod e PNiv.
          Estas funções estão desabilitadas no código (foram transformadas em comentário)!

        • Veja em UArquivoDireto.txt a documentação de TArquivoDireto.
}


{
    Autor: Ricardo Erick Rebelo
    Versão: 1.3 (terceira versão da primeira implementação)
    Última Modificação: 29/03/05 por Ricardo Erick Rebêlo
    Documentação: UArquivoLog.txt

    AVISOS: • a partir da versão 1.3 o padrão é não haver entradas de auto-log  (CUIDADO!)
            • não substituir nos executáveis anteriores a 12/03/05 (*)
            • a partir da versão 1.2, alguns uses foram alterados para compatibilidade com DELPHI 5
}

unit UArquivoLog;

interface

uses Classes, UArquivoDireto;  {para usar TStringList e TArquivoDireto}

type

{ ############### TArquivoLog ############### }

  TArquivoLog = class
  private
    STotCache: integer; // versão 1.2
    SNome: string;
    SAberto, SDebug, SSobrescreve, SCached, SUsaCache, SCacheDespeja,
      SLiberaCache: boolean;  // de SCached a SLiberaCache > versão 1.1
    SAutoLog, SLogTudo: boolean;   // controle de auto-log > versão 1.3
    {SArquivo: TextFile; alterado na versão 1.2 para:} SArquivo: TArquivoDireto;
    SCache: TStringList;  // versão 1.1
    procedure   SetNome( PNome: string);
    procedure   SetCached( PCached: boolean);  // versão 1.1
    procedure   Zera;
    function    AbreApp: boolean;
{   function    NomeLogCod( PCod: TLogCod): string;
    function    NomeLogNiv( PNiv: TLogNiv): string; - obsoletas na versão 1.2 }
    function    DataHoraPraString( PDataHora: TDateTime): string;
    procedure   GravaEmCache( PDataHora: TDateTime; PCod, PNiv, PComent: string);
        // versão 1.1 - alterada para usar strings em Código e Nível (versão 1.2)
  public
    constructor Cria; overload;
    constructor Cria( PNome: string); overload;
    function    Abre: boolean;
    function    Fecha: boolean;
    function    Reseta: boolean;
    function    Despeja: boolean; // versão 1.1
    procedure   ResetaCache; // versão 1.1
    procedure   Grava( PCod, PNiv, PComent: string); overload;
    procedure   Grava( PDataHora: TDateTime; PCod, PNiv, PComent: string); overload;
    destructor  Destroi;

    property UsaCache: boolean read SUsaCache; // versão 1.1
    property Aberto: boolean read SAberto;
  published
    property Nome: string read SNome write SetNome;
    property Debug: boolean read SDebug write SDebug;
    property Sobrescreve: boolean read SSobrescreve write SSobrescreve;
    property Cached: boolean read SCached write SetCached; // versão 1.1
    property CacheDespeja: boolean read SCacheDespeja write SCacheDespeja; // versão 1.1
    property LiberaCache: boolean read SLiberaCache write SLiberaCache; // versão 1.1
    property AutoLog: boolean read SAutoLog write SAutoLog; // versão 1.3
    property LogTudo: boolean read SLogTudo write SLogTudo; // versão 1.3
  end;

{############################################
#   I  M  P  L  E  M  E  N  T  A  Ç  Ã  O   #
############################################}

implementation

uses SysUtils, Forms, Windows, UTipos; {para uso de rotinas de I/O, mensagens de erro, rotinas de data, etc...}

{ ############### TArquivoLog ############### }

//===================================== ALTERADA EM 1.1 a 1.3

function TArquivoLog.Abre: boolean;
begin
  if SAberto then
  begin
    if (SAutoLog and SLogTudo) then Grava( 'Log-Arquivo', 'Erro Leve', 'Tentando abrir arquivo de Log já aberto: ' + SNome + '!');
    Fecha;
    if SDebug then Application.MessageBox( PChar( 'Tentando abrir arquivo de Log já aberto: ' +
                       SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
    { usamos uma mensagem apenas se estivermos no modo de debug }
  end;  { grava Log de erro se tentar abrir arquivo já aberto e fecha arquivo }

  if AbreApp then  { tenta abrir para incremento, senão continua }
    if SSobrescreve then  { se pode sobrescrever, tenta abrir sobescrevendo }
      if SArquivo.Grava( SNome) then begin { tenta abrir SArquivo com SNome sobescrevendo }
        SArquivo.SetSementes( -1254553677, 137, 0); {mesmo no erro de abrir, setamos as sementes pra desencargo de consciência}
        if SAutoLog then Grava( 'Log-Arquivo', 'Erro Médio', 'Impossível abrir ou criar arquivo de Log: ' + SNome + '!');
        Abre := True;       { em caso de erro, a função retorna verdadeiro (erros) }
        if SDebug then Application.MessageBox( PChar(
                           'Impossível abrir ou criar arquivo de Log: ' + SNome + '!'),
                           'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
        { usamos uma mensagem apenas se estivermos no modo de debug }
      end else begin
        SArquivo.SetSementes( -1254553677, 137, 0); {ao sobrescrever o arquivo, devemos "zerar" as sementes com estes valores}
        SAberto := True;    { no sucesso, SAberto se torna verdadeiro... }
        Abre := False;      { e a função retorna falso (sem erros) }
        if SAutoLog then Grava( 'Log-Arquivo', 'Erro Pesado', 'Reiniciado arquivo de Log: ' + SNome + '!');
        if SUsaCache and SCacheDespeja then Despeja;  { despeja se houver cache }
        if SDebug then Application.MessageBox( PChar( 'Reiniciado arquivo de Log: ' +
                           SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
        { usamos uma mensagem apenas se estivermos no modo de debug }
      end
    else begin
      if SAutoLog then Grava( 'Log-Arquivo', 'Erro Médio', 'Impossível abrir arquivo de Log: ' + SNome + '!');
      Abre := True;       { em caso de erro, a função retorna verdadeiro (erros) }
      if SDebug then Application.MessageBox( PChar( 'Impossível abrir arquivo de Log: ' +
                         SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
      { usamos uma mensagem apenas se estivermos no modo de debug }
    end
  else Abre := False;  { e a função retorna falso (sem erros) }
end;

//===================================== ALTERADA EM 1.1 E 1.2

function TArquivoLog.AbreApp: boolean;
var
  temp1, temp2, temp3: integer;
  temp4: string;
  temp5: boolean;
begin
  if  SArquivo.Le( SNome) then begin { tenta abrir SArquivo com SNome }
    AbreApp := True;   { esse é um caso de erro que vai ser tratado por Abre }
    exit;
  end;

  SArquivo.SetSementes( -1254553677, 137, 0); {daqui até o fim do while pesquisa das sementes atuais}
  while( not SArquivo.LeInteiro( temp3) ) do  {vamos ler o que tem no arquivo até esta instrução não conseguir ler mais}
  begin                                        // ou seja, até o fim do arquivo
    temp1 := temp3;    // nunca se esquecer que temp3 vai continuar com valor de temp1 até antes do if abaixo
    SArquivo.LeInteiro( temp2);
    SArquivo.SetSementes( temp2, byte(temp1), 0); // a partir daqui, a semente ja é outra...
    SArquivo.LeBoolean( temp5); // esta e a próxima linha lêem dados que agora não são importantes para levar o cursor do arquivo até temp3
    SArquivo.LeString( temp4); SArquivo.LeString( temp4); SArquivo.LeString( temp4); SArquivo.LeString( temp4);
    {Application.MessageBox( PChar( temp4), 'txchum', MB_ICONQUESTION + MB_DEFBUTTON2); //para debugagem}
    SArquivo.LeInteiro( temp3);  // aqui temp3 é lido pra compararmos com o valor de temp1
    if temp3 <> temp1 then begin {verifica-se a integridade da criptografia e do arquivo de uma só vez aqui}
      if SDebug then Application.MessageBox( PChar( 'Arquivo de Log: ' +
                         SNome + ' está corrompido!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
      AbreApp := True;   { o arquivo estah corrompido, soh sabemos do erro em debug! }
      exit; {este caso de erro vai ser tratado por Abre }
    end;
  end;
  SArquivo.Fecha; {fecha o arquivo para poder entrar no modo Incluir}
  if not SArquivo.Inclui( SNome) then begin { tenta abrir SArquivo com SNome para incremento }
    SAberto := True;    { no sucesso, SAberto se torna verdadeiro... }
    if (SUsaCache and SCacheDespeja) then Despeja;  { despeja se houver cache }
    AbreApp := False;   { e a função retorna falso (sem erros) }
  end else AbreApp := True; { em caso de erro, a função retorna verdadeiro (erros) }
end;

//=====================================

constructor TArquivoLog.Cria;
begin
  SNome := '';
  Zera;        { zera nome e executa Zera (variáveis) }
end;

//=====================================

constructor TArquivoLog.Cria(PNome: string);
begin
  SNome := PNome;
  Zera;           { Seta nome e executa Zera (variáveis) }
end;

//===================================== ALTERADA EM 1.1

function TArquivoLog.DataHoraPraString(PDataHora: TDateTime): string;
var
  CData: string;
  ano, mes, dia, hora, minuto, segundo, milisegundo: word;
begin
  DecodeDate( PDataHora, ano, mes, dia);
  DecodeTime( PDataHora, hora, minuto, segundo, milisegundo);
  CData := formatfloat('0000', ano) + '/' +
           formatfloat('00', mes) + '/' +
           formatfloat('00', dia) + ' | ' +
           formatfloat('00', hora) + ':' +
           formatfloat('00', minuto) + ':' +
           formatfloat('00', segundo) + '.' +
           formatfloat('000', milisegundo);
  DataHoraPraString := CData;  { converte data e hora em  aaaa/mm/dd | hh:mm:ss:mmmm }
end;   { P.S.: ALTERAR ESTA FUNÇÃO DE ACORDO COM A NECESSIDADE DE INDEXAÇÃO }

//===================================== CRIADA EM 1.1 / ALTERADA EM 1.2 e 1.3

function TArquivoLog.Despeja: boolean;
var
  contador, temp1, temp2: integer;
begin
  if not SAberto then
  begin
    if SDebug then Application.MessageBox( PChar( 'Tentando despejar arquivo de Log não aberto: '
                     + SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
    { usamos uma mensagem apenas se estivermos no modo de debug }
    Abre;
    if (SAutoLog and SLogTudo) then Grava( 'Log-Arquivo', 'Erro Leve', 'Tentando despejar arquivo de Log não aberto: ' + SNome + '!');
    Fecha;            { se o log está fechado, abre, Loga, fecha }
    Despeja := True;  { erro ao tentar despejar }
    exit;             { pára a execução da função }
  end;

  if not SCached then
  begin
    if (SAutoLog and SLogTudo) then Grava( 'Log-Arquivo', 'Erro Leve', 'Tentando despejar arquivo de Log não-cacheável: ' + SNome + '!');
    if SDebug then Application.MessageBox( PChar( 'Tentando despejar arquivo de Log não-cacheável: '
                     + SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
    { usamos uma mensagem apenas se estivermos no modo de debug }
    Despeja := True;  { erro ao tentar despejar }
    exit;             { pára a execução da função }
  end;

  if not SUsaCache then
  begin
    if (SAutoLog and SLogTudo) then Grava( 'Log-Arquivo', 'Aviso', 'Tentando despejar arquivo de Log com cache vazia: ' + SNome + '!');
    if SDebug then Application.MessageBox( PChar( 'Tentando despejar arquivo de Log com cache vazia: '
                     + SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
    { usamos uma mensagem apenas se estivermos no modo de debug }
    Despeja := True;  { erro ao tentar despejar }
    exit;             { pára a execução da função }
  end;

  for contador := 0 to STotCache-1 do
  begin
    temp1 := trunc ( random( 256));
    temp2 := trunc ( random( 2147483647));  // valores da próxima semente são escolhidos aleatoriamente
    SArquivo.GravaInteiro( temp1); // grava semente de strings na semente anterior
    SArquivo.GravaInteiro( temp2); // grava semente de inteiros na semente anterior
    SArquivo.SetSementes( temp2, byte(temp1), 0); // seta as sementes novas
    SArquivo.GravaBoolean( true); // grava verdadeiro (cacheado) na semente nova
    SArquivo.GravaString( SCache.Strings[ contador*4]); // grava a data na semente nova
    SArquivo.GravaString( SCache.Strings[ contador*4+1]); // grava o código de erro na semente nova
    SArquivo.GravaString( SCache.Strings[ contador*4+2]); // grava o nível de erro na semente nova
    SArquivo.GravaString( SCache.Strings[ contador*4+3]); // grava a mensagem de erro na semente nova
    SArquivo.GravaInteiro( temp1); // grava a semente de strings na semente nova (para verificar integridade)
    if SArquivo.erro <> TENenhum then begin
      if SAutoLog then Grava( 'ErroArquivo', 'ErroMedio', 'Erro ao despejar cache em arquivo de Log: ' + SNome + '!');
      Despeja := True;       { em caso de erro, a função retorna verdadeiro (erros) }
      if SDebug then Application.MessageBox( PChar(
                       'Erro ao despejar cache em arquivo de Log: ' + SNome + '!'),
                       'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
               { usamos uma mensagem apenas se estivermos no modo de debug }
      exit;
    end;
  end;
  ResetaCache; { se tudo ok, reseta a cache }
  Despeja := False;      { e a função retorna falso (sem erros) }
end;

//===================================== ALTERADA EM 1.1 a 1.3


destructor TArquivoLog.Destroi;
begin
  if SUsaCache and SCacheDespeja and (not SAberto) then
  begin
    Abre;  { tenta abrir se houver cache e o arquivo estiver fechado }
    if (SAutoLog and SLogTudo) then Grava( 'Log-Arquivo', 'Erro Leve', 'Foi preciso abrir o arquivo para despejar a cache: ' + SNome + '!');
    if SDebug then Application.MessageBox( PChar( 'Foi preciso abrir o arquivo para despejar a cache: '
                     + SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
  end;   { se a cache estiver cheia, para despejar, e o arquivo fechado, abre e avisa isso }

  if SUsaCache and (not SLiberaCache) and (not SCacheDespeja) then
  begin
    if not SAberto then
    begin
      Abre;  { tenta abrir se houver cache e o arquivo estiver fechado }
      if (SAutoLog and SLogTudo) then Grava( 'Log-Arquivo', 'Erro Leve', 'Foi preciso abrir o arquivo para o próximo erro: ' + SNome + '!');
      if SDebug then Application.MessageBox( PChar( 'Foi preciso abrir o arquivo para o próximo erro: '
                       + SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
    end;

    if SAutoLog then Grava( 'Log-Arquivo', 'Erro Pesado', 'Cache perdida ao destruir objeto sem opção de despejo e/ou liberação de cache: ' + SNome + '!');
    if SDebug then Application.MessageBox( PChar( 'Cache perdida ao destruir objeto sem opção de despejo e/ou liberação de cache: '
                     + SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);  { erro de tentar fechar com cache sem opções viáveis }
  end;  { se a cache não poder ser liberada nem despejada, haverá erro de liberação indevida }

  if SAberto then Fecha;  { fecha o arquivo se ele se encontra aberto }
  SCache.Destroy;
  SArquivo.Destroi; // versão 1.2
end;

//===================================== ALTERADA EM 1.1 a 1.3

function TArquivoLog.Fecha: boolean;
begin
  if not SAberto then
  begin
    if (SAutoLog and SLogTudo) then Grava( 'Log-Arquivo', 'Erro Leve', 'Tentando fechar arquivo de Log não aberto: ' + SNome + '!');
    if SDebug then Application.MessageBox( PChar( 'Tentando fechar arquivo de Log não aberto: ' +
                       SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
    { usamos uma mensagem apenas se estivermos no modo de debug }
    Fecha := True;  {erro ao fechar}
    exit;
  end;  { abre e grava Log de erro se tentar fechar arquivo não aberto }

  if SUsaCache and SCacheDespeja then Despeja;  { despeja a cache se houver cache }

  if SUsaCache and (not SLiberaCache) then
  begin
    if SAutoLog then Grava( 'Log-Arquivo', 'Erro Leve', 'Fechando o arquivo com cache sem permissão de liberar ou despejar: ' + SNome + '!');
    if SDebug then Application.MessageBox( PChar( 'Fechando o arquivo com cache sem permissão de liberar ou despejar: ' +
                       SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
    { usamos uma mensagem apenas se estivermos no modo de debug }
    { erro ao não poder nem despejar nem liberar cache }
  end;

  if SArquivo.Fecha then begin { tenta fechar o arquivo... }
    if SAutoLog then Grava( 'Log-Arquivo', 'Erro Médio', 'Erro ao fechar o arquivo de Log' + SNome + '!');
                  { no erro, tenta gravar Log de erro de fechamento do Log }
    Fecha := True;  { em caso de erro, a função retorna verdadeiro (erros) }
    if SDebug then Application.MessageBox( PChar(
                       'Erro ao fechar o arquivo de Log: ' + SNome + '!'),
                       'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
    { usamos uma mensagem apenas se estivermos no modo de debug }
  end else begin
    SAberto := False;      { se conseguir, SAberto é falso... }
    Fecha := False;        { e a função retorna falso (sem erros) }
  end;
end;

//===================================== ALTERADA EM 1.2 POR COMPATIBILIDADE COM DELPHI 5

procedure TArquivoLog.Grava(PCod, PNiv, PComent: string);
begin
  Grava( Now, PCod, PNiv, PComent);  { repassa com o tempo atual } // now é usada por compatibilidade com Delphi 5
end;

//===================================== ALTERADA EM 1.1 E 1.2

procedure TArquivoLog.Grava(PDataHora: TDateTime; PCod, PNiv, PComent: string);
var
  temp1, temp2: integer;
begin
  if SAberto then
  begin
    if SUsaCache and SCacheDespeja then Despeja;  { despeja a cache se houver cache }
    temp1 := trunc ( random( 256));
    temp2 := trunc ( random( 2147483647));
    SArquivo.GravaInteiro( temp1); // grava semente de strings na semente anterior
    SArquivo.GravaInteiro( temp2); // grava semente de inteiros na semente anterior
    SArquivo.SetSementes( temp2, byte(temp1), 0); // seta as sementes novas
    SArquivo.GravaBoolean( false); // grava falso (não-cacheado) na semente nova
    SArquivo.GravaString( DataHoraPraString( PDataHora)); // grava a data na semente nova
    SArquivo.GravaString( PCod); // grava o código de erro na semente nova
    SArquivo.GravaString( PNiv); // grava o nível de erro na semente nova
    SArquivo.GravaString( PComent); // grava a mensagem de erro na semente nova
    SArquivo.GravaInteiro( temp1); // grava a semente de strings na semente nova (para verificar integridade)
    if SArquivo.erro <> TENenhum then begin
        // esse erro apenas exaure a memória, já que nunca vai gravar nada!!!!
      if SDebug then Application.MessageBox( PChar(
                         'Erro ao tentar gravar no arquivo de Log: ' + SNome + '!'),
                         'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
      { usamos uma mensagem apenas se estivermos no modo de debug }
      exit;
    end;
  end else begin
    if SCached then
    begin
      GravaEmCache( PDataHora, PCod, PNiv, PComent);
    end else begin
      if SDebug then Application.MessageBox( PChar(
                         'Tentando gravar em arquivo de Log fechado e não-cacheado: ' + SNome + '!'),
                         'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
      { usamos uma mensagem apenas se estivermos no modo de debug }
    end;
  end;
end;

//===================================== CRIADA EM 1.1 E ALTERADA EM 1.2

procedure TArquivoLog.GravaEmCache(PDataHora: TDateTime; PCod, PNiv, PComent: string);
begin
  if not SCached then
  begin
    if SDebug then Application.MessageBox( PChar( 'Tentando cachear arquivo de Log não-cacheável: '
                     + SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
    { usamos uma mensagem apenas se estivermos no modo de debug }
    exit;             { pára a execução da função }
  end;

  SCache.Add( DataHoraPraString( PDataHora) );
  SCache.Add( PCod );
  SCache.Add( PNiv );
  SCache.Add( PComent);        { grava em cache o Log }

  SUsaCache := True;     { agora, há algo na cache do arquivo }
  Inc( STotCache);
end;

(* SUGESTÃO: abaixo estão alguns códigos e níveis de erro anteriormente
             usados no ArquivoLog - podem ser usados como referência

//===================================== OBSOLETA NA VERSÃO 1.2

function TArquivoLog.NomeLogCod(PCod: TLogCod): string;
begin
  Case PCod of
    LCDebug: NomeLogCod := 'LCDebug';
    LCErroArquivo: NomeLogCod := 'LCErroArquivo';
    LCErroBase: NomeLogCod := 'LCErroBase';
    LCErroDB: NomeLogCod := 'LCErroDB';
    LCEvento: NomeLogCod := 'LCEvento';
    LCPerformance: NomeLogCod := 'LCPerformance';
  else
    NomeLogCod := '<desconhecido>';
  end;                               { retorna o nome do Código de Log }
end;

//===================================== OBSOLETA NA VERSÃO 1.2

function TArquivoLog.NomeLogNiv(PNiv: TLogNiv): string;
begin
  Case PNiv of
    LNMensagem: NomeLogNiv := 'LNMensagem';
    LNAviso: NomeLogNiv := 'LNAviso';
    LNErroLeve: NomeLogNiv := 'LNErroLeve';
    LNErroMedio: NomeLogNiv := 'LNErroMedio';
    LNErroPesado: NomeLogNiv := 'LNErroPesado';
    LNErroCritico: NomeLogNiv := 'LNErroCritico';
  else
    NomeLogNiv := '<desconhecido>';  { retorna o nome do Nível de Log }
  end;
end; *)

//===================================== ALTERADA EM 1.1 a 1.3

function TArquivoLog.Reseta: boolean;
var
  CAberto: boolean;
begin
  CAberto := SAberto;
  if SNome = '' then Reseta := True  { se o nome for nulo, erro }
  else begin
    if SAberto then Fecha;  { fecha se arquivo aberto }
    if SArquivo.Grava( SNome) then begin { tenta abrir SArquivo com SNome sobescrevendo }
      if SAutoLog then Grava( 'Log-Arquivo', 'Erro Médio', 'Impossível resetar arquivo de Log: ' + SNome + '!');
      Reseta := True;       { em caso de erro, a função retorna verdadeiro (erros) }
      if SDebug then Application.MessageBox( PChar(
                         'Impossível resetar arquivo de Log: ' + SNome + '!'),
                         'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
      { usamos uma mensagem apenas se estivermos no modo de debug }
    end else begin
      SAberto := True;    { no sucesso, SAberto se torna verdadeiro... }
      if SAutoLog then Grava( 'Log', 'Evento', 'Resetado arquivo de Log: ' + SNome + '!');
      if not CAberto then
      begin
        SArquivo.Fecha;
        SAberto := False;  { fecha arquivo }
      end;
      Reseta := False;    { tudo deu certo, função falsa em erro }
      if SDebug then Application.MessageBox( PChar( 'Resetado arquivo de Log: ' +
                         SNome + '!'), 'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
      { usamos uma mensagem apenas se estivermos no modo de debug }
    end;
  end;
end;

//===================================== CRIADA EM 1.1 E ALTERADA EM 1.2

procedure TArquivoLog.ResetaCache;
begin
  SCache.Clear;
  SUsaCache := False;  { limpa a cache, usacache é falso e totcache = 0 }
  STotCache := 0;
end;

//===================================== CRIADA EM 1.1 E ALTERADA EM 1.2 e 1.3

procedure TArquivoLog.SetCached(PCached: boolean);
begin
  if PCached then SCached := True else
  begin
    if SUsaCache then
    begin
      if (SAutoLog and SLogTudo) then Grava( 'Log-Arquivo', 'Erro Leve', 'Erro ao tentar setar arquivo como não-cacheado com cache ativa: ' + SNome + '!');
                    { no erro, tenta gravar Log de erro ao gravar do Log }
      if SDebug then Application.MessageBox( PChar(
                         'Erro ao tentar setar arquivo como não-cacheado com cache ativa: ' + SNome + '!'),
                         'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
      { usamos uma mensagem apenas se estivermos no modo de debug }
    end else SCached := False;
  end;
end;

//===================================== ALTERADA NA VERSÃO 1.2 e 1.3

procedure TArquivoLog.SetNome(PNome: string);
begin
  if SAberto then
  begin
    if SAutoLog then Grava( 'Log-Arquivo', 'Aviso', 'Erro ao tentar mudar para "' + PNome + '" arquivo de Log já aberto: ' + SNome + '!');
                  { no erro, tenta gravar Log de erro ao gravar do Log }
    if SDebug then Application.MessageBox( PChar(
                       'Erro ao tentar mudar para "' + PNome + '" arquivo de Log já aberto: ' + SNome + '!'),
                       'Debug', MB_ICONQUESTION + MB_DEFBUTTON2);
    { usamos uma mensagem apenas se estivermos no modo de debug }
  end else SNome := PNome;
end;

//===================================== ALTERADA EM 1.1 E 1.2

procedure TArquivoLog.Zera;
begin
  randomize; // versão 1.2 - para que a criptografia "mochila" simples possa funcionar
  if SArquivo <> nil then SArquivo.Destroi; // versão 1.2 - garante o código se erros nas próximas versões
  SArquivo := TArquivoDireto.Cria;  // versão 1.2 - cria um objeto TArquivoDireto
  STotCache := 0; // versão 1.2 // a cache é vazia na criação
  SAberto := False;
  SDebug := False;
  SSobrescreve := False;
  SAutoLog := False;  // versão 1.3
  SLogTudo := False;  // versão 1.3
  SUsaCache := False; // versão 1.1
  SLiberaCache := False; // versão 1.1
  SCacheDespeja := False; // versão 1.1
  SCached := False; { apenas seta variáveis iniciais } // versão 1.1
  SCache := TStringList.Create;  { cria uma lista de strings nula } // versão 1.1
end;

//=====================================

end.