Boost :: Python- possible de convertir automatiquement à partir de dict - & gt; std :: carte?

J'ai une classe C++, avec une fonction membre qui permet de prendre un petit-de-grand nombre de paramètres. Permet nom de ces paramètres, a-f. Tous les paramètres ont des valeurs par défaut. En tant que partie du projet de python je travail, je tiens à exposer cette classe pour python. Actuellement, la fonction de membre ressemble à quelque chose comme ceci:

class myClass {
    public:
    //Constructors - set a-f to default values.

    void SetParameters(std::map<std::string, double> &);
    private:
    double a, b, c, d, e, f;
}

void myClass::SetParameters(std::map<std::string, double> const& params) {
    //Code to iterate over the map, and set any found key/value pairs to their
    //corresponding variable.  i.e.- "a" --> 2.0, would set myClass::a to 2.0
}

Idéalement, en Python, je tiens à le faire à l'aide d'un dict:

>>> A = myModule.myClass();
>>> A.SetParameters({'a': 2.2, 'd': 4.3, b: '9.3'})

De cette façon, l'utilisateur peut entrer les valeurs dans n'importe quel ordre, et entrer n'importe quel nombre d'entre eux à être dépassé. Toute réflexion sur la façon dont cela peut être réalisé dans boost::python? Il me semble que je peux le faire via la modification de la carte d'entrée pour un boost::python objet, et à l'aide de l'extrait de fonctions. Cependant, cela m'obligerait à modifier l'interface de ma bibliothèque (je préfère le garder le std::carte d'interface, et avoir une certaine intermédiaire/auto technique de conversion de la version de python). Pensées?

source d'informationauteur MarkD

  1. 21

    Je pense qu'il y a un couple de façons qui sont plus faciles à atteindre que d'écrire votre propre convertisseur. Vous pouvez utiliser boost::python map_indexing_suite pour faire la conversion pour vous, ou vous pouvez utiliser des mots clés les arguments en python. Personnellement, je préfère le mot-clé arguments, comme c'est le plus "Pythonic" façon de le faire.

    Alors c'est votre classe (j'ai ajouté une définition de type de la carte):

    typedef std::map<std::string, double> MyMap;

class myClass {
public:
    //Constructors - set a-f to default values.

    void SetParameters(MyMap &);
private:
    double a, b, c, d, e, f;
};

    Exemple à l'aide de map_indexing_suite:

    #include <boost/python/suite/indexing/map_indexing_suite.hpp>

using boost::python;

BOOST_PYTHON_MODULE(mymodule)
{
    class_<std::map<std::string, double> >("MyMap")
        .def(map_indexing_suite<std::map<std::wstring, double> >() );

    class_<myClass>("myClass")
        .def("SetParameters", &myClass::SetParameters);
}

    Exemple à l'aide de mots clés arguments. Cela nécessite l'utilisation d'un raw_function wrapper:

    using namespace boost::python;

object SetParameters(tuple args, dict kwargs)
{
    myClass& self = extract<myClass&>(args[0]);

    list keys = kwargs.keys();

    MyMap outMap;
    for(int i = 0; i < len(keys); ++i) {
        object curArg = kwargs[keys[i]];
        if(curArg) {
            outMap[extract<std::string>(keys[i])] = extract<double>(kwargs[keys[i]]);
        }               
    }
    self.SetParameters(outMap);

    return object();
}

BOOST_PYTHON_MODULE(mymodule)
{
    class_<myClass>("myClass")
        .def("SetParameters", raw_function(&SetParameters, 1));
}

    cela permet d'écrire des trucs comme ça en Python:

    A.SetParameters(a = 2.2, d = 4.3, b = 9.3)
  2. 6

    Ce blog a une jolie description claire de la façon d'écrire ces convertisseurs. Le motif de base est de définir une classe qui est de la forme:

    struct SomeType_from_PyObject
{
    SomeType_from_PyObject();
    static void* convertible(PyObject* obj_ptr);
    static void construct(PyObject* obj_ptr,
                          converter::rvalue_from_python_stage1_data* data);
};

    Où le constructeur est responsable de l'ajout de ce convertisseur Boost.Python registre:

    SomeType_from_PyObject::SomeType_from_PyObject()
{
    converter::registry::push_back(&convertible,
                                   &construct,
                                   type_id<SomeType>());
}

    La fonction convertible dit Boost si oui ou non ce convertisseur permet de convertir les spécifiée objet Python:

    void* SomeType_from_PyObject::convertible(PyObject* obj_ptr)
{
    if (PyMapping_Check(obj_ptr)) {
        return obj_ptr;
    } else {
        return NULL;
    }
}

    La construct fonction crée un objet du type de conversion:

    void SomeType_from_PyObject::construct(PyObject* obj_ptr,
                                       converter::rvalue_from_python_stage1_data* data)
{
    typedef converter::rvalue_from_python_storage<SomeType> storage_t;
    storage_t* the_storage = reinterpret_cast<storage_t*>(data);
    void* memory_chunk = the_storage->storage.bytes;
    object obj(handle<>(borrowed(obj_ptr)));
    SomeType* output = new (memory_chunk) SomeType();
    //Use the contents of obj to populate output, e.g. using extract<>
    data->convertible = memory_chunk;
}

    et puis dans votre l'intérieur de votre BOOST_PYTHON_MODULE, inclure la ligne

    SomeType_from_PyObject();
  3. 0

    Je suis juste de mes orteils mouillés avec boost::python ne peut donc pas répondre complètement à votre question. Mais le premier obstacle que je vois est de garantir que le py dict les touches sont toutes les chaînes. Python dicts peut également être saisi sur les n-uplets (et je suppose que plusieurs types).