为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;
}

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