Обтекание std::vector с помощью boost:: python vector_indexing_suite

Я работаю над библиотекой С++ с привязками Python (с использованием boost:: python), представляющими данные, хранящиеся в файле. Большинство моих полутехнических пользователей будут использовать Python для взаимодействия с ним, поэтому мне нужно сделать его максимально возможным как Pythonic. Тем не менее, у меня также будут программисты на С++, использующие API, поэтому я не хочу компрометировать на стороне С++ для размещения привязок Python.

Большая часть библиотеки будет сделана из контейнеров. Чтобы сделать вещи интуитивно понятными для пользователей python, я бы хотел, чтобы они вели себя как списки python, т.е.:

Настройка тестирования

Способ shared_ptr

Используя shared_ptr, я могу получить то же поведение, что и выше, но это также означает, что я должен представлять все данные в С++ с помощью общих указателей, что не очень хорошо со многих точек зрения.

В моей тестовой установке это дает тот же результат, что и чистый Python:

Способ vector<Foo>

Использование вектора непосредственно дает хорошую чистую настройку на стороне С++. Однако результат не ведет себя так же, как чистый Python.

Что является "неправильным" - изменение исходного экземпляра не изменило значение внутри контейнера.

Надеюсь, я не хочу слишком много

Интересно, что этот код работает независимо от того, какой из двух инкапсуляций я использую:

Это означает, что boost:: python может иметь дело с "поддельным совместным владением" (через механизм возврата by_proxy). Есть ли способ достичь того же при вставке новых элементов?

Однако, если ответ отрицательный, мне бы хотелось услышать другие предложения - есть ли пример в наборе инструментов Python, где реализована подобная инкапсуляция коллекции, но которая не ведет себя как список python?

Ответы

Ответ 1

Из-за семантических различий между языками часто бывает сложно применить одно многоразовое решение для всех сценариев, когда задействованы коллекции. Самая большая проблема заключается в том, что в то время как коллекции Python напрямую поддерживают ссылки, коллекции С++ требуют уровня косвенности, например, с помощью типов элементов shared_ptr. Без этой косвенности коллекции С++ не смогут поддерживать ту же функциональность, что и коллекции Python. Например, рассмотрим два индекса, которые относятся к одному и тому же объекту:

s = Spam()
spams = []
spams.append(s)
spams.append(s)

Без типов типа указателя коллекция С++ не может иметь двух индексов, относящихся к одному и тому же объекту. Тем не менее, в зависимости от использования и потребностей могут быть варианты, которые позволяют использовать интерфейс Pythonic-ish для пользователей Python, сохраняя при этом единственную реализацию для С++.

Самое решение Pythonic - использовать пользовательский конвертер, который преобразует итеративный объект Python в коллекцию С++. См. этот ответ для деталей реализации. Рассмотрим этот вариант, если:
- Элементы коллекции дешевы для копирования.
- Функции С++ работают только на типах rvalue (т.е. std::vector<> или const std::vector<>&). Это ограничение не позволяет С++ вносить изменения в коллекцию Python или ее элементы.
Расширение vector_indexing_suite, повторное использование как можно большего числа возможностей, таких как его прокси-серверы для безопасного обращения с удалением индекса и перераспределением базового коллекция:
- Представьте модель с пользовательским HeldType, который будет функционировать как интеллектуальный указатель и делегировать либо возвращенный объект экземпляра, либо объект-объект элемента от vector_indexing_suite.
- Monkey исправляет методы сбора, которые вставляют элементы в коллекцию, чтобы пользовательский HeldType был настроен на делегирование прокси-сервера элемента.

При экспонировании класса Boost.Python HeldType является типом объекта, который внедряется в объект Boost.Python. При доступе к объекту завернутых типов Boost.Python вызывает get_pointer() для HeldType. Ниже приведен класс object_holder, позволяющий возвращать дескриптор либо принадлежащему ему экземпляру, либо прокси-серверу элемента:

/// @brief smart pointer type that will delegate to a python
///        object if one is set.
template <typename T>
class object_holder
{
public:

  typedef T element_type;

  object_holder(element_type* ptr)
    : ptr_(ptr),
      object_()
  {}

  element_type* get() const
  {
    if (!object_.is_none())
    {
      return boost::python::extract<element_type*>(object_)();
    }
    return ptr_ ? ptr_.get() : NULL;
  }

