Nikolay Pavlov

Reading VARIANT from Stream - Delphi’s Way

In this post I described an efficient way to write a VARIANT to a stream in a binary format. Doing so will be of no use whatsoever if you cannot bring back a fully-fledged VARIANT from the stream.

Reading a VARIANT is analoguous to writing it, but there is an interesting points. You have to know how to set properly the type of the output variant. If the VARIANT is a single value, the right way to do it is to use VarCast function. If the VARIANT is an array, however, you should create it by using VarArrayCreate. Only after you set the type, you can assign the data.

Here comes the code:

function DeserializeVariant (Stream: TMemoryStream): variant;
var
  VariantType: word;
  TempVariant: variant;
 function Read1(var Buffer; Count: Longint): Longint;
 begin
   Result := Stream.Read (Buffer, Count);
   if Result <> Count then raise Exception.Create ('Invalid stream data!');
 end;
          
 procedure ReadSingleData (VariantType: word; out V: variant);
 var
   S: string; L: integer;
   PCh: PChar;
 begin
  VarCast (V, V, VariantType);
  case VariantType of
    varSmallint: Read1 (TVarData(V).VSmallint, SizeOf (Smallint));
    varInteger: Read1 (TVarData (V).VInteger, SizeOf (Integer));
    varSingle: Read1 (TVarData (V).VSingle, SizeOf (Single));
    varDouble: Read1 (TVarData (V).VDouble, SizeOf (Double));
    varCurrency: Read1 (TVarData (V).VCurrency, SizeOf (Currency));
    varDate: Read1 (TVarData (V).VDate, SizeOf (Double));
    varOleStr, varString: begin
      Read1 (L, SizeOf (integer));
      GetMem (PCh, L + 1);
      Read1 (PCh^, L);
      PCh[L] := #0;
      S := PChar(PCh);
      V := S;
      FreeMem (PCh, L + 1);
    end;
    varError: Read1 (TVarData (V).VError, SizeOf (Longint));
    varBoolean: Read1 (TVarData (V).VBoolean, SizeOf (Boolean));
    varByte: Read1 (TVarData (V).VByte, SizeOf (Byte));
  end;
 end;

procedure ReadArrayData (VariantType: word; out V: variant);
 var
   I: integer;
   Size: integer;
   Element: Variant;
   VarType: word;
   ElementSize: integer;
   ArrayDataSize: integer;
   PData: pointer;
 begin
   Read1 (Size, SizeOf (integer));
   V := VarArrayCreate ([0, Size - 1], VariantType and varTypeMask);
   if IsSimpleType (VariantType) then
   begin
     ElementSize := GetSimpleTypeSize (TVarData (V).VType);
     ArrayDataSize := Size * ElementSize;
     Stream.SetSize (Stream.Size + ArrayDataSize);
     PData := VarArrayLock (V);
     try
       Stream.Read (PData^, ArrayDataSize);
     finally
       VarArrayUnlock (V);
     end;
   end
   else
   for I := 0 to Size - 1 do begin
     Read1 (VarType, SizeOf (word));
     if VarType and varArray = 0 then ReadSingleData (VarType, Element)
     else ReadArrayData (VarType, Element);
     V[I] := Element;
   end;
 end;

begin
  Stream.Seek (0, soFromBeginning);
  Read1 (VariantType, SizeOf (word));
  if VariantType and varArray = 0 then begin
     VarCast (TempVariant, TempVariant, VariantType);
     ReadSingleData (VariantType and varTypeMask, TempVariant);
  end
  else ReadArrayData (VariantType and varTypeMask, TempVariant);
  Result := TempVariant;
end;

This entry was posted on Thursday, July 10th, 2008 at 11:40 am and is filed under Delphi, Win32. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.

11 Responses to “Reading VARIANT from Stream - Delphi’s Way”

HornPoertef Says:
August 3rd, 2008 at 3:08 am
Very nice!!
Serialização de Variants : Malta on Delphi Says:
August 13th, 2008 at 4:18 am
[…] tarde encontrei os posts de Nikolay Pavlov - nem acredito que encontrei um parente de Pavlov e ainda um que programa em Delphi! Nikolay estava […]
Alex Says:
August 17th, 2008 at 7:05 am
Your blog is interesting!

Keep up the good work!
Hans Says:
October 26th, 2008 at 6:53 pm
Thanx, for the sample, Nic. Which unit did you use for IsSimpleType() and GetSimpleTypeSize(0) ?
Nik Says:
October 27th, 2008 at 11:58 am
Hans,

These two functions are mine as well, but I forgot to provide the code for them. They don’t do anything much special, I use them as kind of C macros.

Here they are.

function IsSimpleType (VarType: word) : boolean;
begin
Result := (VarType and varTypeMask) in
[varByte, varSmallint, varInteger, varSingle, varDouble, varCurrency, varDate, varError, varBoolean];
end;

function GetSimpleTypeSize (VarType: word): integer;
begin
case VarType and varTypeMask of
varSmallint: Result := SizeOf (Smallint);
varInteger: Result := SizeOf (Integer);
varSingle: Result := SizeOf (Single);
varDouble: Result := SizeOf (Double);
varCurrency: Result := SizeOf (Currency);
varDate: Result := SizeOf (Double);
varError: Result := SizeOf (Longint);
varBoolean: Result := SizeOf (Boolean);
varByte: Result := SizeOf (Byte);
else
Result := -1;
end;
end;
Tim Lichtenberg Says:
March 24th, 2009 at 3:08 pm
the line
Stream.Seek (0, soFromBeginning);
is problematic. What if someone writes several variants into the same stream?
It should be up to the user to set the correct position in the stream.
Nik Says:
May 27th, 2009 at 2:19 pm
Tim, I agree. Thanks for pointing this out.

However, my goal was to show how to (de)serialize variants, and such details like position in the stream can be handled by developers themselves. That’s why I won’t edit the code in the post.
Christian Says:
October 26th, 2009 at 2:56 pm
Very nice code! Thanks for the great work.

However, when I try to deserialize a TFileStream, Delphi raises the exception EVariantTypeCastError: \’Could not convert variant of type (Empty) into type ($0996)\’. The file stream contains a TClientDataSet (that has been saved to a file).

How can I solve the problem?
Nik Says:
November 2nd, 2009 at 12:25 pm
Christian, I believe you misunderstood the purpose of the code. The sample above deserializes a variant, serialized by the the appropriate code of another post (see the link in the first sentence).
Christian Says:
November 13th, 2009 at 12:33 am
Nik, I’m sorry, I think I’ve got some things wrong in my original question. However, I am using your code (this post and the other one) to transmit stream data via variants. Now I want to do the following: I have a TClientDataset that has been created and saved to a file (by another application). In my code, on the server side, I read this TClientDataset into a file stream. When trying to convert this file stream to a variant to send it to the Client, I get the mentioned EVariantTypeCastError.
KATHRYNBROOKS Says:
July 14th, 2010 at 1:44 pm
I propose not to wait until you get enough money to buy goods! You should just take the credit loans or just collateral loan and feel fine

Reading VARIANT from Stream - Delphi’s Way

11 Responses to “Reading VARIANT from Stream - Delphi’s Way”

Leave a Reply

Archives

Categories