generación funtor de miembro de tipo puntero de función

Question

Estoy tratando de simplificar (a través de make_fn()) la generación de funtores que los parámetros de procesamiento previo (vía wrap()) para funciones miembro de aridad n .
La generación de los funtores está trabajando básicamente, pero hasta ahora sólo mediante la especificación explícita de los tipos de parámetros para la función de miembro.
Ahora me gustaría generar el funtor correcta del tipo de función miembro que maneja:

struct X {};

template<class C, typename T1, bool (C::*F)(T1)>
inline // there are more for T1..TN
bool wrap(C* c, X x) 
{
    return (c->*F)(process<T1>(x));
}

template<class C, typename T1, bool (C::*F)(T1)> 
inline // there are more for T1..TN
boost::function<bool (C*, X)> make_fn(F f) // <- problem here, F is not a type
{
    return boost::bind(&wrap<C, T1, F>, _1, _2);
}

Con esto, sin embargo, vc ++ y g ++ no ver F como un tipo para el parámetro de make_fn(). Debo faltar algo obvio aquí y estoy sintiendo un poco ciego.

La idea era que debería funcionar así:

struct A 
{
    bool f1(bool) { return true; }
};

void test()
{
    A a;
    X x;
    make_fn(&A::f1)(&a, x);
}

Cualquier ideas sobre cómo hacer que el trabajo?

Antecedentes:
Tengo una interfaz fija que, cuando se simplifica, se parece a esto:

bool invoke(C* c, const char* const functionName, int argCount, X* args);

X es un tipo de variante, que tengo que convertir a ciertos tipos de back-end (int, std :: string, ...).
Para manejar estas llamadas Tengo un mapa de funtores de ordenador que son por su nombre y un mapa de estas llamadas a funciones miembro de algún caso.
La intención de la envoltura es evitar las conversiones manuales y en lugar de generar palabras funcionales que hacen la conversión para mí o throw. Tengo este trabajo con una solución basada macro, pero esa solución requiere que se especifique el tipo y el parámetro de contar de forma explícita.
A través de la resolución de sobrecarga función espero para generar el funtor conversión correcta implícitamente de la firma de la función miembro.

Answer 1

Me parece que está intentando convertir un puntero pasado a una función en un argumento de plantilla no tipo, que me temo que no va a funcionar (véanse los comentarios a su pregunta).

Lo que podría hacer, es para almacenar el puntero de función en un objeto de función. A continuación aparece para compilar:

#include <boost/bind.hpp>
#include <boost/function.hpp>

struct X {};

template <class T>
bool process(X) { return true; }


template <class C, class T1, class Func>
struct wrap1
{
    typedef bool result_type;
    Func f;

    wrap1(Func f): f(f) {}

    bool operator()(C* c, X x)
    {
        return (c->*f)(process<T1>(x));
    }
};

template<class C, typename T1>
inline // there are more for T1..TN
boost::function<bool (C*, X)> make_fn(bool (C::*f)(T1))
{
    return boost::bind(wrap1<C, T1, bool (C::*)(T1)>(f), _1, _2);
}


struct A
{
    bool f1(bool) { return true; }
};

void test()
{
    A a;
    X x;
    make_fn(&A::f1)(&a, x);
}

Sin embargo, no estoy seguro si eso es bueno y cómo debe crear el resto de los envoltorios. Para este último que sólo podría conseguir un compilador que soporta plantillas variadic. :)