简体   繁体   English

如何使用带有 Boost.Python 的 std::map 或 std::vector 参数的构造函数包装 C++ 类?

[英]How to wrap a C++ class with a constructor that takes a std::map or std::vector argument with Boost.Python?

Disclaimer : yes, I do know about boost::python::map_indexing_suite .免责声明:是的,我知道boost::python::map_indexing_suite

Task : I have a C++ class which I want to wrap with Boost.Python.任务:我有一个 C++ 类,我想用 Boost.Python 包装它。 Its constructor takes a std::map argument.它的构造函数接受一个std::map参数。 Here is the C++ header:这是 C++ 头文件:

// myclass.hh
typedef std::map<int, float> mymap_t;

class MyClass {
  public:
  explicit MyClass(const mymap_t& m);
  // ...
};
// ...

Here is the Boost.Python wrapper (essential parts only):这是 Boost.Python 包装器(仅限必要部分):

// myclasswrapper.cc
#include "mymap.hh"
#include "boost/python.hpp"
#include "boost/python/suite/indexing/map_indexing_suite.hpp"

namespace bpy = boost::python;

// wrapping mymap_t
bpy::class_<mymap_t>("MyMap")
     .def(bpy::map_indexing_suite<mymap_t>())
    ;

// wrapping MyClass
bpy::class_<MyClass>("MyClass", "My example class",
  bpy::init<mymap_t>()   // ??? what to put here?
)
  // .def(...method wrappers...)
;

This compiles.这编译。 However, I cannot create the mapped MyClass object from the Python side because I don't know what to pass as argument to the constructor.但是,我无法从 Python 端创建映射的MyClass对象,因为我不知道将什么作为参数传递给构造函数。 Dictionaries do not get converted to std::map -s automatically:字典不会自动转换为std::map -s:

# python test
myclass = MyClass({1:3.14, 5:42.03})

the interpreter complains (rightly so):口译员抱怨(理所当然):

Boost.Python.ArgumentError: Python argument types in
    MyClass.__init__(MyClass, dict)
did not match C++ signature:
    __init__(_object*, std::__1::map<int, float, ...

and MyMap on the Python side cannot be initialised with a dictionary either. Python 端的MyMap也不能用字典初始化。

Having googled away the best part of a day, I could find only examples for "normal" methods taking std::map arguments that are mapped with .def(...) .在谷歌搜索了一天中最好的部分后,我只能找到“普通”方法的示例,这些方法采用使用.def(...)映射的std::map参数。 And in .def(...) you do not have to specify explicitly the arguments of the mapped method, they are magically discovered..def(...)您不必明确指定映射方法的参数,它们会被神奇地发现。 With constructors you must use boost::python::init<...>() , or at least that is what I understood from the docs.对于构造函数,您必须使用boost::python::init<...>() ,或者至少这是我从文档中理解的。

Questions :问题

  1. Shall I add something to the MyMap wrapper to help map_indexing_suite convert from a Python dictionary?我应该在MyMap包装器中添加一些东西来帮助map_indexing_suite从 Python 字典转换吗?
  2. Shall I use a different template argument in boost::python::init<...> in the MyClass wrapper?我应该在MyClass包装器的boost::python::init<...>中使用不同的模板参数吗?
  3. Any other ideas...?还有其他想法吗...?

Note : I have also seen this accepted answer at SO , then I scrolled down and read the comment by @YvesgereY:注意:我也在SO 上看到了这个已接受的答案,然后我向下滚动并阅读了@YvesgereY 的评论:

"For the record, map_indexing_suite solution doesn't work, since no implicit "dict->std::map" from_python converter will be applied." “根据记录,map_indexing_suite 解决方案不起作用,因为不会应用隐式的“dict->std::map”from_python 转换器。”

And I lost faith :-)我失去了信心:-)

I have found a nice solution: added a template that can convert a Python dictionary to std::map .我找到了一个不错的解决方案:添加了一个可以将 Python 字典转换为std::map的模板。 The logic is based on this extremely useful primer , with slight modifications mostly obtained from this source file and some additional comments.逻辑基于这个非常有用的入门,略有修改,主要是从这个源文件和一些附加注释中获得的。

Below is the template definition:下面是模板定义:

// dict2map.hh
#include "boost/python.hpp"
namespace bpy = boost::python;

/// This template encapsulates the conversion machinery.
template<typename key_t, typename val_t>
struct Dict2Map {

    /// The type of the map we convert the Python dict into
    typedef std::map<key_t, val_t> map_t;

    /// constructor
    /// registers the converter with the Boost.Python runtime
    Dict2Map() {
        bpy::converter::registry::push_back(
            &convertible,
            &construct,
            bpy::type_id<map_t>()
#ifdef BOOST_PYTHON_SUPPORTS_PY_SIGNATURES
            , &bpy::converter::wrap_pytype<&PyDict_Type>::get_pytype
#endif
        );
    }

