root/branches/0_1_3/FlistFormat.pas

///////////////////////////////////////////////////////////
//                     GGBuildTools                      //
//    Набор утилит для сборки проектов Gipat Group       //
//             Copyright (C) 2007 Gipat Group            //
//              Распространяется на условиях             //
//    Gipat Group's opened EI-editor-utility license     //
//                      версии 1.0                       //
//                                                       //
//                  www.gipatgroup.org                   //
///////////////////////////////////////////////////////////

//К работе над данным файлом приложили руки, ноги.... короче аффтары:
// 1) Sagrer (sagrer@yandex.ru)

////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////
//        Модуль для работы с файлами Flist       //
//       В этом файле хранится файловый список.   //
//      с дополнительной инфой вроде размера или  //
//                  чексуммы...                   //
//                                                //
//              версия формата - 1                //
////////////////////////////////////////////////////

unit FlistFormat;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, Windows, LCLAnIniFile, crc, ExtraFileUtilsLcl, ExtraFunctionsLcl;
  
const
  Flist_FormatVersion = 1;                //Номер версии формата в данном сырце.
  //Дефолтные значения переменных класса....
  Flist_Def_PathsAreAbsolute = false;           //По умолчанию использовать относительные пути.
  Flist_Def_AddSize = true;                     //По умолчанию оставлять инфу о размере файла.
  Flist_Def_AddCRC32 = true;                    //По умолчанию высчитывать и писать файлам CRC32.
  Flist_Def_DoConsoleOutput = false;            //По умолчанию инфу в консоль не выводить.
  //Тип файла
  Flist_Filetype_File = 0;                //Тип файла - файл.
  Flist_Filetype_Directory = 1;           //Тип файла - директория.
  Flist_Filetype_Unknown = 2;             //Тип файла - хз что.
  //Ответы CheckFile
  Flist_CheckFile_Identical = 0;          //Файл идентичен.
  Flist_CheckFile_MismatchedCRC32 = 1;    //Не совпадает CRC32.
  Flist_CheckFile_MismatchedSize = 2;     //Не совпадает размер.
  Flist_CheckFile_ElementNotExists = 3;   //Нет записи о файле в базе.
  Flist_CheckFile_FileNotExists = 4;      //Файл на диске не существует.
  Flist_CheckFile_NothingExists = 5;      //Не существует ни файла на диске ни записи о нем в массиве.
  Flist_CheckFile_Error = 6;              //Ошибка. (какая - хз).
  Flist_CheckFile_NonIdentical = 7;       //Не совпадает (чем - либо хз либо неважно).


type

  RFlistFile = record                     //Структура для инфы о файле в списке.
    FilePath : AnsiString;                //Путь к файлу.
    FileType : byte;                      //Тип файла - Flist_Filetype_* .
    FileSize : Int64;                   //Размер файла.
    CRC32 : Cardinal;                     //CRC32 файла.
  end;
  
  RComparedElement = record               //Структура для инфы о проверенном элементе.
    FilePath : AnsiString;                //Путь к файлу.
    FileType : byte;                      //Тип файла - Flist_Filetype_* .
    CheckResult : byte;                   //Результат сравнения списка и реального файла\папки.
  end;
  
  AComparedList = array of RComparedElement;   //Тип массива с инфой о сравнении.

  TFlistFormat = class                    //Класс для работы с файлами формата Flist (*.flist).
  private
    //Закрытые методы.
    function ParseFileType(const InputStr : AnsiString) : byte;       //Вернуть код типа файла по строковому значению типа.
    function ReturnFileTypeStr(const InputCode : byte) : AnsiString;  //Наоборот сгенерить значение типа файла из кода.
  public
    //Переменные
    //[Main]
    PathsAreAbsolute : Boolean;           //Используются ли абсолютные пути. Если false - то используются пути относительно места где лежит данный *.flist
    AddSize : Boolean;                    //Добавлять ли инфу о размере файла.
    AddCRC32 : Boolean;                   //Добавлять ли crc32 файла.
    FilesNum : LongInt;                   //Количество файлов в списке.
    //[Files]
    FileList : array of RFlistFile;       //Собсно массив с файлами (инфой про них).
    //Служебные
    ErrorMessage : AnsiString;            //Сообщение о ошибке если была
    FileLoaded : boolean;                 //Если true - значит уже загружался какой-то файл.
    LoadedFileName : AnsiString;          //Имя загруженного в последний раз файла.
    GlobalRoot : AnsiString;              //Если тут пусто - глобальный корень та папка где лежит flist.
    DoConsoleOutput : boolean;            //Если поставить true то по-возможности будет скидывать инфу о прогрессе в консоль.
    
    //Конструкторы-деструкторы...
    constructor Create;
    destructor Destroy; override;
    
    //Открытые методы...
    procedure Clear();                                              //Очистить инфу класса.
    function GetGlobalRoot() : AnsiString;                          //Вернуть корень.
    function Load(const FileName : AnsiString) : boolean;           //Загрузить файл в класс.
    function Save(const FileName : AnsiString) : boolean;           //Сохранить инфу из класса в файл.
    function ElementNameExists(const ElementName : AnsiString) : boolean;   //Существует ли элемент с таким именем.
    function GetElementNumber(const ElementName : AnsiString) : Integer;   //Какой номер у элемента с таким именем.
    function FileExistsHere(const FileName : AnsiString) : boolean;     //Существует ли файл с таким именем.
    function GetFileNumberHere(const FileName : AnsiString) : Integer;   //Какой номер у файла с таким именем.
    function DirExistsHere(const DirName : AnsiString) : boolean;       //Существует ли дира с таким именем.
    function GetDirNumberHere(const DirName : AnsiString) : Integer;   //Определить номер диры с таким именем.
    function GetRealElementName(const ElemName : AnsiString) : AnsiString;   //Определить абсолютное имя для элемента
    function GetRealElementName(const ElemNum : Integer) : AnsiString;   //Определить абсолютное имя для элемента с таким-то номером в списке.
    function AddFile(const FileName : AnsiString) : boolean;        //Добавить файл.
    function AddRealFile(const FileName : AnsiString) : boolean;    //Добавить реально существующий на диске файл (с подсчетом реальной инфы).
    function AddDirectory(const DirName : AnsiString) : boolean;    //Добавить пустую диру.
    function AddRealDirectory(const DirName : AnsiString; const Recursive : boolean) : boolean;  //Добавить реальную диру с подсчетом всей инфы по файлам.
    function RemoveFile(const FileName : AnsiString) : boolean;     //Удалить файл из базы.
    function RemoveDirectory(const DirName : AnsiString) : boolean;  //Удалить диру (со всеми входящими файлами и дирами).
    function CheckFile(const ListFileName, RealFileName : AnsiString) : byte;   //Проверить насколько реальный файл соответствует инфе в файле. Возвращает значение одной из констант Flist_CheckFile_*. Можно сравнивать директории.
    procedure CompareDirs(const ListDirName, RealDirName : AnsiString; var ComparedList : AComparedList);   //Сравнить 2 папки, результат записывается в ComparedList.
    function CompareWithFlist(var OtherFlist : TFlistFormat; const ListDirName : AnsiString; var ComparedList : AComparedList) : boolean;   //Сравнить текущий файл с другим, считая его (этот другой файл) как будто за текущую версию файлов на венте.
    function CompareWithFlist(const OtherFlistFile, ListDirName : AnsiString; var ComparedList : AComparedList) : boolean;   //Сравнить текущий файл с другим, считая его (этот другой файл) как будто за текущую версию файлов на венте.
    function ConvertToSimpleComparedList(var ComparedList : AComparedList) : Boolean;  //Превратить список сравнения в нечно упрощенное - без лишней инфы про то как именно что различается, когда важен сам факт наличия различия.

  end;
  
