Invalid Variant Operation Trying to Access OleVariant

So, do you mean create a type with a record structure that matches how "structVTIQSnap = packed record" is defined and then try to cast the OleVariant as that new type?

Well, I've only ever used simple (intrinsic) types in parameter variants and olevariants. I don't see how the code in the function HandleVTIQuoteSnap can know to automatically typecast the incoming olevariant to a structVTIQSnap.

If it wasn't an OleVariant, you would get a compile error on this line (instead of a runtime exception):

    symbol := structQSnap.bstrSymbol; // this line causes the exception

If TForm1 can reference the TLB in its uses clause, and if the "structVTIQSnap" is in the interface section of the TLB, then you shouldn't need to redeclare the structure.

Otherwise, yes, declare the structure locally. Either way, as long as the function itself can know what a structVTIQSnap is, the following line might work:

    symbol := (structQSnap as structVTIQSnap).bstrSymbol;

I have doubts about this, but this is all I've got.  :(  Good luck.

Hmm.  Just tried that and get: [DCC Error] Main.pas(296): E2015 Operator not applicable to this operand type.

Any ideas?  Thanks.

No, sorry I couldn't help.

just an idea :

type
  structVTIQSnap = packed record
     bstrSymbol: WideString;
     // other stuff...
  end;
 
procedure TForm1.HandleVTIQuoteSnap(ASender: TObject; var structQSnap: OleVariant);
var
  symbol: WideString;
  Temp: structVTIQSnap;
begin
  Temp := structQSnap;
  symbol := temp.bstrSymbol;
end;

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

That gives an error "Incompatible Types: structVTIQSnap and OleVariant.

guess that won't work either, sowwy

I never understood Borland's half implementation of structures in COM...  eg you can define them in the type library editor, but there is no IRecordInfo support in the varaint routines.

So, the problem is this: using Ole automation (IDispatch based), you cannot pass structures as direct params; they must be handled as IRecordInfo interfaces. What you have (I believe) in the OleVariant parameter is actually a variant holding the record data and IRecordInfo interface. To start off with, add the following declarations in your source code (in the form unit, below the form declaration is fine).

---

////////////////////////////////////////////////////////////////////////////////
//   Record type identifier
////////////////////////////////////////////////////////////////////////////////
const
  VT_RECORD               =  36;

////////////////////////////////////////////////////////////////////////////////
//   IRecordInfo UUID
////////////////////////////////////////////////////////////////////////////////
const
  IID_IRecordInfo:        TGUID = '{0000002F-0000-0000-C000-000000000046}';

////////////////////////////////////////////////////////////////////////////////
//   IRecordInfo interface
////////////////////////////////////////////////////////////////////////////////
type
  IRecordInfo             =  interface(IUnknown)
     ['{0000002F-0000-0000-C000-000000000046}']
     function RecordInit(out pvNew): HResult; stdcall;
     function RecordClear(pvExisting: Pointer): HResult; stdcall;
     function RecordCopy(pvExisting: Pointer; out pvNew: Pointer): HResult; stdcall;
     function GetGuid(out pGuid: TGUID): HResult; stdcall;
     function GetName(out pbstrName: POleStr): HResult; stdcall;
     function GetSize(out pcbSize: ULONG): HResult; stdcall;
     function GetTypeInfo(out ppTypeInfo: ITypeInfo): HResult; stdcall;
     function GetField(pvData: Pointer; szFieldName: POleStr; out pvarField: TVariantArg): HResult; stdcall;
     function GetFieldNoCopy(pvData: Pointer; szFieldNamd: POleStr; out pvarField: TVariantArg; out ppvData: Pointer): HResult; stdcall;
     function PutField(wFlags: ULONG; pvData: Pointer; szFieldName: POleStr; pvarField: PVariantArg): HResult; stdcall;
     function PutFieldNoCopy(wFlags: ULONG; pvData: Pointer; szFieldName: POleStr; pvarField: TVariantArg): HResult; stdcall;
     function GetFieldNames(var pcNames: ULONG; rgBstrNames: Pointer): HResult; stdcall;
     function IsMatchingType(pRecordInfo: IRecordInfo): HResult; stdcall;
     function RecordCreate: Pointer; stdcall;
     function RecordCreateCopy(pvSource: Pointer; out ppvDest: Pointer): HResult; stdcall;
     function RecordDestroy(pvRecord: Pointer): HResult; stdcall;
  end;

////////////////////////////////////////////////////////////////////////////////
//   RecordInfo structure
////////////////////////////////////////////////////////////////////////////////
type
  PRecordInfo             =  ^TRecordInfo;
  TRecordInfo             =  packed record
     lpRecord:            Pointer;
     pvRecInfo:           IRecordInfo;
  end;

---

Next, add the following support routines:

---

////////////////////////////////////////////////////////////////////////////////
//   Helper functions
////////////////////////////////////////////////////////////////////////////////
function   OleIsRecordType(V: OleVariant): Boolean;
function   OleGetRecord(V: OleVariant; out RecordInfo: TRecordInfo): HResult;
procedure  OleCleanupRecord(var RecordInfo: TRecordInfo);
function   OleGetRecordField(RecordInfo: TRecordInfo; FieldName: String; out Value: OleVariant): HResult;

---

The implementation for these routines is as follows:

---

function OleIsRecordType(V: OleVariant): Boolean;
var  lpVar:      PVariantArg;
begin

  // Cast as pointer to variant arg
  lpVar:=PVariantArg(@V);

  // Resource protection
  try
     // Check for by ref variant type
     if (lpVar^.vt = (VT_VARIANT or VT_BYREF)) then
     begin
        // Get byref variant pointer
        lpVar:=PVariantArg(lpVar.pvarVal);
     end;
  finally
     // Check for VT_RECORD type
     result:=(lpVar^.vt = VT_RECORD) or (lpVar^.vt = (VT_RECORD or VT_BYREF));
  end;

