如何包裝一個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; 
    } 
};