//Функции в прямом, открытом виде %).
function Flist_CheckFile_2Text(const Code : Byte) : AnsiString;    //Сгенерить текстовую строку из кода Flist_CheckFile_*

implementation

/////////////////////////////////////////////
//              TFlistFormat               //
/////////////////////////////////////////////

//-----------------------------------------//
//        Конструкторы-деструкторы...      //
//-----------------------------------------//

constructor TFlistFormat.Create;
begin
  //Проставить дефолтные значения...
  Self.Clear();
  ErrorMessage := 'none';
  DoConsoleOutput := Flist_Def_DoConsoleOutput;

  //Создать вложенные объекты классов...

end;

destructor TFlistFormat.Destroy;
begin
  //Выкидываем мусор
  SetLength(FileList,0);

  //Выполнить унаследованный деструктор
  inherited;
end;

//------------------------------------------//
//           Закрытые методы...             //
//------------------------------------------//

function TFlistFormat.ParseFileType(const InputStr : AnsiString) : byte;
//Вернуть код типа файла по строковому значению типа.
begin
  if LowerCase(InputStr) = 'file' then begin
    //Файл
    Result := Flist_Filetype_File;
  end
  else if LowerCase(InputStr) = 'dir' then begin
    //Дира
    Result := Flist_Filetype_Directory;
  end
  else begin
    //хз-что
    Result := Flist_Filetype_Unknown;
  end;
end;

function TFlistFormat.ReturnFileTypeStr(const InputCode : byte) : AnsiString;
//Наоборот сгенерить значение типа файла из кода.
begin
  if InputCode = Flist_Filetype_File then begin
    //Файл
    Result := 'File';
  end
  else if InputCode = Flist_Filetype_Directory then begin
    //Дира
    Result := 'Dir';
  end
  else begin
    //хз-что
    Result := 'Unknown';
  end;
end;

//------------------------------------------//
//           Открытые методы...             //
//------------------------------------------//

procedure TFlistFormat.Clear();
//Очистить инфу класса.
begin
  //Фактически - проставить дефолтные значения...
  PathsAreAbsolute := Flist_Def_PathsAreAbsolute;
  AddSize := Flist_Def_AddSize;
  AddCRC32 := Flist_Def_AddCRC32;
  FilesNum := 0;
  //Ну и массив в 0 элементов
  SetLength(FileList,0);
  //Другая служебная инфа.
  FileLoaded := false;
  LoadedFileName := '';
  GlobalRoot := '';
end;

