Ich versuche zu vereinfachen (viamake_fn()) die Erzeugung von Funktoren, die Parameter vorverarbeiten (viawrap()) für Mitgliedsfunktionen von arityn.
Das Generieren der Funktoren funktioniert grundsätzlich, allerdings bisher nur durch explizite Angabe der Parametertypen für die Member-Funktion.
Jetzt möchte ich den richtigen Funktor aus dem Member-Funktionstyp generieren, den er verarbeitet:

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);
}

Damit sehen jedoch vc ++ und g ++ nichtF als Typ für den Parameter vonmake_fn(). Ich muss hier etwas Offensichtliches vermissen und fühle mich etwas blind.

Die Idee war, dass es so funktionieren sollte:

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

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

Irgendwelche Ideen, wie das funktioniert?

Hintergrund:
Ich habe eine feste Schnittstelle, die vereinfacht so aussieht:

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

X ist ein Variantentyp, den ich in bestimmte Backend-Typen konvertieren muss (int, std :: string, ...).
Um diese Aufrufe zu verarbeiten, habe ich eine Karte von Funktoren, die nach Namen durchsucht werden, und ordne diese Aufrufe den Mitgliedsfunktionen einer Instanz zu.
Ziel des Wrappings ist es, manuelle Konvertierungen zu vermeiden und stattdessen Funktoren zu generieren, die die Konvertierung für mich oder für mich durchführenthrow. Ich habe dies mit einer makrobasierten Lösung arbeiten, aber diese Lösung muss die Typen und die Parameteranzahl explizit angeben.
Ich hoffe, über die Funktion Overload Resolution implizit aus der Member-Funktionssignatur den richtigen Konvertierungsfunktor zu generieren.