C++通用Functor仿函数 LOKI库中的模版使用以及设计新思维

如LOKI库中有一个通用的仿函数，调用方式如下：

TC_Functor < void  , TL:: TLMaker <  const  string&,  int  >::Result> cmd3(TestFunction3);

string s3(  "s3" );

cmd3(s3, 10);

TC_FunctorWrapper<TC_Functor<  void , TL:: TLMaker  < const  string&,  int >::Result> > fwrapper3(cmd3, s3, 10);

fwrapper3();

TC_Functor是一个通用的仿函数。介绍TC_Functor之前，先介绍几个数据结构和工具。

定义类型链表：

 

    template<typename Head, typename Tail>
    struct TypeList
    {
        typedef Head H;
        typedef Tail T;
    };

    #define TYPELIST_1(T1) TypeList<T1, TL::NullType>
    #define TYPELIST_2(T1, T2) TypeList<T1, TL::TYPELIST_1(T2)>
    #define TYPELIST_3(T1, T2, T3) TypeList<T1, TL::TYPELIST_2(T2, T3)>
    #define TYPELIST_4(T1, T2, T3, T4) TypeList<T1, TL::TYPELIST_3(T2, T3, T4)>
    #define TYPELIST_5(T1, T2, T3, T4, T5) TypeList<T1, TL::TYPELIST_4(T2, T3, T4, T5)>
    #define TYPELIST_6(T1, T2, T3, T4, T5, T6) TypeList<T1, TL::TYPELIST_5(T2, T3, T4, T5, T6)>
    #define TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) TypeList<T1, TL::TYPELIST_6(T2, T3, T4, T5, T6, T7)>
    #define TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) TypeList<T1, TL::TYPELIST_7(T2, T3, T4, T5, T6, T7, T8)>
    #define TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) TypeList<T1, TL::TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9)>
    #define TYPELIST_10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) TypeList<T1, TL::TYPELIST_9(T2, T3, T4, T5, T6, T7, T8, T9, T10)>
    #define TYPELIST_11(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) TypeList<T1, TL::TYPELIST_10(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
    #define TYPELIST_12(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) TypeList<T1, TL::TYPELIST_11(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>
    #define TYPELIST_13(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) TypeList<T1, TL::TYPELIST_12(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>
    #define TYPELIST_14(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) TypeList<T1, TL::TYPELIST_13(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>
    #define TYPELIST_15(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) TypeList<T1, TL::TYPELIST_14(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>
    #define TYPELIST_16(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) TypeList<T1, TL::TYPELIST_15(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)>
    #define TYPELIST_17(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) TypeList<T1, TL::TYPELIST_16(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)>
    #define TYPELIST_18(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) TypeList<T1, TL::TYPELIST_17(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)>
    #define TYPELIST_19(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) TypeList<T1, TL::TYPELIST_18(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)>
    #define TYPELIST_20 (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) TypeList<T1, TL::TYPELIST_19(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)>

TypeList分别有一个Head和Tail的内置类型，但是该新的数据类型并非只是两种类型的复合，目前支持20种，因为Head或者Tail本身就可以是TypeList，如：

string,int,int可以表示为 TypeList< string ,TypeList<int,TypeList<int,NullType>>>。

我们可以将三种分开的类型，用一种数据类型表示，但是我们不能每次都自己去写成这么纠结的 生成 TypeList< string ,TypeList<int,TypeList<int,NullType>>>类型，所以提供一种生成 TypeList类型的工具：

    template<class T1=NullType,  class T2=NullType,  class T3= NullType,  class T4= NullType,  class T5= NullType,
             class T6= NullType,  class T7= NullType,  class T8= NullType,  class T9= NullType,  class T10= NullType,
             class T11= NullType, class T12= NullType, class T13= NullType, class T14= NullType, class T15= NullType,
             class T16= 1, class T17= NullType, class T18= NullType, class T19= NullType, class T20= NullType>
    struct TLMaker
    {
    private:
        typedef TYPELIST_20( T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
                            T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) TmpList;
    public:
        typedef typename EraseAll<TmpList, NullType>::Result Result;
    };

