UnitWrapper.h

Go to the documentation of this file.

/*
 * Copyright (C) by
 *   MetraLabs GmbH (MLAB), GERMANY
 *  and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Redistribution and modification of this code is strictly prohibited.
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_TOOLBOXES_PYTHON_UNITWRAPPERY_H_
#define _MIRA_TOOLBOXES_PYTHON_UNITWRAPPERY_H_

#include <Python.h>

#include <python/BoostPythonWrapper.h>

#include <transform/Pose.h>
#include <fw/Unit.h>

#include <python/PythonSet.h>
#include <python/PythonException.h>
#include <python/PythonInterpreter.h>
#include <python/ReflectorWrapper.h>
#include <python/ScopedGIL.h>

namespace mira { namespace python {


class PyUnitWrapper;

class PyUnit : public mira::Unit
{
    MIRA_OBJECT(PyUnit)

    friend class PyUnitWrapper;
    friend class PythonUnitLoader;

protected:
    PyUnit(Duration cycleTime = Duration::milliseconds(500),
           Authority::Flags flags = Authority::NORMAL) :
        Unit(cycleTime, flags)
    {}

public:
    virtual ~PyUnit()
    {
        // this allows the unit to be safely deleted in Python without segfaulting
        ScopedGILLock lock;
        mUnitObject = boost::python::object();
        checkout();
        setPropertyNode(boost::shared_ptr<PropertyNode>());
    }

    void setUnitObject(boost::python::object unit)
    {
        mUnitObject = unit;
    }

    PyUnitWrapper& unit()
    {
        return boost::python::extract<PyUnitWrapper&>(mUnitObject);
    }

    template<class Reflector>
    void reflect(Reflector& r);

    void initialize();
    void process(const mira::Timer& timer);
    void finalize();

protected:
    boost::python::object mUnitObject;
};

class PyUnitWrapperBase
{
public:
    PyUnitWrapperBase() : mUnit(NULL) {}

    virtual ~PyUnitWrapperBase() {}

    virtual void reflect(BaseReflectorWrapper& r) = 0;

    virtual void initialize() = 0;

    virtual void process() = 0;

    virtual void finalize() = 0;

    void setUnit(PyUnit* unit) { mUnit = unit; }

    PyUnit& getUnit()
    {
        if(!isValid()) {
            MIRA_THROW(XRuntime, "Unit is not properly initialized")
        }
        return *mUnit;
    }

    PyUnit* getUnitPtr()
    {
        return mUnit;
    }

    bool isValid() const { return mUnit != NULL; }

private:

    PyUnit* mUnit;
};


class PyUnitWrapper: public PyUnitWrapperBase, public boost::python::wrapper<PyUnitWrapperBase>
{
public:
    PyUnitWrapper(PyObject* self) :
        mSelf(self),
        mCycleTime(Duration::milliseconds(500)),
        mFlags(Authority::NORMAL)
    {
        boost::python::detail::initialize_wrapper(self, this);
    }
    PyUnitWrapper(PyObject* self, uint32 flags) :
        mSelf(self),
        mCycleTime(Duration::milliseconds(500)),
        mFlags((Authority::Flags)flags)
    {
        boost::python::detail::initialize_wrapper(self, this);
    }

    PyUnitWrapper(PyObject* self, const Duration& cycleTime) :
        mSelf(self),
        mCycleTime(cycleTime),
        mFlags(Authority::NORMAL)
    {
        boost::python::detail::initialize_wrapper(self, this);
    }

    PyUnitWrapper(PyObject* self, const Duration& cycleTime, uint32 flags) :
        mSelf(self),
        mCycleTime(cycleTime),
        mFlags((Authority::Flags)flags)
    {
        boost::python::detail::initialize_wrapper(self, this);
    }

    virtual ~PyUnitWrapper();

    void checkinCycleTime(const std::string& ns, const std::string& name,
                          const Duration& cycleTime);

    void checkin(const std::string& ns, const std::string& name)
    {
        checkinCycleTime(ns, name, mCycleTime);
    }

    void checkout();

    boost::python::handle<> self()
    {
        return boost::python::handle<>(boost::python::borrowed(mSelf));
    }

    void reflect(BaseReflectorWrapper& r);
    void initialize();
    void process();
    void finalize();

    void bootup(const std::string& message);
    void warning(const std::string& category, const std::string& message);
    void error(const std::string& category, const std::string& message);
    void ok(const std::string& category);

    void spin();

    std::string getNamespace();
    std::string getName();
    std::string getGlobalName();
    std::string getID();
    std::string getGlobalID();
    const Duration& getCycleTime();
    const Authority::Flags& getAuthorityFlags();
    uint32 getAuthorityFlagsAsUInt32();

    std::string resolveName(const std::string& name);

    bool waitForService(const std::string& service);

    bool waitForServiceDuration(const std::string& service, const Duration& d);

    std::string waitForServiceInterface(const std::string& service);

    std::string waitForServiceInterfaceDuration(const std::string& service,
                                                const Duration& d);

    bool existsService(const std::string& service);

    boost::python::list queryServicesForInterface(const std::string& interface);

    void publishService();

    bool doesChannelExist(const std::string& channelID);

    bool waitForChannel(const std::string& channelID);

    bool waitForChannelDuration(const std::string& channelID, const Duration& d);

    mira::Channel<void> getChannel(const std::string& channelID);

    Pose2 getTransform2Latest(const std::string& target, const std::string& source);
    Pose2 getTransform2(const std::string& target, const std::string& source, const Time& time);
    Pose3 getTransform3Latest(const std::string& target, const std::string& source);
    Pose3 getTransform3(const std::string& target, const std::string& source, const Time& time);
    void publishTransform2Now(const std::string& node, const Pose2& t);
    void publishTransform2(const std::string& node, const Pose2& t, const Time& timestamp);
    void publishTransform3Now(const std::string& node, const Pose3& t);
    void publishTransform3(const std::string& node, const Pose3& t, const Time& timestamp);
    void publishTransformIndirect2Now(const std::string& frameID,
                                      const std::string& targetID,
                                      const std::string& sourceID,
                                      const Pose2& transform);
    void publishTransformIndirect2(const std::string& frameID,
                                   const std::string& targetID,
                                   const std::string& sourceID,
                                   const Pose2& transform,
                                   const Time& timestamp);
    void publishTransformIndirect3Now(const std::string& frameID,
                                      const std::string& targetID,
                                      const std::string& sourceID,
                                      const Pose3& transform);
    void publishTransformIndirect3(const std::string& frameID,
                                   const std::string& targetID,
                                   const std::string& sourceID,
                                   const Pose3& transform,
                                   const Time& timestamp);
    void addTransformLink(const std::string& childID, const std::string& parentID);

    boost::python::object channelPublish(const std::string& channelID,
                                         boost::python::object type);

    class BaseCallback
    {
    public:
        virtual ~BaseCallback() {}
    };

    template<typename T>
    class Callback : public BaseCallback
    {
    public:
        Callback(const boost::python::object& callable)
            : mCallable(callable)
        {
        }

        void operator()(ChannelRead<T> read)
        {
            mira::python::ScopedGILLock lock;
            try
            {
                mCallable(read);
            }
            catch(boost::python::error_already_set&)
            {
                MIRA_THROW(mira::XRuntime, "Failed to call callback: " <<
                                           mira::python::getLastExceptionString());
            }
        }

    protected:
        boost::python::object mCallable;
    };

    template<typename T>
    class CallbackInterval : public BaseCallback
    {
    public:
        CallbackInterval(const boost::python::object& callable)
            : mCallable(callable)
        {
        }

        void operator()(ChannelReadInterval<T> read)
        {
            mira::python::ScopedGILLock lock;
            try
            {
                mCallable(read);
            }
            catch(boost::python::error_already_set&)
            {
                MIRA_THROW(mira::XRuntime, "Failed to call callback: " <<
                                           mira::python::getLastExceptionString());
            }
        }

    protected:
        boost::python::object mCallable;
    };

    boost::python::object subscribe(const std::string& channelID,
                                           boost::python::object type);

    boost::python::object subscribeCb(const std::string& channelID,
                                      boost::python::object type,
                                      boost::python::object callable);

    boost::python::object subscribeIntervalCb(const std::string& channelID,
                                              boost::python::object type,
                                              boost::python::object callable,
                                              const Duration& storageDuration);

    void unsubscribe(const std::string& channelID, boost::python::object type);

    bool isSubscribedOn(const std::string& channelID);

protected:

    template<typename T>
    Channel<T> subscribe_internal(const std::string& channelID,
                                  boost::python::object callable,
                                  const Duration& storageDuration)
    {
        using namespace boost::python;
        boost::shared_ptr<CallbackInterval<T>> callback(new CallbackInterval<T>(callable));
        mCallbacks.push_back(callback);
        return getUnit().subscribeInterval(channelID, &CallbackInterval<T>::operator(), callback.get(), storageDuration);
    }

    template<typename T>
    Channel<T> subscribe_internal(const std::string& channelID,
                                  boost::python::object callable)
    {
        using namespace boost::python;
        boost::shared_ptr<Callback<T>> callback(new Callback<T>(callable));
        mCallbacks.push_back(callback);
        return getUnit().subscribe(channelID, &Callback<T>::operator(), callback.get());
    }

    template<typename T>
    Channel<T> subscribe_internal(const std::string& channelID)
    {
        return getUnit().subscribe<T>(channelID);
    }

    template<typename T>
    void unsubscribe_internal(const std::string& channelID)
    {
         getUnit().unsubscribe<T>(channelID);
    }

    template<typename T>
    Channel<T> publish_internal(const std::string& channelID)
    {
        return getUnit().publish<T>(channelID);
    }

    PyObject* mSelf;
    Duration mCycleTime;
    Authority::Flags mFlags;
    std::vector<boost::shared_ptr<BaseCallback>> mCallbacks;

    template<typename T>
    friend Channel<T> subscribe(PyUnitWrapper& unit, const std::string& channelID);

    template<typename T>
    friend Channel<T> subscribeCb(PyUnitWrapper& unit, const std::string& channelID,
                                  boost::python::object callable);

    template<typename T>
    friend Channel<T> subscribeIntervalCb(PyUnitWrapper& unit, const std::string& channelID,
                                          boost::python::object callable,
                                          const Duration& storageDuration);

    template<typename T>
    friend Channel<T> publish(PyUnitWrapper& unit, const std::string& channelID);

    template<typename T>
    friend void unsubscribe(PyUnitWrapper& unit, const std::string& channelID);

};


template<class Reflector>
void PyUnit::reflect(Reflector& r)
{
    using namespace boost::python;
    MIRA_REFLECT_BASE(r, Unit);

    ScopedGILLock lock;
    ReflectorWrapper<Reflector> reflectorWrapper(r);
    try
    {
        PyUnitWrapper& u = unit();
        MIRA_REFLECT_CALL(Reflector, r, "PyUnit::reflect", u.reflect(reflectorWrapper));
    }
    catch (const error_already_set&)
    {
        MIRA_THROW(XRuntime, "Failed to call reflect on unit: " << getLastExceptionString());
    }
}


template<typename T>
Channel<T> subscribe(PyUnitWrapper& unit, const std::string& channelID) {
    return unit.subscribe_internal<T>(channelID);
}

template<typename T>
Channel<T> subscribeCb(PyUnitWrapper& unit, const std::string& channelID,
                       boost::python::object callable) {
    return unit.subscribe_internal<T>(channelID, callable);
}

template<typename T>
Channel<T> subscribeIntervalCb(PyUnitWrapper& unit, const std::string& channelID,
                               boost::python::object callable,
                               const Duration& storageDuration) {
    return unit.subscribe_internal<T>(channelID, callable, storageDuration);
}

template<typename T>
void unsubscribe(PyUnitWrapper& unit, const std::string& channelID) {
    unit.unsubscribe_internal<T>(channelID);
}

template<typename T>
Channel<T> publish(PyUnitWrapper& unit, const std::string& channelID) {
    return unit.publish_internal<T>(channelID);
}


template <typename T>
struct ChannelAccessWrapper
{
    static T get(Channel<T>& channel)
    {
        return channel.get();
    }

    static T getTime(Channel<T>& channel, const Time& time)
    {
        return channel.get(time);
    }

    static T getTimeDuration(Channel<T>& channel, const Time& time,
                             const Duration& tolerance)
    {
        return channel.get(time, tolerance);
    }

    static ChannelRead<T> read(Channel<T>& channel)
    {
        return channel.read();
    }

    static ChannelRead<T> readTime(Channel<T>& channel, const Time& time)
    {
        return channel.read(time);
    }

    static ChannelRead<T> readTimeDuration(Channel<T>& channel, const Time& time,
                                           const Duration& tolerance)
    {
        return channel.read(time, tolerance);
    }

    static void postTimeFrame(Channel<T>& channel, const T& value, const Time& time,
                              const std::string& frameID)
    {
        auto w = channel.write();
        w->timestamp = time;
        w->value() = value;
        w->frameID = frameID;
    }

    static void postTime(Channel<T>& channel, const T& value, const Time& time)
    {
        channel.post(value, time);
    }

    static void post(Channel<T>& channel, const T& value)
    {
        channel.post(value);
    }
};

template <typename T>
struct ChannelWaitWrapper
{
    static bool waitForPublisherTime(Channel<T>& channel, const Duration& d)
    {
        ScopedGILThreadLock lock;
        return channel.waitForPublisher(d);
    }

    static bool waitForPublisher(Channel<T>& channel)
    {
        return ChannelWaitWrapper<T>::waitForPublisherTime(channel, Duration::infinity());
    }

    static bool waitForDataTime(Channel<T>& channel, const Duration& d)
    {
        ScopedGILThreadLock lock;
        ChannelRead<T> r = channel.waitForData(d);
        return r.isValid();
    }

    static bool waitForData(Channel<T>& channel)
    {
        return ChannelWaitWrapper<T>::waitForDataTime(channel, Duration::infinity());
    }
};

template<typename T>
struct ChannelReadWrapperBase {
    static Time getTimestamp(ChannelRead<T>& read) {
        return read->timestamp;
    }

    static std::string getFrameID(ChannelRead<T>& read) {
        return read->frameID;
    }

    static uint32 getSequenceID(ChannelRead<T>& read) {
        return read->sequenceID;
    }
};

template<typename T>
struct ChannelReadWrapper : public ChannelReadWrapperBase<T> {
    static const T& getValue(ChannelRead<T>& read) {
        return read->value();
    }
};

template<typename T>
struct ChannelReadIntervalWrapper {
    typedef typename ChannelReadInterval<T>::IntervalList::const_iterator IntervalListIterator;

    static IntervalListIterator begin(ChannelReadInterval<T>& rv)
    {
        return static_cast<IntervalListIterator>(rv.begin());
    }

    static IntervalListIterator end(ChannelReadInterval<T>& rv)
    {
        return static_cast<IntervalListIterator>(rv.end());
    }
};


template<typename T>
boost::python::object convertJSONtoObject(const json::Value& value)
{
    JSONDeserializer deserializer(value);
    T obj;
    deserializer.deserialize(obj);
    return boost::python::object(obj);
}

template<typename T>
json::Value convertObjectToJSON(const T& obj)
{
    JSONSerializer json;
    return json.serialize(obj);
}


}}

MIRA_NO_PUBLIC_DEFAULT_CONSTRUCTOR(python::PyUnit) // this must be outside of namespaces


#define MIRA_PYTHON_COMMA_HELPER ,

#define MIRA_PYTHONCONNECTOR_ALL_TYPES(MACRO)   \
MACRO(bool, "Bool");                            \
MACRO(int, "Int");                              \
MACRO(int64, "Int64");                          \
MACRO(float, "Float");                          \
MACRO(std::string, "String");

#define MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER(MACRO, TYPE, PREFIX)                    \
MACRO(TYPE, bool, PREFIX, "Bool");          \
MACRO(TYPE, int, PREFIX, "Int");            \
MACRO(TYPE, int64, PREFIX, "Int64");        \
MACRO(TYPE, float, PREFIX, "Float");        \
MACRO##_STRING(TYPE, std::string, PREFIX, "String");

#define MIRA_PYTHONCONNECTOR_ALL_TYPES_2(MACRO)                         \
MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER(MACRO, bool, "Bool");           \
MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER(MACRO, int, "Int");             \
MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER(MACRO, int64, "Int64");         \
MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER(MACRO, float, "Float");         \
MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER(MACRO, std::string, "String");

#define MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(type, name)                      \
        .def("subscribeInterval", &mira::python::subscribeIntervalCb<type>)     \
        .staticmethod("subscribeInterval")                                      \
        .def("subscribe", &mira::python::subscribeCb<type>)                     \
        .def("subscribe", &mira::python::subscribe<type>)                       \
        .staticmethod("subscribe")                                              \
        .def("unsubscribe", &mira::python::unsubscribe<type>)                   \
        .staticmethod("unsubscribe")                                            \
        .def("publish", &mira::python::publish<type>)                           \
        .staticmethod("publish")                                                \
        .def("convertJSONtoObject", &mira::python::convertJSONtoObject<type>)   \
        .staticmethod("convertJSONtoObject")                                    \
        .def("convertObjectToJSON", &mira::python::convertObjectToJSON<type>)   \
    ;                                                                           \
    class_<mira::Channel<type> >((std::string("Channel")+name).c_str())         \
        .def("post", &mira::python::ChannelAccessWrapper<type>::postTimeFrame)  \
        .def("post", &mira::python::ChannelAccessWrapper<type>::postTime)       \
        .def("post", &mira::python::ChannelAccessWrapper<type>::post)           \
        .def("get", &mira::python::ChannelAccessWrapper<type>::get)             \
        .def("get", &mira::python::ChannelAccessWrapper<type>::getTime)         \
        .def("read", &mira::python::ChannelAccessWrapper<type>::read)           \
        .def("read", &mira::python::ChannelAccessWrapper<type>::readTime)       \
        .def("read", &mira::python::ChannelAccessWrapper<type>::readTimeDuration)   \
        .def("hasPublisher", &Channel<type>::hasPublisher)                      \
        .def("hasSubscriber", &Channel<type>::hasSubscriber)                    \
        .def("isValid", &Channel<type>::isValid)                                \
        .def("waitForPublisher", &mira::python::ChannelWaitWrapper<type>::waitForPublisherTime) \
        .def("waitForPublisher", &mira::python::ChannelWaitWrapper<type>::waitForPublisher) \
        .def("waitForData", &mira::python::ChannelWaitWrapper<type>::waitForDataTime)   \
        .def("waitForData", &mira::python::ChannelWaitWrapper<type>::waitForData)   \
    ;                                                                           \
    class_<mira::ChannelRead<type> >((std::string("ChannelRead")+name).c_str())\
        .add_property("Value", make_function(&mira::python::ChannelReadWrapper<type>::getValue,     \
             return_value_policy<reference_existing_object>()))                 \
        .add_property("Timestamp", &mira::python::ChannelReadWrapper<type>::getTimestamp)   \
        .add_property("FrameID", &mira::python::ChannelReadWrapper<type>::getFrameID)       \
        .add_property("SequenceID", &mira::python::ChannelReadWrapper<type>::getSequenceID) \
    ;                                                                           \
    class_<mira::ChannelReadInterval<type> >((std::string("ChannelReadInterval")+name).c_str())\
        .def("__len__", &mira::ChannelReadInterval<type>::size) \
        .def("__iter__", boost::python::range<return_value_policy<return_by_value> >(&mira::python::ChannelReadIntervalWrapper<type>::begin, &mira::python::ChannelReadIntervalWrapper<type>::end)) \
    ;

#define MIRA_PYTHONCONNECTOR_TYPE_FOOTER(type)                                  \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(type,#type)

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_CHANNEL_WRAPPER(type, name)              \
    class_<mira::Channel<type> >("Channel" name)                                \
        .def("post", &mira::python::ChannelAccessWrapper<type>::postTimeFrame)  \
        .def("post", &mira::python::ChannelAccessWrapper<type>::postTime)       \
        .def("post", &mira::python::ChannelAccessWrapper<type>::post)           \
        .def("get", &mira::python::ChannelAccessWrapper<type>::get)             \
        .def("get", &mira::python::ChannelAccessWrapper<type>::getTime)         \
        .def("get", &mira::python::ChannelAccessWrapper<type>::getTimeDuration) \
        .def("read", &mira::python::ChannelAccessWrapper<type>::read)           \
        .def("read", &mira::python::ChannelAccessWrapper<type>::readTime)       \
        .def("read", &mira::python::ChannelAccessWrapper<type>::readTimeDuration)   \
        .def("hasPublisher", &Channel<type>::hasPublisher)                      \
        .def("hasSubscriber", &Channel<type>::hasSubscriber)                    \
        .def("isValid", &Channel<type>::isValid)                                \
        .def("waitForPublisher", &mira::python::ChannelWaitWrapper<type>::waitForPublisherTime) \
        .def("waitForPublisher", &mira::python::ChannelWaitWrapper<type>::waitForPublisher) \
        .def("waitForData", &mira::python::ChannelWaitWrapper<type>::waitForDataTime)   \
        .def("waitForData", &mira::python::ChannelWaitWrapper<type>::waitForData)   \
    ;                                                                           \
    class_<mira::ChannelRead<type> >((std::string("ChannelRead")+name).c_str())\
        .add_property("Value", make_function(&mira::python::ChannelReadWrapper<type>::getValue,     \
             return_value_policy<return_by_value>()))                   \
        .add_property("Timestamp", &mira::python::ChannelReadWrapper<type>::getTimestamp)   \
        .add_property("FrameID", &mira::python::ChannelReadWrapper<type>::getFrameID)       \
        .add_property("SequenceID", &mira::python::ChannelReadWrapper<type>::getSequenceID) \
    ;                                                                           \
    class_<mira::ChannelReadInterval<type> >((std::string("ChannelReadInterval")+name).c_str())\
        .def("__len__", &mira::ChannelReadInterval<type>::size) \
        .def("__iter__", range<return_value_policy<return_by_value> >(&mira::python::ChannelReadIntervalWrapper<type>::begin, &mira::python::ChannelReadIntervalWrapper<type>::end)) \
    ;

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_VECTOR_CHANNEL_WRAPPER(type, name)                           \
    class_<std::vector<type> >("Vector" name)                                                       \
        .def(vector_indexing_suite<std::vector<type> >())                                           \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(std::vector<type>, "Vector" name)

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_SET_CHANNEL_WRAPPER(type, name)                              \
    MIRA_PYTHONCONNECTOR_PYTHONSET_FUNCTIONS(type, "Set" name,                                      \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(std::set<type>, "Set" name))

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_CHANNEL_WRAPPER(type1, type2, name1, name2)              \
    class_<std::map<type1, type2> >("Map" name1 name2)                                              \
        .def(map_indexing_suite<std::map<type1, type2> >())                                         \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(std::map<type1 MIRA_PYTHON_COMMA_HELPER type2>, "Map" name1 name2)

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_CHANNEL_WRAPPER_STRING(type1, type2, name1, name2)       \
    class_<std::map<type1, type2> >("Map" name1 name2)                                              \
        .def(map_indexing_suite<std::map<type1, type2>, true>())                                    \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(std::map<type1 MIRA_PYTHON_COMMA_HELPER type2>, "Map" name1 name2)

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_OF_VECTORS_CHANNEL_WRAPPER(type1, type2, name1, name2)   \
    class_<std::map<type1, std::vector<type2> > >("Map" name1 "Vector" name2)                       \
        .def(map_indexing_suite<std::map<type1, std::vector<type2> > >())                           \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(std::map<type1 MIRA_PYTHON_COMMA_HELPER std::vector<type2> >, "Map" name1 "Vector" name2)

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_OF_VECTORS_CHANNEL_WRAPPER_STRING(type1, type2, name1, name2)    \
    class_<std::map<type1, std::vector<type2> > >("Map" name1 "Vector" name2)                               \
        .def(map_indexing_suite<std::map<type1, std::vector<type2> >, true>())                              \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(std::map<type1 MIRA_PYTHON_COMMA_HELPER std::vector<type2> >, "Map" name1 "Vector" name2)

#endif