function TFlistFormat.GetGlobalRoot() : AnsiString;
//Вернуть корень.
begin
  if Self.GlobalRoot = '' then begin
    //Если глобальный путь не указан.
    if Self.FileLoaded = true then begin
      //Если загружался какой-то файл - берем путь к этому файлу.
      Result := ExtractFilePath(Self.LoadedFileName);
    end
    else begin
      //Иначе берем путь к текущей дире.
      Result := GetCurrentDir();
    end;
  end
  else begin
    //Если указан глобальный путь к корню - просто возвращаем его.
    Result := Self.GlobalRoot;
  end;
end;

function TFlistFormat.Load(const FileName : AnsiString) : boolean;
//Загрузить инфу файла в класс.
var
  AnIniFile : TAnIniFile;
  AllOk : boolean;
  IniValueList : AIniValueList;
  I, J : Integer;
  
begin
  //Инициализация.
  AnIniFile := TAnIniFile.Create;
  SetLength(IniValueList,0,0);  //Инициализация пустого динамического массива для инфы секции [Files]
  Result := false;
  if Self.DoConsoleOutput = true then begin
    Writeln('Loading file '+FileName+' ... ');
  end;
  
  //Очистка инфы класса...
  Self.Clear();
  
  //Собсно грузим...
  AllOk := FileExists(FileName);
  if AllOk = false then begin
    //Если файла не существует...
    ErrorMessage := 'File '+FileName+' is not exists.';
  end
  else begin
    //Если сам файлик вообще существует... Загружаем...
    AllOk := AnIniFile.Load(FileName);
    if AllOk = false then begin
      //Не удалось загрузить файл.
      ErrorMessage := 'Error, loading file '+FileName;
    end;
  end;
  
  if AllOk = true then begin
    //Ок, загружено. Читаем сигнатуру...
    if AnIniFile.ReadString('Main', 'FormatName') <> 'FileList' then begin
      //Это не FileList-файл.
      AllOk := false;
      ErrorMessage := 'File '+FileName+' is not FileList file.';
    end;
  end;

  if AllOk = true then begin
    //Проверяем версию формата...

    if AnIniFile.ReadInteger('Main', 'FormatVersion') > Flist_FormatVersion then begin
      //Формат более новой версии чем код в бинарнике.
      AllOk := false;
      ErrorMessage := 'File '+FileName+' has more new version ('+AnIniFile.ReadString('Main', 'FormatVersion')+') then i know ('+IntToStr(Flist_FormatVersion)+'). Aborted loading. Try update to a new version of this software.';
    end;
  end;
  
  if AllOk = true then begin
    //Собсно читаем инфу...
    //Когда будет версий формата больше одной - тут будет еще и поверсионка.

    //[Main]
    PathsAreAbsolute := AnIniFile.ReadBool('Main','PathsAreAbsolute');
    AddSize := AnIniFile.ReadBool('Main','AddSize');
    AddCRC32 := AnIniFile.ReadBool('Main','AddCRC32');
    //FilesNum := AnIniFile.ReadInteger('Main','FilesNum');      //Ненужно, важнее реальное количество в списке.

    //[Files]
    AnIniFile.ReadIniValueList('Files',IniValueList);   //Читаем секцию...
    //Заносим инфу о количестве файлов...
    FilesNum := Length(IniValueList);
    //Выделяем память под файлы...
    SetLength(FileList,FilesNum);
    //И собсно парсим...
    if FilesNum > 0 then begin
      //Если собсно есть что парсить.
      for I := 0 to FilesNum-1 do begin
        for J := 0 to Length(IniValueList[I])-1 do begin
          //По элементам.
          if IniValueList[I,J].Name = 'File' then begin
            FileList[I].FilePath := IniValueList[I,J].Value;
          end
          else if IniValueList[I,J].Name = 'Type' then begin
            FileList[I].FileType := ParseFileType(IniValueList[I,J].Value);
          end
          else if IniValueList[I,J].Name = 'Size' then begin
            FileList[I].FileSize := StrToInt(IniValueList[I,J].Value);
          end
          else if IniValueList[I,J].Name = 'CRC32' then begin
            FileList[I].CRC32 := StrToInt('$'+IniValueList[I,J].Value);     //Знак доллара - т.к. чтается число в виде HEX.
          end;
        end;
      end;
    end;

    //Ну, вроде бы все что надо прочитано. Теперь отмечаем что фсеок и собсно все.
    Result := true;
    if Self.DoConsoleOutput = true then begin
      Writeln('Loaded file '+FileName);
    end;
    FileLoaded := true;
    LoadedFileName := FileName;
  end;
  
  //Уборка мусора.
  AnIniFile.Free;
  SetLength(IniValueList,0,0);
end;

function TFlistFormat.Save(const FileName : AnsiString) : boolean;
//Сохранить инфу из класса в файл.
var
  AnIniFile : TAnIniFile;
  I, J, ValElemNum : Integer;
  IniValueList : AIniValueList;
  
