Models of ResultConverter

<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 `to_python_indirect`

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 `U cv&` (where cv is any optional cv-qualification) or a Dereferenceable type such that `*x` is convertible to `U const&`, where `U` is a class type.	`A` type deferencing a C++ class exposed to Python using class template `class_`.
MakeHolder	`h = MakeHolder::execute(p);`	A class whose static `execute()` creates an `instance_holder`.

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();
  };
}}

Class `to_python_indirect` observers

PyObject* operator()(T x) const;

Requires: x refers to an object (if it is a pointer type, it is non-null). convertible() == true.
Effects: 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.

Class `to_python_indirect` statics

bool convertible()

Effects: Returns true iff any module has registered a Python type corresponding to U.

Example

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;
   };
};

boost/python/to_python_value.hpp

Introduction
Class template to_python_value
Class to_python_value observers

Introduction

to_python_value is a model of ResultConverter which copies its argument into a new Python object.

Class template `to_python_value`

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;
   };
}}

Class `to_python_value` observers

static bool convertible();

Returns: true iff a converter has been registered which can convert T to python by-value.

PyObject* operator()(argument_type x) const;

Requires: convertible() == true
Effects: converts x to python
Returns: the resulting Python object iff a converter for T has been registered, 0 otherwise.