TSeries + DataEndpoint

Src/Myc.Trade.DataArray.pas

@@ -6,7 +6,7 @@ type
     // A series is an array of values with the newest ite at index=0. Each series counts the total of added items since creation, but
     // it actually may contain less items, because the array size is limited by the lookback parameter, when adding items.
     // Series are immutable.
-    TMycDataArray<T> = record
+    TSeries<T> = record
     private
         const
             ChunkSize = 1024;
@@ -21,13 +21,14 @@ type
         function GetItems(Idx: Int64): T; inline;
     public
         constructor Create(const AChunks: TArray<TChunk>; ACount, ATotalCount: Int64);
+
+        class operator Initialize(out Dest: TSeries<T>);
         // Add a singe item
-        function Add(const Data: T; Lookback: Int64): TMycDataArray<T>; overload;
+        function Add(const Data: T; Lookback: Int64): TSeries<T>; overload;
         // Add a ranmge of items
-        function Add(const Data: array of T; First, Count, Lookback: Int64): TMycDataArray<T>; overload;
-        class function CreateEmpty: TMycDataArray<T>; static;
+        function Add(const Data: array of T; First, Count, Lookback: Int64): TSeries<T>; overload;
         // Helper to create a data array from a raw TArray.
-        class function CreateFromArray(const AData: TArray<T>; First, Count: Integer): TMycDataArray<T>; static;
+        class function CreateFromArray(const AData: TArray<T>; First, Count: Integer): TSeries<T>; static;
         property Count: Int64 read FCount;
         property TotalCount: Int64 read FTotalCount;
         property Items[Idx: Int64]: T read GetItems; default;
@@ -35,28 +36,22 @@ type
 
 implementation
 
-{ TMycDataArray<T> }
+{ TSeries<T> }
 
-constructor TMycDataArray<T>.Create(const AChunks: TArray<TChunk>; ACount, ATotalCount: Int64);
+constructor TSeries<T>.Create(const AChunks: TArray<TChunk>; ACount, ATotalCount: Int64);
 begin
     FChunks := AChunks;
     FCount := ACount;
     FTotalCount := ATotalCount;
 end;
 
-class function TMycDataArray<T>.CreateEmpty: TMycDataArray<T>;
-begin
-    Result.FChunks := nil;
-    Result.FCount := 0;
-end;
-
-class function TMycDataArray<T>.CreateFromArray(const AData: TArray<T>; First, Count: Integer): TMycDataArray<T>;
+class function TSeries<T>.CreateFromArray(const AData: TArray<T>; First, Count: Integer): TSeries<T>;
 begin
     // Use the Add method on an empty array to perform the chunking logic.
-    Result := CreateEmpty.Add(AData, First, Count, Count);
+    Result.Add(AData, First, Count, Count);
 end;
 
-function TMycDataArray<T>.Add(const Data: array of T; First, Count, Lookback: Int64): TMycDataArray<T>;
+function TSeries<T>.Add(const Data: array of T; First, Count, Lookback: Int64): TSeries<T>;
 var
     destPhysicalIdx, sourcePhysicalIdx: Int64;
     itemsToSkip: Int64;
@@ -103,15 +98,15 @@ begin
         end;
     end;
 
-    Result := TMycDataArray<T>.Create(newChunks, newCount, FTotalCount + Count);
+    Result := TSeries<T>.Create(newChunks, newCount, FTotalCount + Count);
 end;
 
-function TMycDataArray<T>.Add(const Data: T; Lookback: Int64): TMycDataArray<T>;
+function TSeries<T>.Add(const Data: T; Lookback: Int64): TSeries<T>;
 begin
     Result := Add([Data], 0, 1, Lookback);
 end;
 
-function TMycDataArray<T>.GetItems(Idx: Int64): T;
+function TSeries<T>.GetItems(Idx: Int64): T;
 var
     physicalIndex: Int64;
 begin
@@ -120,9 +115,15 @@ begin
     Result := FChunks[physicalIndex div ChunkSize][physicalIndex mod ChunkSize];
 end;
 
-function TMycDataArray<T>.LogicalToPhysicalIndex(LogicalIndex: Int64): Int64;
+function TSeries<T>.LogicalToPhysicalIndex(LogicalIndex: Int64): Int64;
 begin
     Result := FCount - LogicalIndex - 1;
 end;
 
+class operator TSeries<T>.Initialize(out Dest: TSeries<T>);
+begin
+    Dest.FCount := 0;
+    Dest.FTotalCount := 0;
+end;
+
 end.