其中 EraseAll如下：

   

 template<class TList, class T> struct EraseAll;
    template<class T> struct EraseAll< NullType, T>
    {
        typedef NullType Result;
    };
    template<class T, class Tail> struct EraseAll< TypeList< T, Tail>, T>
    {
        typedef typename EraseAll< Tail, T>:: Result Result;
    };
    template<class Head, class Tail, class T> struct EraseAll<TypeList <Head, Tail>, T>
    {
        typedef TypeList<Head, typename EraseAll< Tail, T>:: Result> Result;
    };

使用的时候:

TLMaker<int, int>::Result可以得到TypeList<int,TypeList<int,NullType>>类型。

步骤如下：

1) TLMaker<int,  int >::Result是需要TLMake中内置的Result类型，也就是 EraseAll <  TmpList ,  NullType >::  Result，也就是需要 EraseAll <  TmpList ,  NullType >内置的Result。而这里有四个 EraseAll声明，我们需要通过Template的类型看偏特化使用哪一个EraseAll的声明，这就需要我们首先解析TmpList。

2) typedef  TYPELIST_20(  T1 ,  T2 ,  T3 ,  T4 ,  T5 ,  T6 ,  T7 ,  T8 ,  T9 ,  T10 , T11 ,  T12 ,  T13 ,  T14 ,  T15 ,  T16 ,  T17 ,  T18 ,  T19 ,  T20 )  TmpList其中我们指定了第一个模版类型int，第二个模版类型也是int，其他的模版类型都是默认的NullType，我们将产生一个拥有 TYPELIST_20 ， 经过 20层define递归的，TypeList如下：

TypeList<int,TypeList<int,TypeLIst< NullType,TypeList< NullType,TypeList<.....20 >>,我们需要借助EraseAll来消除多余的NullType，将之变成 TypeList<int,TypeList<int,NullType>>。

3) EraseAll <  TmpList ,  NullType >其中TmpList为 TypeList<int,TypeList<int,TypeLIst< NullType,TypeList< NullType,TypeList<.....20 >>，可以看成TypeList<int,Tail>的类型，其中由于int不为NullType，所以不能匹配 template <  class   T ,  class   Tail >  struct   EraseAll <  TypeList <  T ,  Tail >,  T >的偏特化，只能匹配 template <  class   Head ,  class   Tail ,  class   T >  struct   EraseAll  < TypeList  <  Head ,  Tail >,  T >的EraseAll的偏特化，其中Head为int，Tail为 TypeLIst< NullType,TypeList< NullType,TypeList<.....20 >,T为NullType，而该偏特化中的Result其实本身是一个嵌套的递归的Result，继续按照这个方法往下推断，直到TypeList中的Head为NullType为止（其实也就是递归 两次，我们这里只有两个int），这个时候将可以匹配 template <  class   T ,  class   Tail >  struct   EraseAll <  TypeList <  T ,  Tail >,  T >这个偏特化模版。最后直到结果成为 TypeList<i nt,TypeList<int,NullType>>.

