Ast Refactoring

Src/Data/Myc.Data.Scalar.JSON.pas

@@ -0,0 +1,153 @@
+unit Myc.Data.Scalar.JSON;
+
+interface
+
+uses
+    System.SysUtils,
+    System.Rtti,
+    System.TypInfo,
+    Myc.Data.Scalar;
+
+type
+    TRttiAstHelper = class
+    private
+        // Maps a Delphi RTTI type to its TScalarKind.
+        class function TypeToScalarKind(AType: TRttiType): TScalarKind; static;
+    public
+        // Creates a JSON definition string from a record type info.
+        class function RecordDefinitionToJson(ATypeInfo: PTypeInfo): string; static;
+        // Creates a record definition from a JSON string.
+        class function JsonToRecordDefinition(const AJson: string): TScalarRecordDefinition; static;
+    end;
+
+implementation
+
+uses
+    Myc.Data.Decimal,
+    System.Generics.Collections,
+    System.JSON;
+
+{ TRttiAstHelper }
+
+class function TRttiAstHelper.JsonToRecordDefinition(const AJson: string): TScalarRecordDefinition;
+var
+    jsonValue: TJSONValue;
+    rootObj: TJSONObject;
+    fieldsArray: TJSONArray;
+    i: Integer;
+    fieldObj: TJSONObject;
+    kindStr: string;
+    fields: TArray<TScalarRecordField>;
+begin
+    jsonValue := TJSONObject.ParseJSONValue(AJson);
+    if not Assigned(jsonValue) then
+        exit;
+
+    try
+        if not (jsonValue is TJSONObject) then
+            exit;
+
+        rootObj := jsonValue as TJSONObject;
+        if not rootObj.TryGetValue<TJSONArray>('fields', fieldsArray) then
+            exit;
+
+        SetLength(fields, fieldsArray.Count);
+        for i := 0 to fieldsArray.Count - 1 do
+        begin
+            fieldObj := fieldsArray.Items[i] as TJSONObject;
+            if not Assigned(fieldObj) then
+                continue; // or raise error
+
+            fields[i].Name := fieldObj.GetValue<string>('name');
+
+            kindStr := fieldObj.GetValue<string>('kind');
+            fields[i].Kind := TScalarKind(GetEnumValue(TypeInfo(TScalarKind), kindStr));
+        end;
+        Result := TScalarRecordDefinition.Create(fields);
+    finally
+        jsonValue.Free;
+    end;
+end;
+
+class function TRttiAstHelper.RecordDefinitionToJson(ATypeInfo: PTypeInfo): string;
+var
+    ctx: TRttiContext;
+    rttiType: TRttiType;
+    rttiRecordType: TRttiRecordType;
+    field: TRttiField;
+    rootObj: TJSONObject;
+    fieldsArray: TJSONArray;
+    fieldObj: TJSONObject;
+begin
+    // 1. Create TRttiContext and get TRttiRecordType.
+    ctx := TRttiContext.Create;
+    rttiType := ctx.GetType(ATypeInfo);
+
+    if not (rttiType is TRttiRecordType) then
+        raise EArgumentException.Create('PTypeInfo provided is not a record type.');
+
+    rttiRecordType := rttiType as TRttiRecordType;
+
+    // 2. Create root TJSONObject and a TJSONArray for 'fields'.
+    rootObj := TJSONObject.Create;
+    try
+        fieldsArray := TJSONArray.Create;
+        rootObj.AddPair('fields', fieldsArray);
+
+        // 3. Loop through all fields of the record type.
+        for field in rttiRecordType.GetFields do
+        begin
+            // 4a. Create a TJSONObject for the field definition.
+            fieldObj := TJSONObject.Create;
+
+            // 4b. Add field name.
+            fieldObj.AddPair('name', TJSONString.Create(field.Name));
+
+            // 4c. Call TypeToScalarKind to get the type and add it.
+            fieldObj.AddPair('kind', TJSONString.Create(GetEnumName(TypeInfo(TScalarKind), Ord(TypeToScalarKind(field.FieldType)))));
+
+            // 4d. Add the field object to the 'fields' array.
+            fieldsArray.Add(fieldObj);
+        end;
+
+        // 5. Convert the root JSON object to a string and set it as Result.
+        Result := rootObj.ToJSON;
+    finally
+        rootObj.Free;
+    end;
+end;
+
+class function TRttiAstHelper.TypeToScalarKind(AType: TRttiType): TScalarKind;
+var
+    typeHandle: PTypeInfo;
+begin
+    // 1. Use a case statement or if-checks on AType.Handle.
+    typeHandle := AType.Handle;
+
+    // 2. Compare with TypeInfo(Integer), TypeInfo(Double), TypeInfo(TDecimal) etc.
+    if typeHandle = TypeInfo(Integer) then
+        Result := skInteger
+    else if typeHandle = TypeInfo(Int64) then
+        Result := skInt64
+    else if typeHandle = TypeInfo(UInt64) then
+        Result := skUInt64
+    else if typeHandle = TypeInfo(Single) then
+        Result := skSingle
+    else if typeHandle = TypeInfo(Double) then
+        Result := skDouble
+    else if typeHandle = TypeInfo(TDateTime) then
+        Result := skDateTime
+    else if typeHandle = TypeInfo(Boolean) then
+        Result := skBoolean
+    else if typeHandle = TypeInfo(Char) then
+        Result := skChar
+    else if typeHandle = TypeInfo(TDecimal) then
+        Result := skDecimal
+    else if typeHandle = TypeInfo(TTimestamp) then
+        Result := skTimestamp
+    else
+        // 4. Raise an exception for unsupported types.
+        raise EArgumentException.CreateFmt('Unsupported record field type: %s', [AType.Name]);
+end;
+
+end.

Src/Data/Myc.Data.Scalar.pas

@@ -1,4 +1,4 @@
-unit Myc.Data.POD;
+unit Myc.Data.Scalar;
 
 interface
 
@@ -160,8 +160,6 @@ type
     end;
 
     TScalarMemberSeries = record
-    strict private
-        FKind: TScalarKind;
     private
         FDef: TScalarRecordDefinition;
         FArray: TChunkArray<TScalarValue>;