код

unit uMembers;

interface

uses
  //============================== Модули проекта ==============================
  uXmlUtils,
  //=============================== Левые модули ===============================
  ECXMLParser, FileWorks,
  //=================== Системные модули и модули компонентов ==================
  Windows, SysUtils, Classes, Contnrs, Forms;

type
  // Класс - участник соревнования
  TMember = class
  private
    // Поля
    FName: string;    // Имя
    FGender: Boolean; // Пол (True = Ж, False = М)
    FRating: Cardinal; // Рейтинг
    FPlace: Cardinal; // Место в турнирной таблице
    FLastVisit: TDateTime; // Время последного захода
    FModified: Boolean; // Флаг изменённости

    // Поля событий
    //FOnChange: TNotifyEvent; // Событие изменения

    // Функции доступа к полям/свойствам
    procedure SetName(const ANew: string);
    procedure SetGender(const ANew: Boolean);
    procedure SetRating(const ANew: Cardinal);
    procedure SetLastVisit(const ANew: TDateTime);

    // Технологические функции

  public
    // Конструктор и деструктор
    constructor Create;

    // Методы
    procedure SaveToXML(ANode: TXMLItem);
    procedure LoadFromXML(ANode: TXMLItem);
    procedure IncRating;
    procedure DecRating;

    // Свойства
    property Name: string read FName write SetName;
    property Gender: Boolean read FGender write SetGender;
    property Rating: Cardinal read FRating write SetRating;
    property Place: Cardinal read FPlace write FPlace;
    property LastVisit: TDateTime read FLastVisit write SetLastVisit;
    property Modified: Boolean read FModified write FModified;

    // События
    //property OnChange: TNotifyEvent read FOnChange write FOnChange;
  end;

  // Тип сортировки
  TMembersSortType = (mstByName, mstByRating, mstByLastVisit, mstByPlace);


  // Класс - список участников
  TMemberList = class
  private
    // Поля
    FMembers: TObjectList;
    FModified: Boolean;
    FStartTime: TDateTime; // Дата/время начала ведения статистики
    FLastSaveTime: TDateTime; // Дата последнего сохранения файла
    FSortedBy: TMembersSortType;

    // Функции доступа к полям/свойствам
    function GetCount: Integer;
    function GetMember(const Index: Integer): TMember;
    function GetModified: Boolean;

    // Технологические функции
  public
    // Конструктор и деструктор
    constructor Create;
    destructor Destroy; override;

    // Методы
    function NewMember: TMember;
    procedure AddMember(AMember: TMember);
    procedure DeleteMember(AMember: TMember);
    function LoadFromFile(const FileName: string): Boolean;
    function SaveToFile(const FileName: string): Boolean;
    procedure CalcPlaces;
    procedure Sort(const SortType: TMembersSortType);

    // Свойства
    property Count: Integer read GetCount;
    property Members[const Index: Integer]: TMember read GetMember; default;
    property Modified: Boolean read GetModified write FModified;
    property StartTime: TDateTime read FStartTime;
    property LastSaveTime: TDateTime read FLastSaveTime write FLastSaveTime;
    property SortedBy: TMembersSortType read FSortedBy;

    // События
  end;

function GetFileLastSaveTime(const FileName: string; var T: TDateTime): Boolean;
function CompareByName(Item1, Item2: Pointer): Integer;
function CompareByRating(Item1, Item2: Pointer): Integer;
function CompareByLastVisit(Item1, Item2: Pointer): Integer;
function CompareByPlace(Item1, Item2: Pointer): Integer;

var
  SortDirection: Integer = -1; // Для процедур сравнения

implementation

uses Math, DateUtils;

{ TMember }

constructor TMember.Create;
begin
  // Инициализация
  FName:= 'Новый кандидат';
  FGender:= False;
  FRating:= 0;
  FLastVisit:= Now();
  FModified:= False;
end;

procedure TMember.DecRating;
begin
  if FRating > 0
    then begin
           Dec(FRating);
           FModified:= True;
         end;
