Boost.Python: как выставить std::unique_ptr

Я довольно новичок в boost.python и пытаюсь представить возвращаемое значение функции для python.

Сигнатура функции выглядит так:

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

При вызове функции в python я получаю следующую ошибку:

TypeError: No to_python (by-value) converter found for C++ type: std::unique_ptr<Message, std::default_delete<Message> >

Мой вызов функции в Python выглядит так:

a = mymodule.MyClass()
a.someFunc("some string here") # error here

Я пытался выставить std::unique_ptr, но просто не могу заставить его работать.. Кто-нибудь знает, как правильно выставить класс указателя? Спасибо!

Изменить: я попробовал следующее:

class_<std::unique_ptr<Message, std::default_delete<Message>>, bost::noncopyable ("Message", init<>())

;

Этот пример компилируется, но я все еще получаю ошибку, упомянутую выше. Также я попытался выставить класс Message сам

class_<Message>("Message", init<unsigned>())

        .def(init<unsigned, unsigned>()) 
        .def("f", &Message::f)
;
Источник

4 ответа

Решение

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

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

  • Когда C++ передает владение Python, функция C++ должна:
    • быть выставленным с CallPolicy boost::python::return_value_policy с boost::python::manage_new_object конвертер результатов.
    • иметь unique_ptr управление выпуском через release() и вернуть необработанный указатель
  • Когда Python передает владение C++, функция C++ должна:
    • принять экземпляр через auto_ptr, В FAQ упоминается, что указатели вернулись из C++ с 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() нужно обернуть через вспомогательные функции.

Функции, передающие владение из C++ в 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)
    ;
}

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

>>> 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)
Источник

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

Источник

Поддержка 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> как питон shierarchy и передать его в функцию, которая принимает его по ссылке.
Код Python:

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

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

output(hier(), nds)
Источник

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

  1. Возвращаемое значение будет скопировано (но unique_ptr не копируется);
  2. Возвращаемое значение будет перемещено (теперь проблема в том, что boost:: python не обеспечивает поддержку семантики перемещения). (эй, я использую 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>());
Источник
Другие вопросы по тегам