为C＋＋实现一个IDL （四）

如《为C＋＋实现一个IDL（三）》一文中所说，还剩最后一个问题，还是使用前面的测试代码说明。

async_call函数的原型是：

typedef  void ( * FUNC_TYPE)( int ,  char ,  string ,  short );

void  async_call ( int  v0,  char  v1,  string  v2, FUNC_TYPE func);

这是模板类根据in/out来产生的。

在异步调用中，参数是和操作保存在一起的，因为要交给线程处理。前面已经说过，Method模板类中将保有这些参数，Method的定义如下（以例子中4个参数的特化版本来说明）：

template  < class  A,  class  B,  class  C,  class  D >
struct  Method  < void (A,B,C,D) >  :  public  Base  <  typename Loki::TL::MakeTypelist <  A,B,C,D  > ::Result  >
{
    A a;
    B b;
    C c;
    D d;
    Method ()
    {
        parameters.push_back ( & a);
        parameters.push_back ( & b);
        parameters.push_back ( & c);
        parameters.push_back ( & d);
    }
};

相应地，Base类使用这个特化版本：

template  < class  TYPES,  class  IN_TYPES >
struct  Base  < TYPES, IN_TYPES,  3 >  :  public  IMethod
{
    typedef typename FuncTypeTraits  < TYPES > ::Result FUNC_TYPE;

     void  async_call (
        typename Loki::TL::TypeAt  < IN_TYPES,  0 > ::Result::OriginalType v0, 
        typename Loki::TL::TypeAt  < IN_TYPES,  1 > ::Result::OriginalType v1, 
        typename Loki::TL::TypeAt  < IN_TYPES,  2 > ::Result::OriginalType v2, 
        FUNC_TYPE func  =   0 )
    {
    }
};

TYPES模板参数中保存了所有的参数类型，IN_TYPES模板参数中保存了所有的in参数类型，但它们不知道如何来对应起来，async_call也不知道如何把几个参数值交给parameters（在IMethod中定义，见上一篇）。

如果我们在生成IN_TYPES的时候，把它在TYPES中的位置（索引）也一起交给它，就能解决这个问题。

InList第二个模板参数是一个常量，当我们把TYPES交给它时，以上面的代码为例，将会使用T_COUNT值为4的偏特化版本。这时候，将会首先推导出IN_TYPES中的第一个类型int，它在IN_TYPES中的索引是0，并接着调用T_COUNT值是3的偏特化版本，这样递归推导，直到调用T_COUNT值为0的偏特化版本，这个过程就结束了。在这个递归过程中，能够得到各个类型以及对应的“索引”值：int: 4, char: 3, string: 2。

注意这个索引值和实际的索引值是有差别的，实际的索引值应该是4-T_COUNT，所以上面的对应关系应该是：int: 0, char: 1, string: 2。

最初传递给InList的TYPES有4个元素，当它递归调用时，这个值就会依次递减，后面的递归调用并不知道应该用4去减掉T_COUNT作为索引，因为4并没有传递过来。简单的解决办法是再加上一个模板参数，让它往下传递，当然这种方式并不好看，好在我们不是真的必须这么做。

注意，在Base类中，它是知道TYPES的个数的，那么只要用这个数减去前面生成的IN_TYPE的“索引”，就能得到这个类型在TYPES中的真正索引。（这部分真是有点罗嗦）

修改InList模板类，让它生成由 [ in类型以及in类型在TYPES中的“索引”] 构成的新Typelist。

首先要增加一个辅助模板类：

template  < class  T,  int  INDEX >
struct  TypeReversedIndex
{
    typedef T type;
     enum  {value  =  INDEX};
};

它能够保存一个类型，以及一个整数。取名为TypeReversedIndex，意思是说它要保存一个Type和一个ReversedIndex（反的索引）。

InList模板类也要修改，OutList依旧是免费赠送：

template  <   class  T,  int  T_COUNT  =  Loki::TL::Length  < T > ::value  >
struct  InList
{
    typedef typename If  <
        InOutTypeTraits  < typename T::Head > ::isin,
        typename Loki::Typelist  <  TypeReversedIndex  < typename T::Head, T_COUNT > , typename InList  < typename T::Tail > ::Result  > , 
        typename InList  < typename T::Tail > ::Result
     > ::Result Result;
};


template  < class  T >
struct  InList  <  T,  0   >
{
    typedef typename Loki::TL::MakeTypelist  <> ::Result Result;
};

template  <   class  T,  int  T_COUNT  =  Loki::TL::Length  < T > ::value  >
struct  OutList
{
    typedef typename If  <
        InOutTypeTraits  < typename T::Head > ::isout,
        typename Loki::Typelist  <  TypeReversedIndex  < typename T::Head, T_COUNT > , typename OutList  < typename T::Tail > ::Result  > , 
        typename OutList  < typename T::Tail > ::Result
     > ::Result Result;
};