下面是一个类型萃取器：

   

 template<bool flag, typename U, typename V>
    struct TypeSelect
    {
     typedef U Result;
    };

    template<typename U, typename V>
    struct TypeSelect<false, U, V>
    {
     typedef V Result;
    };

    ///////////////////////////////////////////////////////////////////////////////////////
    /**
     * 类型萃取器, copy至 Loki库
     */
    template<typename T>
    class TypeTraits
    {
    private:

        ///////////////////////////////////////////////////////
        //提取引用的原始类型(即去掉引用类型)
        template<class U>
        struct ReferenceTraits
        {
            enum { result = false };
            typedef U Result;
        };

        template<class U>
        struct ReferenceTraits<U&>
        {
            enum { result = true };
            typedef U Result;
        };

     ///////////////////////////////////////////////////////
     //指针类型
     template<class U>
     struct PointerTraits
     {
            enum { result = false };
            typedef TL:: NullType Result;
     };

     template<class U>
     struct PointerTraits<U*>
     {
            enum { result = true };
            typedef U Result;
     };

     template<class U>
     struct PointerTraits<U*&>
     {
            enum { result = true };
            typedef U Result;
     };

     ///////////////////////////////////////////////////////
     //成员函数指针, gcc 下面支持有问题, 屏蔽之
     template<typename U>
     struct PointerToMemberTraits
     {
            enum { result = false };
     };

     template<class U, class V>
     struct PointerToMemberTraits< U V::*>
     {
            enum { result = true };
     };

     template<class U, class V>
     struct PointerToMemberTraits< U V::*&>
     {
            enum { result = true };
     };

        ///////////////////////////////////////////////////////
        // const
        template<typename U>
        struct UnConstTraits
        {
            enum { result = false };
            typedef U Result;
        };
        template<typename U>
        struct UnConstTraits<const U>
        {
            enum { result = true };
            typedef U Result;
        };
        template<typename U>
        struct UnConstTraits<const U&>
        {
            enum { result = true };
            typedef U& Result;
        };

        ///////////////////////////////////////////////////////
        // volatile
        template<typename U>
        struct UnVolatileTraits
        {
            enum { result = false };
            typedef U Result;
        };
        template<typename U>
        struct UnVolatileTraits<volatile U>
        {
            enum { result = true };
            typedef U Result;
        };
        template<typename U>
        struct UnVolatileTraits<volatile U&>
        {
            enum { result = true };
            typedef U& Result;
        };
    public:
        //T是否是指针类型
     enum { isPointer        = PointerTraits< T>::result };
        //T是否是引用类型
        enum { isReference           = ReferenceTraits<T >::result };
        //T是否指向成员函数的指针
        enum { isMemberPointer  = PointerToMemberTraits<T >::result };

        //T是否是Const类型
        enum { isConst          = UnConstTraits< T>::result };
        //T是否是Volatile类型
        enum { isVolatile       = UnVolatileTraits< T>::result };

        //如果T是指针类型,则获取T的原类型, 即去掉指针类型
     typedef typename PointerTraits<T>::Result           PointeeType;
        //如果T是引用类型,则获取T的原类型, 即去掉引用类型
     typedef typename ReferenceTraits<T>::Result         ReferencedType;
        //如果T是Const类型,则获取T的原类型, 即去掉 Const类型
        typedef typename UnConstTraits<T>::Result           NonConstType;
        //如果T是volatile类型,则获取T的原类型, 即去掉volatile类型
        typedef typename UnVolatileTraits<T>::Result        NonVolatileType;
        //去掉const volatile类型
        typedef typename UnVolatileTraits<typename UnConstTraits<T >::Result >::Result UnqualifiedType ;

    public:

     //////////////////////////////////////////////////////
     //
     typedef TL::TLMaker<unsigned char, unsigned short, unsigned int , unsigned long, unsigned long long>::Result UnsignedInts;
     typedef TL::TLMaker<signed char, short, int, long, long long>:: Result SignedInts;
     typedef TL::TLMaker<bool, char, wchar_t>::Result OtherInts;
     typedef TL::TLMaker<float, double, long double>::Result Floats;
        typedef TL::TYPELIST_2(TL:: EmptyType, TL:: NullType) NullTypes;

        //无符号整形
     enum { isStdUnsignedInt = TL:: IndexOf< UnsignedInts, T>::value >= 0 };
        //有符号整形
     enum { isStdSignedInt      = TL:: IndexOf< SignedInts, T>::value >= 0 };
        //整形
     enum { isStdInt            = isStdUnsignedInt || isStdSignedInt || TL::IndexOf <OtherInts , T>::value >= 0 };
        //浮点类型
     enum { isStdFloat         = TL:: IndexOf< Floats, T>::value >= 0 };
        //数值类型
     enum { isStdArith         = isStdInt || isStdFloat };
        //基础类型(包括void)
     enum { isStdFundamental    = isStdArith || TL::IndexOf<TL::TYPELIST_1( void), T>::value >= 0};
        //空类型
        enum { isNullType       = TL:: IndexOf< NullTypes, T>::value >= 0 };
        //简单类型
        enum { isBaseType       = isStdArith || isPointer || isMemberPointer };

     //对于复杂类型, 获取数据的引用类型, 即加上引用类型
     typedef typename TypeSelect<isBaseType, T, ReferencedType&>::Result ReferenceType ;

        //对于复杂类型且非空类型, 获取数据的引用类型, 即加上引用类型
        //typedef typename TypeSelect<isBaseType || isNullType, T, ReferencedType&>::Result ReferenceTypeEx;

        //获取数据的原类型, 消除引用的引用这种情况
     typedef typename TypeSelect<!isReference, T, ReferencedType&>::Result ParameterType ;
    };

