Introduction

boost/parameter/python.hpp вводит группу def_visitors, которую можно использовать для легкого разоблачения Boost. Функции с поддержкой параметров для Python с Boost. Пайтон. Он также предоставляет шаблон функций def(), который можно использовать для раскрытия Boost. Бесплатные функции с поддержкой параметров.

Когда привязывается буст. Функция с поддержкой параметров, теги ключевых слов должны быть указаны. Кроме того, потому что рост. Функции с включенным параметром являются шаблонами, необходимо указать желаемую подпись функции.

Теги ключевых слов и связанные с ними типы аргументов указаны как MPL Sequence, используя синтаксис типа функции, описанный в ParameterSpec ниже. Кроме того, boost::parameter::python::function и boost::parameter::python::def требует класса с перегрузками пересылки. Мы более подробно рассмотрим, как это делается в разделе учебника ниже.

Tutorial

В этом разделе мы опишем шаги, необходимые для связывания простого увеличения. Функция с параметрами для Python. Для понимания этого раздела требуется знание параметров Boost.Parameter macros.

Функция класса и члена, которую мы заинтересованы в связывании, выглядит следующим образом:

#include <boost/parameter/keyword.hpp>
#include <boost/parameter/preprocessor.hpp>
#include <boost/parameter/python.hpp>
#include <boost/python.hpp>
// First the keywords
BOOST_PARAMETER_KEYWORD(tag, title)
BOOST_PARAMETER_KEYWORD(tag, width)
BOOST_PARAMETER_KEYWORD(tag, height)
class window
{
public:
    BOOST_PARAMETER_MEMBER_FUNCTION(
      (void), open, tag,
      (required (title, (std::string)))
      (optional (width, (unsigned), 400)
                (height, (unsigned), 400))
    )
    {
        … function implementation …
    }
};

Он определяет набор перегруженных функций-членов, называемых open, с одним требуемым параметром и двумя дополнительными. Для связывания этой функции с Python мы используем утилиту связывания boost::parameter::python::function. boost::parameter::python::function представляет собой def_visitor, который мы преобразуем и передадим boost::python::class_::def().

Для использования boost::parameter::python::function сначала нужно определить класс с перегрузками пересылки. Это необходимо, потому что окно::open() является шаблоном функции, поэтому мы не можем ссылаться на него каким-либо другим способом.

struct open_fwd
{
    template <class A0, class A1, class A2>
    void operator()(
        boost::type<void>, window& self
      , A0 const& a0, A1 const& a1, A2 const& a2
    )
    {
        self.open(a0, a1, a2);
    }
};

Первый параметр boost::type сообщает перегрузке пересылки, каким должен быть тип возврата. В этом случае мы знаем, что он всегда пуст, но в некоторых случаях, когда мы экспортируем несколько специализаций Роста. Шаблон с поддержкой параметров, мы должны использовать этот параметр, чтобы вывести тип возврата.

окно::open() принимает в общей сложности 3 параметра, поэтому передающая функция должна принимать также три параметра.

Далее определим модуль и экспортируем класс:

BOOST_PYTHON_MODULE(my_module)
{
    using namespace boost::python;
    namespace py = boost::parameter::python;
    namespace mpl = boost::mpl;
    class_<window>("window")
        .def(
            "open", py::function<
                open_fwd
              , mpl::vector<
                    void
                  , tag::title(std::string)
                  , tag::width*(unsigned)
                  , tag::height*(unsigned)
                >
            >()
        );
}

py::функция проходит по двум параметрам. Первый — это класс с перегрузками, которые мы определили ранее. Второй - это MPL-последовательность с типами тегов ключевых слов и типами аргументов для функции, указанной как типы функций. Синтаксис указателя, используемый в tag::width* и tag::height*, означает, что параметр необязателен. Первым элементом MPL-последовательности является тип возврата функции, в данном случае void, который передается в качестве первого аргумента в operator() в классе пересылки.

Вот так! Этот класс теперь можно использовать в Python с ожидаемым синтаксисом:

>>> w = my_module.window()
>>> w.open(title = "foo", height = 20)

concept ParameterSpec

ParameterSpec - это тип функции K(T), который описывает как тег ключевого слова K, так и тип аргумента T для параметра.

K либо:

• требуемоеключевое слово формыТег
• или, опциональноеключевое слово формыТег *
• или,специальноеключевое слово формыТег**

где Tag — тип тега ключевого слова, используемый в специализации boost::parameter::keyword.

Диапазон arity для MPL последовательности Параметр Spec определяется как закрытый диапазон:

[ mpl::size<S> - number of special keyword tags in S, mpl::size<S> ]

Например, диапазон arity mpl::vector2, диапазон arity mpl::vector2.

special keywords

Иногда желательно иметь значение по умолчанию для параметра, отличающегося по типу от параметра. Этот метод полезен для выполнения простой диспетчеризации меток на основе наличия параметра. Например:

namespace core
{
  template <class ArgumentPack>
  void dfs_dispatch(ArgumentPack const& args, mpl::false_)
  {
      …compute and use default color map…
  }
  template <class ArgumentPack, class ColorMap>
  void dfs_dispatch(ArgumentPack const& args, ColorMap colormap)
  {
      …use colormap…
  }
}
template <class ArgumentPack>
void depth_first_search(ArgumentPack const& args)
{
    core::dfs_dispatch(args, args[color | mpl::false_()]);
}

В приведенном выше примере тип по умолчанию для color является mpl::false_, тип, который отличается от любой цветовой карты, которую может предоставить пользователь.

