如何包装一个C++类与构造函数一个std ::地图或std :: vector的说法并带有Boost.Python？

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, ... 

和MyMap在Python端不能与字典或者初始化。

已经用Google搜索了好几天，最精彩的部分，我能找到的唯一采取的是映射与.def(...)std::map参数“正常”的方法的例子。并且在.def(...)中，您不必明确指定映射方法的参数，它们被神奇地发现。使用构造函数，您必须使用boost::python::init<...>()，或者至少这是我从文档中理解的。

问题：

1. 要我补充一下到MyMap包装，以帮助map_indexing_suite转换从Pyt​​hon字典？
2. 我应当用MyClass包装在boost::python::init<...>不同的模板参数？
3. 任何其他的想法...？

注意：我也看到this accepted answer at SO，然后我向下滚动和读取@YvesgereY评论：

“为了记录在案，map_indexing_suite解决方案不起作用，因为没有 隐“dict-> std :: map”from_python转换器将被应用。“

，我失去了信心:-)

Answer 1

我找到了一个很好的解决方案：添加，可以转换一个Python字典std::map的模板。该逻辑是基于this extremely useful primer，具有主要来自this source file获得轻微的修改和一些额外的注释。

下面是模板定义：

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