begin
  //Инициализация.
  AnIniFile := TAnIniFile.Create;
  SetLength(IniValueList,0,0);
  Result := false;
  if Self.DoConsoleOutput = true then begin
    Writeln('Saving file '+FileName+' ... ');
  end;
  
  //Крейтим новое файло...
  AnIniFile.MakNewFile;
  //Закидываем инфу...
  //[Main]
  AnIniFile.WriteString('Main', 'FormatName', 'FileList');
  AnIniFile.WriteInteger('Main', 'FormatVersion', Flist_FormatVersion);
  AnIniFile.WriteBool('Main', 'PathsAreAbsolute', PathsAreAbsolute);
  AnIniFile.WriteBool('Main', 'AddSize', AddSize);
  AnIniFile.WriteBool('Main', 'AddCRC32', AddCRC32);
  AnIniFile.WriteInteger('Main', 'FilesNum', FilesNum);
  
  //[Files]
  //Определить сколько элементов будет в каждой "строке" IniValueList
  ValElemNum := 2;      //Минимум.
  if AddSize = true then ValElemNum := ValElemNum+1;
  if AddCRC32 = true then ValElemNum := ValElemNum+1;
  //Выделить память под элементы IniValueList
  SetLength(IniValueList,FilesNum,ValElemNum);
  //Закинуть всю инфу по файлам в IniValueList
  for I := 0 to FilesNum-1 do begin
    J := 0;
    //File
    IniValueList[I,J].Name := 'File';
    IniValueList[I,J].Value := FileList[I].FilePath;
    J := J+1;
    //Type
    IniValueList[I,J].Name := 'Type';
    IniValueList[I,J].Value := ReturnFileTypeStr(FileList[I].FileType);
    J := J+1;
    //Size
    if AddSize = true then begin
      IniValueList[I,J].Name := 'Size';
      IniValueList[I,J].Value := IntToStr(FileList[I].FileSize);
      J := J+1;
    end;
    //CRC32
    if AddCRC32 = true then begin
      IniValueList[I,J].Name := 'CRC32';
      IniValueList[I,J].Value := IntToHex(FileList[I].CRC32,8);
    end;
  end;
  //Записать сгенеренный список в секцию...
  AnIniFile.WriteIniValueList('Files',IniValueList);
  
  //Терь можно сохранить файл...
  Result := AnIniFile.Save(FileName);
  //Если сохранилось удачно - запоминаем чего там за файлег.
  if Result = true then begin
    FileLoaded := true;
    LoadedFileName := FileName;
    if Self.DoConsoleOutput = true then begin
      Writeln('Saved file '+FileName);
    end;
  end;
  
  //Выкидываем хлам (ака мусор).
  AnIniFile.Free;
  SetLength(IniValueList,0,0);
end;

function TFlistFormat.ElementNameExists(const ElementName : AnsiString) : boolean;
//Существует ли элемент с таким именем.
var
  I : Integer;
  TempElemName : AnsiString;
  
begin
  //Инициализация.
  Result := false;
  I := -1;
  TempElemName := UpperCase(DelLastSlash(ElementName));
  
  //Пробежаться по массиву с файлами пока элемент не будет найден или пока массив не закончится.
  repeat
  
    I := I+1;
    //Итак, независимо от того что это - папка ли, файл ли - смотрим.
    if UpperCase(DelLastSlash(FileList[I].FilePath)) = TempElemName then begin
      Result := true;     //Все, нашли, из цикла оно терь вылетит и вернется true.
    end;
    
  until (Result = true) or (I = FilesNum-1);
  
end;

function TFlistFormat.GetElementNumber(const ElementName : AnsiString) : Integer;
//Какой номер у элемента с таким именем.
var
  I : Integer;
  TempElemName : AnsiString;

begin
  //Инициализация.
  Result := -1;
  I := -1;
  TempElemName := UpperCase(DelLastSlash(ElementName));

  //Пробежаться по массиву с файлами пока элемент не будет найден или пока массив не закончится.
  repeat

    I := I+1;
    //Итак, независимо от того что это - папка ли, файл ли - смотрим.
    if UpperCase(DelLastSlash(FileList[I].FilePath)) = TempElemName then begin
      Result := I;     //Все, нашли, из цикла оно терь вылетит и вернется true.
    end;

  until (Result = I) or (I = FilesNum-1);

end;

function TFlistFormat.FileExistsHere(const FileName : AnsiString) : boolean;
//Существует ли файл с таким именем.
var
  I : Integer;
  TempFileName : AnsiString;
  
begin
  //Инициализация.
  Result := false;
  I := -1;
  TempFileName := UpperCase(FileName);

  //Пробежаться по массиву с файлами пока элемент не будет найден или пока массив не закончится.
  repeat

    I := I+1;
    
    if FileList[I].FileType = Flist_Filetype_File then begin
      //Только если это файло.
      if UpperCase(FileList[I].FilePath) = TempFileName then begin
        Result := true;     //Все, нашли, из цикла оно терь вылетит и вернется true.
      end;
    end;

  until (Result = true) or (I = FilesNum-1);

end;

function TFlistFormat.GetFileNumberHere(const FileName : AnsiString) : Integer;
//Какой номер у файла с таким именем.
var
  I : Integer;
  TempFileName : AnsiString;

