<default_call_policies>является моделью<CallPolicies>без поведения<precall>или<postcall>и<result_converter>, которая обрабатывает возврат по стоимости. Завернутые функции C++ и функции членов<use default_call_policies>, если не указано иное. Вы можете найти новые модели<CallPolicies>от<default_call_policies>.

namespace boost { namespace python
{
    struct default_call_policies
    {
        static bool precall(PyObject*);
        static PyObject* postcall(PyObject*, PyObject* result);
        typedef default_result_converter result_converter;
        template <class Sig> struct extract_return_type : mpl::front<Sig>{};
    };
}}

bool precall(PyObject*);

PyObject* postcall(PyObject*, PyObject* result);

default_result_converter - это модель<ResultConverterGenerator>, которая может использоваться для обертывания функций C++, возвращающих неточечные типы<charconst*>и<PyObject*>, по значению.

namespace boost { namespace python
{
    struct default_result_converter
    {
        template <class T> struct apply;
    };
}}

template <class T> struct apply

Этот пример взят из Boost. Сама реализация Python. Поскольку шаблон класса return_value_policy не реализует поведение до вызова или после вызова, его базовым классом по умолчанию является политика default_call_policies:

template <class Handler, class Base = default_call_policies>
struct return_value_policy : Base
{
   typedef Handler result_converter;
};

<return_arg>и<return_self>инстанциации являются моделями<CallPolicies>, которые возвращают указанный параметр аргумента (обычно<*this>) обернутой (члена) функции.

namespace boost { namespace python
{
   template <size_t arg_pos=1, class Base = default_call_policies>
   struct return_arg : Base
   {
      static PyObject* postcall(PyObject*, PyObject* result);
      struct result_converter{ template <class T> struct apply; };
      template <class Sig> struct extract_return_type : mpl::at_c<Sig, arg_pos>{};
   };
}}

PyObject* postcall(PyObject* args, PyObject* result);

namespace boost { namespace python
{
   template <class Base = default_call_policies>
   struct return_self
     : return_arg<1,Base>
   {};
}}

Определение модуля C++:

#include <boost/python/module.hpp>
#include <boost/python/class.hpp>
#include <boost/python/return_arg.hpp>
struct Widget
{
   Widget() :sensitive_(true){}
   bool get_sensitive() const { return sensitive_; }
   void set_sensitive(bool s) { this->sensitive_ = s; }
 private:
   bool sensitive_;
};
struct Label : Widget
{
   Label() {}
   std::string  get_label() const { return label_; }
   void set_label(const std::string &l){ label_ = l; }
 private:
   std::string label_;
};
using namespace boost::python;
BOOST_PYTHON_MODULE(return_self_ext)
{
   class_<widget>("Widget")
      .def("sensitive", &Widget::get_sensitive)
      .def("sensitive", &Widget::set_sensitive, return_self<>())
      ;
   class_<Label, bases<Widget> >("Label")
      .def("label", &Label::get_label)
      .def("label", &Label::set_label, return_self<>())
      ;
}

Код Python:

>>> from return_self_ext import *
>>> l1 = Label().label("foo").sensitive(false)
>>> l2 = Label().sensitive(false).label("foo")

<return_internal_reference>Мгновения представляют собой модели<CallPolicies>, которые позволяют безопасно возвращать указатели и ссылки на объекты, удерживаемые внутри аргументом свободной или членской функции или от цели членской функции, не делая копию референта. По умолчанию для своего первого аргумента шаблона обрабатывает общий случай, когда содержащий объект является целью (<*this>) обернутой функции члена.

namespace boost { namespace python
{
   template <std::size_t owner_arg = 1, class Base = default_call_policies>
   struct return_internal_reference : Base
   {
      static PyObject* postcall(PyObject*, PyObject* result);
      typedef reference_existing_object result_converter;
   };
}}

PyObject* postcall(PyObject* args, PyObject* result);

Определение модуля C++:

#include <boost/python/module.hpp>
#include <boost/python/class.hpp>
#include <boost/python/return_internal_reference.hpp>
class Bar
{
 public:
   Bar(int x) : x(x) {}
   int get_x() const { return x; }
   void set_x(int x) { this->x = x; }
 private:
   int x;
};
class Foo
{
 public:
   Foo(int x) : b(x) {}
   // Returns an internal reference
   Bar const& get_bar() const { return b; }
 private:
   Bar b;
};
using namespace boost::python;
BOOST_PYTHON_MODULE(internal_refs)
{
   class_<Bar>("Bar", init<int>())
      .def("get_x", &Bar::get_x)
      .def("set_x", &Bar::set_x)
      ;
   class_<Foo>("Foo", init<int>())
      .def("get_bar", &Foo::get_bar
          , return_internal_reference<>())
      ;
}

Код Python:

>>> from internal_refs import *
>>> f = Foo(3)
>>> b1 = f.get_bar()
>>> b2 = f.get_bar()
>>> b1.get_x()
3
>>> b2.get_x()
3
>>> b1.set_x(42)
>>> b2.get_x()
42

Возврат_значение_политические инстанциации являются просто моделями<CallPolicies>, которые состоят из<ResultConverterGenerator>и факультативных<Base><CallPolicies>.

namespace boost { namespace python
{
  template <class ResultConverterGenerator, class Base = default_call_policies>
  struct return_value_policy : Base
  {
      typedef ResultConverterGenerator result_converter;
  };
}}

Определение модуля C++:

#include <boost/python/module.hpp>
#include <boost/python/class.hpp>
#include <boost/python/copy_const_reference.hpp>
#include <boost/python/return_value_policy.hpp>
// classes to wrap
struct Bar { int x; }
struct Foo {
   Foo(int x) : { b.x = x; }
   Bar const& get_bar() const { return b; }
 private:
   Bar b;
};
// Wrapper code
using namespace boost::python;
BOOST_PYTHON_MODULE(my_module)
{
   class_<Bar>("Bar");
   class_<Foo>("Foo", init<int>())
      .def("get_bar", &Foo::get_bar
          , return_value_policy<copy_const_reference>())
      ;
}

Код Python:

>>> from my_module import *
>>> f = Foo(3)         # create a Foo object
>>> b = f.get_bar()    # make a copy of the internal Bar object

Этот заголовок предоставляет возможности для установления пожизненной зависимости между двумя аргументами функции Python или объектами результата. Подопечный объект не будет уничтожен до тех пор, пока хранитель поддерживаетслабые ссылки(классы расширения Boost.Python поддерживают слабые ссылки). Если объект-хранитель не поддерживает слабых ссылок и не является<None>, будет сделано соответствующее исключение. Эти две группы<with_custodian_and_ward>и<with_custodian_and_ward_postcall>отличаются друг от друга тем, в какой момент они вступают в силу.

Чтобы уменьшить вероятность непреднамеренного создания болтающихся указателей, по умолчанию необходимо выполнить пожизненное связывание перед вызовом базового объекта C++. Однако до вызова объект результата недоступен, поэтому<with_custodian_and_ward_postcall>предоставляется для связывания жизней после вызова. Кроме того, если после<with_custodian_and_ward<>::precall>бросается исключение C++, но до того, как базовый объект C++ фактически хранит указатель, срок службы объектов хранителя и подопечного будет искусственно связан, поэтому вместо этого можно выбрать<with_custodian_and_ward_postcall>, в зависимости от семантики обертываемой функции.

Обратите внимание, что это не подходящий инструмент для использования при обертывании функций, которые передают право собственности на необработанный указатель через границу вызова функции. Пожалуйста, посмотрите FAQ, если вы хотите это сделать.

namespace boost { namespace python
{
   template <std::size_t custodian, std::size_t ward, class Base = default_call_policies>
   struct with_custodian_and_ward : Base
   {
      static bool precall(PyObject* args);
   };
}}

bool precall(PyObject* args);

namespace boost { namespace python
{
   template <std::size_t custodian, std::size_t ward, class Base = default_call_policies>
   struct with_custodian_and_ward_postcall : Base
   {
      static PyObject* postcall(PyObject* args, PyObject* result);
   };
}}

PyObject *postcall(PyObject* args, PyObject* result);

Следующий пример показывает, как<with_custodian_and_ward_postcall>используется библиотекой для реализации<return_internal_reference>.

template <std::size_t owner_arg = 1, class Base = default_call_policies>
struct return_internal_reference
    : with_custodian_and_ward_postcall<0, owner_arg, Base>
{
   typedef reference_existing_object result_converter;
};