Boost.Python: как открыть std:: unique_ptr

Ответ 1

Короче говоря, Boost.Python не поддерживает move-semantics и поэтому не поддерживает std::unique_ptr. Boost.Python журнал новостей/изменений не имеет указаний на то, что он был обновлен для перемещения семантики С++ 11. Кроме того, этот запрос функции для поддержки unique_ptr не был затронут более года.

Тем не менее, Boost.Python поддерживает передачу эксклюзивного права собственности на объект на Python и обратно с помощью std::auto_ptr. Поскольку unique_ptr по существу является более безопасной версией auto_ptr, он должен быть достаточно прямым для адаптации API с помощью unique_ptr к API, который использует auto_ptr:

• Когда С++ передает право собственности на Python, функция С++ должна:
  • будет отображаться с помощью CallPolicy boost::python::return_value_policy с конвертером результатов boost::python::manage_new_object.
  • имеет unique_ptr управление выпуском через release() и возвращает необработанный указатель
• Когда Python передает право собственности на С++, функция С++ должна:
  • принять экземпляр через auto_ptr. FAQ упоминает, что указатели, возвращаемые из С++ с помощью политики manage_new_object, будут управляться через std::auto_ptr.
  • иметь auto_ptr управление выпуском до unique_ptr через release()

Учитывая API/библиотеку, которая не может быть изменена:

/// @brief Mockup Spam class.
struct Spam;

/// @brief Mockup factory for Spam.
struct SpamFactory
{
  /// @brief Create Spam instances.
  std::unique_ptr<Spam> make(const std::string&);

  /// @brief Delete Spam instances.
  void consume(std::unique_ptr<Spam>);
};

SpamFactory::make() и SpamFactory::consume() необходимо обернуть через вспомогательные функции.

Функции, передающие права собственности с С++ на Python, могут быть в общем завернуты функцией, которая создаст объекты функции Python:

/// @brief Adapter a member function that returns a unique_ptr to
///        a python function object that returns a raw pointer but
///        explicitly passes ownership to Python.
template <typename T,
          typename C,
          typename ...Args>
boost::python::object adapt_unique(std::unique_ptr<T> (C::*fn)(Args...))
{
  return boost::python::make_function(
      [fn](C& self, Args... args) { return (self.*fn)(args...).release(); },
      boost::python::return_value_policy<boost::python::manage_new_object>(),
      boost::mpl::vector<T*, C&, Args...>()
    );
}

Лямбда делегирует исходную функцию и releases() право собственности на экземпляр на Python, а политика вызова указывает, что Python будет владеть значением, возвращенным из лямбда. mpl::vector описывает подпись вызова Boost.Python, позволяя ему правильно управлять диспетчером функций между языками.

Результат adapt_unique отображается как SpamFactory.make():

boost::python::class_<SpamFactory>(...)
  .def("make", adapt_unique(&SpamFactory::make))
  // ...
  ;

В целом адаптация SpamFactory::consume() сложнее, но достаточно просто написать простую вспомогательную функцию:

/// @brief Wrapper function for SpamFactory::consume_spam().  This
///        is required because Boost.Python will pass a handle to the
///        Spam instance as an auto_ptr that needs to be converted to
///        convert to a unique_ptr.
void SpamFactory_consume(
  SpamFactory& self,
  std::auto_ptr<Spam> ptr) // Note auto_ptr provided by Boost.Python.
{
  return self.consume(std::unique_ptr<Spam>{ptr.release()});
}

Вспомогательная функция делегирует исходную функцию и преобразует auto_ptr, предоставленную Boost.Python, в unique_ptr, требуемую API. Вспомогательная функция SpamFactory_consume отображается как SpamFactory.consume():

boost::python::class_<SpamFactory>(...)
  // ...
 .def("consume", &SpamFactory_consume)
 ;

Вот полный пример кода:

#include <iostream>
#include <memory>
#include <boost/python.hpp>

/// @brief Mockup Spam class.
struct Spam
{
  Spam(std::size_t x) : x(x) { std::cout << "Spam()" << std::endl; }
  ~Spam() { std::cout << "~Spam()" << std::endl; }
  Spam(const Spam&) = delete;
  Spam& operator=(const Spam&) = delete;
  std::size_t x;
};

/// @brief Mockup factor for Spam.
struct SpamFactory
{
  /// @brief Create Spam instances.
  std::unique_ptr<Spam> make(const std::string& str)
  {
    return std::unique_ptr<Spam>{new Spam{str.size()}};
  }

  /// @brief Delete Spam instances.
  void consume(std::unique_ptr<Spam>) {}
};