end;

procedure TMember.IncRating;
begin
  Inc(FRating);
  FLastVisit:= Now();
  FModified:= True;
end;

procedure TMember.LoadFromXML(ANode: TXMLItem);
begin
  FName:=      XmlGetStringParam(ANode,   'Name',      FName);
  FGender:=    XmlGetBoolParam(ANode,     'Gender',    FGender);
  FRating:=    XmlGetIntegerParam(ANode,  'Rating',    FRating);
  FLastVisit:= XmlGetDateTimeParam(ANode, 'LastVisit', FLastVisit);
  FModified:=  False;
end;

procedure TMember.SaveToXML(ANode: TXMLItem);
begin
  XmlAddStringParam(ANode,   'Name',      FName);
  XmlAddBoolParam(ANode,     'Gender',    FGender);
  XmlAddIntegerParam(ANode,  'Rating',    FRating);
  XmlAddDateTimeParam(ANode, 'LastVisit', FLastVisit);
  FModified:=  False;
end;

procedure TMember.SetGender(const ANew: Boolean);
begin
  if FGender <> ANew
    then begin
           FGender:= ANew;
           FModified:= True;
         end;
end;

procedure TMember.SetLastVisit(const ANew: TDateTime);
begin
  if FLastVisit <> ANew
    then begin
           FLastVisit:= ANew;
           FModified:= True;
         end;
end;

procedure TMember.SetName(const ANew: string);
begin
  if FName <> ANew
    then begin
           FName:= ANew;
           FModified:= True;
         end;
end;

procedure TMember.SetRating(const ANew: Cardinal);
begin
  if FRating <> ANew
    then begin
           FRating:= ANew;
           FModified:= True;
         end;
end;

{ TMemberList }

constructor TMemberList.Create;
begin
  FMembers:= TObjectList.Create(True);
end;

destructor TMemberList.Destroy;
begin
  FMembers.Free();
  inherited;
end;

function TMemberList.GetCount: Integer;
begin
  Result:= FMembers.Count;
end;

function TMemberList.GetMember(const Index: Integer): TMember;
begin
  if (Index > -1) and (Index < Self.Count)
    then Result:= TMember(FMembers[Index])
    else Result:= nil;
end;

function TMemberList.GetModified: Boolean;
var
  Index: Integer;
begin
  Result:= FModified;

  if not Result
    then for Index:= 0 to FMembers.Count - 1 do
           if TMember(FMembers[Index]).Modified
             then begin
                    Result:= True;
                    Exit;
                  end;
end;

function TMemberList.LoadFromFile(const FileName: string): Boolean;
var
  Parser: TECXMLParser;
  Index: Integer;
  Member: TMember;
