ReflectorWrapper.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.
 */

/*
 * @file ReflectorWrapper.h
 *    Python wrapper for MIRA reflectors.
 *
 * @author Christian Vollmer, Tim Langner
 * @date:  2011/03/09
 */

#ifndef _MIRA_TOOLBOXES_PYTHON_REFLECTORWRAPPER_H_
#define _MIRA_TOOLBOXES_PYTHON_REFLECTORWRAPPER_H_

#include <Python.h>

#include <python/BoostPythonWrapper.h>

#ifndef Q_MOC_RUN
#include <boost/python/stl_iterator.hpp>
#endif

#include <boost/preprocessor/arithmetic/div.hpp>
#include <boost/preprocessor/arithmetic/mul.hpp>

#include <serialization/ReflectorInterface.h>
#include <serialization/GetterSetter.h>
#include <serialization/adapters/std/vector>
#include <python/PythonException.h>
#include <python/RPCDefinitions.h>
#include <python/ScopedGIL.h>
#include <python/Version.h>

namespace mira { namespace python {


template <typename T>
inline std::vector<T> listToVector(const boost::python::object& l)
{
    return std::vector<T>(boost::python::stl_input_iterator< T >(l),
                          boost::python::stl_input_iterator< T >());
}

template<typename Reflector>
struct ReflectorWrapperVersionHelper
{
    static serialization::VersionType versionHelp(Reflector& r,
                                                  serialization::VersionType version,
                                                  boost::python::object callerType)
    {
        return version;
    }
};

// expose protected MetaSerializer::version(VersionType, string) by subclassing
template<>
struct ReflectorWrapperVersionHelper<MetaSerializer> : public MetaSerializer
{
    typedef ReflectorWrapperVersionHelper<MetaSerializer> Derived;
    static serialization::VersionType versionHelp(MetaSerializer& r,
                                                  serialization::VersionType version,
                                                  boost::python::object callerType)
    {
        PyObject* module_ = PyObject_GetAttrString(callerType.ptr(), "__module__");
        PyObject* name_   = PyObject_GetAttrString(callerType.ptr(), "__name__");
        std::string module = boost::python::extract<std::string>(module_);
        std::string name   = boost::python::extract<std::string>(name_);
        return ((Derived&)r).version(version, module + "." + name);
    }
};

template<typename ReturnType = json::Value>
struct ReflectorWrapperRPCCallHelper
{
    #define REFLECTORWRAPPERGEN_SERVICE_METHODS(z,n,_)                  \
    static ReturnType rpcCall##n(boost::python::object callable BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, const json::Value& p)) {  \
        using namespace boost::python;                                  \
        ScopedGILLock lock;                                             \
        try                                                             \
        {                                                               \
            boost::python::object value = callable(BOOST_PP_ENUM_PARAMS_Z(z, n, p));    \
            return boost::python::extract<ReturnType>(value);           \
        }                                                               \
        catch(boost::python::error_already_set&)                        \
        {                                                               \
            MIRA_THROW(XInvalidParameter, "Error calling rpc method: " << getLastExceptionString()); \
        }                                                               \
        return ReturnType();                                            \
    }
    BOOST_PP_REPEAT(BOOST_PP_INC(RPC_METHODS_MAX_PARAMS), REFLECTORWRAPPERGEN_SERVICE_METHODS, nil)
    #undef REFLECTORWRAPPERGEN_SERVICE_METHODS
};

template<>
struct ReflectorWrapperRPCCallHelper<void>
{
    #define REFLECTORWRAPPERGEN_SERVICE_METHODS(z,n,_)                  \
    static void rpcCall##n(boost::python::object callable BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, const json::Value& p)) {    \
        using namespace boost::python;                                  \
        ScopedGILLock lock;                                             \
        try                                                             \
        {                                                               \
            callable(BOOST_PP_ENUM_PARAMS_Z(z, n, p));                  \
        }                                                               \
        catch(boost::python::error_already_set&)                        \
        {                                                               \
            MIRA_THROW(XInvalidParameter, "Error calling rpc method: " << getLastExceptionString()); \
        }                                                               \
    }
    BOOST_PP_REPEAT(BOOST_PP_INC(RPC_METHODS_MAX_PARAMS), REFLECTORWRAPPERGEN_SERVICE_METHODS, nil)
    #undef REFLECTORWRAPPERGEN_SERVICE_METHODS
};

class BaseReflectorWrapper
{
public:

    virtual ~BaseReflectorWrapper() {}

    // Since boost::python does not allow us to make this function pure virtual,
    // we provide a dummy default implementation here.
    virtual void member(const std::string& name,
                        boost::python::object getterCallable,
                        boost::python::object setterCallable)
    {
        MIRA_THROW(XRuntime, "This method should never be called. Something is horribly wrong!")
    }

    virtual void property(const std::string& name,
                          boost::python::object getterCallable,
                          boost::python::object setterCallable)
    {
        MIRA_THROW(XRuntime, "This method should never be called. Something is horribly wrong!")
    }

    virtual void interface(const std::string& name)
    {
        MIRA_THROW(XRuntime, "This method should never be called. Something is horribly wrong!")
    }

    virtual void method(const std::string& name,
                        boost::python::object callable)
    {
        MIRA_THROW(XRuntime, "This method should never be called. Something is horribly wrong!")
    }
};

template<typename Reflector>
class ReflectorWrapper : public BaseReflectorWrapper
{
public:

    ReflectorWrapper(Reflector& r) :
        mReflector(r)
    {
    }

    virtual ~ReflectorWrapper()
    {
    }

    void reflectCall(const std::string& context, boost::python::object callable)
    {
        if (!PyCallable_Check(callable.ptr()))
            MIRA_THROW(XRuntime, "parameter is no callable object.");

        ScopedGILLock lock;
        MIRA_REFLECT_CALL(Reflector, mReflector, context.c_str(), callable(*this));
    }

    serialization::VersionType version(serialization::VersionType version,
                                       boost::python::object callerType)
    {
        return ReflectorWrapperVersionHelper<Reflector>::versionHelp(mReflector, version, callerType);
    }

#define REFLECTOR_WRAPPER_CALL_member(access, T) \
    if (defaultValue.is_none())\
    {\
        mReflector.access(name.c_str(),\
                          Getter<T>(boost::bind(&ReflectorWrapper<Reflector>::get<T>, getterCallable)),\
                          Setter<T>(boost::bind(&ReflectorWrapper<Reflector>::set<T>, setterCallable, _1)),\
                          comment.c_str());\
    }\
    else\
    {\
        mReflector.access(name.c_str(),\
                          Getter<T>(boost::bind(&ReflectorWrapper<Reflector>::get<T>, getterCallable)),\
                          Setter<T>(boost::bind(&ReflectorWrapper<Reflector>::set<T>, setterCallable, _1)),\
                          comment.c_str(),\
                          extract<T>(defaultValue));\
    }

#define REFLECTOR_WRAPPER_CALL_roproperty(access, T) \
    mReflector.access(name.c_str(),\
                      Getter<T>(boost::bind(&ReflectorWrapper<Reflector>::get<T>, getterCallable)),\
                      comment.c_str());

#define REFLECTOR_WRAPPER_CALL_LIST_member(access, T) \
    if (defaultValue.is_none())\
    {\
        mReflector.access(name.c_str(),\
                          Getter<std::vector<T>>(boost::bind(&ReflectorWrapper<Reflector>::getList<T>, getterCallable)),\
                          Setter<std::vector<T>>(boost::bind(&ReflectorWrapper<Reflector>::setList<T>, setterCallable, _1)),\
                          comment.c_str());\
    }\
    else\
    {\
        std::vector<T> dv = listToVector<T>(defaultValue); \
        mReflector.access(name.c_str(),\
                          Getter<std::vector<T>>(boost::bind(&ReflectorWrapper<Reflector>::getList<T>, getterCallable)),\
                          Setter<std::vector<T>>(boost::bind(&ReflectorWrapper<Reflector>::setList<T>, setterCallable, _1)),\
                          comment.c_str(),\
                          dv);\
    }

#define REFLECTOR_WRAPPER_CALL_LIST_roproperty(access, T) \
    mReflector.access(name.c_str(),\
                      Getter<std::vector<T>>(boost::bind(&ReflectorWrapper<Reflector>::getList<T>, getterCallable)),\
                      comment.c_str());

#define REFLECTOR_WRAPPER_CALL_property      REFLECTOR_WRAPPER_CALL_member
#define REFLECTOR_WRAPPER_CALL_LIST_property REFLECTOR_WRAPPER_CALL_LIST_member

#define REFLECTOR_WRAPPER_CHECK_GETSET_member \
    if (!PyCallable_Check(getterCallable.ptr()))\
        MIRA_THROW(XRuntime, "getter parameter is no callable object.");\
    if (!PyCallable_Check(setterCallable.ptr())) \
        MIRA_THROW(XRuntime, "setter parameter is no callable object.");\

#define REFLECTOR_WRAPPER_CHECK_GETSET_roproperty \
    if (!PyCallable_Check(getterCallable.ptr()))\
        MIRA_THROW(XRuntime, "getter parameter is no callable object.");\

#define REFLECTOR_WRAPPER_CHECK_GETSET_property REFLECTOR_WRAPPER_CHECK_GETSET_member

#define REFLECTOR_WRAPPER_CALL_IF_TYPE(PyType, CType, access) \
    if (PyType_IsSubtype((PyTypeObject*)type.ptr(), &PyType))\
    {\
        REFLECTOR_WRAPPER_CALL_##access(access, CType)\
        return;\
    }

#define REFLECTOR_WRAPPER_CALL_IF_LIST_TYPE(PyType, CType, access) \
    if (PyType_IsSubtype((PyTypeObject*)listType.ptr(), &PyType))\
    {\
        REFLECTOR_WRAPPER_CALL_LIST_##access(access, CType)\
        return;\
    }

#ifdef MIRA_PYTHON3\
    // https://docs.python.org/3/howto/cporting.html#long-int-unification
    // https://docs.python.org/3/howto/cporting.html#str-unicode-unification
    #define REFLECTOR_WRAPPER_FIND_TYPE(access) \
        REFLECTOR_WRAPPER_CALL_IF_TYPE(PyBool_Type, bool, access) \
        REFLECTOR_WRAPPER_CALL_IF_TYPE(PyLong_Type, int64, access) \
        REFLECTOR_WRAPPER_CALL_IF_TYPE(PyFloat_Type, double, access) \
        REFLECTOR_WRAPPER_CALL_IF_TYPE(PyUnicode_Type, std::string, access)

    #define REFLECTOR_WRAPPER_FIND_LIST_TYPE(access) \
        REFLECTOR_WRAPPER_CALL_IF_LIST_TYPE(PyBool_Type, bool, access) \
        REFLECTOR_WRAPPER_CALL_IF_LIST_TYPE(PyLong_Type, int64, access) \
        REFLECTOR_WRAPPER_CALL_IF_LIST_TYPE(PyFloat_Type, double, access) \
        REFLECTOR_WRAPPER_CALL_IF_LIST_TYPE(PyUnicode_Type, std::string, access)
#else
    #define REFLECTOR_WRAPPER_FIND_TYPE(access) \
        REFLECTOR_WRAPPER_CALL_IF_TYPE(PyBool_Type, bool, access) \
        REFLECTOR_WRAPPER_CALL_IF_TYPE(PyInt_Type, int, access) \
        REFLECTOR_WRAPPER_CALL_IF_TYPE(PyLong_Type, int64, access) \
        REFLECTOR_WRAPPER_CALL_IF_TYPE(PyFloat_Type, double, access) \
        REFLECTOR_WRAPPER_CALL_IF_TYPE(PyString_Type, std::string, access) \
        REFLECTOR_WRAPPER_CALL_IF_TYPE(PyUnicode_Type, std::string, access)

    #define REFLECTOR_WRAPPER_FIND_LIST_TYPE(access) \
        REFLECTOR_WRAPPER_CALL_IF_LIST_TYPE(PyBool_Type, bool, access) \
        REFLECTOR_WRAPPER_CALL_IF_LIST_TYPE(PyInt_Type, int, access) \
        REFLECTOR_WRAPPER_CALL_IF_LIST_TYPE(PyLong_Type, int64, access) \
        REFLECTOR_WRAPPER_CALL_IF_LIST_TYPE(PyFloat_Type, double, access) \
        REFLECTOR_WRAPPER_CALL_IF_LIST_TYPE(PyString_Type, std::string, access) \
        REFLECTOR_WRAPPER_CALL_IF_LIST_TYPE(PyUnicode_Type, std::string, access)
#endif

#define REFLECTOR_WRAPPER_ACCESS(access) \
    using namespace boost::python;\
    REFLECTOR_WRAPPER_CHECK_GETSET_##access\
\
    if (PyObject_IsInstance(type.ptr(), (PyObject*) &PyList_Type))\
    {\
        int n = PyList_Size(type.ptr());\
        if (n!=1)\
            MIRA_THROW(XRuntime, "List must contain exactly one type information.");\
        object listType = type[0];\
        if (!PyType_Check(listType.ptr()))\
            MIRA_THROW(XRuntime, "Type parameter in list is no type object.");\
\
        REFLECTOR_WRAPPER_FIND_LIST_TYPE(access) \
\
        std::string typeStr = extract<std::string>(str(listType));\
        MIRA_THROW(XRuntime, "Reflect not implemented for primitive type " + typeStr + ".");\
    }\
    else\
    {\
        if (!PyType_Check(type.ptr()))\
            MIRA_THROW(XRuntime, "Type parameter is no type object.");\
\
        REFLECTOR_WRAPPER_FIND_TYPE(access) \
\
        std::string typeStr = extract<std::string>(str(type));\
        MIRA_THROW(XRuntime, "Reflect not implemented for primitive type " + typeStr + ".");\
    }

    void memberWithCommentAndDefault(const std::string& name,
                                     boost::python::object type,
                                     boost::python::object getterCallable,
                                     boost::python::object setterCallable,
                                     const std::string& comment, boost::python::object defaultValue)
    {
        REFLECTOR_WRAPPER_ACCESS(member)
    }

    void propertyWithCommentAndDefault(const std::string& name,
                                       boost::python::object type,
                                       boost::python::object getterCallable,
                                       boost::python::object setterCallable,
                                       const std::string& comment, boost::python::object defaultValue)
    {
        REFLECTOR_WRAPPER_ACCESS(property)
    }

    void ropropertyWithComment(const std::string& name,
                               boost::python::object type,
                               boost::python::object getterCallable,
                               const std::string& comment)
    {
        REFLECTOR_WRAPPER_ACCESS(roproperty)
    }

#undef REFLECTOR_WRAPPER_CALL
#undef REFLECTOR_WRAPPER_CALL_LIST
#undef REFLECTOR_WRAPPER_CALL_IF_TYPE
#undef REFLECTOR_WRAPPER_CALL_IF_LIST_TYPE
#undef REFLECTOR_WRAPPER_FIND_TYPE
#undef REFLECTOR_WRAPPER_FIND_LIST_TYPE
#undef REFLECTOR_WRAPPER_ACCESS

    void memberWithComment(const std::string& name,
                           boost::python::object type,
                           boost::python::object getterCallable,
                           boost::python::object setterCallable,
                           const std::string& comment)
    {
        using namespace boost::python;
        memberWithCommentAndDefault(name, type, getterCallable, setterCallable, comment, object());
    }

    void propertyWithComment(const std::string& name,
                             boost::python::object type,
                             boost::python::object getterCallable,
                             boost::python::object setterCallable,
                             const std::string& comment)
    {
        using namespace boost::python;
        propertyWithCommentAndDefault(name, type, getterCallable, setterCallable, comment, object());
    }

    void member(const std::string& name,
                boost::python::object type,
                boost::python::object getterCallable,
                boost::python::object setterCallable)
    {
        using namespace boost::python;
        memberWithComment(name, type, getterCallable, setterCallable, "");
    }

    void property(const std::string& name,
                  boost::python::object type,
                  boost::python::object getterCallable,
                  boost::python::object setterCallable)
    {
        using namespace boost::python;
        propertyWithComment(name, type, getterCallable, setterCallable, "");
    }

    void roproperty(const std::string& name,
                  boost::python::object type,
                  boost::python::object getterCallable)
    {
        using namespace boost::python;
        ropropertyWithComment(name, type, getterCallable, "");
    }

    void interface(const std::string& name)
    {
        mReflector.interface(name.c_str());
    }

    int argumentCount(boost::python::object callable)
    {
        using namespace boost::python;

        if (!PyCallable_Check(callable.ptr()))
            MIRA_THROW(XRuntime, "callable parameter is no callable object.");

        int possibleSelfArg = 0;

#ifdef MIRA_PYTHON3
        const char * codeAttr = "__code__";
        const char * selfAttr = "__self__";
#else
        const char * codeAttr = "func_code";
        const char * selfAttr = "im_self";
#endif
        // Handle function objects vs. methods
        //  * python functions: have a 'func_code'/__code__ attribute
        //  * python methods: only their __call__ method has func_code/__code__
        bool isMethod = PyObject_HasAttrString(callable.ptr(), codeAttr) == 0;
        // TODO: Python's inspect module can likely help here

        object funcCode;
        if (isMethod)
        {
            // method object, need to increment count for 'self'
            possibleSelfArg = 1;
            funcCode = callable.attr("__call__").attr(codeAttr);
        }
        else
        {
            funcCode = callable.attr(codeAttr);

            // Handle instancemethod type callable
            if (PyObject_HasAttrString(callable.ptr(), selfAttr) == 1)
                possibleSelfArg = 1;
        }

        // 0x4 in the flags means we have a function signature with *args
        int flags = extract<int>(funcCode.attr("co_flags"));
        if (flags & 0x04)
            MIRA_THROW(XRuntime, "RPC methods with dynamic number of arguments are not supported");

        int argCount = extract<int>(funcCode.attr("co_argcount")) - possibleSelfArg;

        if (argCount > RPC_METHODS_MAX_PARAMS-1)
            MIRA_THROW(XRuntime, "RPC methods with more than " << RPC_METHODS_MAX_PARAMS-1 << " arguments are not supported");

        return argCount;
    }

    template<typename ReturnType = json::Value>
    void methodWithComment(const std::string& name, boost::python::object callable, const std::string& comment)
    {
        int argCount = argumentCount(callable);

        if (argCount == 0)
            mReflector.template method<ReturnType>(name.c_str(), boost::bind(&ReflectorWrapperRPCCallHelper<ReturnType>::rpcCall0, callable), comment.c_str());
#define REFLECTORWRAPPERGEN_SERVICE_CALLS(z,n,_)                    \
        if (argCount == n)                                          \
            mReflector.template method<ReturnType, BOOST_PP_ENUM_PARAMS(n, json::Value BOOST_PP_INTERCEPT)>(name.c_str(), boost::bind(&ReflectorWrapperRPCCallHelper<ReturnType>::BOOST_PP_CAT(rpcCall, n), callable, BOOST_PP_ENUM_SHIFTED_PARAMS_Z(z,BOOST_PP_INC(n), _)), comment.c_str());
        BOOST_PP_REPEAT_FROM_TO(1, RPC_METHODS_MAX_PARAMS, REFLECTORWRAPPERGEN_SERVICE_CALLS, _)
#undef REFLECTORWRAPPERGEN_SERVICE_CALLS
    }

#define REFLECTORWRAPPERGEN_NAME_DESC_DECL(z,n,_) const std::string& name##n, const std::string& description##n
#define REFLECTORWRAPPERGEN_NAME_DESC(z,n,_) name##n.c_str(), description##n.c_str()

#define REFLECTORWRAPPERGEN_SERVICE_CALLS_DESCRIPTIONS(z,n,_)                                                                   \
    template<typename ReturnType = json::Value>                                                                                 \
    void methodWithParamDescription##n(const std::string& name, boost::python::object callable, const std::string& comment,     \
                                       BOOST_PP_ENUM(n, REFLECTORWRAPPERGEN_NAME_DESC_DECL, _))                                 \
    {                                                                                                                           \
        mReflector.template method<ReturnType, BOOST_PP_ENUM_PARAMS(n, json::Value BOOST_PP_INTERCEPT)>(                        \
                          name.c_str(),                                                                                         \
                          boost::bind(&ReflectorWrapperRPCCallHelper<ReturnType>::rpcCall##n,                                   \
                                      callable, BOOST_PP_ENUM_SHIFTED_PARAMS_Z(z, BOOST_PP_INC(n), _)),                         \
                          comment.c_str(),                                                                                      \
                          BOOST_PP_ENUM(n, REFLECTORWRAPPERGEN_NAME_DESC, _));                                                  \
    }
    BOOST_PP_REPEAT_FROM_TO(1, RPC_METHODS_MAX_PARAMS, REFLECTORWRAPPERGEN_SERVICE_CALLS_DESCRIPTIONS, _)
#undef REFLECTORWRAPPERGEN_SERVICE_CALLS_DESCRIPTIONS
#undef REFLECTORWRAPPERGEN_NAME_DESC

// some extra empty methods - never called, but required to compile dispatch methods
#define REFLECTORWRAPPERGEN_SERVICE_CALLS_DESCRIPTIONS(z,n,_)                                                                   \
    template<typename ReturnType = json::Value>                                                                                 \
    void methodWithParamDescription##n(const std::string& name, boost::python::object callable, const std::string& comment,     \
                                       BOOST_PP_ENUM(n, REFLECTORWRAPPERGEN_NAME_DESC_DECL, _)) {}
    BOOST_PP_REPEAT_FROM_TO(RPC_METHODS_MAX_PARAMS, BOOST_PP_DIV(BOOST_PP_MUL(3, RPC_METHODS_MAX_PARAMS),2), REFLECTORWRAPPERGEN_SERVICE_CALLS_DESCRIPTIONS, _)
#undef REFLECTORWRAPPERGEN_SERVICE_CALLS_DESCRIPTIONS
#undef REFLECTORWRAPPERGEN_NAME_DESC_DECL

// extra empty method - never called, but required to compile dispatch methods
template<typename ReturnType = json::Value>                                                                                     \
void methodWithParamDescriptionAndSample0(const std::string& name, boost::python::object callable, const std::string& comment) {}

#define REFLECTORWRAPPERGEN_NAME_DESC_SAMPLE_DECL(z,n,_) const std::string& name##n, const std::string& description##n, boost::python::object sample##n
#define REFLECTORWRAPPERGEN_NAME_DESC_SAMPLE(z,n,_) name##n.c_str(), description##n.c_str(),                                            \
                                                    boost::python::extract<json::Value>(PyObject_HasAttrString(sample##n.ptr(), "convertObjectToJSON") ? sample##n.attr("convertObjectToJSON")() : sample##n)()

#define REFLECTORWRAPPERGEN_SERVICE_CALLS_DESCRIPTIONS_SAMPLES(z,n,_)                                                                   \
    template<typename ReturnType = json::Value>                                                                                         \
    void methodWithParamDescriptionAndSample##n(const std::string& name, boost::python::object callable, const std::string& comment,    \
                                                BOOST_PP_ENUM(n, REFLECTORWRAPPERGEN_NAME_DESC_SAMPLE_DECL, _))                         \
    {                                                                                                                                   \
        boost::function<ReturnType(BOOST_PP_ENUM_PARAMS(n, json::Value BOOST_PP_INTERCEPT))> fn;                                        \
        fn = boost::bind(&ReflectorWrapperRPCCallHelper<json::Value>::rpcCall##n,                                                       \
                         callable, BOOST_PP_ENUM_SHIFTED_PARAMS_Z(z, BOOST_PP_INC(n), _));                                              \
                                                                                                                                        \
        mReflector.template method<ReturnType, BOOST_PP_ENUM_PARAMS(n, json::Value BOOST_PP_INTERCEPT)>(                                \
                          name.c_str(), fn, comment.c_str(),                                                                            \
                          BOOST_PP_ENUM(n, REFLECTORWRAPPERGEN_NAME_DESC_SAMPLE, _));                                                   \
    }
    BOOST_PP_REPEAT_FROM_TO(1, RPC_METHODS_MAX_PARAMS, REFLECTORWRAPPERGEN_SERVICE_CALLS_DESCRIPTIONS_SAMPLES, _)
#undef REFLECTORWRAPPERGEN_SERVICE_CALLS_DESCRIPTIONS_SAMPLES
#undef REFLECTORWRAPPERGEN_NAME_DESC_SAMPLE_DECL
#undef REFLECTORWRAPPERGEN_NAME_DESC_SAMPLE

#define REFLECTORWRAPPERGEN_P_DECL(z,n,_) boost::python::object p##n
#define REFLECTORWRAPPERGEN_P_TO_STRING_P_TO_STRING(z,n,_) boost::python::extract<std::string>(BOOST_PP_CAT(p, BOOST_PP_MUL(2, n)))(),                      \
                                                           boost::python::extract<std::string>(BOOST_PP_CAT(p, BOOST_PP_INC(BOOST_PP_MUL(2, n))))()
#define REFLECTORWRAPPERGEN_P_TO_STRING_P_TO_STRING_OBJECT(z,n,_) boost::python::extract<std::string>(BOOST_PP_CAT(p, BOOST_PP_MUL(3, n)))(),               \
                                                                  boost::python::extract<std::string>(BOOST_PP_CAT(p, BOOST_PP_INC(BOOST_PP_MUL(3, n))))(), \
                                                                  BOOST_PP_CAT(p, BOOST_PP_INC(BOOST_PP_INC(BOOST_PP_MUL(3, n))))

// If we expose the above methods to Python directly, the Python interpreter cannot distinguish in all cases which one to use -
// e.g. with 6 extra params, these could be either 3x name+desc or 2x name+desc+sample. The correct one of course must match the number of
// arguments expected by callable, but this number is not known to the Python interpreter when it selects the overload, so given the choice
// between methodWithParamDescription3 and methodWithParamDescriptionAndSample2, it is not guaranteed to call the right one.
// The problem is solved by only exposing dispatch methods and deciding inside whether the params should form a sequence of name+description
// or of name+description+sample, after checking the number of arguments that callable takes.
#define REFLECTORWRAPPERGEN_SERVICE_CALLS_DISPATCH(z,n,_)                                                                       \
    template<typename ReturnType = json::Value>                                                                                 \
    void methodDispatch##n(const std::string& name, boost::python::object callable, const std::string& comment,                 \
                           BOOST_PP_ENUM(n, REFLECTORWRAPPERGEN_P_DECL, _))                                                     \
    {                                                                                                                           \
        int argCount = argumentCount(callable);                                                                                 \
        if (argCount*2 == n) {                                                                                                  \
            this->template BOOST_PP_CAT(methodWithParamDescription, BOOST_PP_DIV(n,2))<ReturnType>                              \
            (name, callable, comment                                                                                            \
             BOOST_PP_ENUM_TRAILING(BOOST_PP_DIV(n,2), REFLECTORWRAPPERGEN_P_TO_STRING_P_TO_STRING, p));                        \
            return;                                                                                                             \
        }                                                                                                                       \
        if (argCount*3 == n) {                                                                                                  \
            this->template BOOST_PP_CAT(methodWithParamDescriptionAndSample, BOOST_PP_DIV(n,3))<ReturnType>                     \
            (name, callable, comment                                                                                            \
             BOOST_PP_ENUM_TRAILING(BOOST_PP_DIV(n,3), REFLECTORWRAPPERGEN_P_TO_STRING_P_TO_STRING_OBJECT, p));                 \
            return;                                                                                                             \
        }                                                                                                                       \
                                                                                                                                \
        MIRA_THROW(XRuntime, "Number of names/descriptions/sample values for parameters in call to Reflector::method('" << name \
                             << "', ...) do not match the provided function's signature (" << n << " equals neither 2*"         \
                             << argCount << " nor 3*" << argCount << "). Please provide (string) name AND description for EACH "\
                             "RPC method  parameter, or name, description AND sample value for EACH parameter.");               \
    }
    BOOST_PP_REPEAT_FROM_TO(2, BOOST_PP_MUL(3, RPC_METHODS_MAX_PARAMS), REFLECTORWRAPPERGEN_SERVICE_CALLS_DISPATCH, _)
#undef REFLECTORWRAPPERGEN_SERVICE_CALLS_DISPATCH
#undef REFLECTORWRAPPERGEN_P_DECL
#undef REFLECTORWRAPPERGEN_P_TO_STRING_P_TO_STRING
#undef REFLECTORWRAPPERGEN_P_TO_STRING_P_TO_STRING_OBJECT

    template<typename ReturnType = json::Value>
    void method(const std::string& name, boost::python::object callable)
    {
        methodWithComment<ReturnType>(name, callable, "");
    }

protected:

    template<typename T>
    static T get(boost::python::object callable)
    {
        using namespace boost::python;

        ScopedGILLock lock;
        try
        {
            boost::python::object value = callable();
            return boost::python::extract<T>(value);
        }
        catch(boost::python::error_already_set&)
        {
            MIRA_THROW(XInvalidParameter, "Error calling getter: " << getLastExceptionString());
        }
        return T();
    }

    template<typename T>
    static void set(boost::python::object callable, const T& value)
    {
        ScopedGILLock lock;
        try
        {
            callable(boost::python::object(value));
        }
        catch(boost::python::error_already_set&)
        {
            MIRA_THROW(XInvalidParameter, "Error calling setter: " << getLastExceptionString());
        }
    }

    template<typename T>
    static std::vector<T> getList(boost::python::object callable)
    {
        using namespace boost::python;

        ScopedGILLock lock;
        try
        {
            boost::python::object value = callable();
            return listToVector<T>(value);
        }
        catch(boost::python::error_already_set&)
        {
            MIRA_THROW(XInvalidParameter, "Error calling getter: " << getLastExceptionString());
        }
        return std::vector<T>();
    }

    template<typename T>
    static void setList(boost::python::object callable, const std::vector<T>& value)
    {
        ScopedGILLock lock;
        boost::python::list l;
        foreach(const T& t, value)
            l.append(t);
        try
        {
            callable(boost::python::object(l));
        }
        catch(boost::python::error_already_set&)
        {
            MIRA_THROW(XInvalidParameter, "Error calling setter: " << getLastExceptionString());
        }
    }

    Reflector& mReflector;
};


}}

#endif /* _MIRA_TOOLBOXES_PYTHON_REFLECTORWRAPPER_H_ */