    /// Check if conversion is possible
    static void* convertible(PyObject* objptr) {
        return PyDict_Check(objptr)? objptr: nullptr;
    }

    /// Perform the conversion
    static void construct(
        PyObject* objptr,
        bpy::converter::rvalue_from_python_stage1_data* data
    ) {
        // convert the PyObject pointed to by `objptr` to a bpy::dict
        bpy::handle<> objhandle{ bpy::borrowed(objptr) };   // "smart ptr"
        bpy::dict d{ objhandle };

        // get a pointer to memory into which we construct the map
        // this is provided by the Python runtime
        void* storage = 
            reinterpret_cast<
                bpy::converter::rvalue_from_python_storage<map_t>*
            >(data)->storage.bytes;

        // placement-new allocate the result
        new(storage) map_t{};

        // iterate over the dictionary `d`, fill up the map `m`
        map_t& m{ *(static_cast<map_t *>(storage)) };
        bpy::list keys{ d.keys() };
        int keycount{ static_cast<int>(bpy::len(keys)) };
        for (int i = 0; i < keycount; ++i) {
            // get the key
            bpy::object keyobj{ keys[i] };
            bpy::extract<key_t> keyproxy{ keyobj };
            if (! keyproxy.check()) {
                PyErr_SetString(PyExc_KeyError, "Bad key type");
                bpy::throw_error_already_set();
            }
            key_t key = keyproxy();

            // get the corresponding value
            bpy::object valobj{ d[keyobj] };
            bpy::extract<val_t> valproxy{ valobj };
            if (! valproxy.check()) {
                PyErr_SetString(PyExc_ValueError, "Bad value type");
                bpy::throw_error_already_set();
            }
            val_t val = valproxy();
            m[key] = val;
        }

        // remember the location for later
        data->convertible = storage;
    }
};

In order to use it, you must create a Dict2Map instance so that its constructor gets invoked.为了使用它,您必须创建一个Dict2Map实例,以便调用其构造函数。 One possible way of doing it is to create a static Dict2Map<key_t, val_t> variable in the source file where you define the Python wrappers.一种可能的方法是在定义 Python 包装器的源文件中创建一个静态Dict2Map<key_t, val_t>变量。 Using my example:使用我的例子:

// myclasswrapper.cc
#include "mymap.hh"
#include "dict2map.hh"

// register the converter at runtime
static Dict2Map<char, double> reg{};

#include "boost/python.hpp" // not really necessary
namespace bpy = boost::python;

// wrapping MyClass
bpy::class_<MyClass>("MyClass", "My example class",
  bpy::init<mymap_t>()
)
  // .def(...method wrappers...)
;

Now it is possible to create MyClass objects on the Python side like this:现在可以像这样在 Python 端创建MyClass对象:

myclass = MyClass({"foo":1, "bar":2})

Edit : Python lists can be converted to C++ std::vector -s in an analogous manner.编辑:Python 列表可以以类似的方式转换为 C++ std::vector -s。 Here is the corresponding template:下面是对应的模板:

template<typename elem_t>
struct List2Vec {

    /// The type of the vector we convert the Python list into
    typedef std::vector<elem_t> vec_t;

    /// constructor
    /// registers the converter
    List2Vec() {
        bpy::converter::registry::push_back(
            &convertible,
            &construct,
            bpy::type_id<vec_t>()
#ifdef BOOST_PYTHON_SUPPORTS_PY_SIGNATURES
            , &bpy::converter::wrap_pytype<&PyList_Type>::get_pytype
#endif
        );
    }

    /// Check if conversion is possible
    static void* convertible(PyObject* objptr) {
        return PyList_Check(objptr)? objptr: nullptr;
    }

    /// Perform the conversion
    static void construct(
        PyObject* objptr,
        bpy::converter::rvalue_from_python_stage1_data* data
    ) {
        // convert the PyObject pointed to by `objptr` to a bpy::list
        bpy::handle<> objhandle{ bpy::borrowed(objptr) };   // "smart ptr"
        bpy::list lst{ objhandle };

        // get a pointer to memory into which we construct the vector
        // this is provided by the Python side somehow
        void* storage = 
            reinterpret_cast<
                bpy::converter::rvalue_from_python_storage<vec_t>*
            >(data)->storage.bytes;

        // placement-new allocate the result
        new(storage) vec_t{};

        // iterate over the list `lst`, fill up the vector `vec`
        int elemcount{ static_cast<int>(bpy::len(lst)) };
        vec_t& vec{ *(static_cast<vec_t *>(storage)) };
        for (int i = 0; i < elemcount; ++i) {
            // get the element
            bpy::object elemobj{ lst[i] };
            bpy::extract<elem_t> elemproxy{ elemobj };
            if (! elemproxy.check()) {
                PyErr_SetString(PyExc_ValueError, "Bad element type");
                bpy::throw_error_already_set();
            }
            elem_t elem = elemproxy();
            vec.push_back(elem);
        }

        // remember the location for later
        data->convertible = storage;
    }
};

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM