Changeset 322 for Generics/NativeGenerics/Units

Timestamp:

Feb 8, 2012, 9:47:54 AM (14 years ago)

Author:

chronos

Message:

• Added: TGMemoryStream implementation.
• Added: Additional methods to TGList.

Location:

Generics/NativeGenerics/Units

Files:

• GenericList.pas (modified) (4 diffs)
• GenericStream.pas (modified) (3 diffs)

Generics/NativeGenerics/Units/GenericList.pas

@@ -38 +38 @@
     procedure AddArray(Values: array of TItem);
     procedure AddList(List: TGList<TItem>);
+    procedure AddListPart(List: TGList<TItem>; ItemIndex, ItemCount: TIndex);
     procedure Assign(Source: TGList<TItem>); virtual;
     procedure Clear; virtual;
@@ -48 +49 @@
     property First: TItem read GetFirst write SetFirst;
     procedure Fill(Start, Count: TIndex; Value: TItem);
-    function GetArray: TItemArray;
+    function GetArray(Index, ACount: TIndex): TItemArray;
+    procedure GetList(List: TGList<TItem>; Index, ACount: TIndex);
     function Implode(Separator: string; Converter: TToStringConverter): string;
     function IndexOf(Item: TItem; Start: TIndex = 0): TIndex;
@@ -161 +163 @@
 end;
 
-function TGList<TItem>.GetArray: TItemArray;
+function TGList<TItem>.GetArray(Index, ACount: TIndex): TItemArray;
 var
   I: Integer;
 begin
-  SetLength(Result, Count);
+  SetLength(Result, ACount);
   I := 0;
   while I < Count do begin
-    Result[I] := FItems[I];
-    I := I + 1;
-  end;
+    Result[I] := FItems[Index + I];
+    I := I + 1;
+  end;
+end;
+
+procedure TGList<TItem>.GetList(List: TGList; Index, ACount: TIndex);
+begin
+ List.Clear;
+ List.AddListPart(Self, Index, ACount);
 end;
 
@@ -506 +514 @@
 end;
 
+procedure TGList<TItem>.AddListPart(List: TGList; ItemIndex, ItemCount: TIndex);
+var
+  I: TIndex;
+  J: TIndex;
+begin
+  I := Count;
+  J := ItemIndex;
+  Count := Count + ItemCount;
+  while I < Count do begin
+    Items[I] := List[J];
+    I := I + 1;
+    J := J + 1;
+  end;
+end;
+
 procedure TGList<TItem>.Clear;
 begin

Generics/NativeGenerics/Units/GenericStream.pas

@@ -24 +24 @@
     procedure Write(Item: TItem); virtual; abstract;
     procedure WriteArray(Item: array of TItem); virtual; abstract;
+    procedure WriteList(List: TGList<TItem>); virtual; abstract;
     function Read: TItem; virtual; abstract;
     function ReadArray(Count: TIndex): TItemArray; virtual; abstract;
@@ -35 +36 @@
   end;
 
+  TGMemoryStream<TItem> = class(TGStream<TItem>)
+  private
+    FList: TGList<TItem>;
+    FPosition: TIndex;
+  public
+    procedure Assign(Source: TGStream<TItem>); override;
+    procedure Write(Item: TItem); override;
+    procedure WriteArray(Values: array of TItem); override;
+    procedure WriteList(List: TGList<TItem>); override;
+    function Read: TItem; override;
+    function ReadArray(Count: TIndex): TItemArray; override;
+    function ReadList(List: TGList<TItem>; Count: TIndex): TIndex;
+    function Insert(Count: TIndex): Integer; override;
+    function Remove(Count: TIndex): Integer; override;
+    function Seek(Offset: TIndex; Origin: TSeekOrigin = soCurrent): TIndex; override;
+    constructor Create; override;
+    destructor Destroy; override;
+    property List: TGList<TItem> read FList;
+  end;
+
 
 implementation
 
+
+{ TGStream }
 
 procedure TGStream<TItem>.Assign(Source: TGStream<TItem>);
@@ -85 +108 @@
 end;
 
+{ TMemoryStreamByte }
+
+procedure TGMemoryStream<TItem>.Assign(Source: TGStream<TItem>);
+begin
+  inherited;
+  if Source is TGMemoryStream<TItem> then begin
+    FList.Assign(TGMemoryStream<TItem>(Source).FList);
+    FPosition := TGMemoryStream<TItem>(Source).FPosition;
+  end;
+end;
+
+procedure TGMemoryStream<TItem>.Write(Item: TItem);
+begin
+  if FList.Count < (FPosition + 1) then
+    FList.Count := FPosition + 1;
+  FList[FPosition] := Item;
+  Inc(FPosition);
+end;
+
+procedure TGMemoryStream<TItem>.WriteArray(Values: array of TItem);
+begin
+  if FList.Count < (FPosition + Length(Values)) then
+    FList.Count := FPosition + Length(Values);
+  FList.ReplaceArray(FPosition, Values);
+  Inc(FPosition, Length(Values));
+end;
+
+procedure TGMemoryStream<TItem>.WriteList(List: TGList<TItem>);
+begin
+  FList.ReplaceList(FPosition, List);
+end;
+
+function TGMemoryStream<TItem>.Read: TItem;
+begin
+  Result := FList[FPosition];
+  Inc(FPosition);
+end;
+
+function TGMemoryStream<TItem>.ReadArray(Count: TIndex): TItemArray;
+begin
+  Result := FList.GetArray(FPosition, Count);
+end;
+
+function TGMemoryStream<TItem>.ReadList(List: TGList<TItem>; Count: TIndex): TIndex;
+begin
+  if (FPosition + Count) > FList.Count then
+    Count := FList.Count - FPosition;
+  FList.GetList(List, FPosition, Count);
+  Result := Count;
+end;
+
+function TGMemoryStream<TItem>.Insert(Count: TIndex): TIndex;
+begin
+  FList.InsertCount(FPosition, Count);
+  Result := Count;
+end;
+
+function TGMemoryStream<TItem>.Remove(Count: TIndex): TIndex;
+begin
+  Result := FList.Count - FPosition;
+  if Count < Result then Result := Count;
+  FList.DeleteItems(FPosition, Count);
+end;
+
+function TGMemoryStream<TItem>.Seek(Offset: TIndex; Origin: TSeekOrigin): TIndex;
+begin
+  case Origin of
+    soBeginning: FPosition := Offset;
+    soCurrent: FPosition := FPosition + Offset;
+    soEnd: FPosition := FList.Count + Offset;
+  end;
+  if FPosition > FList.Count then FPosition := FList.Count;
+  if FPosition < 0 then FPosition := 0;
+  Result := FPosition;
+end;
+
+constructor TGMemoryStream<TItem>.Create;
+begin
+  inherited;
+  FList := TGList<TItem>.Create;
+end;
+
+destructor TGMemoryStream<TItem>.Destroy;
+begin
+  FList.Free;
+  inherited Destroy;
+end;
+
+
 end.