## Models of ResultConverter

### boost/python/to_python_indirect.hpp

#### Introduction

    <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

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