Array mit verschiedenen Records

[Billa]

uppsss.. laufen denn die Fortran-Programme parallel weiter? In solchen Umgebungen gibt es i.d.R. noch mehr "Dinosaurier", deshalb könnte eine solche Routine mehrfach verwendet werden. In meinem Job haben wir es aus historischen Gründen mit dBase und Dataease-Dateien aus mehreren Projekten zu tun. (eigene und von Kunden) Also haben wir uns die Mühe EINMAL gemacht und einen Konverter nach SQL geschrieben. Der wird über Textdateien gesteuert. Das Ding taugte bisher für ca ein Dutzend Migrationsprojekte. Aber das scheint ein anderer Fall zu sein.

Wenn Du sowieso später neue Datenstrukturen entwickeln willst, lohnt sich der Aufwand vielleicht wirklich nicht. Ich ziehe es allerdings vor, im Klartext lesbare Steuerdateien zu verwenden, statt verschachtelte Klassen und Objekte. Nach spätestens einem halben Jahr taucht dann doch ein Fall auf, wo das ohne Zweifel elegante Konstrukt dann doch nicht mehr passt. Ich will Dich nicht überreden, aber Wiederverwendbarkeit ist ein n icht zu unterschätzender Kosten- und Zeitvorteil. Viel Erfolg jedenfalls. An dieser Stelle klinke ich mich aus. ...muß ja schließlich ein bißchen was arbeiten....

[Apollonius]

Was haltet ihr von einem array of pointer? Also ungefähr so:

Delphi-Quellcode:

type
TRec1=record //alter Record
//
end;
PRec1=^TRec1;
TRec2=record //neuer Record;
//
end;
PRec2=^TRec2;
var alteversion: boolean; Daten:array[0..9] of pointer;//Größe des Arrays natürlich beliebig
    groesse:integer; //abhängig von alteVersion auf sizeof(TRec1) oder sizeof(TRec2) gesetzt

//Jetzt erstmal alteVersion und Groesse richtig setzen. Dann für jedes Element von Daten mit getmem genau so viel Speicher allozieren, wie für den benutzten Record gebraucht wird. Beim auslesen dann in den entsprechenden Zeigertyp casten

for i:=0 to 9 do
  getmem(array[i],groesse)
//Jetzt einlesen
meinStream.read(array[i]^,groesse);

//Verwendung:
if alteVersion then
  begin
    PRec1(Daten[0])^ //Und irgendwas damit machen
  end
else
  begin
    PRec2(Daten[0])^ //Und irgendwas damit machen
  end;

//Am Ende natürlich freemem nicht vergessen

Ist natürlich relativ viel Code, da du oft alteVersion abfragen musst, aber du kannst dir ja Funktionen bauen, die das automatisieren.

[Scrutor]

so, ich hab mir nun was ganz anderes einfallen lassen, was meiner meinung nach auch am einfachsten ist.

ich habe nun 6 verschiedene records, also für jeden Datumsfall ein extra record.

nur jetzt steh ich wieder auf dem schlauch, wie kann ich die denn jetzt zuordnen ?

Delphi-Quellcode:

...
var
  Data0:TDaten_0;
  Data1:TDaten_1;
  Data2:TDaten_2;
  Data3:TDaten_3;
  Data4:TDaten_4;
  Data5:TDaten_5;

...

  Format:=0;
  CreateDate:=StrToDate(FormatDateTime('dd.mm.yy',GetFileModifyDate(Fread)));
  if CreateDate<StrTodate('22.01.04') then Format:=1;
  if CreateDate<StrTodate('23.07.03') then Format:=2;
  if CreateDate<StrTodate('21.02.02') then Format:=3;
  if CreateDate<StrTodate('27.04.01') then Format:=4;
  if CreateDate<StrTodate('31.10.00') then Format:=5;
  case Format of  //format wählen
    0: begin
         //benutze "Data0" record
         DataArray[0]:=Data0;
         groesse[0]:=Sizeof(TDaten_0);
       end;
    1: begin
         //benutze "Data1" record
       end
    else
     begin
       ShowMessage('Format wird noch nicht unterstützt.');
       exit;
     end;
  end;

  fStream:=TMemoryStream.Create;
  try
    fStream.LoadFromFile(Fread);

    fStream.ReadBuffer(DataArray[0],sizeof(groesse[0]));
    {fStream.ReadBuffer(DataZ2,SizeOf(DataZ2));
    fStream.ReadBuffer(DataZ3,SizeOf(DataZ3));
    fStream.ReadBuffer(DataZ4,SizeOf(DataZ4));}

      //  fStream.ReadBuffer(DataZ5,SizeOf(DataZ5));
  finally
    fStream.Free;
  end;
 
  EditIdVor.Text:=trim(DataArray[0].IdVorr);

