baum bestehend aus arrays abspeichern

[brutus]

moin, wie kann ich einen baum der aus arrays besteht in einer externen datei abspeichern?

Delphi-Quellcode:

type PKnot  = ^TKnot;
     TKnot  = record
                 A:array[1..11]of string;
                 S:array[1..11] of Pknot;
                 end;
     TListe  = class (Tobject)

[SirThornberry]

du musst dir ein format ausdenken und dann rekursiv deine Strukur durchgehen (dabei in einen buffer schreiben). Am Ende brauchst du nur noch den Buffer speichern

[brutus]

jo dass ist mir auch irgendwie klar bloss ich habe ebend das Problem, dass ich keine konkrete vorstellung vom format eines arrays eines baumes in einer datei habe (hab bis jetzt immer nur knoten mit genau einem inhaltswert abgespeichert aber ebend nicht ein gesamtes array)

[SirThornberry]

woher weiß man wieviel unterknoten dein array hat?

[brutus]

dass ist es ja dass weiß man nicht es wird vom benutzter festgelegt !!!

[SirThornberry]

du musst doch aber auch irgendwie im programm feststellen wieviel unterzweige belegt sind. Ansonsten kann man es ja nicht abspeichern wenn man nicht weiß wieviel PKnot in dem S belegt sind

[brutus]

kann man dass nicht über eine for schleife abfragen so in etwa wie

Delphi-Quellcode:

FOR i:= 1 TO 11 Do IF p.s[i]<>NIL THEN ...

???

[SirThornberry]

das ist ja das was ich wissen wollte. Also ermittelst du mit "p.s[i]<>NIL" wieviel unterelemente da sind.

[brutus]

müßte eigentlich so gehen wenn ich jetzt kein denkfehler habe (hab dass noch nicht ausprobiert)...
hast du jetzt irgendeinen vorschlag wie ich dass realiesieren kann?

<edit>jo dass geht so, bei anderen prozeduren geht das auch</edit>

[stoxx]

Zitat:

Zitat von brutus

müßte eigentlich so gehen wenn ich jetzt kein denkfehler habe (hab dass noch nicht ausprobiert)...
hast du jetzt irgendeinen vorschlag wie ich dass realiesieren kann?

<edit>jo dass geht so, bei anderen prozeduren geht das auch</edit>

gib doch jedem Knoten eine eindeutige Nummer. und speicher ab, welcher Knoten auf welche Nummer "zeigt"
Somit lässt sich doch der Baum wunderbar abspeichern.
Oder Du nimmst, wenn es nicht allzugroße Datenmengen sind, XML ..
Da kannst Du die Struktur gleich so abspeichern wie sie ist, ohne Dir gedanken beim wiederherstellen machen zu müssen, welcher Knoten wohin gehört ...

[SirThornberry]

Gibt es nur soviel Strings (A) wieviel Knoten es auch gibt (S)?

Hier die Speichern- und Laden-Procedure, allerdings ungetestet

Delphi-Quellcode:

procedure LoadKnotFromStream(AStream: TStream; AKnot: PKnot);
var LChilds, LCount, LInt: Integer;
begin
  AStream.Read(LChilds, SizeOf(LChilds));
  for LCount := 1 to 11 do
  begin
    if LCount <= LChilds then
    begin
      //Länge des Strings lesen
      AStream.Read(LInt, SizeOf(LInt));
      setlength(AKnot.A[LCount], LInt);
      //String aus Stream lesen
      AStream.Read(AKnot.A[LCount][1], LInt);
      //speicher für unterknoten anfordern
      new(AKnot.S[LCount]);
      LoadKnotFromStream(AStream, AKnot.S[LCount]);
    end else
      AKnot.S[LCount] := nil;
  end;
end;

procedure SaveKnotToStream(AStream: TStream; AKnot: PKnot);
var LChilds, LCount, LInt: Integer;
begin
  //ermitteln wieviel Chidls
  LChilds := 0;
  while (LChilds < 11) and (AKnot.S[LChilds + 1] <> nil) do
    inc(LChilds);
  //Anzahl der Childs in Stream speichern
  AStream.Write(LChilds, SizeOf(LChilds));
  //Childs durchgehen
  for LCount := 1 to LChilds do
  begin
    //Länge des Strings ermitteln
    LInt := Length(AKnot.A[LCount]);
    //Länge des Strings speichern
    AStream.Write(LInt, SizeOf(LInt));
    //String speichern
    AStream.Write(AKnot.A[LCount][1], LInt);
    //unterKnoten aufrufen
    SaveKnotToStream(AStream, AKnot.S[LChilds]);
  end;
end;

irgendwo wirst du ja einen RootKnoten vom Typ "TKnot" haben. Somit erfolgt der Aufruf so:

Delphi-Quellcode:

var LStream: TStream;
begin
  LStream := TMemoryStream.Create;
  SaveKnotToStream(LStream, PKnot(@YourRootKnot));
  LStream.SaveToFile('xyz.txt');
  LStream.Free;
end;

Laden funkioniert dann nach dem gleichen Prinzip.

[brutus]

nein es kann z.b. auch folgender maßen aufgebaut sein:

Knoten 1: besteht aus 4 strings und verweist 2 andere Knoten die aus 3 und 6 strings bestehen u.s.w.

[brutus]

DANKE ! ! ! ich werd es gleich mal ausprobieren !!!

[SirThornberry]

hmm, dann müsst ich bzw. eher du den source bissl abändern.
woher weißt du wieviel Stings benötigt werden (also abgespeicher werden müssen). Mit <> nil gehts ja diesmal nicht.

So hier mal abgeänderter Source um alle 11 Strings abzuspeichern (ungetestet)

Delphi-Quellcode:

procedure LoadKnotFromStream(AStream: TStream; AKnot: PKnot);
var LChilds, LCount, LInt: Integer;
begin
  for LCount := 1 to 11 do
  begin
    //Länge des Strings lesen
    AStream.Read(LInt, SizeOf(LInt));
    setlength(AKnot.A[LCount], LInt);
    //String aus Stream lesen
    AStream.Read(AKnot.A[LCount][1], LInt);
  end;

  AStream.Read(LChilds, SizeOf(LChilds));
  for LCount := 1 to 11 do
  begin
    if LCount <= LChilds then
    begin
      //speicher für unterknoten anfordern
      new(AKnot.S[LCount]);
      LoadKnotFromStream(AStream, AKnot.S[LCount]);
    end else
      AKnot.S[LCount] := nil;
  end;
end;

procedure SaveKnotToStream(AStream: TStream; AKnot: PKnot);
var LChilds, LCount, LInt: Integer;
begin
  for LCount := 1 to 11 do
  begin
    //Länge des Strings ermitteln
    LInt := Length(AKnot.A[LCount]);
    //Länge des Strings speichern
    AStream.Write(LInt, SizeOf(LInt));
    //String speichern
    AStream.Write(AKnot.A[LCount][1], LInt);
  end;

  //ermitteln wieviel Chidls
  LChilds := 0;
  while (LChilds < 11) and (AKnot.S[LChilds + 1] <> nil) do
    inc(LChilds);
  //Anzahl der Childs in Stream speichern
  AStream.Write(LChilds, SizeOf(LChilds));
  //Childs durchgehen
  for LCount := 1 to LChilds do
    SaveKnotToStream(AStream, AKnot.S[LChilds]);
end;

[brutus]

der benutzer gibt an (per radiobutton.activated) wieviel strings benötigt werden und wie sie gefüllt werden

[SirThornberry]

ok, hier schonmal die speichernprocedure

Delphi-Quellcode:

function LoadKnotFromFile(AFilename: String; AKnot: TKnot): Integer;
  procedure LLoadKnotFromStream(AStream: TStream; APKnot: PKnot; AStrCount: Integer);
  var LChilds, LCount, LInt: Integer;
  begin
    for LCount := 1 to AStrCount do
    begin
      //Länge des Strings lesen
      AStream.Read(LInt, SizeOf(LInt));
      setlength(APKnot.A[LCount], LInt);
      //String aus Stream lesen
      AStream.Read(APKnot.A[LCount][1], LInt);
    end;

    AStream.Read(LChilds, SizeOf(LChilds));
    for LCount := 1 to 11 do
    begin
      if LCount <= LChilds then
      begin
        //speicher für unterknoten anfordern
        new(APKnot.S[LCount]);
        LLoadKnotFromStream(AStream, APKnot.S[LCount], AStrCount);
      end else
        APKnot.S[LCount] := nil;
    end;
  end;
var LStream: TMemoryStream;
    LStrCount: Integer;
begin
  LStream := TMemoryStream.Create;
  LStream.LoadFromFile(AFilename);
  LStream.Read(LStrCount, SizeOf(LStrCount));
  LLoadKnotFromStream(LStream, @AKnot, LStrCount);
  LStream.Free;
  result := LStrCount;
end;

procedure SaveToFile(AFilename: String; AKnot: TKnot; AStrCount: Integer);
  procedure LSaveKnotToStream(AStream: TStream; APKnot: PKnot);
  var LChilds, LCount, LInt: Integer;
  begin
    for LCount := 1 to AStrCount do
    begin
      //Länge des Strings ermitteln
      LInt := Length(APKnot.A[LCount]);
      //Länge des Strings speichern
      AStream.Write(LInt, SizeOf(LInt));
      //String speichern
      AStream.Write(APKnot.A[LCount][1], LInt);
    end;

    //ermitteln wieviel Chidls
    LChilds := 0;
    while (LChilds < 11) and (APKnot.S[LChilds + 1] <> nil) do
      inc(LChilds);
    //Anzahl der Childs in Stream speichern
    AStream.Write(LChilds, SizeOf(LChilds));
    //Childs durchgehen
    for LCount := 1 to LChilds do
      LSaveKnotToStream(AStream, APKnot.S[LChilds]);
  end;
var LStream: TMemoryStream;
begin
  LStream := TMemoryStream.Create;
  LStream.Write(AStrCount, SizeOf(AStrCount));
  LSaveKnotToStream(LStream, @AKnot);
  LStream.SaveToFile(AFilename);
  LStream.Free;
end;