下面我们分析一下，如何通过一个引用类型获取原生类型，通过一个原生类型获取引用类型，通过一个指针类型，获取原生类型。

typedef  typename  TypeTraits < string& >:: ParameterType  Param1  将会把 Param1定义为 sting类型。

1）该 TypeTraits的模版类型为String&，我们要获取其中的 ParameterType，也就是 typedef   typename   TypeSelect <!  isReference ,  T ,  ReferencedType  &>:: Result ;

2)我们需要确定是使用 TypeSelect的那个偏特化，首先得知道 isReference 到底是true还是false。

3) enum  {  isReference  =  ReferenceTraits  < T  >::result }是 TypeTraits中的一个匿名枚举，作用和静态变量类似，我们需要确定 isReference 的值，首先需要一个 ReferenceTraits。 ReferenceTraits的定义如下：

                  template<class U>
        struct ReferenceTraits
        {
            enum { result = false };
            typedef U Result;
        };

        template<class U>
        struct ReferenceTraits< U&>
        {
            enum { result = true };
            typedef U Result;
        };

     
 //指针类型
     
template<class U>
     
struct PointerTraits
     {
           
enum { result = false };
           
typedef TL:: NullType Result;
     };

     
template<class U>
     
struct PointerTraits<U*>
     {
           
enum { result = true };
           
typedef U Result;
     };

     template<class U>
     struct PointerTraits<U*&>
     {
            enum { result = true };
            typedef U Result;
     };

上述分别是引用和指针的萃取器，我们通过模版的偏特化规则，可以得知， ReferenceTraits<string&>将会使用 template <  class   U >  struct   ReferenceTraits <  U &>这个偏特化的实例，也就是说 isReference  =  ReferenceTraits  < T  >::result的价为true。

4)1中的 typedef   typename   TypeSelect <!  isReference ,  T ,  ReferencedType  &>:: Result表达式中的 TypeSelect是<false,string&,string&>,其中第三个为 ReferencedType为string，TypeSelect的偏特化会选择

template < typename  U ,  typename  V >  struct  TypeSelect < false ,  U ,  V >，取得类型为string。

TypeAt, 取链表在i位置上的类型, i超出了返回, 则返回DefaultType。

    

template< class TList, unsigned int index, typename DefaultType = NullType > structTypeAtNonStrict
    {
        typedef DefaultType Result;
    };
    template < class Head, class Tail, typename DefaultType> struct TypeAtNonStrict <TypeList < Head,  Tail>, 0, DefaultType>
    {
        typedef Head Result;
    };
    template < class Head, class Tail, unsigned int i, typename DefaultType > struct TypeAtNonStrict <TypeList < Head, Tail>, i, DefaultType >
    {
        typedef typename TypeAtNonStrict< Tail, i - 1, DefaultType >::Result Result ;
    };

主要是利用i进行倒序递归操作，获取Tail来实现获取 TypeList类型 指定位置的类型。

通过上述的复合类型和工具，我们了解到了如何利用

• 内置Typedef以及递归的方式
• 类内置匿名enum
• template的偏特化

