Grundlegende Frage zur Strukturierung von Records und tList

[BoolString]

Besten Dank für die bisherigen Anregungen!

Ich habe mich gestern Abend einmal hingesetzt und versucht etwas entsprechendes aufzubauen. Dazu sind nun einzelne Klassen für unterschiedliche Datenobjekte entstanden. Nach der Anregung von Sirius habe ich eine ObjectList zur Hälterung der einzelnen Datenobjekte verwendet. Leider muss ich aber feststellen, daß meine Erfahrungen im Klassendesign mangelhaft sind und ich somit an einigen Punkten nicht weiterkomme. Hier ein Ausschnitt aus meinem Versuch, der die relevanten Teile beinhaltet:

Delphi-Quellcode:

Type
  tDataSetType = (seqString    = 0,
                  seqValueList = 1,
                  seqMatrix    = 2,
                  seqTable     = 3 );


  tDataTypeName      = String;
  tDataTypeString    = String;
  tDataTypeValueList = Array of Double;


  t2dVariantArrayDouble = Record
                            Title     : String;
                            RowTitles : Array of String;
                            ColTitles : Array of String;
                            Cells     : Array of Array of Double;
                          end;



  tDataObjectString = Class (tObject)
  Private
    fName : tDataTypeName;
    fData : tDataTypeString;
    Function CountDataChars : Longint;
  Public
    Property Name  : tDataTypeString read fName write fName;
    Property Data  : tDataTypeString read fData write fData;
    Property Count : Longint read CountDataChars;
  end;



  tDataObjectMatrix = Class (tObject)
  Private
    fName : tDataTypeName;
    fData : t2dVariantArrayDouble;
    Function CountDataRows : Longint;
    Function CountDataCols : Longint;
  Public
    Property Name : tDataTypeString read fName write fName;
    Property Data : t2dVariantArrayDouble read fData write fData;
    Property Rows : Longint read CountDataRows;
    Property Cols : Longint read CountDataCols;
  end;



  tDatasets = Class (tObject)
  Private
    fDatasetList : tObjectList;
  Public
    Constructor Create;
    Destructor  Destroy;
    Function    New (SequenceType : tDatasetType) : Integer;
    Function    Get (aIndex: Longint; Var aDataObject: tDataObjectString) : Boolean; overload;
    Function    Get (aIndex: Longint; Var aDataObject: tDataObjectValues) : Boolean; overload;
    Function    Get (aIndex: Longint; Var aDataObject: tDataObjectMatrix) : Boolean; overload;
  end;



Implementation
// --------------------------------- Datenobjekt tDataObjectString
Function tDataObjectString.CountDataChars : Longint;
begin
  Result := Length (fData);
end;


// --------------------------------- Datenobjekt tDataObjectMatrix

Function tDataObjectMatrix.CountDataRows : Longint;
Begin
  Result := High(fData.Cells) + 1;
end;

Function tDataObjectMatrix.CountDataCols : Longint;
Begin
  if CountDataRows > 0 THen Result := High(fData.Cells [0]) + 1
                       Else Result := 0;
end;


// --------------------------------- Liste der Datenobjekte
Constructor tDatasets.Create;
Begin
  Inherited Create;
  fDatasetList := tObjectList.Create;
  fDatasetList.OwnsObjects := True;
end;


Destructor tDatasets.Destroy;
Var aObject : Integer;
Begin
 For aObject := fDatasetList.Count - 1 downto 0 do
 Begin
   fDatasetList.Delete (aObject);
 end;

 Inherited Destroy;
end;


Function tDatasets.New (SequenceType : tDatasetType) : Integer;
Begin
  Try
    Case SequenceType of
      seqString    : fDatasetList.Add (tDataObjectString.Create);
      seqValueList : fDatasetList.Add (tDataObjectValues.Create);
      seqMatrix    : fDatasetList.Add (tDataObjectMatrix.Create);
    end;
    Result := fDatasetList.Count;
  Except
    Result := -1;
  end;
end;


Function tDatasets.Get (aIndex: Longint; Var aDataObject: tDataObjectString) : Boolean;
Begin
  Result := False;

  If (aIndex >=0) And (aIndex < fDatasetList.Count) THen
  Begin
    If (fDatasetList.Items [aIndex] is tDataObjectString) THen
    Begin
      aDataObject := (fDatasetList.Items [aIndex] as tDataObjectString);
      Result := True;
    end;
  end;
end;


Function tDatasets.Get (aIndex: Longint; Var aDataObject: tDataObjectMatrix) : Boolean;
Begin
  Result := False;

  If (aIndex >=0) And (aIndex < fDatasetList.Count) THen
  Begin
    If (fDatasetList.Items [aIndex] is tDataObjectMatrix) THen
    Begin
      aDataObject := (fDatasetList.Items [aIndex] as tDataObjectMatrix);
      Result := True;
    end;
  end;
end;

Somit kann ich auch schön Datensätze erzeugen und diese per Index in der Klasse tDatasets referenzieren. Da ich nun aber variante Arrays benötige, habe ich ein Problem mit dem Zugriff. Ich habe allerdings die Vermutung, daß die Probleme meinem derzeitigen Erfahrungsschatz zuzuordnen sind.

Delphi-Quellcode:

Var DatasetList : tDatasets;
    anObject    : tDataObjectMatrix;
  
Begin
  DatasetList := tDatasets.Create;
  DatasetList.New (seqMatrix);

  If DatasetList.Get (0, anObject) THen
  Begin
    anObject.Name       := 'Testobjekt';
    anObject.Data.Title := 'Darin enthaltene Matrix';             // Der linken Seite kann nichts zugewiesen werden
    SetLength ((anObject as tDataObjectMatrix).Data.Cells, 2, 2); // Konstantenobjekt kann nicht als Var-Parameter weitergegeben werden
  end;
end;

Wie müsste man die Klassen sauber aufbauen, damit ich mit den varianten Elementen arbeiten kann?

Auch wenn es natürlich viel Material ist und sich vielleicht nicht gerade als Einstiegstopic in ein neues Forum eignet, wäre ich über konkrete Tipps dankbar Es geht mir nicht darum, daß ich hier etwas fertiges haben möchte. Aber momentan wäre ein Schubser in die richtige Richtung sehr hilfreich. Bisher habe ich überwiegend nur fertige Klassen ein wenig erweitert. Ich denke, ich muss mich da jetzt tatsächlich endlich mal reinfummeln.

Liebe Grüße und besten Dank

Jan


PS: Falls der Hintergrund interessiert: ich würde gerne ein kleines Softwareprojekt aufbohren und um Berechnungen für numerische Daten erweitern;
Serolis-Projekt

[...]