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.