通过新的思维方式来进行类型转化以及定义复合新类型。

于是，接下来定义通用的TC_Functor就很自然了：

template <typename R, class TList = TL:: NullType>
/**
 * @brief 函数对象类, 可以封装对: 函数对象, 函数, 成员函数
 *     的调用
 */
class TC_Functor
{
public :
    typedef R     ResultType;
    typedef TList ParamList;

    /**定义封装类型*/
    typedef TC_FunctorWrapper< TC_Functor< R, TList> > wrapper_type;

    /**定义类型列表中每个参数的原类型*/
    typedef typename TL:: TypeTraits< typename TL::TypeAtNonStrict < TList, 0, TL::EmptyType >::Result >::ParameterType Param1 ;
    typedef typename TL:: TypeTraits< typename TL::TypeAtNonStrict < TList, 1, TL::EmptyType >::Result >::ParameterType Param2 ;
    typedef typename TL:: TypeTraits< typename TL::TypeAtNonStrict < TList, 2, TL::EmptyType >::Result >::ParameterType Param3 ;
    typedef typename TL:: TypeTraits< typename TL::TypeAtNonStrict < TList, 3, TL::EmptyType >::Result >::ParameterType Param4 ;
    typedef typename TL:: TypeTraits< typename TL::TypeAtNonStrict < TList, 4, TL::EmptyType >::Result >::ParameterType Param5 ;
    typedef typename TL:: TypeTraits< typename TL::TypeAtNonStrict < TList, 5, TL::EmptyType >::Result >::ParameterType Param6 ;
    typedef typename TL:: TypeTraits< typename TL::TypeAtNonStrict < TList, 6, TL::EmptyType >::Result >::ParameterType Param7 ;
    typedef typename TL:: TypeTraits< typename TL::TypeAtNonStrict < TList, 7, TL::EmptyType >::Result >::ParameterType Param8 ;
    typedef typename TL:: TypeTraits< typename TL::TypeAtNonStrict < TList, 8, TL::EmptyType >::Result >::ParameterType Param9 ;
    typedef typename TL:: TypeTraits< typename TL::TypeAtNonStrict < TList, 9, TL::EmptyType >::Result >::ParameterType Param10 ;

    /**定义类型列表中每个参数的引用类型*/
    typedef typename TL:: TypeTraits< Param1>:: ReferenceType Reference1;
    typedef typename TL:: TypeTraits< Param2>:: ReferenceType Reference2;
    typedef typename TL:: TypeTraits< Param3>:: ReferenceType Reference3;
    typedef typename TL:: TypeTraits< Param4>:: ReferenceType Reference4;
    typedef typename TL:: TypeTraits< Param5>:: ReferenceType Reference5;
    typedef typename TL:: TypeTraits< Param6>:: ReferenceType Reference6;
    typedef typename TL:: TypeTraits< Param7>:: ReferenceType Reference7;
    typedef typename TL:: TypeTraits< Param8>:: ReferenceType Reference8;
    typedef typename TL:: TypeTraits< Param9>:: ReferenceType Reference9;
    typedef typename TL:: TypeTraits< Param10>:: ReferenceType Reference10;

public :
    TC_Functor ()
    {
    }

    TC_Functor (const TC_Functor &functor)
    : _spImpl(functor._spImpl->clone())
    {
    }

    TC_Functor& operator=( const TC_Functor &functor)
    {
        if( this != &functor)
        {
            _spImpl = std::auto_ptr<Impl>(functor._spImpl->clone());
        }

        return (* this);
    }

    template< class Fun>
    TC_Functor (Fun fun)
     : _spImpl( new TC_FunctorHandler< TC_Functor, Fun>(fun))
    {
    }

      template< typename PointerToObj, typename PointerToMemFun>
      TC_Functor( const PointerToObj &pObj, PointerToMemFun pMemFn)
     : _spImpl( new TC_MemFunHandler< TC_Functor, PointerToObj, PointerToMemFun >(pObj, pMemFn)) 
     {
     }

