...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
<boost/python/to_python_indirect.hpp> supplies a way to construct new Python objects that hold wrapped C++ class instances via a pointer or smart pointer. [endsect]
Class template to_python_indirect
converts objects of its first argument type to python as extension
class instances, using the ownership policy provided by its 2nd argument.
Parameter |
Requirements |
Description |
---|---|---|
T |
Either |
|
MakeHolder |
|
A class whose static |
Instantiations of to_python_indirect are models of ResultConverter
.
namespace boost { namespace python { template <class T, class MakeHolder> struct to_python_indirect { static bool convertible(); PyObject* operator()(T ptr_or_reference) const; private: static PyTypeObject* type(); }; }}
PyObject* operator()(T x) const;
x
refers to an
object (if it is a pointer type, it is non-null). convertible()
== true
.
Creates an appropriately-typed Boost.Python extension class instance, uses MakeHolder to create an instance_holder from x, installs the instance_holder in the new extension class instance, and returns a pointer to it.
bool convertible()
Returns true iff any module has registered a Python type corresponding to U.
This example replicates the functionality of reference_existing_object
, but
without some of the compile-time error checking.
struct make_reference_holder { typedef boost::python::objects::instance_holder* result_type; template <class T> static result_type execute(T* p) { return new boost::python::objects::pointer_holder<T*, T>(p); } }; struct reference_existing_object { // metafunction returning the ResultConverter template <class T> struct apply { typedef boost::python::to_python_indirect<T,make_reference_holder> type; }; };
to_python_value
is a
model of ResultConverter
which copies its argument into a new Python object.
namespace boost { namespace python { template <class T> struct to_python_value { typedef typename add_reference< typename add_const<T>::type >::type argument_type; static bool convertible(); PyObject* operator()(argument_type) const; }; }}
static bool convertible();
true
iff a converter
has been registered which can convert T
to python by-value.
PyObject* operator()(argument_type x) const;
convertible()
== true
converts x
to python
the resulting Python object iff a converter for T
has been registered, 0
otherwise.