[英]How to wrap a C++ class with a constructor that takes a std::map or std::vector argument with Boost.Python?
免責聲明:是的,我知道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
也不能用字典初始化。
在谷歌搜索了一天中最好的部分后,我只能找到“普通”方法的示例,這些方法采用使用.def(...)
映射的std::map
參數。 在.def(...)
您不必明確指定映射方法的參數,它們會被神奇地發現。 對於構造函數,您必須使用boost::python::init<...>()
,或者至少這是我從文檔中理解的。
問題:
MyMap
包裝器中添加一些東西來幫助map_indexing_suite
從 Python 字典轉換嗎?MyClass
包裝器的boost::python::init<...>
中使用不同的模板參數嗎?注意:我也在SO 上看到了這個已接受的答案,然后我向下滾動並閱讀了@YvesgereY 的評論:
“根據記錄,map_indexing_suite 解決方案不起作用,因為不會應用隱式的“dict->std::map”from_python 轉換器。”
我失去了信心:-)
我找到了一個不錯的解決方案:添加了一個可以將 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;
}
};
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.