begin
  //Инициализация.
  Result := -1;
  I := -1;
  TempFileName := UpperCase(FileName);

  //Пробежаться по массиву с файлами пока элемент не будет найден или пока массив не закончится.
  repeat

    I := I+1;

    if FileList[I].FileType = Flist_Filetype_File then begin
      //Только если это файло.
      if UpperCase(FileList[I].FilePath) = TempFileName then begin
        Result := I;     //Все, нашли, из цикла оно терь вылетит и вернется true.
      end;
    end;

  until (Result = I) or (I = FilesNum-1);

end;

function TFlistFormat.DirExistsHere(const DirName : AnsiString) : boolean;
//Существует ли дира с таким именем.
var
  I : Integer;
  TempDirName : AnsiString;

begin
  //Инициализация.
  Result := false;
  I := -1;
  TempDirName := DelLastSlash(UpperCase(DirName));

  //Пробежаться по массиву с файлами пока элемент не будет найден или пока массив не закончится.
  repeat

    I := I+1;

    if FileList[I].FileType = Flist_Filetype_Directory then begin
      //Только если это дира.
      if UpperCase(DelLastSlash(FileList[I].FilePath)) = TempDirName then begin
        Result := true;     //Все, нашли, из цикла оно терь вылетит и вернется true.
      end;
    end;

  until (Result = true) or (I = FilesNum-1);

end;

function TFlistFormat.GetDirNumberHere(const DirName : AnsiString) : Integer;
//Определить номер диры с таким именем.
var
  I : Integer;
  TempDirName : AnsiString;

begin
  //Инициализация.
  Result := -1;
  I := -1;
  TempDirName := DelLastSlash(UpperCase(DirName));

  //Пробежаться по массиву с файлами пока элемент не будет найден или пока массив не закончится.
  repeat

    I := I+1;

    if FileList[I].FileType = Flist_Filetype_Directory then begin
      //Только если это дира.
      if UpperCase(DelLastSlash(FileList[I].FilePath)) = TempDirName then begin
        Result := I;     //Все, нашли, из цикла оно терь вылетит и вернется true.
      end;
    end;

  until (Result = I) or (I = FilesNum-1);

end;

function TFlistFormat.GetRealElementName(const ElemName : AnsiString) : AnsiString;
//Определить абсолютное имя для элемента
begin
  //Получаем абсолютный путь....
  if IsLocalPath(ElemName) = true then begin
    //Если надо генерить - генерим.
    Result := ResolveLocalPath(ElemName,Self.GetGlobalRoot());
  end
  else begin
    //Он уже глобальный.
    Result := ElemName;
  end;
end;

function TFlistFormat.GetRealElementName(const ElemNum : Integer) : AnsiString;
//Определить абсолютное имя для элемента с таким-то номером в списке.
begin
  //Просто вызываем функцию выше с именем элемента...
  Result := GetRealElementName(Self.FileList[ElemNum].FilePath);
end;

function TFlistFormat.AddFile(const FileName : AnsiString) : boolean;
//Добавить файл.
var
  CurrFileNum : Integer;
  LocalName, GlobalName : AnsiString;
  
begin
  //Инициализация.
  Result := false;
  CurrFileNum := FilesNum;   //После добавления нового файла эта цифра будет номером последнего элемента массива.
  
  //Увеличить размер массива на один.
  FilesNum := FilesNum+1;
  SetLength(FileList,FilesNum);
  
  //Получаем абсолютный путь....
  if IsLocalPath(FileName) = true then begin
    //Если надо генерить - генерим.
    GlobalName := ResolveLocalPath(FileName,Self.GetGlobalRoot());
  end
  else begin
    //Он уже глобальный.
    GlobalName := FileName;
  end;

  //Если нужно - получаем относительный путь.
  if Self.PathsAreAbsolute = false then begin
    LocalName := GetLocalPath(Self.GetGlobalRoot(),GlobalName);
  end;
  
  //Забить параметры для файла.
  //FilePath
  if Self.PathsAreAbsolute = true then begin
    //Имя должно быть абсолютное.
    FileList[CurrFileNum].FilePath := GlobalName;
  end
  else begin
    //Имя должно быть относительное
    FileList[CurrFileNum].FilePath := LocalName;
  end;
  //FileType
  FileList[CurrFileNum].FileType := Flist_Filetype_File;
  //FileSize
  if Self.AddSize = true then begin
    FileList[CurrFileNum].FileSize := 0;
  end;
  //CRC32
  if Self.AddCRC32 = true then begin
    FileList[CurrFileNum].CRC32 := crc32(0, nil, 0);         //Получится "пустое" значение CRC32.
  end;
  
  //Вернуть результат.
  Result := true;
end;

function TFlistFormat.AddRealFile(const FileName : AnsiString) : boolean;
//Добавить реально существующий на диске файл (с подсчетом реальной инфы).
var
  CurrFileNum : Integer;
  LocalName, GlobalName : AnsiString;
  