template  < class  T >
struct  OutList  <  T,  0   >
{
    typedef typename Loki::TL::MakeTypelist  <> ::Result Result;
};

Base类就可以写出来了：

template  < class  TYPES,  class  IN_TYPES >
struct  Base  < TYPES, IN_TYPES,  3 >  :  public  IMethod
{
    typedef typename FuncTypeTraits  < TYPES > ::Result FUNC_TYPE;
    typedef IN_TYPES type;

     enum  {TYPES_COUNT  =  typename Loki::TL::Length < TYPES > ::value};

     void  async_call (
        typename Loki::TL::TypeAt  < IN_TYPES,  0 > ::Result::type::OriginalType v0, 
        typename Loki::TL::TypeAt  < IN_TYPES,  1 > ::Result::type::OriginalType v1, 
        typename Loki::TL::TypeAt  < IN_TYPES,  2 > ::Result::type::OriginalType v2, 
        FUNC_TYPE func  =   0 )
    {
        ((typename Loki::TL::TypeAt  < IN_TYPES,  0 > ::Result::type * )
            parameters[TYPES_COUNT  -  typename Loki::TL::TypeAt  < IN_TYPES,  0 > ::Result::value]) -> setValue (v0);
        ((typename Loki::TL::TypeAt  < IN_TYPES,  1 > ::Result::type * )
            parameters[TYPES_COUNT  -  typename Loki::TL::TypeAt  < IN_TYPES,  1 > ::Result::value]) -> setValue (v1);
        ((typename Loki::TL::TypeAt  < IN_TYPES,  2 > ::Result::type * )
            parameters[TYPES_COUNT  -  typename Loki::TL::TypeAt  < IN_TYPES,  2 > ::Result::value]) -> setValue (v2);
    }
};

parameters中存放的是IParameter*类型，这里使用了强制转型，并调用in/inout模板类的setValue方法给它赋值。

为了测试结果，我为IParameter加上了void print () const虚函数，并在in/inout/out模板类中实现它，打印出类型，in/inout类中还将打印出参数值。

class  IParameter
{
public :
     virtual   void  print ()  const   =   0 ;
};

template  < class  T >
struct   in  :  public  IParameter
{
    typedef T OriginalType;
    T value;
     void  setValue (T v){
        value  =  v;
    }
     void  print ()  const  { 
        cout  <<  typeid( * this ).name()  <<   " :  "   <<  value  <<  endl; 
    }
};

template  < class  T >
struct   out  :  public  IParameter
{
    typedef T OriginalType;
     virtual   void  print ()  const  {
        cout  <<  typeid( * this ).name()  <<  endl; 
    }
};

template  < class  T >
struct  inout :  public  IParameter
{
    typedef T OriginalType;
    T value;
     void  setValue (T v){
        value  =  v;
    }
     virtual   void  print ()  const  {
        cout  <<  typeid( * this ).name()  <<   " :  "   <<  value  <<  endl; 
    }
};

并在Base::async_call中调用parameters中所有对象的print函数来输出一些调试信息：

for  (size_t i  =   0 ; i  <  parameters.size(); i  ++ )
    parameters[i] -> print ();

简单测试了2种类型，不能保证所有代码都是正确的，毕竟是手工写出来的也没经过检查，模板类在没有实例化的时候某些错误是不会报告的。

测试代码如下：

void  test_func ( int  v0,  char  v1,  string  v2,  short  v3)
{
    cout  <<   " =========================================== "   <<  endl;
    cout  <<   " test_func( "   <<  v0  <<   " ,  "   <<  v1  <<   " ,  "   <<  v2  <<   " ,  "   <<  v3  <<   " ) "   <<  endl;
}

void  test_func1 ( int  v0,  char  v1,  short  v2,  string  v3)
{
    cout  <<   " =========================================== "   <<  endl;
    cout  <<   " test_func1( "   <<  v0  <<   " ,  "   <<  v1  <<   " ,  "   <<  v2  <<   " ,  "   <<  v3  <<   " ) "   <<  endl;
}

int  main()
{
    {
        Method  <   void ( in < int > ,  in < char > , inout < string > ,  out < short > )  >  m;

        m.async_call( 3 ,  ' a ' ,  " test " );
        cout  <<   " =========================================== "   <<  endl;
        m.async_call( 3 ,  ' a ' ,  " test " , test_func);
        cout  <<   " =========================================== "   <<  endl;
    }

    {
        Method  < string ( in < int > ,  out < char > , inout < short > ) >  m;
        m.async_call( 3 ,  4 );
        cout  <<   " =========================================== "   <<  endl;
        m.async_call( 3 ,  4 , test_func1);
        cout  <<   " =========================================== "   <<  endl;
    }

     return   0 ;
}

全部代码太长，就不一一罗列于此了，可以点击 这里下载。