|  | 
<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.