begin
  //Код независит от функции TFlistFormat.AddFile в целях более оптимальной работы.
  //Инициализация.
  Result := false;
  CurrFileNum := FilesNum;   //После добавления нового файла эта цифра будет номером последнего элемента массива.
  
  //Получаем абсолютный путь....
  if IsLocalPath(FileName) = true then begin
    //Если надо генерить - генерим.
    GlobalName := ResolveLocalPath(FileName,Self.GetGlobalRoot());
  end
  else begin
    //Он уже глобальный.
    GlobalName := FileName;
  end;
  
  //Если нужно - получаем относительный путь.
  if Self.PathsAreAbsolute = false then begin
    LocalName := GetLocalPath(Self.GetGlobalRoot(),GlobalName);
  end;

  //Увеличить размер массива на один.
  FilesNum := FilesNum+1;
  SetLength(FileList,FilesNum);

  //Забить параметры для файла.
  //FilePath
  if Self.PathsAreAbsolute = true then begin
    //Имя должно быть абсолютное.
    FileList[CurrFileNum].FilePath := GlobalName;
  end
  else begin
    //Имя должно быть относительное
    FileList[CurrFileNum].FilePath := LocalName;
  end;
  //FileType
  FileList[CurrFileNum].FileType := Flist_Filetype_File;
  //FileSize
  if Self.AddSize = true then begin
    FileList[CurrFileNum].FileSize := GetFileSize(GlobalName);       //Подсчитать размер. Если файла нету - вернет нолик.
  end;
  //CRC32
  if Self.AddCRC32 = true then begin
    FileList[CurrFileNum].CRC32 := FileToCRC32(GlobalName,DoConsoleOutput);    //Подсчитать CRC32 для файла. Если файла нету - будет "пустое" значение.
  end;

  //Вернуть результат.
  Result := true;
end;

function TFlistFormat.AddDirectory(const DirName : AnsiString) : boolean;
//Добавить пустую диру.
var
  CurrFileNum : Integer;
  LocalName, GlobalName : AnsiString;

begin
  //Инициализация.
  Result := false;
  CurrFileNum := FilesNum;   //После добавления новой диры эта цифра будет номером последнего элемента массива.

  //Увеличить размер массива на один.
  FilesNum := FilesNum+1;
  SetLength(FileList,FilesNum);
  
  //Получаем абсолютный путь....
  if IsLocalPath(DirName) = true then begin
    //Если надо генерить - генерим.
    GlobalName := DelLastSlash(ResolveLocalPath(DirName,Self.GetGlobalRoot()));
  end
  else begin
    //Он уже глобальный.
    GlobalName := DelLastSlash(DirName);
  end;

  //Если нужно - получаем относительный путь.
  if Self.PathsAreAbsolute = false then begin
    LocalName := GetLocalPath(Self.GetGlobalRoot(),GlobalName);
  end;

  //Забить параметры для диры.
  //FilePath
  if Self.PathsAreAbsolute = true then begin
    //Имя должно быть абсолютное.
    FileList[CurrFileNum].FilePath := GlobalName;
  end
  else begin
    //Имя должно быть относительное
    FileList[CurrFileNum].FilePath := LocalName;
  end;
  //FileType
  FileList[CurrFileNum].FileType := Flist_Filetype_Directory;

  //Вернуть результат.
  Result := true;
end;

function TFlistFormat.AddRealDirectory(const DirName : AnsiString; const Recursive : boolean) : boolean;
//Добавить реальную диру с подсчетом всей инфы по файлам.
var
  AddingFiles : LongInt;
  LocalName, GlobalName : AnsiString;
  
  function ReallyAddDirectory(const DirName : AnsiString; const Recursive : boolean) : boolean;
  //Функция, непосредственно читающая инфу по директории...
  var
    SearchRec : TSearchRec;
    LocalDirName : AnsiString;
  begin
    //Инициализация.
    Result := false;
    
    //Если нужно - получаем относительный путь.
    if Self.PathsAreAbsolute = false then begin
      LocalDirName := GetLocalPath(Self.GetGlobalRoot(),DirName);
    end;
    
    //Начать сбор инфы...
    if FindFirst(AddLastSlash(DirName)+'*', faAnyFile and faDirectory, SearchRec) = 0 then begin
      //Если поиск успешно начат.
      repeat
        //Повторяем поиск пока не закончится то что можно искать %).
        if (SearchRec.Name <> '.') and (SearchRec.Name <> '..') then begin
          //Чего-то нашли.
          if (SearchRec.Attr and faDirectory) <> faDirectory then begin
            //Ход мыслей прост. Если то что мы нашли не директория - значит это файл %). Ибо проверять
            //по принципу "файл ли это" опасно - директория - она тоже файл %).
            //Итак, то что нашли - файл. Добавляем.

            //Забить параметры для файла.
            //FilePath
            if Self.PathsAreAbsolute = true then begin
              //Имя должно быть абсолютное.
              FileList[FilesNum].FilePath := AddLastSlash(DirName)+SearchRec.Name;
            end
            else begin
              //Имя должно быть относительное
              FileList[FilesNum].FilePath := AddLastSlash(LocalDirName)+SearchRec.Name;
            end;
            //FileType
            FileList[FilesNum].FileType := Flist_Filetype_File;
            //FileSize
            if Self.AddSize = true then begin
              FileList[FilesNum].FileSize := GetFileSize(AddLastSlash(DirName)+SearchRec.Name);       //Подсчитать размер. Если файла нету - вернет нолик.
            end;
            //CRC32
            if Self.AddCRC32 = true then begin
              FileList[FilesNum].CRC32 := FileToCRC32(AddLastSlash(DirName)+SearchRec.Name,DoConsoleOutput);    //Подсчитать CRC32 для файла. Если файла нету - будет "пустое" значение.
            end;
            
            //+1 счетчик файлов в массиве с инфой.
            FilesNum := FilesNum+1;
            
          end
          else begin
            //Если то что нашли - директория. Аналогично - добавляем...

            //Забить параметры для диры.
            //FilePath
            if Self.PathsAreAbsolute = true then begin
              //Имя должно быть абсолютное.
              FileList[FilesNum].FilePath := AddLastSlash(DirName)+SearchRec.Name;
            end
            else begin
              //Имя должно быть относительное
              FileList[FilesNum].FilePath := AddLastSlash(LocalDirName)+SearchRec.Name;
            end;
            //FileType
            FileList[FilesNum].FileType := Flist_Filetype_Directory;
            
            //+1 счетчик файлов в массиве с инфой.
            FilesNum := FilesNum+1;

            //И если нужно - вызвать функцию рекурсивно.
            if Recursive = true then begin
              ReallyAddDirectory(AddLastSlash(DirName)+SearchRec.Name, Recursive);
            end;
          end;
        end;
        
      until FindNext(SearchRec) <> 0;
      
      //Закрыть поиск.
      SysUtils.FindClose(SearchRec);
      //Вернуть результат.
      Result := true;
    end;
  end;
  