begin
  Result:= False;
  Parser:= TECXMLParser.Create(nil);
  try
    // Попытка загрузки
    try
      Parser.LoadFromFile(FileName);
      Result:= GetFileLastSaveTime(FileName, FLastSaveTime);
    except on E: Exception do
             begin
               Application.MessageBox(PChar('Не могу прочитать "' + FileName + '".'#13#10 + E.Message),
                                      PChar('Ошибка'),
                                      MB_OK + MB_ICONERROR);
             end;
    end;

    if Result
      then begin
             Self.FStartTime:= XmlGetDateTimeParam(Parser.Root, 'StartTime', Now());
             FMembers.Clear();

             for Index:= 0 to Parser.Root.Count - 1 do
               begin
                 Member:= NewMember();
                 Member.LoadFromXML(Parser.Root[Index]);
               end;

             // Сортировка по имени
             SortDirection:= -1;
             Sort(mstByName);
             FModified:= False;
           end;
  finally
    Parser.Free();
  end;
end;

function TMemberList.SaveToFile(const FileName: string): Boolean;
var
  Parser: TECXMLParser;
  Index: Integer;
  Item: TXMLItem;
begin
  Result:= False;
  Parser:= TECXMLParser.Create(nil);
  try
    Parser.Root.Name:= 'ChampionshipBase';
    XmlAddIntegerParam(Parser.Root, 'Count', Self.Count);
    XmlAddDateTimeParam(Parser.Root, 'StartTime', FStartTime);

    for Index:= 0 to Self.Count - 1 do
      begin
        Item:= Parser.Root.New();
        Item.Name:= 'Member' + IntToStr(Index);
        Self.Members[Index].SaveToXML(Item);
      end;

    // Попытка сохранения.
    try
      Parser.SaveToFile(FileName);
      FModified:= False;
      Result:= GetFileLastSaveTime(FileName, FLastSaveTime);
    except on E: Exception do
      Application.MessageBox(PChar('Не могу сохранить "' + FileName + '".'#13#10 + E.Message),
                             PChar('Ошибка'),
                             MB_OK + MB_ICONERROR);
    end;
  finally
    Parser.Free();
  end;
end;

function TMemberList.NewMember: TMember;
begin
  Result:= TMember.Create();
  FMembers.Add(Result);
end;

procedure TMemberList.AddMember(AMember: TMember);
begin
  FMembers.Add(AMember);
end;

procedure TMemberList.DeleteMember(AMember: TMember);
var
  Index: Integer;
begin
  for Index:= 0 to Self.Count - 1 do
    if Self.FMembers[Index] = AMember
      then begin
             Self.FMembers.Delete(Index);
             Break;
           end;
end;

function CampareMembers(Item1, Item2: Pointer): Integer;
var
  M1, M2: TMember;
begin
  M1:= TMember(Item1);
  M2:= TMember(Item2);

  if M1.Rating < M2.Rating
    then Result:= +1
    else if M1.Rating > M2.Rating
           then Result:= -1
           else Result:= 0;
end;

procedure TMemberList.CalcPlaces;
var
  Temp: TList;
  Index: Integer;
  R, P: Cardinal;
  Member: TMember;
begin
  Temp:= TList.Create();
  try
    Temp.Assign(Self.FMembers);
    Temp.Sort(CampareMembers);

    R:= 0;
    P:= 1;
    for Index:= 0 to Temp.Count - 1 do
      begin
        Member:= TMember(Temp[Index]);

        if Member.Rating < R
          then Inc(P);

        Member.Place:= P;
        R:= Member.Rating;
      end;
  finally
    Temp.Free();
  end;
end;

function GetFileLastSaveTime(const FileName: string; var T: TDateTime): Boolean;
var
  Stamp: TFileDateTimeStamp;
begin
  Result:= GetFileDateTimeStamp(FileName, Stamp);
  if Result
    then T:= Stamp.LastWrite;
end;

procedure TMemberList.Sort(const SortType: TMembersSortType);
var
  CompareProc: TListSortCompare;
begin
  // Сортировка
  SortDirection:= -1 * SortDirection;

  case SortType of
    mstByName:      CompareProc:= CompareByName;
    mstByRating:    CompareProc:= CompareByRating;
    mstByLastVisit: CompareProc:= CompareByLastVisit;
  else
                    CompareProc:= CompareByPlace;
  end; //case

  FMembers.Sort(CompareProc);
  FSortedBy:= SortType;
  //FModified:= True;
end;

function CompareByName(Item1, Item2: Pointer): Integer;
begin
  Result:= SortDirection * CompareText(TMember(Item1).Name, TMember(Item2).Name);
end;

function CompareByRating(Item1, Item2: Pointer): Integer;
begin
  Result:= SortDirection * CompareValue(TMember(Item1).Rating, TMember(Item2).Rating);
end;

function CompareByLastVisit(Item1, Item2: Pointer): Integer;
begin
  Result:= SortDirection * CompareDateTime(TMember(Item1).LastVisit, TMember(Item2).LastVisit);
end;

function CompareByPlace(Item1, Item2: Pointer): Integer;
begin
  Result:= SortDirection * CompareValue(TMember(Item1).Place, TMember(Item2).Place);
end;

end.