boost python shared_ptr + virtual + overriding in python - boost-python

Question

I would appreciate help making boost-python use a wrapper class I defined for an abstract base class to wrap derived classes.
I have an abstract C++ base class baz, and derived classes foo (not exposed) and bar (exposed to python). There is a factory function returning boost::shared_ptr<baz> pointing to instances of foo, and here I am hoping to get the boost::shared_ptr<baz> from the factory to be wrapped in baz_callback. I would also like to override pure in python, which seems to work for the base class baz (overridden in the mumble python class), but not for the derived class bar (overridden in jungle).
For illustration, I extended an example from the python wiki, see below. All the printouts should have a 1 as second digit, coming from baz_callback::pure, but only the mumble version gets that right. For jungle, the python verion of pure is ignored, and the C++ version used instead.
File override_shared.cc:
#include <boost/python/class.hpp>
#include <boost/python/module_init.hpp>
#include <boost/python/def.hpp>
#include <boost/python/call_method.hpp>
#include <boost/ref.hpp>
#include <boost/utility.hpp>
#include <boost/python/register_ptr_to_python.hpp>
#include <boost/python/pure_virtual.hpp>
using namespace boost::python;
struct baz {
virtual int pure(int) = 0;
int calls_pure(int x) { return pure(x) + 1000; }
};
struct foo : baz {
int pure(int i) { return i+10; };
};
struct bar : baz {
int pure(int i) { return i+30; };
};
struct baz_callback : baz {
baz_callback(PyObject *p) : self(p) {}
int pure(int x) { return 100 + call_method<int>(self, "pure", x); }
PyObject *self;
};
boost::shared_ptr<baz> make_foo()
{
return boost::shared_ptr<foo>(new foo());
}
boost::shared_ptr<baz> make_bar()
{
return boost::shared_ptr<bar>(new bar());
}
BOOST_PYTHON_MODULE_INIT(liboverride_shared)
{
class_<baz, boost::shared_ptr<baz_callback>, boost::noncopyable>("baz")
.def("pure", pure_virtual(&baz::pure))
.def("calls_pure", &baz::calls_pure);
class_<bar, bases<baz> >("bar");
def("make_foo", make_foo);
def("make_bar", make_bar);
// I suspect the problem lies here:
register_ptr_to_python< boost::shared_ptr<baz> >();
}
File override_shared.py:
from liboverride_shared import *
f = make_foo()
class mumble(baz):
def pure(self, x): return x + 20
m = mumble()
class jungle(bar):
def pure(self, x): return x + 40
j = jungle()
def check(name, bar, i, expected):
actual = bar.calls_pure(i)
msg = "ok" if actual == expected else ("bad, expected %d" % expected)
print (name, actual, "--", msg)
check("foo", f, 1, 1111)
check("mumble", m, 2, 1122)
check("jungle", j, 4, 1144)
File CMakeLists.txt:
CMAKE_MINIMUM_REQUIRED(VERSION 3.0)
FIND_PACKAGE(PythonInterp 3 REQUIRED)
FIND_PACKAGE(PythonLibs "${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}" REQUIRED)
FIND_PACKAGE(Boost 1.58.0 REQUIRED COMPONENTS "python-py${PYTHON_VERSION_MAJOR}${PYTHON_VERSION_MINOR}")
INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_DIRS})
ADD_LIBRARY(override_shared SHARED
override_shared.cc
)
TARGET_LINK_LIBRARIES(override_shared ${Boost_LIBRARIES} ${PYTHON_LIBRARIES})