qiezi的学习园地

AS/C/C++/D/Java/JS/Python/Ruby

  C++博客 :: 首页 :: 新随笔 ::  ::  :: 管理 ::
如《为C++实现一个IDL(三)》一文中所说,还剩最后一个问题,还是使用前面的测试代码说明。

async_call函数的原型是:

typedef void(*FUNC_TYPE)(intcharstringshort);

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(
34);
        cout 
<< "===========================================" << endl;
        m.async_call(
34, test_func1);
        cout 
<< "===========================================" << endl;
    }

    
return 0;
}

全部代码太长,就不一一罗列于此了,可以点击这里下载。
posted on 2005-09-22 19:13 qiezi 阅读(455) 评论(7)  编辑 收藏 引用 所属分类: C++asgard项目