При связывании случая, описанного выше, тип по умолчанию для цвета не будет конвертируемым в тип параметра. Поэтому мы должны пометить ключевое слово color как ключевое слово special. Это делается путем указания тега как tag::color** при связывании функции (см. concept ParameterSpec для более подробной информации о теге). Делая это, мы сообщаем связывающим функциям, что им необходимо генерировать две перегрузки, одну с присутствующим параметром color и одну без. Если бы было два ключевых слова Special, необходимо было бы создать четыре перегрузки. Количество генерируемых перегрузок равно 2^N, где N - количество специальных ключевых слов.

class template init

Определяет названный параметр, включенный конструктором.

template <class ParameterSpecs>
struct init : python::def_visitor<init<ParameterSpecs> >
{
    template <class Class>
    void def(Class& class_);
    template <class CallPolicies>
    def_visitor operator[](CallPolicies const& policies) const;
};

#include <boost/parameter/keyword.hpp>
#include <boost/parameter/preprocessor.hpp>
#include <boost/parameter/python.hpp>
#include <boost/python.hpp>
#include <boost/mpl/vector.hpp>
BOOST_PARAMETER_KEYWORD(tag, x)
BOOST_PARAMETER_KEYWORD(tag, y)
struct base
{
    template <class ArgumentPack>
    base(ArgumentPack const& args)
    {
        … use args …
    }
};
class X : base
{
public:
    BOOST_PARAMETER_CONSTRUCTOR(X, (base), tag,
        (required (x, *))
        (optional (y, *))
    )
};
BOOST_PYTHON_MODULE(module name)
{
    using namespace boost::python;
    namespace py = boost::parameter::python;
    namespace mpl = boost::mpl;
    class_<X>("X", no_init)
        .def(
            py::init<
                mpl::vector<tag::x(int), tag::y*(int)>
            >()
        );
}

class template call

Определяет оператор __call__, отображаемый в operator() на C++.

template <class ParameterSpecs>
struct call : python::def_visitor<call<ParameterSpecs> >
{
    template <class Class>
    void def(Class& class_);
    template <class CallPolicies>
    def_visitor operator[](CallPolicies const& policies) const;
};

#include <boost/parameter/keyword.hpp>
#include <boost/parameter/preprocessor.hpp>
#include <boost/parameter/python.hpp>
#include <boost/python.hpp>
#include <boost/mpl/vector.hpp>
BOOST_PARAMETER_KEYWORD(tag, x)
BOOST_PARAMETER_KEYWORD(tag, y)
namespace parameter = boost::parameter;
typedef parameter::parameters<
    parameter::required<tag::x>
  , parameter::optional<tag::y>
> call_parameters;
class X
{
public:
    template <class ArgumentPack>
    int call_impl(ArgumentPack const& args)
    {
        … use args …
    }
    template <class A0>
    int operator()(A0 const& a0)
    {
        return call_impl(call_parameters()(a0));
    }
    template <class A0, class A1>
    int operator()(A0 const& a0, A1 const& a1)
    {
        return call_impl(call_parameters()(a0,a1));
    }
};
BOOST_PYTHON_MODULE(module name)
{
    using namespace boost::python;
    namespace py = parameter::python;
    namespace mpl = boost::mpl;
    class_<X>("X")
        .def(
            py::call<
                mpl::vector<int, tag::x(int), tag::y*(int)>
            >()
        );
}

class template function

Определяет поименованный параметр включенной функции члена.

template <class Fwd, class ParameterSpecs>
struct function : python::def_visitor<function<Fwd, ParameterSpecs> >
{
    template <class Class, class Options>
    void def(Class& class_, char const* name, Options const& options);
};

#include <boost/parameter/keyword.hpp>
#include <boost/parameter/preprocessor.hpp>
#include <boost/parameter/python.hpp>
#include <boost/python.hpp>
#include <boost/mpl/vector.hpp>
BOOST_PARAMETER_KEYWORD(tag, x)
BOOST_PARAMETER_KEYWORD(tag, y)
class X
{
public:
    BOOST_PARAMETER_MEMBER_FUNCTION((void), f, tag,
        (required (x, *))
        (optional (y, *, 1))
    )
    {
        …
    }
};
struct f_fwd
{
    template <class A0, class A1>
    void operator()(boost::type<void>, X& self, A0 const& a0, A1 const& a1)
    {
        self.f(a0, a1);
    }
};
BOOST_PYTHON_MODULE(module name)
{
    using namespace boost::python;
    namespace py = boost::parameter::python;
    namespace mpl = boost::mpl;
    class_<X>("X")
        .def("f",
            py::function<
                f_fwd
              , mpl::vector<void, tag::x(int), tag::y*(int)>
            >()
        );
}

function template def

Определение именованного параметра включенной бесплатной функции в текущем объеме Python.

template <class Fwd, class ParameterSpecs>
void def(char const* name);

BOOST_PARAMETER_FUNCTION((void), f, tag,
    (required (x, *))
    (optional (y, *, 1))
)
{
    …
}
struct f_fwd
{
    template <class A0, class A1>
    void operator()(boost::type<void>, A0 const& a0, A1 const& a1)
    {
        f(a0, a1);
    }
};
BOOST_PYTHON_MODULE(…)
{
    def<
        f_fwd
      , mpl::vector<
            void, tag::x(int), tag::y*(int)
        >
    >("f");
}

Portability

Библиотека привязки Python Boost.Parameter требует частичной специализации шаблона .