      // 判断是否已经设置了functor
      // 可以这样使用if(functor)
      operator bool() const
     {
            return _spImpl. get() ? true : false;
     }

    R operator()()
     {
            return (* _spImpl)();
     }

    R operator()(Reference1 p1)
     {
            return (* _spImpl)(p1);
     }

    R operator()(Reference1 p1, Reference2 p2)
     {
            return (* _spImpl)(p1, p2);
     }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3)
     {
            return (* _spImpl)(p1, p2, p3);
     }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4)
     {
            return (* _spImpl)(p1, p2, p3, p4);
     }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4, Reference5 p5)
     {
            return (* _spImpl)(p1, p2, p3, p4, p5);
     }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4, Reference5 p5,Reference6 p6)
     {
            return (* _spImpl)(p1, p2, p3, p4, p5, p6);
     }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4, Reference5 p5,Reference6 p6, Reference7 p7)
     {
            return (* _spImpl)(p1, p2, p3, p4, p5, p6, p7);
     }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4, Reference5 p5,Reference6 p6, Reference7 p7, Reference8 p8)
     {
            return (* _spImpl)(p1, p2, p3, p4, p5, p6, p7, p8);
     }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4, Reference5 p5,Reference6 p6, Reference7 p7, Reference8 p8, Reference9 p9)
     {
            return (* _spImpl)(p1, p2, p3, p4, p5, p6, p7, p8, p9);
     }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4, Reference5 p5,Reference6 p6, Reference7 p7, Reference8 p8, Reference9 p9, Reference10 p10)
     {
            return (* _spImpl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
     }


private :
    template< class ParentFunctor>
    friend class TC_FunctorWrapper;

    typedef TC_FunctorImp< R, TList> Impl;

    std:: auto_ptr<Impl >     _spImpl;
};

其中TC_FunctorImpl的实现如下：

