DataSeries.Copy

Src/Myc.Trade.Core.DataPoint.pas

@@ -8,13 +8,13 @@ uses
 type
     // The implementation class for IDataSeries<T>.
     TDataArray<T> = class(TInterfacedObject, IDataSeries<T>, IDataArray<T>)
-    private
         const
             ChunkSize = 1024;
         type
             TChunk = TArray<TDataPoint<T>>;
     private
         FChunks: TArray<TChunk>;
+            FChunks1: TArray<TChunk>;
         FCount: Int64;
         FMaxLookback: Int64;
         FTotalCount: Int64;
@@ -33,17 +33,47 @@ type
         procedure Add(const Data: TDataPoint<T>); overload;
         procedure Add(const Data: array of TDataPoint<T>; NumToAdd: Integer = -1); overload;
         procedure Clear;
+        function Copy: IDataSeries<T>;
         property MaxLookback: Int64 read GetMaxLookback;
     end;
 
-type
     // Null object implementation for IDataSeries<T>
     TNullDataSeries<T> = class(TInterfacedObject, IDataSeries<T>)
+    strict private
+    class var
+        FNull: IDataSeries<T>;
+    private
+        class constructor CreateClass;
     public
         function GetCount: Int64;
         function GetItems(Idx: Int64): TDataPoint<T>;
         function GetTotalCount: Int64;
         function IndexOf(TimeStamp: TDateTime): Int64;
+        function Copy: IDataSeries<T>;
+        class property Null: IDataSeries<T> read FNull;
+    end;
+
+    // The implementation class for IDataSeries<T>.
+    TStaticDataSeries<T> = class(TInterfacedObject, IDataSeries<T>)
+    private
+        FChunks: TArray<TDataArray<T>.TChunk>;
+        FCount: Int64;
+        FMaxLookback: Int64;
+        FTotalCount: Int64;
+
+        function LogicalToPhysicalIndex(LogicalIndex: Int64): Int64; inline;
+        function IsIndexInLimits(LogicalIndex: Int64): Boolean;
+
+        // IDataSeries<T> implementation
+        function GetCount: Int64;
+        function GetItems(Idx: Int64): TDataPoint<T>;
+        function GetMaxLookback: Int64;
+        function GetTotalCount: Int64;
+
+    public
+        constructor Create(const AChunks: TArray<TDataArray<T>.TChunk>; ACount, AMaxLookback, ATotalCount: Int64);
+        function Copy: IDataSeries<T>;
+        property MaxLookback: Int64 read GetMaxLookback;
     end;
 
 implementation
@@ -141,6 +171,11 @@ begin
     FTotalCount := 0;
 end;
 
+function TDataArray<T>.Copy: IDataSeries<T>;
+begin
+    Result := TStaticDataSeries<T>.Create( FChunks, FCount, FMaxLookback, FTotalCount );
+end;
+
 function TDataArray<T>.GetCount: Int64;
 begin
     Result := FCount;
@@ -197,11 +232,23 @@ begin
     if chunksToRemove > 0 then
     begin
         var itemsInFreedChunks := chunksToRemove * ChunkSize;
-        FChunks := Copy(FChunks, chunksToRemove, Length(FChunks) - chunksToRemove);
+        FChunks := System.Copy(FChunks, chunksToRemove, Length(FChunks) - chunksToRemove);
         FCount := FCount - itemsInFreedChunks;
     end;
 end;
 
+{ TNullDataSeries<T> Interface Helper }
+
+class constructor TNullDataSeries<T>.CreateClass;
+begin
+    FNull := TNullDataSeries<T>.Create;
+end;
+
+function TNullDataSeries<T>.Copy: IDataSeries<T>;
+begin
+    Result := FNull;
+end;
+
 function TNullDataSeries<T>.GetCount: Int64;
 begin
     Result := 0;
@@ -223,4 +270,57 @@ begin
     Result := -1;
 end;
 
+{ TStaticDataSeries<T> }
+
+constructor TStaticDataSeries<T>.Create(const AChunks: TArray<TDataArray<T>.TChunk>; ACount, AMaxLookback, ATotalCount: Int64);
+begin
+    inherited Create;
+    FChunks := AChunks;
+    FCount := ACount;
+    FMaxLookback := AMaxLookback;
+    FTotalCount := ATotalCount;
+end;
+
+function TStaticDataSeries<T>.Copy: IDataSeries<T>;
+begin
+    Result := Self;
+end;
+
+function TStaticDataSeries<T>.GetCount: Int64;
+begin
+    Result := FCount;
+    if (FMaxLookback > 0) and (Result > FMaxLookback) then
+        Result := FMaxLookback;
+end;
+
+function TStaticDataSeries<T>.GetItems(Idx: Int64): TDataPoint<T>;
+var
+    physicalIndex: Int64;
+begin
+    Assert(IsIndexInLimits(Idx), 'Index is outside of the configured Lookback limits.');
+    physicalIndex := LogicalToPhysicalIndex(Idx);
+    Result := FChunks[physicalIndex div TDataArray<T>.ChunkSize][physicalIndex mod TDataArray<T>.ChunkSize];
+end;
+
+function TStaticDataSeries<T>.GetMaxLookback: Int64;
+begin
+    Result := FMaxLookback;
+end;
+
+function TStaticDataSeries<T>.GetTotalCount: Int64;
+begin
+    Result := FTotalCount;
+end;
+
+function TStaticDataSeries<T>.IsIndexInLimits(LogicalIndex: Int64): Boolean;
+begin
+    Result := (FMaxLookback <= 0) or (LogicalIndex < FMaxLookback);
+end;
+
+function TStaticDataSeries<T>.LogicalToPhysicalIndex(LogicalIndex: Int64): Int64;
+begin
+    Assert((LogicalIndex >= 0) and (LogicalIndex < FCount), 'Logical index is out of bounds.');
+    Result := FCount - LogicalIndex - 1;
+end;
+
 end.