  void reset(boost::python::object object)
  {
    // Verify the object holds the expected element.
    boost::python::extract<element_type*> extractor(object_);
    if (!extractor.check()) return;

    object_ = object;
    ptr_.reset();
  }

private:
  boost::shared_ptr<element_type> ptr_;
  boost::python::object object_;
};

/// @brief Helper function used to extract the pointed to object from
///        an object_holder.  Boost.Python will use this through ADL.
template <typename T>
T* get_pointer(const object_holder<T>& holder)
{
  return holder.get();
}

При поддерживаемой косвенности остается только исправление коллекции для установки object_holder. Один чистый и многоразовый способ поддержать это - использовать def_visitor. Это общий интерфейс, который позволяет объектам class_ расширяться без вмешательства. Например, vector_indexing_suite использует эту возможность.

Класс custom_vector_indexing_suite ниже обезьяны исправляет метод append() для делегирования исходному методу, а затем вызывает object_holder.reset() прокси-сервер для вновь заданного элемента. Это приводит к тому, что object_holder ссылается на элемент, содержащийся в коллекции.

/// @brief Indexing suite that will resets the element HeldType to
///        that of the proxy during element insertion.
template <typename Container,
          typename HeldType>
class custom_vector_indexing_suite
  : public boost::python::def_visitor<
      custom_vector_indexing_suite<Container, HeldType>>
{
private:

  friend class boost::python::def_visitor_access;

  template <typename ClassT>
  void visit(ClassT& cls) const
  {
    // Define vector indexing support.
    cls.def(boost::python::vector_indexing_suite<Container>());

    // Monkey patch element setters with custom functions that
    // delegate to the original implementation then obtain a 
    // handle to the proxy.
    cls
      .def("append", make_append_wrapper(cls.attr("append")))
      // repeat for __setitem__ (slice and non-slice) and extend
      ;
  }

  /// @brief Returned a patched 'append' function.
  static boost::python::object make_append_wrapper(
    boost::python::object original_fn)
  {
    namespace python = boost::python;
    return python::make_function([original_fn](
          python::object self,
          HeldType& value)
        {
          // Copy into the collection.
          original_fn(self, value.get());
          // Reset handle to delegate to a proxy for the newly copied element.
          value.reset(self[-1]);
        },
      // Call policies.
      python::default_call_policies(),
      // Describe the signature.
      boost::mpl::vector<
        void,           // return
        python::object, // self (collection)
        HeldType>()     // value
      );
  }
};

Планирование должно происходить во время выполнения, а пользовательские объекты-объекты не могут быть непосредственно определены в классе через def(), поэтому make_function() функция должна использоваться. Для функторов он требует CallPolicies и MPL front- расширяемая последовательность, представляющая подпись.

Вот полный пример: демонстрирует с помощью object_holder для делегирования прокси и custom_vector_indexing_suite для исправления коллекции.

#include <boost/python.hpp>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>

/// @brief Mockup type.
struct spam
{
  int val;

  spam(int val) : val(val) {}
  bool operator==(const spam& rhs) { return val == rhs.val; }
};

/// @brief Mockup function that operations on a collection of spam instances.
void modify_spams(std::vector<spam>& spams)
{
  for (auto& spam : spams)
    spam.val *= 2;
}

/// @brief smart pointer type that will delegate to a python
///        object if one is set.
template <typename T>
class object_holder
{
public:

  typedef T element_type;

  object_holder(element_type* ptr)
    : ptr_(ptr),
      object_()
  {}

  element_type* get() const
  {
    if (!object_.is_none())
    {
      return boost::python::extract<element_type*>(object_)();
    }
    return ptr_ ? ptr_.get() : NULL;
  }

  void reset(boost::python::object object)
  {
    // Verify the object holds the expected element.
    boost::python::extract<element_type*> extractor(object_);
    if (!extractor.check()) return;

    object_ = object;
    ptr_.reset();
  }

private:
  boost::shared_ptr<element_type> ptr_;
  boost::python::object object_;
};

/// @brief Helper function used to extract the pointed to object from
///        an object_holder.  Boost.Python will use this through ADL.
template <typename T>
T* get_pointer(const object_holder<T>& holder)
{
  return holder.get();
}

/// @brief Indexing suite that will resets the element HeldType to
///        that of the proxy during element insertion.
template <typename Container,
          typename HeldType>
