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.
