1

I'm trying to invoke a COM object's method. The method (in OLEView) looks like this:-

    VARIANT_BOOL GetValues(
                    [out] rsValues** values, 
                    [in, optional] rsCategory* category, 
                    [in, optional] rsProcess* process);

The last two parameters are optional, and I want to 'omit' them from the call (Just passing NULL doesn't work).

My understanding is that all the COM wrappers generated by the Delphi/C++Builder type library importers will convert each passed parameter to a variant. But to pass an 'omitted' parameter I think I have to construct a special Variant like this. 

  varOpt.vt = VT_ERROR;
  varOpt.sCode = DISP_E_PARAMNOTFOUND;

This seems to mean I can't use any of the auto-generated generated component wrappers.

How (using C++Builder or Delphi - I should be able to convert Delphi to C++) can I call the method, and pass an 'omitted' variant?

Update

Here's how I tried to call the method, following the advice in David Heffernan's answer.

procedure TForm38.Wibble(obj : IrsObject);
var vals : IrsValues;
begin
  ps.GetValues(vals, emptyparam, emptyparam);

But this gives this error:

[DCC Error] E2010 Incompatible types: 'IrsCategory' and 'OleVariant'
[DCC Error] E2010 Incompatible types: 'IrsProcess' and 'OleVariant'

As I'm using the non "Disp" object, I believe I'm using early binding.

I'm trying to avoid posting a 45000 line foo_TLB.pas file, but here (I hope) are the relevant sections.

IrsCategory = interface;
IrsCategoryDisp = dispinterface;
IrsProcess = interface;
IrsProcessDisp = dispinterface;

// *********************************************************************//
// Interface: IrsObject
// Flags:     (4416) Dual OleAutomation Dispatchable
// GUID:      {861817F7-EA49-49D1-89FC-395BCA57E342}
// *********************************************************************//
  IrsObject = interface(IDispatch)
    ['{861817F7-EA49-49D1-89FC-395BCA57E342}']
    ...
    function GetValues(out values : IrsValue; 
                              const Category: IrsCategory; 
                              const Process: IrsProcess):): WordBool; safecall;
    ...
  end;


// *********************************************************************//
// Interface: IrsObjectDisp
// Flags:     (4416) Dual OleAutomation Dispatchable
// GUID:      {861817F7-EA49-49D1-89FC-395BCA57E342}
// *********************************************************************// 

IrsObjectDisp = dispinterface ... // basically the same, repeated
Improve this question

2 Answers 2

Reset to default
2

Heisenberg option 1

You are using an automation interface, perhaps with late bound COM, and the parameters are all variants.

Pass EmptyParam to these parameters. 

function EmptyParam: OleVariant;

Contains an OleVariant that represents an unused optional parameter on a dual interface.

EmptyParam can be used for Variants that represent optional parameters whose value is unassigned. This is useful when the code that marshals method calls requires a fixed number of parameters, even if some of them are optional.

When marshaling interface calls that include optional parameters, COM requires a value for those parameters even when they are not used. EmptyParam returns an OleVariant you can pass as that value to indicate that the parameter is not used.

Heisenberg option 2

You are using early bound COM and the parameters are interfaces.

Pass nil to these parameters to omit them. If the parameters are COM interfaces rather than variants, that is the only possible option you have. A COM interface variable must be either a valid interface, or nil.

Improve this answer
Sign up to request clarification or add additional context in comments.

9 Comments

Hi David. Updated question with code snippet, showing error when using 'emptyParam`. I'm obviously trying to invoke the method the 'wrong' way...
You said that the parameters were variants. Apparently you were mistaken. Hence the compilation error. You need to slow down a bit and work out what this function really is. Knowing the types of its parameters is a pre-requisite to calling it. The question needs a bit of work. You don't really have an OnShow handler with a parameter of that type, do you.
Also do bear in mind how difficult it will be for us to answer your questions if you cannot show us any of the types involved. Now your update tells us that you need to supply parameters of type IrsCategory and IrsProcess. Bearing in mind that we cannot know what those types are until you tell us, ask yourself what chance we have of giving you good help.
They're interface pointers. Are you saying COM doesn't support optional parameters that aren't Variants - I thought (looking at generated wrapper code) that all parameters were converted to an array of OleVariants prior to dispatch? (but, you're right about the OnShow handler ;-)
Until you are more precise about what is going on then I've no idea how to help you. I've no idea whether this is early bound or late bound COM. And if you won't tell me what the types are, how the function is declared, and so on, what more do you expect? Please fix the question and then I'm sure we can give you an answer.
|
1

According to MSDN specification for IDL, optional is only valid for parameters of type VARIANT or VARIANT*.

So a function definition in IDL with [in, optional] rsCategory* category, is ill-formed.

Supposing you have to use someone else's object with this signature, my advice would be to treat it as if it were [in], i.e. actually create the objects to pass into it (and release them afterwards).

You weren't clear on whether you are using early-binding or late-binding. Via C++Builder you can do both, if the interface is actually a dualinterface of course. (I don't use Delphi but presumably you can do both there too). In C++Builder the auto-generated late-binding wrappers appear to ignore optional when it is not a VARIANT; I suppose Delphi would be the same.

Late-binding works by passing a list of VARIANTs to the IDispatch::Invoke function, where each variant contains one argument. You could try manually calling Invoke for this function, bypassing the wrappers. (Look in the wrapper for the example code).

Like passing NULL with early binding; this might work if you're using the server in-process, where the server directly receives what you send it - presumably if they thought that using optional was correct here, then their server code will actually support it.

However if you are out-of-process, then you have to rely on marshaling of your parameters, and (I'm not sure about this) but I would expect that standard marshaling may not be able to cope with trying to omit this parameter.

Improve this answer

2 Comments

Thanks - the MSDN IDL link is interesting. But, see this: marc.info/?l=ms-atl&m=103430642431400&w=2 My suspicion is that optional non-variants do work, but the generated wrapper methods don't support them? In C++ I'm use late binding with the IfooDisp interfaces generated by the type library importer.
The point of specs is to say what's guaranteed to work... if you're relying on something outside the spec that appears to work now, be prepared for it to fail at some point in the future. Also, that post talks about "optional BSTR". It's unclear what he means by that. Probably he just passed an empty BSTR. (NULL is an empty BSTR). And there is no such thing as an "ATL control". And he doesn't say whether it's in-process or not. That post seems like an unreliable source of information to me.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.