extending an exposed class using boost python - boost-python

Question

I want to extend a class which has already exposed to python. For example:
snippet 1:
class_<DataValueContainer, DataValueContainer::Pointer>( "DataValueContainer" )
.def( "__len__", &DataValueContainer::Size )
.def( VariableIndexingPython<DataValueContainer, Variable<std::string> >() )
.def( VariableIndexingPython<DataValueContainer, Variable<int> >() )
.def( VariableIndexingPython<DataValueContainer, Variable<double> >() )
.def( self_ns::str( self ) )
;
Now in a different place I want to extend python class DataValueContainer, such as:
snippet 2:
class_<DataValueContainer, DataValueContainer::Pointer>
.def( VariableIndexingPython<DataValueContainer, Variable<MyObject> >() )
Is it possible to do it using boost.python? The reason I want to do that since the snippet 1 is in the kernel of an existing code and I hesitate to modify it.
Best regards

Answer 1

As far as I know, this is not possible without making some minor modifications to snippet 1, or reimplementing parts of boost::python::class_. When an object of type boost::python::class_ is instantiated, type initialization and registration occurs within the internals of Boost.Python. Instantiating class_ with the same type and arguments will effectively overwrite the previous class object.
In Python, the problem is akin to a type being redefined. In the example below, the spam identifier is used for one type, and then associated with a different type:
>>> class spam:
... def action1(self): pass
...
>>> # Redefines spam type.
... class spam:
... def action2(self): pass
...
>>> print hasattr(s, "action1")
False
>>> print hasattr(s, "action2")
True
Rather than the spam type being extended via its identifier:
>>> class spam:
... def action1(self): pass
...
>>> # Extend spam type.
... def action2(s): pass
...
>>> spam.action2 = action2
>>> s = spam()
>>> print hasattr(s, "action1")
True
>>> print hasattr(s, "action2")
True
The Boost.Python examples are fairly equivalent to the Python examples. In this snippet, the spam identifier is modified to point to a new type, as a new class_ instance was instantiated.
#include <boost/python.hpp>
class spam {};
void action1(spam& self) {}
void action2(spam& self) {}
BOOST_PYTHON_MODULE(example)
{
typedef boost::python::class_<spam> spam_class_type;
spam_class_type("spam")
.def("action1", &action1)
;
// Redefines spam type.
spam_class_type("spam")
.def("action2", &action1)
;
}
And its usage:
>>> import example
__main__:1: RuntimeWarning: to-Python converter for spam already
registered; second conversion method ignored.
>>> s = example.spam()
>>> print hasattr(s, "action1")
False
>>> print hasattr(s, "action2")
True
To extend the type in Boost.Python, one simply operates on the same class_ instance:
#include <boost/python.hpp>
class spam {};
void action1(spam& self) {}
void action2(spam& self) {}
BOOST_PYTHON_MODULE(example)
{
typedef boost::python::class_<spam> spam_class_type;
spam_class_type spam_ = spam_class_type("spam");
spam_
.def("action1", &action1)
;
// Extend spam type.
spam_
.def("action2", &action2)
;
}
And its usage:
>>> import example
>>> s = example.spam()
>>> print hasattr(s, "action1")
True
>>> print hasattr(s, "action2")
True