int 001
string 010
array 100
mixed 111
template<uint32_t T, class C1, class C2, class C3, class O>
struct Case
{
typedef T Tag;
typedef C1 Case1;
typedef C2 Case2;
typedef C3 Case3;
};
template<class C1, class C2, class F>
struct Overload
{
typedef C1 ConversionOne;
typedef C2 ConversionTwo;
typedef F Functor;
};
template<uint32_t I, class C1, class C2, class C3>
struct
Switch
{
static inline bool eval(basic::Value* a0, basic::Value* a1, basic::Value* r)
{
switch( IndexArg<I>::eval(a0,a1,r)->getTypeTag() )
{
case C1::Tag :
return Switch<T,I-1,C1::Case1,C1::Case2,C1::Case3>::eval(a0,a1,r);
case C2::Tag :
return Switch<T,I-1,C2::Case1,C2::Case2,C2::Case3>::eval(a0,a1,r);
case C3::Tag :
return Switch<T,I-1,C2::Case1,C2::Case2,C2::Case3>::eval(a0,a1,r);
default:
return false;
}
}
};
template<class C1, class C2, class C3>
struct Switch<0,C1,C2,C3>
{
static inline bool eval(basic::Value* a0, basic::Value* a1, basic::Value* r)
{
switch( IndexArg<0>::eval(a0,a1,r)->getTypeTag() )
{
case C1::Tag :
r = C1::Functor::eval( C1::ConversionOne::eval(a0), C1::ConversionTwo::eval(a1) );
return true;
case C2::Tag :
r = C2::Functor::eval( C2::ConversionOne::eval(a0), C2::ConversionTwo::eval(a1) );
return true;
case C3::Tag :
r = C3::Functor::eval( C3::ConversionOne::eval(a0), C3::ConversionTwo::eval(a1), r);
return true;
default:
return false;
}
}
};
int main()
{
Switch<1,
Case<>
Case<>
Case<>
>::eval( … );
}
The question I have is:
1) How would one go about implementing a dispatch mechanism based on two arguments to execute some function x statically?
2) Is it worth it? i.e. if you transform the code into a two branches how much speed gain would one see?
Thanks in advance.