Pointer :\

[maximov]

Moin,

alle die mit streams dynamische formate schreiben und laden wollen kann ich nur die TFiler klassen (TReader und TWriter) ans herz legen. Die sind wirklich sehr leicht in der handhabung und bieten für alle gängigen stadardtypen entsprechende funktion. Somit muss man sich nicht mehr mit buffern und der länge der daten herrum schlagen und kann sehr schön sequenziell lesen und schreiben.

Hier ein beispiel zum streamen einer 2D map:

Delphi-Quellcode:

Function TMap.SaveToStream(stream: TStream):Boolean;
Var writer : TWriter;
    i      : integer;
begin
  result := true;
  writer := TWriter.Create(stream, $ff);
  try
    try
      writer.WriteSignature;
      writer.WriteListBegin;
      writer.WriteString(ClassName);
      WriteData(writer);
      writer.WriteListEnd;
    except
      result := false
    end;
  finally
    writer.Free;
  end;
end;

Function TMap.LoadFromStream(stream: TStream):Boolean;
Var reader : TReader;
    ctype  : TPersistentClass;
    cname  : string;
begin
  result := true;
  reader:=TReader.Create(stream,$FFFF);
  try
    with reader do begin
      {read at beginning of file}
      ReadSignature;
      ReadListBegin;
      cname := ReadString;
      ctype := GetClass(cname);
      if Assigned(ctype) then
      begin
        try
          ReadData(reader);
        except
          result := False;
        end;
      end;
      ReadListEnd;
    end;
  finally
    reader.Free;
  end;
end;

procedure TMap.ReadData(reader: TReader);
var x,y,size : integer;
begin
 size := sizeOf(TField);
 with reader do begin
       MapName           := ReadString;
       coment         := ReadString;
       Bounds.X       := ReadInteger;
       Bounds.Y       := ReadInteger;
       //-- Read matrix -----
       SetToBounds(bounds,false);
       for x := 0 to Bounds.X-1 do
         for y := 0 to Bounds.Y-1 do
           Read(matrix[x,y],size);
       //----------------------
       ReadString;
       style          := Readinteger;
       mode           := Readinteger;
       TimeLimit      := Readinteger;
       GUID           := ReadString;
       Creator        := ReadString;
       CreateDate     := ReadDate;
  end;
end;

procedure TMap.WriteData(writer: TWriter);
var x,y,size : integer;
begin
  size := sizeOf(TField);
  with writer do begin
     WriteString(MapName);
     WriteString(coment);
     WriteInteger(Bounds.X);
     WriteInteger(Bounds.Y);
     //-- Write matrix -----
     for x := 0 to Bounds.X-1 do
       for y := 0 to Bounds.Y-1 do
         Write(matrix[x,y],size);
     //----------------------
     WriteString('');
     Writeinteger(style);
     Writeinteger(mode);
     Writeinteger(TimeLimit);
     WriteString(GUID);
     WriteString(Creator);
     WriteDate(CreateDate);
  end;
end;

Nur so als anregung, da ihr grad über dynamische (oder auch nicht) formate redet. Was meint ihr?