How to store records to stream and retrieve them

How to store records to stream and retrieve them later
------------------------------------------------------


{ Stores a record to stream. Record can later be retrieved with
  RecordFromStream procedure }

Procedure RecordToStream(DSet          : tdataSet;{ Datset in question }
                         Stream        : TStream; { Stream to store to }
                         PhysFieldsOnly: Boolean; { Do not store lookup and calculated fields }
                         FieldsNotStore: array of tField); { Additional fields that should not be stored }

    Function DoStoreFld(aFld: tField):Boolean;
{ Checks whether the field should be stored }
var i: Integer;
begin
      Result := not PhysFieldsOnly or (aFld.FieldNo > 0); { FieldNo of Lookup and calculated fields is <= 0 }
if Result then
      For i := 0 to High(FieldsNotStore) do
if aFld = FieldsNotStore[i] then begin
        Result := false;
break;
end;
end;

procedure WriteFldname(fldname: string);
var L: longint;
begin
      L := length(fldname);
      Stream.Write(L,sizeOf(L));
      Stream.Write(fldname[1],L);
end;

var I,Cnt,Len: Longint;
    Fld      : tField;
    FldBuff  : Pointer;
    BStream  : tBlobStream;
begin
  Cnt := DSet.FieldCount;
  Getmem(FldBuff,256);
  TRY
    For i := 1 to Cnt do begin
      Fld := DSet.Fields[i-1];
if not DoStoreFld(Fld) then Continue;
      WriteFldname(Fld.Fieldname);
if Fld is tBlobField then begin
        BStream := TBlobStream.Create(Fld as tBlobField, bmRead);
        TRY
          Len := BStream.Size;
          Stream.Write(len,SizeOf(Len));
if Len > 0 then Stream.CopyFrom(BStream,Len);
finally
          BStream.Free;
end;
end else begin
        Len := Fld.dataSize;
        Fld.Getdata(FldBuff);
        Stream.Write(Len,SizeOf(Len));
        Stream.Write(FldBuff^,Len);
      End;
end; { For }
    Len := 0;
    Stream.Write(Len,SizeOf(Len)); { mark the end of the stream with zero }
  FINALLY
    Freemem(FldBuff,256);
  End;
end;


{ Reads record from the stream. The record was previously stored with
  RecordToStream procedure. Dset must be in edit/insert mode }

Procedure RecordFromStream(DSet   : tdataSet; { Datset in question }
                           Stream : TStream;  { Stream to retrieve from }
                           FieldsToIgnore: array of tField); { Fields that should not be retrieved }

    Function DoReadFld(aFld: tField):Boolean;
var i: Integer;
begin
      Result := (aFld <> NIL) and (aFld.FieldNo > 0); { calculated and lookup fields are allways ignored }
if Result then
      For i := 0 to High(FieldsToIgnore) do
if aFld = FieldsToIgnore[i] then begin
        Result := false;
break;
end;
end;

function ReadFldname: string;
var L: longint;
begin
      Stream.Read(L,sizeOf(L));
if L = 0 then result := '' else begin
        SetLength(Result,L);
        Stream.Read(Result[1],L);
end;
end;

var Len    : Longint;
    Fld    : tField;
    Fldname: string;
    FldBuff: Pointer;
begin
  Getmem(FldBuff,256);  
  TRY
    Fldname := ReadFldname;
    While Fldname <> '' do begin
      Fld := DSet.FindField(Fldname);
      Stream.Read(Len,SizeOf(Len));
if (Len > 0) and DoReadFld(Fld) then begin
if Fld is tBlobField then begin
          With TBlobStream.Create(Fld as tBlobField, bmWrite) do Try;
            CopyFrom(Stream,Len);
finally
            Free;
end;
end else begin
if Fld.datasize <> Len then
raise Exception.CreateFmt('Field size changed: Field: %s',[Fldname]);
          Stream.Read(FldBuff^,Fld.dataSize);
          Fld.Setdata(FldBuff);
end;
end else if Len > 0 then Stream.Seek(Len, soFromCurrent);
      Fldname := ReadFldname;
end
  FINALLY
    Freemem(FldBuff,256);
  End;
end;