class custom_vector_indexing_suite
  : public boost::python::def_visitor<
      custom_vector_indexing_suite<Container, HeldType>>
{
private:

  friend class boost::python::def_visitor_access;

  template <typename ClassT>
  void visit(ClassT& cls) const
  {
    // Define vector indexing support.
    cls.def(boost::python::vector_indexing_suite<Container>());

    // Monkey patch element setters with custom functions that
    // delegate to the original implementation then obtain a 
    // handle to the proxy.
    cls
      .def("append", make_append_wrapper(cls.attr("append")))
      // repeat for __setitem__ (slice and non-slice) and extend
      ;
  }

  /// @brief Returned a patched 'append' function.
  static boost::python::object make_append_wrapper(
    boost::python::object original_fn)
  {
    namespace python = boost::python;
    return python::make_function([original_fn](
          python::object self,
          HeldType& value)
        {
          // Copy into the collection.
          original_fn(self, value.get());
          // Reset handle to delegate to a proxy for the newly copied element.
          value.reset(self[-1]);
        },
      // Call policies.
      python::default_call_policies(),
      // Describe the signature.
      boost::mpl::vector<
        void,           // return
        python::object, // self (collection)
        HeldType>()     // value
      );
  }

  // .. make_setitem_wrapper
  // .. make_extend_wrapper
};

BOOST_PYTHON_MODULE(example)
{
  namespace python = boost::python;

  // Expose spam.  Use a custom holder to allow for transparent delegation
  // to different instances.
  python::class_<spam, object_holder<spam>>("Spam", python::init<int>())
    .def_readwrite("val", &spam::val)
    ;

  // Expose a vector of spam.
  python::class_<std::vector<spam>>("SpamVector")
    .def(custom_vector_indexing_suite<
      std::vector<spam>, object_holder<spam>>())
    ;

  python::def("modify_spams", &modify_spams);
}

Интерактивное использование:

>>> import example
>>> spam = example.Spam(5)
>>> spams = example.SpamVector()
>>> spams.append(spam)
>>> assert(spams[0].val == 5)
>>> spam.val = 21
>>> assert(spams[0].val == 21)
>>> example.modify_spams(spams)
>>> assert(spam.val == 42)
>>> spams.append(spam)
>>> spam.val = 100
>>> assert(spams[1].val == 100)
>>> assert(spams[0].val == 42) # The container does not provide indirection.

Пока используется vector_indexing_suite, базовый контейнер С++ должен быть модифицирован только с помощью API-интерфейса Python. Например, вызов push_back в контейнере может привести к перераспределению базовой памяти и вызвать проблемы с существующими прокси-серверами Boost.Python. С другой стороны, можно безопасно модифицировать сами элементы, например, с помощью функции modify_spams() выше.

Ответ 2

К сожалению, ответ отрицательный, вы не можете делать то, что хотите. В python все указатель, а списки - это контейнер указателей. Вектор С++ общих указателей работает, потому что базовая структура данных более или менее эквивалентна списку python. То, что вы запрашиваете, состоит в том, чтобы вектор С++ выделенной памяти действовал как вектор указателей, что не может быть сделано.

Посмотрим, что происходит в списках python, с псевдонимом эквивалентного С++:

foo = Foo(0.0)     # Foo* foo = new Foo(0.0)
vect = []          # std::vector<Foo*> vect
vect.append(foo)   # vect.push_back(foo)

В этот момент foo и vect[0] обе указывают на одну и ту же выделенную память, поэтому изменение *foo изменяет *vect[0].

Теперь с версией vector<Foo>:

foo = Foo(0.0)      # Foo* foo = new Foo(0.0)
vect = FooVector()  # std::vector<Foo> vect
vect.append(foo)    # vect.push_back(*foo)

Здесь vect[0] имеет собственную выделенную память и является копией * foo. По сути, вы не можете сделать vect [0] той же памятью как * foo.

В боковом примечании будьте осторожны с управлением временем жизни footwo при использовании std::vector<Foo>:

footwo = vect[0]    # Foo* footwo = &vect[0]

Последующее приложение может потребовать перемещения выделенного хранилища для вектора и может аннулировать footwo (& vect [0] может измениться).

Обтекание std::vector с помощью boost:: python vector_indexing_suite

Настройка тестирования

Способ `shared_ptr`

Способ `vector<Foo>`

Надеюсь, я не хочу слишком много

Ответы

Ответ 1

Ответ 2

Обтекание std::vector с помощью boost:: python vector_indexing_suite

Настройка тестирования

Способ shared_ptr

Способ vector<Foo>

Надеюсь, я не хочу слишком много

Ответы

Ответ 1

Ответ 2

Способ `shared_ptr`

Способ `vector<Foo>`