begin
  //Функция может работать "рекурсивно". На самом деле прямой рекурсии этой функции даже в этом случае
  //не будет - рекурситься будут только "вложенные" функции. В любом случае - сначала подсчитывает
  //количество добавляемых файлов (либо рекурсивно либо нет, смотря что требуется), потом выделяется память
  //под массив, потом вызывается функция добавления данной папки, которая уже может быть рекурсивной если
  //это необходимо. Таким образом размер динамического массива определяется однократно, что позволяет не
  //заниматься копированием памяти каждый раз когда надо увеличить массив. Рекурсивная функция уже точно знает
  //сколько файлов будет добавлено и размер массива не трогает - только читает и добавляет инфу.
  
  //Инициализация.
  Result := false;
  
  //Получаем абсолютный путь....
  if IsLocalPath(DirName) = true then begin
    //Если надо генерить - генерим.
    GlobalName := DelLastSlash(ResolveLocalPath(DirName,Self.GetGlobalRoot()));
  end
  else begin
    //Он уже глобальный.
    GlobalName := DelLastSlash(DirName);
  end;

  //Если нужно - получаем относительный путь.
  if Self.PathsAreAbsolute = false then begin
    LocalName := GetLocalPath(Self.GetGlobalRoot(),GlobalName);
  end;
  
  //Итак, во-первых подсчитать количество добавляемых файлов...
  AddingFiles := GetFilesNumber(GlobalName,Recursive)+1;       //+1 - данная конкретная дира которая DirName
  //Теперь выставить правильный размер массива... FilesNum не трогаем - это в принципе счетчик тут.
  SetLength(FileList,FilesNum+AddingFiles);

  //Добавить текущую диру.
  //FilePath
  if Self.PathsAreAbsolute = true then begin
    //Имя должно быть абсолютное.
    FileList[FilesNum].FilePath := GlobalName;
  end
  else begin
    //Имя должно быть относительное
    FileList[FilesNum].FilePath := LocalName;
  end;
  //FileType
  FileList[FilesNum].FileType := Flist_Filetype_Directory;
  //+1 количество файлов в инфе.
  FilesNum := FilesNum+1;
  
  //Ок. Можно звать функцию для непосредственного чтения инфы директории, если надо то она и будет рекурситься.
  Result := ReallyAddDirectory(GlobalName, Recursive);
  
end;

function TFlistFormat.RemoveFile(const FileName : AnsiString) : boolean;
//Удалить файл из базы.
var
  RealSearchPath, TempStr : AnsiString;
  Finded : boolean;
  I, J : Integer;
  NewFileList : array of RFlistFile;
  DeletingElem, DummyElem : RFlistFile;
  
