Complicated SWIG polymorphic return
A simpler solution
////////////////////////////////////////////////////////////////////////////////
// TODO: make this macro compatible with .NET Compact Framework, in which you
// can't return a structure over PInvoke.
//
// There is a problem in case you want to wrap a function that returns a pointer
// to a base class in SWIG, if that base class could refer to some derived
// class. For example suppose these classes are defined:
// class Actor { virtual ~Actor(); ... };
// class HumanActor : public Actor { ... };
// class RobotActor : public Actor { ... };
// class DogActor : public Actor { ... };
//
// And there is this function that could return any of the above:
// Actor* GetActor() { ... }
//
// The problem is that on the C# side, GetActor() will always return a new
// base class object (Actor), instead of the derived class (such as HumanActor).
// There is no easy way to deal with this, but I've written a macro that can
// help if you really need it. To use it, first, invoke the macro:
//
// %cs_return_derived_proxy_by_code(Actor, ActorOrDerivedClass, 0)
//
// The second name is a special typedef name that tells SWIG when to use the
// macro's special behavior. In order to make the macro apply to GetActor(),
// change the function declaration to this:
//
// typedef Actor ActorOrDerivedClass;
// ActorOrDerivedClass* GetActor() { ... }
//
// Next, you have to write a global function that obtains a code that will
// be put in a "SwigPtrAndTypeCode" structure to represent the derived type:
//
// %{
// int GetSwigTypeCode(Actor* a)
// {
// if (dynamic_cast<HumanActor*>(a) != NULL) return 1;
// if (dynamic_cast<RobotActor*>(a) != NULL) return 2;
// if (dynamic_cast<DogActor*> (a) != NULL) return 3;
// return 0;
// }
// %}
//
// Now, when you call GetActor() from C#, the C-side wrapper will return
// SwigPtrAndTypeCode, a special 8-byte structure, instead of Actor*.
// SwigPtrAndTypeCode contains the pointer to the Actor together with the
// type code returned from your function.
//
// Finally, the C# side will call a function that you must write called
// NewActorProxy() inside the P/Invoke class. Define it by inserting something
// like the following into your main .i file:
//
// %pragma(csharp) imclasscode=%{
// internal static Actor NewActorProxy(SwigPtrAndTypeCode p, bool memoryOwn)
// {
// switch(p.TypeCode) {
// case 1: return new HumanActor(p.Ptr, memoryOwn);
// case 2: return new RobotActor(p.Ptr, memoryOwn);
// case 3: return new DogActor(p.Ptr, memoryOwn);
// default: return new Actor(p.Ptr, memoryOwn);
// }
// }
// %}
//
// The third argument is an integer flag saying whether the object is reference-
// counted via %counted_obj. If you use %counted_obj for this type, then set
// IsCountedObj=1. They both change csout, so they are not compatible without this
// little hack.
//
// Note: this macro assumes IntPtr is used instead of HandleRef, but it only
// makes a difference if BaseClassPtrType is used as an input argument type.
//
// Finally, sometimes you may want to return more information to C++ than just
// a type code. In that case you use your own structure in place of struct
// SwigPtrAndTypeCode, and use %cs_return_derived_proxy_by_code2() to specify
// two extra arguments: the name of your structure on the C++ side, then the
// name of the structure on the C# side. Use SwigPtrAndTypeCode as an example.
%define %cs_return_derived_proxy_by_code(BaseClass, BaseClassPtrType, IsCountedObj)
%cs_return_derived_proxy_by_code2(BaseClass, BaseClassPtrType, IsCountedObj, SwigPtrAndTypeCode, $imclassname.SwigPtrAndTypeCode)
%enddef
%define %cs_return_derived_proxy_by_code2(BaseClass, BaseClassPtrType, IsCountedObj, CppPtrAndTypeCode, CsPtrAndTypeCode)
typedef BaseClass BaseClassPtrType;
%typemap(ctype, fragment="CppPtrAndTypeCode", out="CppPtrAndTypeCode") BaseClassPtrType* %{ BaseClassPtrType* %}
%typemap(in) BaseClassPtrType* %{ $1 = (BaseClassPtrType*)$input; %}
%typemap(varin) BaseClassPtrType* %{ $1 = (BaseClassPtrType*)$input; %}
//%typemap(memberin) BaseClassPtrType* %{ $1 = (BaseClassPtrType*)$input; %}
%typemap(imtype, out="CsPtrAndTypeCode") BaseClassPtrType* "IntPtr"
%typemap(cstype) BaseClassPtrType* "$csclassname"
%typemap(csin) BaseClassPtrType* "$csclassname.getCPtr($csinput)"
%typemap(csout, excode=SWIGEXCODE) BaseClassPtrType* {
CsPtrAndTypeCode p = $imcall;$excode
#if IsCountedObj
return $imclassname.New ## %mangle(BaseClass) ## Proxy(p, true);
#else
return $imclassname.New ## %mangle(BaseClass) ## Proxy(p, $owner);
#endif
}
%enddef
// REAL LIFE EXAMPLE (redacted for simplicity)
// Allow Element* to be returned using the correct proxy class.
// Not Compact Framework compatible.
%cs_return_derived_proxy_by_code2(Element, ElementOrDerived, 1, ElementPtrEtc, $imclassname.ElementPtrEtc)
%fragment("ElementPtrEtc","header") {
struct ElementPtrEtc
{
ElementPtrEtc() {}
ElementPtrEtc(Element* p) { *this = p; }
void* ptr;
ElemType elemType;
void operator= (Element* p) {
ptr = p;
if (p) {
try {
elemType = (ElemType)p->Type();
} catch(...) {}
}
}
};
}
%pragma(csharp) imclasscode=%{
// Used by %cs_return_derived_proxy
[StructLayout(LayoutKind.Sequential)]
internal struct ElementPtrEtc {
public IntPtr Ptr;
public ElemType ElemType;
}
%}
%pragma(csharp) imclasscode=%{
// Name comes from New ## %mangle(Element) ## Proxy
internal static Element NewElementProxy(ElementPtrEtc p, bool memoryOwn)
{
Element e;
switch((ElemType)p.ElemType) {
case ElemType.ITSC: e = new ItscElem(p.Ptr, memoryOwn); break;
case ElemType.NAMEDPOINT: e = new NamedPoint(p.Ptr, memoryOwn); break;
case ElemType.NAMEDLINE: e = new NamedLine(p.Ptr, memoryOwn); break;
case ElemType.NAMEDPOLYGON: e = new NamedPolygon(p.Ptr, memoryOwn); break;
default: e = new Element(p.Ptr, memoryOwn); break;
}
return e;
}
%}
posted by Qwertie @ 10:08 AM
0 comments