template <typename R, class TList>
class TC_FunctorImp
{
public :
    virtual R operator()() = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template <typename R>
class TC_FunctorImp < R, TL:: EmptyType>
{
public :
    virtual R operator()() = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template <typename R, typename P1>
class TC_FunctorImp < R, TL::TYPELIST_1( P1)>
{
public :
    virtual R operator()( typename TL::TypeTraits <P1 >::ReferenceType p1) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template <typename R, typename P1, typename P2>
class TC_FunctorImp < R, TL::TYPELIST_2( P1, P2)>
{
public :
    virtual R operator()( typename TL::TypeTraits <P1 >::ReferenceType p1,
                         typename TL::TypeTraits <P2 >::ReferenceType p2) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template <typename R, typename P1, typename P2, typename P3>
class TC_FunctorImp < R, TL::TYPELIST_3( P1, P2, P3)>
{
public :
    virtual R operator()( typename TL::TypeTraits <P1 >::ReferenceType p1,
                         typename TL::TypeTraits <P2 >::ReferenceType p2,
                         typename TL::TypeTraits <P3 >::ReferenceType p3) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template <typename R, typename P1, typename P2, typename P3, typename P4 >
class TC_FunctorImp < R, TL::TYPELIST_4( P1, P2, P3, P4)>
{
public :
    virtual R operator()( typename TL::TypeTraits <P1 >::ReferenceType p1,
                         typename TL::TypeTraits <P2 >::ReferenceType p2,
                         typename TL::TypeTraits <P3 >::ReferenceType p3,
                         typename TL::TypeTraits <P4 >::ReferenceType p4) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template <typename R, typename P1, typename P2, typename P3, typename P4 , typename P5>
class TC_FunctorImp < R, TL::TYPELIST_5( P1, P2, P3, P4, P5)>
{
public :
    virtual R operator()( typename TL::TypeTraits <P1 >::ReferenceType p1,
                         typename TL::TypeTraits <P2 >::ReferenceType p2,
                         typename TL::TypeTraits <P3 >::ReferenceType p3,
                         typename TL::TypeTraits <P4 >::ReferenceType p4,
                         typename TL::TypeTraits <P5 >::ReferenceType p5) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template <typename R, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6>
class TC_FunctorImp < R, TL::TYPELIST_6( P1, P2, P3, P4, P5, P6)>
{
public :
    virtual R operator()( typename TL::TypeTraits <P1 >::ReferenceType p1,
                         typename TL::TypeTraits <P2 >::ReferenceType p2,
                         typename TL::TypeTraits <P3 >::ReferenceType p3,
                         typename TL::TypeTraits <P4 >::ReferenceType p4,
                         typename TL::TypeTraits <P5 >::ReferenceType p5,
                         typename TL::TypeTraits <P6 >::ReferenceType p6) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template <typename R, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6,  typename P7>
class TC_FunctorImp < R, TL::TYPELIST_7( P1, P2, P3, P4, P5, P6, P7)>
{
public :
    virtual R operator()( typename TL::TypeTraits <P1 >::ReferenceType p1,
                         typename TL::TypeTraits <P2 >::ReferenceType p2,
                         typename TL::TypeTraits <P3 >::ReferenceType p3,
                         typename TL::TypeTraits <P4 >::ReferenceType p4,
                         typename TL::TypeTraits <P5 >::ReferenceType p5,
                         typename TL::TypeTraits <P6 >::ReferenceType p6,
                         typename TL::TypeTraits <P7 >::ReferenceType p7) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template <typename R, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6,  typename P7, typename P8>
class TC_FunctorImp < R, TL::TYPELIST_8( P1, P2, P3, P4, P5, P6, P7, P8)>
{
public :
    virtual R operator()( typename TL::TypeTraits <P1 >::ReferenceType p1,
                         typename TL::TypeTraits <P2 >::ReferenceType p2,
                         typename TL::TypeTraits <P3 >::ReferenceType p3,
                         typename TL::TypeTraits <P4 >::ReferenceType p4,
                         typename TL::TypeTraits <P5 >::ReferenceType p5,
                         typename TL::TypeTraits <P6 >::ReferenceType p6,
                         typename TL::TypeTraits <P7 >::ReferenceType p7,
                         typename TL::TypeTraits <P8 >::ReferenceType p8) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template <typename R, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6,  typename P7, typename P8, typename P9 >
class TC_FunctorImp < R, TL::TYPELIST_9( P1, P2, P3, P4, P5, P6, P7, P8, P9)>
{
public :
    virtual R operator()( typename TL::TypeTraits <P1 >::ReferenceType p1,
                         typename TL::TypeTraits <P2 >::ReferenceType p2,
                         typename TL::TypeTraits <P3 >::ReferenceType p3,
                         typename TL::TypeTraits <P4 >::ReferenceType p4,
                         typename TL::TypeTraits <P5 >::ReferenceType p5,
                         typename TL::TypeTraits <P6 >::ReferenceType p6,
                         typename TL::TypeTraits <P7 >::ReferenceType p7,
                         typename TL::TypeTraits <P8 >::ReferenceType p8,
                         typename TL::TypeTraits <P9 >::ReferenceType p9) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template <typename R, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6,  typename P7, typename P8, typename P9 , typename P10>
class TC_FunctorImp < R, TL::TYPELIST_10( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)>
{
public :
    virtual R operator()( typename TL::TypeTraits <P1 >::ReferenceType p1,
                         typename TL::TypeTraits <P2 >::ReferenceType p2,
                         typename TL::TypeTraits <P3 >::ReferenceType p3,
                         typename TL::TypeTraits <P4 >::ReferenceType p4,
                         typename TL::TypeTraits <P5 >::ReferenceType p5,
                         typename TL::TypeTraits <P6 >::ReferenceType p6,
                         typename TL::TypeTraits <P7 >::ReferenceType p7,
                         typename TL::TypeTraits <P8 >::ReferenceType p8,
                         typename TL::TypeTraits <P9 >::ReferenceType p9,
                         typename TL::TypeTraits <P10 >::ReferenceType p10) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};