begin
  //Инициализация
  Result := false;
  
  //Смотрим что там за путь в аргументе и если надо приводим его к тому виду как они в массиве.
  if Self.PathsAreAbsolute = true then begin
    //Если нужны абсолютные пути.
    if IsLocalPath(FileName) = true then begin
      //Если надо генерить - генерим.
      RealSearchPath := ResolveLocalPath(FileName,Self.GetGlobalRoot());
    end
    else begin
      //Он уже глобальный.
      RealSearchPath := FileName;
    end;
  end
  else begin
    //Если нужны относительные пути.
    if IsLocalPath(FileName) = true then begin
      //Он уже локальный.
      RealSearchPath := FileName;
    end
    else begin
      //Генерим локальный
      RealSearchPath := GetLocalPath(Self.GetGlobalRoot(),FileName);
    end;
  end;

  //Ищем файл с таким локальным\глобальным именем и удаляем его из массива.
  Finded := false;
  I := -1;
  repeat
    I := I+1;
    if UpperCase(Self.FileList[I].FilePath) = UpperCase(RealSearchPath) then begin
      //Нашли.
      Finded := true;
    end;
  until (Finded = true) or (I = FilesNum-1);
  
  if Finded = true then begin
    //Если нашли чего удалять, а удаляемый элемент не последний - двигаем элементы внутрях массива.
    if I <> (FilesNum-1) then begin
      Move(Self.FileList[I],DeletingElem,SizeOf(RFlistFile));    //Временно копируем инфу удаляемого элемента.
      Move(Self.FileList[I+1],Self.FileList[I],SizeOf(RFlistFile)*(FilesNum-(I+1)));    //Переносим инфу других элементов.
      Move(DeletingElem,Self.FileList[FilesNum-1],SizeOf(RFlistFile));     //Копируем удаляемый элемент в конец массива чтоб его прочистило при смене размера массива (во избежание утечков памяти).
      Move(DummyElem,DeletingElem,SizeOf(RFlistFile));     //Копируем во временный элемент инфу элемента заглушки - чтобы тупой сборщег мусора не полез по ссылкам и не заховал последний элемент массива раньше или позже (т.е. еще раз на пустое место) правильного времени.
    end;
    //Прочистить удаляемый элемент массива.
    Self.FileList[FilesNum-1].CRC32 := 0;
    Self.FileList[FilesNum-1].FilePath := '';
    Self.FileList[FilesNum-1].FileSize := 0;
    Self.FileList[FilesNum-1].FileType := 0;
    //И почистить массив.
    FilesNum := FilesNum-1;
    SetLength(Self.FileList,FilesNum);
    //Done.
    Result := true;
  end;
end;

function TFlistFormat.RemoveDirectory(const DirName : AnsiString) : boolean;
//Удалить диру (со всеми входящими файлами и дирами).
var
  I : Integer;
  RealSearchPath : AnsiString;
  
begin
  //Принцип действия следующий: двигаемся по массиву, если обнаруживаем child-а (в т.ч. и сама эта дира
  //попадет в этот фильтр - явно её удалять и не надо) - то удаляем вышенаписанной функцией, счетчик
  //отщелкиваем назад и идем дальше.
  
  //Инициализация.
  Result := false;
  
  //Смотрим что там за путь в аргументе и если надо приводим его к тому виду как они в массиве.
  if Self.PathsAreAbsolute = true then begin
    //Если нужны абсолютные пути.
    if IsLocalPath(DirName) = true then begin
      //Если надо генерить - генерим.
      RealSearchPath := ResolveLocalPath(DirName,Self.GetGlobalRoot());
    end
    else begin
      //Он уже глобальный.
      RealSearchPath := DirName;
    end;
  end
  else begin
    //Если нужны относительные пути.
    if IsLocalPath(DirName) = true then begin
      //Он уже локальный.
      RealSearchPath := DirName;
    end
    else begin
      //Генерим локальный
      RealSearchPath := GetLocalPath(Self.GetGlobalRoot(),DirName);
    end;
  end;
  
  //Шканим массиву пока счетчик не дойдет до конца массива...
  I := -1;    //Начинаем с нуля.
  repeat
    I := I+1;   //Счетчик.
    if I < Self.FilesNum then begin
      //Эта проверка счетчика на всякий пожарный, ибо мало ли, мы таки будем в процессе работы
      //изменять размер массива который обсчитывается этим самым FilesNum...
      if IsDirsChild(RealSearchPath, Self.FileList[I].FilePath) = true then begin
        //Найден элемент который надо удалять. Удаляем.
        RemoveFile(Self.FileList[I].FilePath);
        //И отщелкиваем назад счетчик.
        I := I-1;
      end;
    end;
  until I = Self.FilesNum-1;

end;

function TFlistFormat.CheckFile(const ListFileName, RealFileName : AnsiString) : byte;
//Проверить насколько реальный файл соответствует инфе в файле.
//Возвращает значение одной из констант Flist_CheckFile_*. Можно сравнивать директории.
var
  IsDirectory : boolean;
  CurElemNum : Integer;
  
begin
  //Инициализация.
  Result := Flist_CheckFile_Error;     //По умолчанию возвращается код ошибки...
  
  //С начала надо узнать с чем имеем дело. Папка или файл.
  //Проверяем, существует ли файл на диске...
  if FileExists(RealFileName) = true then begin
    //То с чем работаем - файл.
    IsDirectory := false;
  end
  else if DirectoryExists(DelLastSlash(RealFileName)) = true then begin
    //То с чем работаем - директория.
    IsDirectory := true;
  end
  else begin
    //Нифига на диске нету, ни файла, ни директории. Проверяем - есть ли чего в базе.
    if ElementNameExists(RealFileName) = true then begin
      //Файло существует в базе, но не существует на диске. Что именно оно из себя
      //представляет - директорию или файл - уже непринципиально.
      Result := Flist_CheckFile_FileNotExists;
    end
    else begin
      //Файло не существует ни в базе, ни на диске - т.е. нигде.
      Result := Flist_CheckFile_NothingExists;
    end;
  end;
  
  if Result = Flist_CheckFile_Error then begin
    //а Flist_CheckFile_Error это еще и индикатор того что функция пока не нашла ответ % )).
    //И то что выполнение попало сюда - означает, что как минимум искомое есть на винте.
    //В зависимости от того - папка это или файл - ищем нужный элемент в базе...
    
    if IsDirectory = false then begin
      //Ищем файл.