Refactoring DataFlow, 1st Generic Data records working

Src/Myc.Trade.DataPoint.pas

@@ -6,7 +6,8 @@ uses
     Myc.Signals,
     Myc.Mutable,
     Myc.Trade.Types,
-    Myc.Trade.DataArray;
+    Myc.Trade.DataArray,
+    Myc.DataRecord;
 
 type
     // A generic interface for components that process data of type T.
@@ -119,6 +120,24 @@ type
         class function CreateSequence<T>(Count: Integer; const Parent: TDataProvider<T>): TArray<TConverter<T, T>>; overload; static;
 
         class function Parallel<T>(Parent: TDataProvider<T>): TConverter<T, T>; static;
+
+        class function FieldToRecord<T>(const Layout: TDataRecord.TLayout; const Name: String): TConverter<T, TDataRecord>; static;
+        class function FieldOfRecord<T>(const Layout: TDataRecord.TLayout; const Name: String): TConverter<TDataRecord, T>; static;
+
+        type
+            TRecordMapping = record
+                Layout: TDataRecord.TLayout;
+                Fields: array of record
+                FromField, ToField: String
+                end;
+            end;
+
+        class function DataMapping(
+            const Inputs: TArray<TRecordMapping>;
+            const Output: TDataRecord.TLayout
+        ): TConverter<TArray<TDataRecord>, TDataRecord>; static;
+
+        class function Join<T>(const DataProviders: TArray<TDataProvider<T>>): TDataProvider<TArray<T>>; static;
     end;
 
 implementation
@@ -315,6 +334,69 @@ begin
     Result := TOhlcAggregation.Create(Timeframe);
 end;
 
+class function TConverter.DataMapping(
+    const Inputs: TArray<TRecordMapping>;
+    const Output: TDataRecord.TLayout
+): TConverter<TArray<TDataRecord>, TDataRecord>;
+var
+    Idxs: array of array of record
+    FromIdx, ToIdx: Integer
+    end;
+begin
+    SetLength(Idxs, Length(Inputs));
+    for var i := 0 to High(Idxs) do
+    begin
+        SetLength(Idxs[i], Length(Inputs[i].Fields));
+        for var j := 0 to High(Idxs[i]) do
+        begin
+            Idxs[i][j].FromIdx := Inputs[i].Layout.IndexOf(Inputs[i].Fields[j].FromField);
+            Idxs[i][j].ToIdx := Output.IndexOf(Inputs[i].Fields[j].ToField);
+        end;
+    end;
+
+    Result :=
+        TConverter<TArray<TDataRecord>, TDataRecord>.CreateGeneric(
+            function(const Inputs: TArray<TDataRecord>): TDataRecord
+            var
+                tmp: array[0..63] of Byte;
+            begin
+                Result := TDataRecord.CreateFrom(Output);
+                for var i := 0 to High(Idxs) do
+                begin
+                    for var j := 0 to High(Idxs[i]) do
+                    begin
+                        Inputs[i].GetValue(Idxs[i][j].FromIdx, tmp);
+                        Result.SetValue(Idxs[i][j].ToIdx, tmp);
+                    end;
+                end;
+            end
+        );
+end;
+
+class function TConverter.FieldOfRecord<T>(const Layout: TDataRecord.TLayout; const Name: String): TConverter<TDataRecord, T>;
+begin
+    var idx := Layout.IndexOf(Name);
+    Result := TConverter<TDataRecord, T>.CreateGeneric(function(const Value: TDataRecord): T begin Value.GetValue(idx, Result); end);
+end;
+
+class function TConverter.FieldToRecord<T>(const Layout: TDataRecord.TLayout; const Name: String): TConverter<T, TDataRecord>;
+begin
+    var idx := Layout.IndexOf(Name);
+    Result :=
+        TConverter<T, TDataRecord>.CreateGeneric(
+            function(const Value: T): TDataRecord
+            begin
+                Result := TDataRecord.CreateFrom(Layout);
+                Result.SetValue(idx, Value);
+            end
+        );
+end;
+
+class function TConverter.Join<T>(const DataProviders: TArray<TDataProvider<T>>): TDataProvider<TArray<T>>;
+begin
+    Result := TMycDataJoin<T>.Create(DataProviders);
+end;
+
 class function TConverter.Parallel<T>(Parent: TDataProvider<T>): TConverter<T, T>;
 begin
     Result := TMycParallelConverter<T>.Create;