如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() {};
};