Boost.Pythonでstd :: mapまたはstd :: vector引数を取るコンストラクタでC++クラスをラップする方法は？

Question

免責事項：はい、私はを知っています約boost::python::map_indexing_suiteを知っています。

タスク：Boost.PythonでラップしたいC++クラスがあります。そのコンストラクタは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...) 
; 

これがコンパイル。しかし、私はコンストラクタへの引数として何を渡すべきかわからないので、私は、MyClassオブジェクトをPython側から作成することはできません。辞書はstd::map -s自動的に変換されません：

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

インタプリタは（当然のように）文句を言う：Pythonの側

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

とMyMapは、いずれかの辞書で初期化することはできません。

グーグルでは、グーグルでグーグルで調べたところ、.def(...)にマップされているstd::mapの引数を取った「通常の」メソッドの例しか見つかりませんでした。そして、.def(...)では、マップされたメソッドの引数を明示的に指定する必要はありません。それらは魔法のように発見されます。コンストラクタでは、boost::python::init<...>()を使用する必要があります。少なくとも、これはドキュメントから理解したものです。

質問：

1. 私はPythonの辞書からmap_indexing_suite変換を助けるためにMyMapラッパーに何かを追加ましょうか？
2. MyClassラッパーのboost::python::init<...>に別のテンプレート引数を使用しますか？
3. その他のアイデア...？

注：暗黙の無 以来、map_indexing_suiteソリューションは、動作しません

」記録のために：私はまた、私は下にスクロールして@YvesgereYによってコメントを読んで、this accepted answer at SO見てきました"dict-> std :: map" from_pythonコンバーターが適用されます。 "

そして私は

Answer 1

:-)信仰を失った私は素敵な解決策を見つけた：std::mapにPythonの辞書に変換することができますテンプレートを追加しました。このロジックは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インスタンスを作成する必要があります。

以下はテンプレート定義です。可能な方法の1つは、ソースファイルにPythonラッパーを定義する静的変数Dict2Map<key_t, val_t>を作成することです。私の例を使用して：編集

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

：

// 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オブジェクトを作成することが可能である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; 
    } 
};