I'm having some trouble seeing what
the best way to wrap a series of classes with Boost.Python while avoiding messy inheritance problems. Say I have
the classes A, B, and C with
the following structure:
struct A {
virtual void foo();
virtual void bar();
virtual void baz();
};
struct B : public A {
virtual void quux();
};
struct C : public A {
virtual void foobar();
};
I want to wrap all classes A, B, and C such that they are extendable from Python.
The normal method for accomplishing this would be along
the lines of:
struct A_Wrapper : public A, boost::python::wrapper<A> {
//dispatch logic for virtual functions
};
Now for classes B and C which extend from A I would like to be able to inherit and share
the wrapping implementation for A. So I'd like to be able to do something along
the lines of:
struct B_Wrapper : public B, public A_Wrapper, public boost::python::wrapper<B> {
//dispatch logic specific for B
};
struct C_Wrapper : public C, public A_Wrapper, public boost::python::wrapper<C> {
//dispatch logic specific for C
}
However, it seems like that would introduce all manner of nastiness with
the double inheritance of
the boost wrapper base and
the double inheritance of A in
the B_Wrapper and C_Wrapper objects. Is there a common way that this instance is solved that I'm missing?
thanks.
