Boost.python inheriting from wrapped classes

Question

I have run into a problem when creating python bindings for an existing library with boost.python. The scenario is as follows:

#include<boost/python.hpp>

namespace bp = boost::python;

struct Base {
    std::stringstream _myString;
    Base() { };
    Base(const Base& base) { _myString<<base._myString.str(); }

    void getString(std::stringstream& some_string) {
        _myString.str("");
        _myString<<some_string.str();
        std::cout<<"Got string: \""<<_myString.str()<<"\""<<std::endl;
    }
};

struct BaseWrapper : Base,
                     bp::wrapper<Base>
{
    BaseWrapper() :
        Base(),
        bp::wrapper<Base>() { };

    BaseWrapper(const Base& base) :
        Base(base),
        bp::wrapper<Base>() { };

    void getString(bp::object pyObj) {
        std::string strLine = bp::extract<std::string>(pyObj);
        std::stringstream sstrLine;
        sstrLine<<strLine;
        Base::getString(sstrLine);
    }
};

struct Derived : Base
{
    Derived() : Base() { };
    Derived(const Derived& derived) : Base() { _myString<<derived._myString.str(); };
};

struct DerivedWrapper : Derived,
                        bp::wrapper<Derived>
{
    DerivedWrapper() :
        Derived(),
        bp::wrapper<Derived>() { };

    DerivedWrapper(const Derived derived) :
        Derived(derived),
        bp::wrapper<Derived>() { };
};

BOOST_PYTHON_MODULE(testInheritance){
    bp::class_<BaseWrapper>("Base")
        .def("getString", &BaseWrapper::getString);

    bp::class_<DerivedWrapper, bp::bases<Base> >("Derived");
}

(Sorry for the long code block, it was the minimum example I could think of.)

You can see that I had to override getString() method in the BaseWrapper so that it would work with Python strings and this part works fine:

>>> import testInheritance
>>> base = testInheritance.Base()
>>> base.getString("bla")
Got string: "bla"
>>>

The problem appears as soon as I try to call getString from a instance of Derived:

>>> derived = testInheritance.Derived()
>>> derived.getString("bla")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Boost.Python.ArgumentError: Python argument types in
    Base.getString(Derived, str)
did not match C++ signature:
    getString(BaseWrapper {lvalue}, boost::python::api::object)
>>>

I can understand what is going wrong here, but I have no idea how to fix that. I would appreciate any help!

Best Regards, eDude

H. Brandsmeier · Accepted Answer · 2012-09-04 09:57:21Z

2

The problem is, that DerivedWrapper has no relationship to BaseWrapper. Thus DerivedWrapper needs to provide its own python adapted implementation of void getString(bp::object pyObj).

So one way to make it work is like this:

struct DerivedWrapper : Derived,
                        bp::wrapper<Derived>
{
    DerivedWrapper() :
        Derived(),
        bp::wrapper<Derived>() { };

    DerivedWrapper(const Derived derived) :
        Derived(derived),
        bp::wrapper<Derived>() { };

    void getString(bp::object pyObj) {
        std::string strLine = bp::extract<std::string>(pyObj);
        std::stringstream sstrLine;
        sstrLine<<"(from DerivedWrapper) "<<strLine;
        Derived::getString(sstrLine);
    }
};

[...]

    bp::class_<DerivedWrapper, bp::bases<Base> >("Derived")
        .def("getString", &DerivedWrapper::getString);

And the output of

base = testInheritance.Base()
base.getString("bla")

derived = testInheritance.Derived()
derived.getString("blub")

is as expected

Got string: "bla"
Got string: "(from DerivedWrapper) blub"

edited Sep 4, 2012 at 9:57

answered Sep 4, 2012 at 7:46

H. Brandsmeier

9675 silver badges20 bronze badges

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

3 Comments

explorerDude Over a year ago

Thank you for your answer! Unfortunately, this solution will produce quite some code duplication, especially if there are extended inheritance schemes. Is there no way to avoid this?

H. Brandsmeier Over a year ago

@explorerDude: is the example above, where the implementation in the wrapper is a python friendly way to acces something from C++, representative for what you want to do? If you just want to do this, then I propose that you avoid the wrappers at all, and provide your example of getString as a non-member funtion (I can give an example). If you really want to override functions from python, then you really need wrappers. In that case I can just try to hide a bit better what is going on above and avoid most of the code duplication.

explorerDude Over a year ago

In my actual case, I need the wrappers also for overloading functions. However, I would be very much interested in seeing both the example with and without wrappers, I think it would help my understanding of the matter a lot. Thank you!

Community · Accepted Answer · 2017-05-23 12:30:14Z

I got exactly the same problem which I manage to solve, but solution has some internal faults in some special cases. There is a known problem about using boost::shared_ptr in python when it is necessary to create boost::weak_ptr references from values passed by boost::python. I won't go into details while it is not related to the post. Anyway I needed to wrap boost::shared_ptr into another class (I called it PythonSharedPtr) to hide boost::shared_ptr from boost::python and then I get similar problem. Consider following setup: class A is used on c++ side as boost::shared_ptr, class B (inherited from A) as boost::shared_ptr and in python both shared_ptr are wrapped into another class (for further info why I needed to make it, is explained at: boost::python and weak_ptr : stuff disappearing http://mail.python.org/pipermail/cplusplus-sig/2009-November/014983.html

So then I need to write proper export to the boost python: class_, wrapped_shared_ptr, noncopyable> and class_, wrapped_shared_ptr, noncopyable>

I think till now it is similar with your code. The tricky part is how to allow in boost::python usage of bases for the exporting of B (while shared_ptr is not related to shared_ptr). After some research in boost::python sources and came with the solution which is pretty nice, but it works only in cases, that there is no multi-inheritance for class B.

Here is the code:

namespace boost { namespace python { namespace objects
{
    template<typename Source, typename Target>
    struct shared_ptr_cast_generator
    {
        static void* execute(void* source)
        {
            const boost::shared_ptr<Source>* sourcePtr = static_cast<boost::shared_ptr<Source>*>(source);
            const boost::shared_ptr<Target> target     = boost::dynamic_pointer_cast<Target>(*sourcePtr);
            if(reinterpret_cast<size_t>(target.get()) == reinterpret_cast<size_t>(sourcePtr->get()))
                return source;
            else
            {
                // assertion which is triggered when multi-inheritance is used for Source type
                // in this case it is necessary to create new instance of shared_ptr<Target> but
                // it is not possible to make it in-place due to memory leak
                assert(!"Wrong cast");
                return nullptr;
            }
        }
    };

    template<typename Source, typename Target>
    struct cast_generator<boost::shared_ptr<Source>, boost::shared_ptr<Target> >
    {
        typedef shared_ptr_cast_generator<Source, Target> type;
    };
}}}

By providing such code, it is possible to adjust second export to the python: class_, wrapped_shared_ptr, noncopyable, bases >

Just be carefull with the conversion stored in execute function - if conversion between Source and Target exists, it returns same address - so it must be also valid if you just reinterpret Source* to Target* (data in both classes must be stored at exactly same places).

Maybe such solution is not sufficient in your case, but at least it can give you some ideas.

Collectives™ on Stack Overflow

Boost.python inheriting from wrapped classes

2 Answers 2

3 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related