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;