end;

function OleGetRecord(V: OleVariant; out RecordInfo: TRecordInfo): HResult;
var  lpVar:      PVariantArg;
     lpRecord:   PRecordInfo;
begin

  // Clear pointer
  lpRecord:=nil;

  // Resource protection
  try
     // Cast as pointer to variant arg
     lpVar:=PVariantArg(@V);
     // Check vt type
     case lpVar^.vt of
        // Straight record
        VT_RECORD   :  lpRecord:=PRecordInfo(@lpVar^.bVal);
        // ByRef record
        VT_VARIANT or
        VT_BYREF    :
        begin
           // Get byref variant pointer
           lpVar:=PVariantArg(lpVar.pvarVal);
           // Byref is no longer an option at this level
           if (lpVar.vt = VT_RECORD) then
           begin
              // Get the record
              lpRecord:=PRecordInfo(@lpVar^.bVal);
           end;
        end;
        VT_RECORD or
        VT_BYREF  :
        begin
           // Get pointer to the record struture
           lpRecord:=lpVar.byRef;
        end;
     else
        // Not a record type
        lpRecord:=nil;
     end;
     // Set result record
     if Assigned(lpRecord) then
     begin
        // We need to make sure the ref count is updated
        RecordInfo.pvRecInfo:=lpRecord^.pvRecInfo;
        // Create record pointer copy
        RecordInfo.pvRecInfo.RecordCreateCopy(lpRecord^.lpRecord, RecordInfo.lpRecord);
     end;
  finally
     // Check record pointer
     if Assigned(lpRecord) then
        // Success
        result:=S_OK
     else
        // Return failure
        result:=E_NOINTERFACE;
  end;

end;

function OleGetRecordField(RecordInfo: TRecordInfo; FieldName: String; out Value: OleVariant): HResult;
var  lpwszField:    PWideChar;
begin

  // Init the outbound param
  Value:=Unassigned;

  // Check record structure to ensure we have the interface and pointer to the data
  if (Assigned(RecordInfo.lpRecord) and Assigned(RecordInfo.pvRecInfo)) then
  begin
     // Convert string to wide char
     lpwszField:=StringToOleStr(FieldName);
     // Resource protection
     try
        // Attempt to get the field value
        result:=RecordInfo.pvRecInfo.GetField(RecordInfo.lpRecord, lpwszField, TVariantArg(Value));
     finally
        // Free the allocated string
        SysFreeString(lpwszField);
     end;
  end
  else
     // No pointer / interface
     result:=E_NOINTERFACE;

end;

procedure OleCleanupRecord(var RecordInfo: TRecordInfo);
begin

  // Resource protection
  try
     // Check the interface pointer
     if Assigned(RecordInfo.pvRecInfo) then
     begin
        // Check data pointer
        if Assigned(RecordInfo.lpRecord) then
        begin
           // Destroy our copy of the record
           RecordInfo.pvRecInfo.RecordDestroy(RecordInfo.lpRecord);
        end;
     end;
  finally
     // Release interface
     RecordInfo.pvRecInfo:=nil;
     // Clear data pointer
     RecordInfo.lpRecord:=nil;
  end;

end;

---

The next thing that you want to do is test your structQSnap parameter to ensure that is is indeed holding a recordinfo interface. This can be done with the following check:

---

procedure TForm1.HandleVTIQuoteSnap(ASender: TObject; var structQSnap: OleVariant);
begin

  // Determine if record type
  if OleIsRecordType(structQSnap) then
  begin
     ... // Ok to proceed...
 
---

If the check comes back as true, then continue oniwards with the code below. Otherwise, I have NO idea what the data is being passed as.

To extract the field information from the interface (and record data pointer), you need to extract the interface and record data, and create a new copy of the record data This is done for you in the OleGetRecord routine. You can then use the OleGetRecordField to extract the desired field data from the record. When done, make sure you cleanup the interface pointer and record data by using the OleCleanupRecord.

--- eg ---

procedure TForm1.HandleVTIQuoteSnap(ASender: TObject; var structQSnap: OleVariant);
var  ovSymbol:   OleVariant;
     recInfo:    TRecordInfo;
     szSymbol:   String;
begin

  // Determine if record type
  if OleIsRecordType(structQSnap) then
  begin
     // Get record data
     if (OleGetRecord(structQSnap, recInfo) = S_OK) then
     begin
        // Resource protection
        try
           // Get desired field
           if (OleGetRecordField(recInfo, 'bstrSymbol', ovSymbol) = S_OK) then
           begin
              // Get as string
              szSymbol:=ovSymbol;
              // Display field value
              ShowMessage(szSymbol);
           end;
        finally
           // Cleanup record
           OleCleanupRecord(recInfo);
        end;
     end;
  end;

end;

---

Please note that this was compiled and tested on Delphi 5 with a sample AX object that returned a record structure in an ole variant. Let me know if you have problems compiling, or with any of the PVariantArg casts.

Hope this helps,
Russell

@rllibby

if OleIsRecordType(structQSnap) then

The above line causes an exception: "Invalid Variant Type"

Its Delphi that is throwing the exception.... most likely in the conversion of the byref (var) to the actual OleVariant. Do me a favor and check the .vt type directly using the following code:

procedure TForm1.HandleVTIQuoteSnap(ASender: TObject; var structQSnap: OleVariant);
var  ovSymbol:   OleVariant;
     recInfo:    TRecordInfo;
     szSymbol:   String;
begin

      ShowMessage(IntToStr(PVariantArg(@structQSnap)^.vt));

Let me know what the integral value is

---

Russell