[Scrutor]

es ist zum verzweifeln, ich komme einfach nicht weiter.

ist es vielleicht möglich eine Variable dynamisch zuzuordnen ?

also beispielsweise im Prinzip so:

Delphi-Quellcode:

var
   Data : ???;
begin
  case Format of
   0: Data:=TDaten_0;
   1: Data:=TDaten_1;
  end;
end;

ich weiss einfach nicht wie ich das machen soll


mfg
Scrutor

[sirius]

Ja, du kannst es dynamisch zuordnen. Da musst du den Speicher selbst verwalten.

Prinzip:

Delphi-Quellcode:

type TDaten1=record
...

var typ:array of byte;
    DatenArray:Array of pointer;


procedure readversion1(const Stream:Tstream;pos:integer);
var Daten1:^TDaten1;
begin
  new(Daten1) //Speicher reservieren
  stream.read(Daten1^,sizeof(TDaten1);
  
  Datenarray[pos]:=Daten1;
  typ[pos]:=1; //du musst dir ja merken, an welcher Stelle du welchen Typ von record hast
end;

procedure readversion2.....

//zugriff
  Daten1:=Datenarray[pos];
  showmessage(Daten1^.xyz);




//am Ende speicher mit dispose freigeben
  case typ[pos] of
    1: begin 
         Daten1:=Datenarray[pos];
         dispose(Daten1);
...

Anmerkung du kannst dir auch gleich einen Typ machen


So, ich muss erstmal los....

[Scrutor]

danke sirius,

aber irgendwie versteh ich nicht so ganz was du da machst bzw. vorhast.

wieso "procedure readversion2....."

blick da nicht so durch .



mfg
Scrutor

[hoika]

Hallo,

ich denke, du gehst falsch heran.
Das einfachste ist doch, wenn du die alten Daten in das neue Format konvertierst
und dann nur mit dem neuen arbeitest.

Ausnahme: Das alte Fortran-Programm läuft immer noch.

In diesem Fall würde ich auf jeden Fall auf Klassen umsteigen.
Trenne das Lesen der Daten von deinen internen Datenstrukturen.

Delphi-Quellcode:

type
  TDataItem = class
    public
      iVersion   : Integer; // 1-6 ?
      sProjectNo : String;
  end;

Zum Lesen benutzt du deine Records,
schreibst die Daten aber dann in das TDataItem rein

Jetzt gibt es nur noch einen Unterschied beim Lesen und Schreiben.
In deinem Code benutzt du nur das TDataItem.


Heiko

[Scrutor]

Hallo hoika,

also das alte Fortran-Programm ist natürlich noch im Dienst und soll auch vorerst parallel weiterlaufen können,
deswegen mach ich mir ja diese Arbeit.

Mit den Klassen hab ich das noch nicht geschnallt. Bin erstmal grad nun noch dran mit Pointern zu arbeiten.

es muss doch irgendwie auch so gehen



mfg
Scrutor

[Apollonius]

Ich und Sirius meinten prinzipiell das selbe. Die unterschiedlichen Readversions bei Sirius gibt es, damit du in einem Fall readversion1 aufrufst und im anderen Fall readversion2. Sirius kapselt das, was ich mittendrin gemacht habe. Du machst also von deiner Version abhängig, welche Funktion du aufrufst.

[Scrutor]

ich bekomme aber nichts von alledem an meinem beispiel zum laufen.

weder deinen ansatz noch den von sirius.

entweder klappt das nicht, oder ich hab einfach nur irgendwo nen denkfehler