source: branches/Xvcl/Xvcl.Generics.pas

unit Xvcl.Generics;

interface

uses
  SysUtils;

type
  TList<T> = class
  private
    FCount: Integer;
    FItems: array of T;
    procedure SetCount(const Value: Integer);
    function GetItem(Index: Integer): T;
    procedure SetItem(Index: Integer; const Value: T);
  public
  type
    TEnumerator = class
    private
      FList: TList<T>;
      FIndex: Integer;
      function GetCurrent: T;
    public
      function MoveNext: Boolean;
      property Current: T read GetCurrent;
    end;
    function GetEnumerator: TEnumerator;
    function Add(Item: T): Integer;
    function Remove(Item: T): Integer;
    procedure Delete(Index: Integer);
    procedure Move(FromIndex, ToIndex: Integer);
    function IndexOf(Item: T): Integer;
    function Compare(Item1, Item2: T): Integer;
    procedure Exchange(Index1, Index2: Integer);
    property Count: Integer read FCount write SetCount;
    property Items[Index: Integer]: T read GetItem write SetItem; default;
  end;

implementation

{ TList<T>.TEnumerator }

function TList<T>.TEnumerator.GetCurrent: T;
begin
  Result := FList.Items[FIndex];
end;

function TList<T>.TEnumerator.MoveNext: Boolean;
begin
  if FIndex < (FList.Count - 1) then begin
    Inc(FIndex);
    Result := True;
  end else Result := False;
end;

{ TList<T> }

function TList<T>.Add(Item: T): Integer;
begin
  Count := Count + 1;
  FItems[Count - 1] := Item;
  Result := Count - 1;
end;

function TList<T>.Compare(Item1, Item2: T): Integer;
begin
  if CompareMem(Pointer(@Item1), Pointer(@Item2), SizeOf(T)) then Result := 0
    else Result := -1;
end;

procedure TList<T>.Delete(Index: Integer);
var
  I: Integer;
begin
  if (Index >= 0) and (Index < Count) then
  for I := Index to Count - 2 do
    Items[I] := Items[I + 1];
end;

procedure TList<T>.Exchange(Index1, Index2: Integer);
var
  Temp: T;
begin
  Temp := Items[Index2];
  Items[Index2] := Items[Index1];
  Items[Index1] := Temp;
end;

function TList<T>.GetEnumerator: TEnumerator;
begin
  Result := TEnumerator.Create;
  Result.FList := Self;
  Result.FIndex := -1;
end;

function TList<T>.GetItem(Index: Integer): T;
begin
  Result := FItems[Index];
end;

function TList<T>.IndexOf(Item: T): Integer;
var
  I: Integer;
begin
  I := 0;
  while (I < Count) and (Compare(Items[I], Item) <> 0) do
    Inc(I);
  if I < Count then Result := I
    else Result := -1;
end;

procedure TList<T>.Move(FromIndex, ToIndex: Integer);
var
  I: Integer;
  Temp: T;
begin
  if (FromIndex >= 0) and (FromIndex < Count) and
  (ToIndex >= 0) and (ToIndex < Count) then begin
    if FromIndex > ToIndex then begin
      Temp := Items[ToIndex];
      for I := ToIndex to FromIndex - 1 do
        Items[I] := Items[I + 1];
      Items[FromIndex] := Temp;
    end else
    if FromIndex < ToIndex then begin
      Temp := Items[FromIndex];
      for I := FromIndex to ToIndex - 1 do
        Items[I] := Items[I + 1];
      Items[ToIndex] := Temp;
    end;
  end;
end;

function TList<T>.Remove(Item: T): Integer;
begin
  Result := IndexOf(Item);
  if Result >= 0 then Delete(Result);
end;

procedure TList<T>.SetCount(const Value: Integer);
begin
  FCount := Value;
  SetLength(FItems, Value);
end;

procedure TList<T>.SetItem(Index: Integer; const Value: T);
begin
  FItems[Index] := Value;
end;

end.