/// @brief Adapter a non-member function that returns a unique_ptr to
///        a python function object that returns a raw pointer but
///        explicitly passes ownership to Python.
template <typename T,
          typename ...Args>
boost::python::object adapt_unique(std::unique_ptr<T> (*fn)(Args...))
{
  return boost::python::make_function(
      [fn](Args... args) { return fn(args...).release(); },
      boost::python::return_value_policy<boost::python::manage_new_object>(),
      boost::mpl::vector<T*, Args...>()
    );
}

/// @brief Adapter a member function that returns a unique_ptr to
///        a python function object that returns a raw pointer but
///        explicitly passes ownership to Python.
template <typename T,
          typename C,
          typename ...Args>
boost::python::object adapt_unique(std::unique_ptr<T> (C::*fn)(Args...))
{
  return boost::python::make_function(
      [fn](C& self, Args... args) { return (self.*fn)(args...).release(); },
      boost::python::return_value_policy<boost::python::manage_new_object>(),
      boost::mpl::vector<T*, C&, Args...>()
    );
}

/// @brief Wrapper function for SpamFactory::consume().  This
///        is required because Boost.Python will pass a handle to the
///        Spam instance as an auto_ptr that needs to be converted to
///        convert to a unique_ptr.
void SpamFactory_consume(
  SpamFactory& self,
  std::auto_ptr<Spam> ptr) // Note auto_ptr provided by Boost.Python.
{
  return self.consume(std::unique_ptr<Spam>{ptr.release()});
}

BOOST_PYTHON_MODULE(example)
{
  namespace python = boost::python;
  python::class_<Spam, boost::noncopyable>(
      "Spam", python::init<std::size_t>())
    .def_readwrite("x", &Spam::x)
    ;

  python::class_<SpamFactory>("SpamFactory", python::init<>())
    .def("make", adapt_unique(&SpamFactory::make))
    .def("consume", &SpamFactory_consume)
    ;
}

Интерактивный Python:

>>> import example
>>> factory = example.SpamFactory()
>>> spam = factory.make("a" * 21)
Spam()
>>> spam.x
21
>>> spam.x *= 2
>>> spam.x
42
>>> factory.consume(spam)
~Spam()
>>> spam.x = 100
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Boost.Python.ArgumentError: Python argument types in
    None.None(Spam, int)
did not match C++ signature:
    None(Spam {lvalue}, unsigned int)

Ответ 2

Мое предложение - получить необработанный указатель из контейнера std::unique_ptr с get(). Вам нужно будет осторожно держать область unique_ptr в течение всего времени, что вы хотите использовать значение необработанного указателя, иначе объект будет удален, и у вас будет указатель на недопустимую область памяти.

Ответ 3

Boost поддерживает movable semantics и unique_ptr начиная с v.1.55. Но в моем проекте я использовал предыдущую версию и сделал такую ​​простую оболочку:

class_<unique_ptr<HierarchyT>, noncopyable>(typpedName<LinksT>("hierarchy", false)
, "hierarchy holder")
    .def("__call__", &unique_ptr<HierarchyT>::get,
        return_internal_reference<>(),
        "get holding hierarchy")
    .def("reset", &unique_ptr<HierarchyT>::reset,
        "reset holding hierarhy")
    ;

создать unique_ptr<HierarchyT> как Python shierarchy и передать его функции, которая принимает ее по ссылке.
Код Python:

hier = mc.shierarchy()
mc.clusterize(hier, nds)

где функция С++ float clusterize(unique_ptr<HierarchyT>& hier,...).
Затем, чтобы получить доступ к результатам в Python, сделайте вызов hier(), чтобы получить обернутый объект из unique_ptr:

output(hier(), nds)

Ответ 4

Я думаю, что в настоящее время нет способа сделать то, что вы ищете... Причина в том, что std::unique_ptr<Message> someFunc(const std::string &str) возвращается по значению, что означает одну из двух вещей:

• Возвращаемое значение будет скопировано (но unique_ptr не копируется);
• Возвращаемое значение будет перемещено (теперь проблема в том, что boost:: python не обеспечивает поддержку семантики перемещения). (heyy, я использую boost 1,53, не уверен в новейших версиях);

Является ли someFunc() создающим объект? В случае ДА, я думаю, что решение заключается в создании обертки, в случае НЕТ, вы можете вернуться по ссылке:

std::unique_ptr<Message>& someFunc(const std::string &str)

вывести класс:

class_<std::unique_ptr<Message, std::default_delete<Message>>, boost::noncopyable>("unique_ptr_message")
    .def("get", &std::unique_ptr<Message>::get, return_value_policy<reference_existing_object>())
;

а также функции:

def("someFunc", someFunc,  return_value_policy<reference_existing_object>());