如何使用一个构造函数包装一个C++类，该构造函数使用 Boost.Python 获取 std::map 或 std::v

Question

免责声明：是的，我知道boost::python::map_indexing_suite。

任务：我有一个C++类，我想用Boost.Python包装它。它的构造函数采用std::map参数。这是C++标头：

// myclass.hh
typedef std::map<int, float> mymap_t;
class MyClass {
public:
explicit MyClass(const mymap_t& m);
// ...
};
// ...

以下是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...)
;

这将编译。但是，我无法从 Python 端创建映射的MyClass对象，因为我不知道将什么作为参数传递给构造函数。字典不会自动转换为std::map-s：

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

口译员抱怨(理所当然)：

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

Python 端的MyMap也不能用字典初始化。

在谷歌搜索了一天中最好的部分之后，我只能找到"正常"方法的示例，这些方法采用std::map与.def(...)映射的参数。在.def(...)中，您不必显式指定映射方法的参数，它们会被神奇地发现。对于构造函数，您必须使用boost::python::init<...>()，或者至少这是我从文档中理解的。

问题：

1. 我应该在MyMap包装器中添加一些东西来帮助map_indexing_suite从 Python 字典转换吗？
2. 我应该在MyClass包装器中boost::python::init<...>使用不同的模板参数吗？
3. 还有其他想法吗？

注意：我也在SO上看到了这个公认的答案，然后我向下滚动并阅读了@YvesgereY的评论：

"为了记录，map_indexing_suite解决方案不起作用，因为没有 将应用隐式的"dict->std：：map"from_python转换器。

我失去了信心：-)

Answer 1

我找到了一个不错的解决方案：添加了一个可以将 Python 字典转换为std::map的模板。该逻辑基于这个非常有用的入门，略有修改，主要从此源文件和一些附加注释中获得。

以下是模板定义：

// 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;
}
};

为了使用它，您必须创建一个Dict2Map实例，以便调用其构造函数。一种可能的方法是在定义 Python 包装器的源文件中创建一个静态Dict2Map<key_t, val_t>变量。使用我的例子：

// 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...)
;

现在可以像这样在 Python 端创建MyClass对象：

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

编辑：Python列表可以以类似的方式转换为C++std::vector-s。这是相应的模板：

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;
}
};