Une manière intelligente d'exporter des fonctions polymorphes C++ avec boost.python

Question

J'ai une fonction C++ très polymorphe qui peut être appelée avec près de 20 types différents.

Pour l'exposer à python que je fais quelque chose comme ceci:

#include originalFunctionNamespace.hpp 

template<class T> 
    T foo(T x) 
    { 
     return orignalFunctionNamespace::foo(x); 
    } 

mais de les appeler de python je dois spécialiser les fonctions avec chaque type qu'ils soutiennent:

BOOST_PYTHON_MODULE(module_foo) 
{ 
    def("foo", foo<orignalFunctionNamespace::type1>); 
    def("foo", foo<orignalFunctionNamespace::type2>); 
    def("foo", foo<orignalFunctionNamespace::type3>); 
    def("foo", foo<orignalFunctionNamespace::type4>); 
    def("foo", foo<orignalFunctionNamespace::type5>); 
    def("foo", foo<orignalFunctionNamespace::type6>); 
    def("foo", foo<orignalFunctionNamespace::type7>); 
    ... 
    ... 
    ... 
    def("foo", foo<orignalFunctionNamespace::typeN>); 
} 

Cela fonctionne, mais je ne peux m'empêcher de penser qu'il doit y avoir une façon plus intelligente de le faire. Comme je dois le faire pour de nombreuses fonctions, les choses deviennent de plus en plus grandes et répétitives. Des suggestions?

Answer 1

Cela me semble être une utilisation possible de la magie typeliste.

Si vous utilisez (ou peut utiliser) le nouveau standard C++ 0x, vous pouvez écrire quelque chose comme ceci:

template <typename ArgType> 
void def_foo_overloads() 
{ 
    def("foo", foo<ArgType>); 
    // last type in list 
} 
template <typename ArgType, typename... MoreArgTypes> 
void def_foo_overloads() 
{ 
    def("foo", foo<ArgType>); 
    def_foo_overloads(MoreArgTypes...); 
} 

// use it like: 
def_foo_overloads<orignalFunctionNamespace::type1, 
        orignalFunctionNamespace::type2, 
        ... 
        orignalFunctionNamespace::typeN>(); 

Si vous n'avez pas accès à la nouvelle norme, vous pouvez faites l'équivalent en utilisant les anciennes typologies récursives.