欧美日韩一区精品,亚洲国产高潮在线观看,久久精品一区二区三区中文字幕

qiezi — Wed, 28 Sep 2005 14:57:00 GMT

本篇没什么清晰的目的�Q�只是解释一下前面的几个问题�Q��ƈ提出一些新的目标�?BR>
在“asgard��目遗留问题”中�Q�我��单提��C��几个问题�Q��ƈ且想了一些解��x��案�?BR>
其中�Q�最首要解决的是�W?条“服务对象的大小”和�W?条“全局元信息”，�q?条将影响到调用机制、call对象的生成。一个调用将生成一个call对象�Q�由�U�程池来处理�Q�同步调用将由异步调用来模拟�?BR>
在call对象中，保存了所有in/out参数的包装对象。当处理同步调用�Ӟ��׃��out参数可能是一个栈上对象（或简单类型，�q�里�l�称对象�Q�，所以需要另一个包装类——outret模板�c�，它保存out参数的引用�?BR>
当同步调用发生时�Q�生成一个call对象�Q�当然out参数的引用已�l�包含在里面�Q�，把这个call对象交给�U�程池处理，调用的线�E�阻塞等待调用结束后被唤醒，�q�就是所谓的异步调用模拟同步调用。由于异步调用被包装��h��了，所以在调用者看来跟同步调用没什么区别。当然这个动作�ƈ非必要，完全可以不��用模拟，而采用真正的同步调用�Q�只是看到ICE是这么实现的�Q�心痒痒而已�?BR>

asgard的目标是把现有的�pȝ��功能包装成�ؓ服务�Q�所以在通用斚w��我考虑得比较多�?BR>
比如服务端要开放下面这样一个服务：

service StringService
{
Method <string(inout<string>, in<string>)> strcat;
Method <string(inout<string>, in<string>, in<uint>)> strncat;
};

�q�且把C标准库中的strcat和strncat作�ؓ�q?个方法的实现�?BR>
看一下存在哪些问题？

1、函数第1个参数如果直接映��ؓstring�Q�在服务端将出现�~�冲区溢出�?BR>
2、C标准库中的strcat�q�回值是一个指针，它指向strcat的第一个参敎ͼ�搞这个标准库的�h是不是没惌��q�个�q�回值多么没用啊�Q�？直接�q�回一个操作的长度不是更好�Q�）�Q�在服务端发回客��L��Ӟ��q�个�q�不需要被发回来，因�ؓstrcat的第1个参数已�l�能带回操作后的内容了�?BR>
3、strncat的第3个参数表�C�第1个缓冲区参数的长度，如果能把它和�W?个参数合��h��用一个buffer对象表示�Q�就能省事了�?BR>
理想情况下，我们的服务对象这��h��写：

service StringService
{
Method <void(inout< buffer<char> >, in<string>)> strcat;
Method <void(inout< buffer<char> >, in<string>)> strncat;
};

我们的目的是把老的代码包装成新鲜时髦的服务�Q�当然不用保留老式代码中的指针�Q�以及��用指针和长度2个值来表示一个缓冲区的做法。buffer�c�d��构造时要接受一个size_t参数�Q�指定缓冲区的大��?BR>
�q�在服务端将产生映射问题�Q�由于这个Method定义的�Ş式和C标准库中的函数�Ş式不一致�?BR>
我想应该��d��C��个适配器模板类�Q�比如：

this->strcat.setFunction (adapter<char*(char*, const char*), convert<void, 0>(inout< buffer<char> >, in<string>)> (::strcat));

this->strncat.setFunction (adapter<char*(char*, const char*, size_t), convert<void, 0>(inout< buffer<char> >, in<string>, length<in<uint>, 1>)> (::strncat));

convert表示把第0个参敎ͼ��q�里指返回��|��转成void�c�d��Q�length, 1>表示�q�个参数�c�d��是int�Q�它是从�W?个参��C��提取的长度，大致��是使用�q�种规则�Q�语法可能以后会有变动�?BR>
�q�点内容是我几个月前��在考虑的，也是我想做这个项目的动机�Q�不�q�直到最�q�一�D�|��间才从可行性方面仔�l�考虑�?BR>
通过前面几个模板的练习，现在已经大致知道哪些东西是可以用模板做出来，哪些不能使用模板�Q�这应该是最大的收获了。很多东西单靠模板或是虚函数都不好完成，但结合�v来就能��生意想不到的效果�?BR>

又仔�l�想了一下，上面的代码应该还可以修改��化：

this->strcat.setFunction (adapter<convert<void, 0>(inout< buffer<char> >, in<string>)> ( ) (::strcat));

this->strncat.setFunction (adapter<convert<void, 0>(inout< buffer<char> >, in<string>, length<in<uint>, 1>)> ( ) (::strncat));

使用一个仿函数来做�Q�函数指针的�c�d��可以从operator ()的参敎ͼ�模板参数�Q�中推导出来�?img src ="http://m.shnenglu.com/cpunion/aggbug/481.html" width = "1" height = "1" />

qiezi 2005-09-28 22:57 发表评论

qiezi — Sat, 24 Sep 2005 09:00:00 GMT

asgard��目已经准备了一�D�|��间了�Q�不�q�有些基本问题还需要考虑�Q�也有一些是新发现的问题�Q�以及自认�ؓ比较好的解决办法�?BR>
通过�W?、第4条的仔细研究�Q�已�l�渐渐完善、明��了动态部分和静态部分的关系�Q��得Method包装�c�L��完成的功能渐渐接�q�于一个函敎ͼ�而元信息则脱��d��体的对象提升到全局�Q�当然还有些��问题没有解冻I��?BR>
1、参数名�U�的问题�?/STRONG>

��Z��与SOAP�{�基于XML的协议兼容，必须开始就把参数名�U�考虑在内�?BR>
代码�l�过C�Q�＋�~�译器编译以后，�c�d��、变量名�U�等都不复存在，唯一留下的是RTTI�Q�显然不能解册��个问题。所以只能在定义时把它加入�?BR>

BEGIN_SERVICE(TestService)
    METHOD (void(in<int>, inout<string>, out<short>), method1, index, info, result);
END_SERVICE()

如果使用�q�种方式�Q�index, info, result分别表示变量名字�Q�在宏里面�{成字�W�串�Q�看��h��好像不太舒服�Q�而且宏不支持参数个数变化�?BR>

BEGIN_SERVICE(TestService)
    METHOD (void(in<int>, inout<string>, out<short>), method1, "(index, info, result)");
    METHOD (int(in<int>, inout<string>), method2, "result(index, info)");
END_SERVICE()

�q�种可能�E�稍舒服一点，在Method构造函数或其它地方解析�q�个字符�Ԍ��赋给各个参数。不�q�它的缺�Ҏ��把编译期应该��查出来的错误�Q��g�q�到�q�行期。如果在�~�译期来做，又会使接口描�q�变得很复杂�?BR>
只是��Z��得到参数的名字，��p��增加�q�么些麻烦�?BR>
c++0x只是一个库的标准，估计XTI也不会加入这些特性，而且c++0x很遥�q�，所以暂时以�q�种方式来做�?BR>
暂时的解军_��法：

BEGIN_SERVICE(TestService)
    METHOD (void(in<int>, inout<string>, out<short>), method1);
    METHOD (int(in<int>, inout<string>), method2);
    BEGIN_SERVICE_DEFINE(TestService)
        METHOD_DEFINE (method1, "(index, info, result)", test_func);
        METHOD_DEFINE (method2, "result(index, info)", &Test::test_method);
    END_SERVICE_DEFINE()
END_SERVICE()

�~�点是参数名�U�C��的错误，要�g�q�到�q�行期才能解��x��?BR>
2、服务对象的大小�?BR>
如果客户端要调用其中一个方法，生成一个TestService�Q�则构造成本太高，特别是一个服务中有多个方法的时候。一个服务容�U�了多个�Ҏ��Q�而每个方法包含一个vector�Q�以及各个参敎ͼ��q�还没考虑以后的扩展�?BR>
所以应该修改调用方式，让它只只需要生成调用所需的最��（��）对象�?BR>
�q�部分考虑�q�不成熟�Q�暂时可以不��它�Q�而以�Ҏ��作�ؓ考虑的对象�?BR>
暂时惛_��的解军_��法：

Method对象中的parameters容器和各个参敎ͼ�只在调用operator ()或async_call�Ӟ��才真正生成出来�?BR>
�q�样的话�Q�Method对象中仅保存一个空的vector�?BR>
甚至�q�个vector也可以只是一个空指针�Q�当调用那几个函数时�Q�才生成一个�?BR>
暂时把这个过�E�命名�ؓCreate On Call(COC)�?BR>
COC的好处是显而易见的�Q�每个对象将只有8字节�Q�虚表指针＋数据对象的指针，“数据对象”是实际调用时才生成的对象，包括参数vector容器、回调函数指针（可能由动态生成一个委托对象，以适应�q�泛�c�d��的回调函敎ͼ�、对象锁�Q�防止干扰到前一个调用）。初始化成本接近0�Q�虚函数表的初始化忽略不计）�?BR>
当调用operator()或async_call�Ӟ��以下��U�CALL�Q�，��调用create_parameters虚函敎ͼ�动态生成一个vector。这��P��没有调用到的Method不会象原来一样媄响到服务对象的构建性能�?BR>
�q�就要求把Method的“元”信息提到全局�Q�当然更�W�合“元”的本意�Q�原来由服务对象查询Method以获得“元”信息的�q�程�Q�现在看来也是不合理的�?BR>
3、in模板可以省略�?/STRONG>

in是默认的参数�c�d��Q�返回值则默认为out�c�d��Q�这都是不需要明��指定的�?BR>
解决办法�Q?BR>
�q�个问题是比较好解决的，在InOutTypeTraits模板�c�M��Q��ؓ各个偏特化版本定义一个type�c�d��Q�InOutTypeTraits�Q�T�Q?:type的类型�ؓin�Q�T�Q�，InOutTypes�Q�in�Q�T�Q�＞::type的类型�ؓin�Q�T�Q�，InOutTypes�Q�inout�Q�T�Q�＞::type的类型�ؓinout�Q�T�Q�，InOutTypes�Q�out�Q�T�Q�＞::type的类型�ؓout�Q�T�Q�，InList模板�c�M��q�行�q�种转换�?BR>
4、异步调用队列�?/STRONG>

在第2点中介绍道：

每个对象��只�?字节�Q�虚表指针＋数据对象的指针，“数据对象”是实际调用时才生成的对象，包括参数vector容器、回调函数指针（可能由动态生成一个委托对象，以适应�q�泛�c�d��的回调函敎ͼ�、对象锁�Q�防止干扰到前一个调用）。初始化成本接近0�Q�虚函数表的初始化忽略不计）�?BR>
提到了对象锁�Q�这是一�U�低效的做法�Q�可以��用异步调用队列来替代它�?BR>
解决办法�Q?/STRONG>

当开始一个调用时�Q��时生成上面所说的“数据对象”，交由一个调用队列去完成。这�Ӟ��׃��Method对象基本不管理数据，所以它成了一个空壻I��作用是保存类型信息�?BR>
异步调用最好的实现��是整个�pȝ��都由异步调用构成�Q�而同步调用是由异步调用模拟而成。原本打��绕�q�这�U�方式，用最��单的�Ҏ��来做�Q�现在好像又�l�回来了�?BR>
上面�q�个做法�Q�很好地把元信息和真实数据分开了，所以打��改成这�U�结构�?BR>
5、全局元信息�?BR>
通过�W?条的研究�Q�已�l��得Method对象成�ؓ一个空壻I��而“数据对象”在没有调用时又不生成，使得自省�l�构必须重新做�?BR>
考察了java�{�语�a�的自省，也打��把元信息的位置提升到全局�Q�而每个Method对象��只保留一个全局元信息的指针�Q�这样应该更自然�?BR>

�Q�以后遇到的问题只更新到�q�个文档中）

qiezi 2005-09-24 17:00 发表评论

qiezi — Thu, 22 Sep 2005 11:13:00 GMT
如《�ؓC�Q�＋实现一个IDL�Q�三�Q�》一文中所��_��q�剩最后一个问题，�q�是使用前面的测试代码说明�?BR>
async_call函数的原型是�Q?BR>

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

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

�q�是模板�c�L��据in/out来��生的�?BR>
在异步调用中�Q�参数是和操作保存在一��L��Q�因��交给�U�程处理。前面已�l�说�q�，Method模板�c�M��保有这些参敎ͼ�Method的定义如下（以例子中4个参数的特化版本来说明）�Q?BR>

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�c�M��用这个特化版本：

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模板参数中保存了所有的参数�c�d��Q�IN_TYPES模板参数中保存了所有的in参数�c�d��Q�但它们不知道如何来对应��h��Q�async_call也不知道如何把几个参数��g��l�parameters�Q�在IMethod中定义，见上一��）�?BR>
如果我们在生成IN_TYPES的时候，把它在TYPES中的位置�Q�烦引）也一起交�l�它�Q�就能解册��个问题�?BR>
InList�W�二个模板参数是一个常量，当我们把TYPES交给它时�Q�以上面的代码�ؓ例，��会使用T_COUNT��gؓ4的偏特化版本。这时候，��会首先推导出IN_TYPES中的�W�一个类型int�Q�它在IN_TYPES中的索引�?�Q��ƈ接着调用T_COUNT值是3的偏特化版本�Q�这样递归推导�Q�直到调用T_COUNT��gؓ0的偏特化版本�Q�这个过�E�就�l�束了。在�q�个递归�q�程中，能够得到各个�c�d��以及对应的“烦引”��|��int: 4, char: 3, string: 2�?BR>
注意�q�个索引值和实际的烦引值是有差别的�Q�实际的索引值应该是4-T_COUNT�Q�所以上面的对应关系应该是：int: 0, char: 1, string: 2�?BR>
最初传递给InList的TYPES�?个元素，当它递归调用�Ӟ��q�个值就会依�ơ递减�Q�后面的递归调用�q�不知道应该�?��d��掉T_COUNT作�ؓ索引�Q�因�?�q�没有传递过来。简单的解决办法是再加上一个模板参敎ͼ�让它往下传递，当然�q�种方式�q�不好看�Q�好在我们不是真的必��这么做�?BR>
注意�Q�在Base�c�M��Q�它是知道TYPES的个数的�Q�那么只要用�q�个数减��d��面生成的IN_TYPE的“烦引”，��p��得到�q�个�c�d��在TYPES中的真正索引。（�q�部分真是有点罗嗦）

修改InList模板�c�，让它生成�?FONT style="BACKGROUND-COLOR: #a9a9a9" color=#a9a9a9> [ in�c�d��以及in�c�d��在TYPES中的“烦引”] 构成的新Typelist�?BR>
首先要增加一个辅助模板类�Q?BR>

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

它能够保存一个类型，以及一个整数。取名�ؓTypeReversedIndex�Q�意思是说它要保存一个Type和一个ReversedIndex�Q�反的烦引）�?BR>
InList模板�c�M��要修改，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�c�d��可以写出来了�Q?BR>

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*�c�d��Q�这里��用了强制转型�Q��ƈ调用in/inout模板�cȝ��setValue�Ҏ��l�它赋倹{�?BR>
��Z��试�l�果�Q�我为IParameter加上了void print () const虚函敎ͼ��q�在in/inout/out模板�c�M��实现它，打印出类型，in/inout�c�M��q�将打印出参数倹{�?BR>

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

�q�在Base::async_call中调用parameters中所有对象的print函数来输��Z��些调试信息：

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

��单测试了2�U�类型，不能保证所有代码都是正��的�Q�毕竟是手工写出来的也没�l�过��查，模板�c�d��没有实例化的时候某些错误是不会报告的�?BR>
��试代码如下�Q?BR>

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

全部代码太长�Q�就不一一�|�列于此了，可以点击�q�里下蝲�?BR>

qiezi 2005-09-22 19:13 发表评论

qiezi — Wed, 21 Sep 2005 12:34:00 GMT
     摘要: 一、修正错误。首先修正第二篇中的一些错误，错误的内容可见第二篇的评论。在Base�c�M��Q�FUNC_TYPE需要所有的in/out�c�d��Q�如果Method的模板参数——即函数�c�d��参数——的�q�回��g��是void�Q�则把它装配成out参数�Q�作为FUNC_TYPE函数�c�d��的最后一个参敎ͼ��q�可以通过偏特化来实现。修改Method模板�c�，把所有类型包装成一个Typelist�Q�直接传递给Base模板�c�，由Base��L��?..  阅读全文

qiezi 2005-09-21 20:34 发表评论

qiezi — Tue, 20 Sep 2005 14:34:00 GMT

说明�Q?BR>要看懂后面那部分代码�Q�即使用Typelist的部分，最好预先看�q�《C�Q�＋设计新思维》，英文版名为《Modern C++ Design》�?BR>If模板�c�d��写完后想��h��好像在哪见过�Q�早晨去公司查阅了一下，在《��生式�~�程——方法、工具与应用》一书中有讲�Q�英文名为《Generative Programming -- Methods, Tools, and Applications》基本和本篇中一个样�?BR>

�?��ؕ七八�p�地讲了一些，有一个遗留问题，函数原型的推对{�?BR>
��要描�q�如下：

Method < void(in<int>, in<char>, inout<string>, out<short>) > method;

// 同步调用
string str = "hello";
short value = 2;
method (3, 'a', str, value);

// 异步调用1
method.async_call (3, 'a', "hello");

// 异步调用2
void test_func (int, char, string, short);
method.async_call (3, 'a', "hello", test_func);

要��生这3�U�函数�Ş式。参数类型如何�{换，是以后的话题�Q�本��主要解军_��步调用的函数原�Ş推导问题。本��也不讨论Method的模板参敎ͼ�即那个函数类型）�q�回�c�d��不�ؓvoid的情��c�?BR>
�W�一�U��Ş式，同步调用�Q�比较好处理�Q�参��C��数和模板参数的数量相同�?BR>
�?�U��Ş式，如何让编译器�Ҏ��in/out来推导出函数原型�Q?BR>
我们需要编译器做这��L��处理�Q�async_call的参数类型中�Q�in�c�d��的参数将保留�Q�out�c�d��的参��C��需要，inout�c�d��也需要保留�?BR>
要用到的Loki头文�Ӟ��

#include <static_check.h>
#include <Typelist.h>

using namespace Loki;
using namespace Loki::TL;

首先看看in/inout/out的声明。�ؓ了简化，�q�里��L��了跟�c�d��推导无关的部分�?/P>
class NullType
{
    NullType ();
};

template <class T>
struct in
{
    typedef T OriginalType;
};

template <class T>
struct out
{
    typedef T OriginalType;
};

template <class T>
struct inout
{
    typedef T OriginalType;
};

下面Method模板�cȝ��声明�Q��用偏特化来��生代码。�ؓ了简化，我只取函数参��C��Cؓ4个参数的版本�Q�比照着上面的代码来解释�Q�只解释method.async_call (3, 'a', "hello", test_func);�q�个版本�Q�因为另一个比它简单�?BR>

template <class T>
struct Method
{
};

template <class Ret, class A, class B, class C, class D>
struct Method <Ret(A,B,C,D)>
{
};

�Ҏ��上面Method的定义，Method < void(in, in, inout, out) > �Q�async_call函数的类型将是：

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

实际上FUNC_TYPE应该能够接受更广泛的�c�d��Q�比如void(int, char, char*, short)�Q�这可以在内部做一些�{换，不过本篇的重点不在这里，所以只讲上面的那种形式�?BR>
直接在Method�c�M��实现有些�ȝ��Q�所以我把这个函数放在一个基�c�M��实现�Q�只要编译器能帮我们推导��Z��面这�U��Ş式就行了�Q?BR>

template <class Ret, class A, class B, class C, class D>
struct Method <Ret(A,B,C,D)> : public Base < A, B, C >
{
};

注意�Q�这里是以Method < void(in, in, inout, out) >�q�种形式来讲的，才会有上面那�U��承关�p�R��而实际上�Q�由于in/out在参��C��的位�|�、数量都是未知的�Q�要到定义时才能��定�Q�所以��用模板来推导。（入正题了�Q?/P>
也就是说�Q�只要我们能使用静态推导方式，获得A,B,C,D�q�四个参��C��所有的in�c�d��Q�把它交�l�Base作�ؓ模板参数��成了�?/P>
�q�里需要一个辅助的模板�c�，用来在编译时帮助推导�Q?BR>

template <class T>
class InOutTypeTraits
{
    Loki::CompileTimeError <false> Not_Supported_Type;
};

template <class T>
struct InOutTypeTraits < in<T> >
{
    enum {isin=1, isout=0};
};

template <class T>
struct InOutTypeTraits < out<T> >
{
    enum {isin=0, isout=1};
};

template <class T>
struct InOutTypeTraits < inout<T> >
{
    enum {isin=1, isout=1};
};

template <>
struct InOutTypeTraits < NullType >
{
    enum {isin=0, isout=0};
};

通过另一个模板类InList来帮我们产生所有的in�c�d��Q�它的结果是一个Typelist。�ؓ了方便以后��用，我把out�c�d��产生器也做了一个OutList�?BR>

template <int CONDITION, class _IF, class _ELSE>
struct If
{
    typedef _IF Result;
};

template <class _IF, class _ELSE>
struct If <0, _IF, _ELSE>
{
    typedef _ELSE Result;
};

template <class A = NullType, class B = NullType, class C = NullType, class D = NullType,
    class E = NullType, class F = NullType, class G = NullType, class H = NullType
>
struct InList
{
    typedef typename If <
        InOutTypeTraits <A>::isin,
        typename Typelist < A, typename InList<B,C,D,E,F,G>::Result >,
        typename InList<B,C,D,E,F,G,H>::Result
    >::Result Result;
};

template <class A>
struct InList <A, NullType, NullType, NullType, NullType, NullType, NullType, NullType>
{
    typedef typename If <
        InOutTypeTraits <A>::isin,
        typename MakeTypelist <A>::Result,
        typename MakeTypelist <>::Result
    >::Result Result;
};

template <class A = NullType, class B = NullType, class C = NullType, class D = NullType,
    class E = NullType, class F = NullType, class G = NullType, class H = NullType
>
struct OutList
{
    typedef typename If <
        InOutTypeTraits<A>::isout,
        typename Typelist < A, typename OutList<B,C,D,E,F,G>::Result >,
        typename OutList<B,C,D,E,F,G,H>::Result
    >::Result Result;
};

template <class A>
struct OutList <A, NullType, NullType, NullType, NullType, NullType, NullType, NullType>
{
    typedef typename MakeTypelist <A>::Result Result;
};

它的原理是，�Ҏ��If模板�c�L��判断一个类型是不是in�c�d��Q�是的话��把它加入到Typelist中，不是��排除它�?BR>
InList , in, inout, out::Result是一个Typelist , Typelist, Typelist, NullType> > >�c�d��Q�说��单点�Q�它和MakeTypelist < in, in, inout >::Result是等��L��?BR>
现在Base模板�c�d��接受一个模板参敎ͼ�它是一个Typelist�c�d��Q�这个不详细讲了�Q�把它的定义写出来：

template <class T, int T_COUNT = Length <IN_TYPE>::value >
struct Base
{
    Loki::CompileTimeError <false> Only_Use_Partial_Specialisation_Version;
};

template <class T>
struct Base <T, 0>
{
    typedef void(*FUNC_TYPE)();

    template <class FUNC_TYPE>
    void async_call (FUNC_TYPE func)
    {
    }
    void async_call ()
    {
    }
};

template <class T>
struct Base <T, 1>
{
    typedef void(*FUNC_TYPE)(
        typename TypeAt <T, 0>::Result::OriginalType);

    void async_call (
        typename TypeAt <T, 0>::Result::OriginalType v0,
        FUNC_TYPE func)
    {
    }
    void async_call (typename TypeAt <T, 0>::Result::OriginalType v0)
    {
    }
};

template <class T>
struct Base <T, 2>
{
    typedef void(*FUNC_TYPE)(
        typename TypeAt <T, 0>::Result::OriginalType,
        typename TypeAt <T, 1>::Result::OriginalType);

    void async_call (
        typename TypeAt <T, 0>::Result::OriginalType v0,
        typename TypeAt <T, 1>::Result::OriginalType v1,
        FUNC_TYPE func)
    {
    }
    void async_call (
        typename TypeAt <T, 0>::Result::OriginalType v0,
        typename TypeAt <T, 1>::Result::OriginalType v1)
    {
    }
};

template <class T>
struct Base <T, 3>
{
    typedef void(*FUNC_TYPE)(
        typename TypeAt <T, 0>::Result::OriginalType,
        typename TypeAt <T, 1>::Result::OriginalType,
        typename TypeAt <T, 2>::Result::OriginalType);

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

template <class T>
struct Base <T, 4>
{
    typedef void(*FUNC_TYPE)(
        typename TypeAt <T, 0>::Result::OriginalType,
        typename TypeAt <T, 1>::Result::OriginalType,
        typename TypeAt <T, 2>::Result::OriginalType,
        typename TypeAt <T, 3>::Result::OriginalType);

    void async_call (
        typename TypeAt <T, 0>::Result::OriginalType v0,
        typename TypeAt <T, 1>::Result::OriginalType v1,
        typename TypeAt <T, 2>::Result::OriginalType v2,
        typename TypeAt <T, 3>::Result::OriginalType v3,
        FUNC_TYPE func)
    {
    }
    void async_call (
        typename TypeAt <T, 0>::Result::OriginalType v0,
        typename TypeAt <T, 1>::Result::OriginalType v1,
        typename TypeAt <T, 2>::Result::OriginalType v2,
        typename TypeAt <T, 3>::Result::OriginalType v3)
    {
    }
};

�q�部分有点多�Q�其实还是比较清晰的。注意这个Base的版本已�l�不是上面所讲的那个了�?BR>
函数原�Ş推导问题��p��完了。上面的代码不一定还能编译，昨天是能�~�译的，被我修改了一些，��Z��解释�Q�又�Ҏ��昨天那样子�?img src ="http://m.shnenglu.com/cpunion/aggbug/349.html" width = "1" height = "1" />

qiezi 2005-09-20 22:34 发表评论

qiezi — Sat, 17 Sep 2005 11:40:00 GMT

前面��单写了点静态结构，�q�一�ơ将主要��x��动态模型以及调用方式�?/P>
�q�个�p�d��的名字叫“�ؓC++实现一个IDL”，实际上应该叫“�ؓC++实现一个Remoting”可能更好一些，说是IDL�Q�主要是想通过宏，使用��单的�c�d��定义辑ֈ�自动生成调用代码的目的�?/P>
一、首先来看看调用习惯�?/STRONG>

从调用习惯入手，主要是因为看到目前有很多�?工具包在调用上都有很多不便之处。假如能在一开始就从这点出发，��p��把调用接口设计得更好一些�?/P>
先来看看服务端如何开放一个服务�?/P>
int main ()
{
    // 发布为SOAP服务�Q�先生成一个服务容器�?BR>    // 服务��发布在localhost�?911上，localhost用来�l�定loopback�|�卡�?/SPAN>
    SOAPProxy soap_service (7911, “localhost�?;

    TestService test_service;
    soap_service.addService  (“test_service�? &test_service);

    TestService service1;
    soap_service.addService (“HelloService�? &service1);

    try{
        soap_service.run ();
    } catch (SocketException& e)
    {
    } catch (SignalException& e)
    {
    }

    return 0;
}

我希望就是这么简单，客户端调用有多种方式�Q?BR>1、 ��用服务的IDL定义�Q�直接调用：

int main ()
{
    SOAPProxy soap_service (7911, “localhost�?;

    try{
        TestService test_service (“test_service�? &soap_service);
        test_service.method1 (/**/);
    } catch (SocketException& e)
    {
    }
    return 0;
}

�q�种方式比较��单，调用时会��查是否已�l�连接，然后发送调用请求，�q�处理调用结果�?/P>
2、服务验证方式：

int main ()
{
    SOAPProxy soap_service (7911, “localhost�?;
    TestService test_service;
    soap_service.getService (“test_service�? &test_service);

    if (test_service)
    {
        try{
            test_service.method1 (/**/);
        } catch (SocketException& e)
        {
        }
    }
    return 0;
}

3、服务发现方式：

int main ()
{
    SOAPProxy soap_service (7911, “localhost�?;
    vector <string> services_name = soap_service.getServiceNames ();
    //
    IService* test_service = soap_service.getService (“test_service�?;
    if (test_service)
    {
        vector <string> methods = test_service->getMethodNames ();
        IMethod* method = test_service->getMethod (“method1�?;
        vector <Type*> types = method->getParameterType s()
        method->addArg (3);
        method->addArg (4);
        //
        method->invoke ();
        //
    }
    return 0;
}

二、基本需求�?BR>
��单分析一下，上面一共涉及了哪些�c�d��Q?BR>IProxy:
�q�是所有Proxy�cȝ��基类(和接�?�Q�它可以容纳多个服务对象�Q�提供服务绑定、服务查询、服务发现、服务验证�?BR>IService:
所有Service�cȝ��基类�Q�可以容�U�_��个方�?Method)�Q�提供方法查询、服务验证�?BR>IMethod:
所有Method模板�cȝ��基类�Q�容�U�_��个参敎ͼ�包括�q�回��|��可通过查询参数�c�d��获得�Ҏ��的类型定义�?BR>IParameter:
所有参数的基类�Q�包含一个参数类型描�q�和一个参数倹{�?BR>IType:
所有类型的基类�Q�预定义了一些基本类型，可自定义�c�d��?/P>
看�v来挺多的�Q�其实很难接触到�q�些�Q�只需要��用宏来定义一个服务，��可以通过模板的类型推��|��自动生成�q�些复杂的定义�?/P>三、调用过�E��?BR>
以下只简单分析一下同步调用，异步调用��是以后的扩充话题�?BR>�Ҏ��W�二节的3�U�不同调用过�E�，��要描�q�如下：

直接调用�?BR>

生成SOAPProxy�Q�让它连接到�q�程��L��?BR>
生成一个TestService对象�Q�设�|�远�E�主��Z��的服务名�U�ͼ��q�指定��用SOAPProxy�Q�也即��用SOAP协议�?BR>
调用TestService::method1�Ҏ��。根据method1的定义，把服务名�U�、方法名�U�、各个in参数�{�打包成一个“集合”，交给SOAPProxy处理�?BR>
SOAPProxy把这个“集合”�{换成SOAP消息�Q�发送到�q�程��L��Q�阻塞线�E��?BR>
�q�程��L��上的SOAPProxy对象收到数据�Q�进行解析。当解析��Z��个服务调用时�Q�把它交�l�TestService服务处理�?BR>
TestService解析��Z��个方法调用，把它交给Method处理�?BR>
Method解析出各个参敎ͼ�验证参数�c�d��、完整性等�Q��ƈ执行调用或返回错误�?BR>
Method调用的返回信�?包括调用�l�果、返回倹{��out参数�{?被打包成一个“集合”，交给TestService处理�?BR>
TestService处理后，交给SOAPProxy�?BR>
SOAPProxy把结果打包成SOAP消息�Q�发回调用端�?BR>
调用端解析SOAP消息�Q�把OUT参数��D��l�调用者提供的对象�Q�调用完成�?

服务验证方式�?BR>

生成SOAPProxy�Q�让它连接到�q�程��L��?BR>
生成TestService对象�Q�调用SOAPProxy的getService验证版本�?BR>
SOAPProxy把TestService对象的信�?名称、成员及基类型等)发送到�q�程��L��Q�阻塞�?BR>
�q�程��L��解析收到的信息，查找服务名，�q�比较查扑ֈ�的服务类型与解析得到的类型�?BR>
比较�l�果发回�l�调用端�?BR>
调用端接着采用直接调用的方式，调用�q�程服务�?/LI>

�q�种方式看�v来多了一些操作，不过验证的好处是能够减少调用时的异常�?

服务发现方式�?BR>

生成SOAPProxy�Q�让它连接到�q�程��L��?BR>
查询�q�程开攄��服务名称�?可省�?

查找特定服务�Q�得到服务描�q�C��息�?BR>
查找服务中的�Ҏ��Q�得到方法描�q�C��息�?BR>
压入各个参数�Q��ƈ执行调用�?BR>
调用前先判断参数是否与描�q�C��_��然后调用SOAPProxy生成SOAP消息�Q�发送到�q�程��L��Q�阻塞�?BR>
�q�程��L��解析��用。。。后面过�E�与�W?�U�方式相同，�q�程��L��q�不知道客户端��用的是哪�U�方式来调用。远�E�主机处理结束，��返回SOAP消息�l�调用端�?BR>
调用端解析出调用�l�果�Q��ƈ把各个OUT参数的��D��l�method对象�?/LI>

使用�q�种方式�Q�调用端不需要服务的�c�d��定义�?

四、异步调�?异步分派(AMI/AMD)�?BR>
同步调用�Ӟ��调用端线�E�需要等待调用结果，服务端线�E�也要等待调用结束返回，才处理下一个调用�?BR>��Z��在服务调用期间让�U�程能做更多的事�Q?BR>调用端把调用交给�U�程池完成，�q�在调用完成后采用某�U�机刉��知�U�程处理�l�果�Q�或者直接由�U�程池中的调用线�E�调用结果处理函数。这�U�方式称为AMI(异步�Ҏ��调用)�?BR>服务端主�U�程则把接收到的消息解析后，攑օ�处理队列�Q�由�U�程池去处理调用�q�程。当调用完成后，�l�果攑օ��l�果队列�Q�由�ȝ��E�处理成消息�Q�发送回调用端。这�U�方式称为AMD(异步�Ҏ��分派)�?BR>调用端和服务端依旧是使用通讯协议来沟通，双方都不知道�Ҏ��是否采用了异步方式�?/P>
AMI和AMD对于静态定义的服务是有影响的，比如下面一个服务：

struct TestService
{
    Method <void(in<int>, out<int>)> method1;
}

在同步调用时�Q�它的调用方式：

TestService test_service;
int a;
service.method1 (3, a); // 或者 service.method1 (3, &a)�Q�打��兼容这2�U�方式�?/SPAN>

异步调用�Ӟ��调用方式�Q?/P>
void method1_result (int, int);
TestService test_service;
test_service.method1.async_call(3, method1_result); // 调用完成后，让调用线�E�去调用method1_result通知调用�l�果�?BR>// 或者像下面
IMethod* result = test_service.method1.async_call (3);
while (!result->done())  // �q�有很多好办法，�q�里只是��Z��单�?/SPAN>
{
    sleep (1);
}
cout << result->getArg(1)->toInt();

正如上面演示的一��P��异步调用的结果有2�U�方式去处理�?BR>一是由�U�程池调用完以后�Q�接着调用一个函��C��通知�l�果。它不需要轮询，不过涉及��C��U�程问题�Q�增加了一些复杂性�?BR>另一�U�方式调用结束后�Q�原调用�U�程在某个适当的“时机”去查询调用�l�果。这个时机可以是定时查询�Q�也可以是被�U�程消息通知而去处理�?/P>
五、其它�?BR>
�q�一��加上前一��，应该是提��C��全部的要炏V�?BR>目前剩下的唯一一个难点，可能是在处理异步调用�Ӟ��Method的定义�?BR>正如上面演示的，一个方法在同步调用和异步调用时�Q�就�?�U�调用方式：

service.method1 (3, a);
test_service.method1.async_call(3, method1_result);
IMethod* result = test_service.method1.async_call (3);

特别圎ͼ�它如何根据in和个数和out的个敎ͼ�产生�?个参��C��数匹配的异步调用函数�Q?BR>再来回顾一下method1的定义：

Method <void(in<int>, out<int>)> method1;

昄��有一定的复杂性，不过我认��是可以处理掉的。拿3个参数的偏特化版本来说明�Q?/P>
template <class Ret, class A, class B, class C>
class Method <Out<Ret>(A,B,C)> : public MethodBase <Out<Ret>,A,B,C>
{
};

template <class Ret=NullType, class A=NullType, class B=NullType, class C=NullType, class D=NullType, IN_COUNT=InCount< A,B,C,D>::value >
class MethodBase
{
};

通过对MethodBase�cȝ��IN�Q�COUNT参数定义偏特化，卛_��定义��些不同的版本�?BR>
当然仅仅是知道了IN参数的个敎ͼ��q�没有提取出IN参数的类型，所以还不能生成函数的原型，或许需要把typelist加进来了�Q�loki中的那个�Q��?BR>

�q�是后面要考虑的内容，今天先想到这�?/P>

qiezi 2005-09-17 19:40 发表评论

qiezi — Wed, 14 Sep 2005 17:27:00 GMT

一、问题�?BR>
�q�段旉��考虑实现一个纯C�Q�＋的分布式服务包装库，��要描�q�如下：

有如下类和函敎ͼ�

struct Test
{
    void test1 (/*in*/ int v1, /*in*/ int* v2);
    int test2 (/*in*/ int& v1, /*out*/ int* v2);
};

int test_func (/*in*/ int* v1, /*inout*/ string* v2);

��x��它们作�ؓ服务发布出去�Q�以SOAP或其它方式。发布�ؓ一个TestService�Q��ƈ让它携带多一些信�?

struct TestService
{
    void test1 (in<int> v1, in<int> v2);
    int test2 (in<int> v1, out<int> v2);
    int test_func (in<int> v1, inout<string> v2);
};

C�Q�＋有许多工兗��库来做到这点，但是�Q�都需要生成一堆代码，很是不爽�?BR>
其它语言�Q�比如python, java, c#�{�，都可以通过自省机制�Q�抛开IDL在语�a�内实现�?BR>
C�Q�＋�q��不能做这个，它只是缺��够的�c�d��信息。比如上面的例子�Q�如果要发布为服务，那么臛_��应该把它的参数、返回值搞得明��些�Q�否则要么会造成不必要的参数传递，要么会��生错误（把OUT参数取值可不是安全的）�?BR>
比如上面出现的int, int&, int*�Q�在作�ؓin参数�Ӟ��我们是想传递它的��|��c�d��为int。而int*和string*作�ؓout参数�Ӟ��我们惌��它传递指针或引用�Q�当调用�q�回�Ӟ��我们�l�它赋倹{�?BR>
C�Q�＋语言的类型极��Z��富，却没有描�q�C��个参数到底是in�q�是out。java也没有，但它可以正常序列化一个null��|��在C�Q�＋中，�q�可能存在一些麻烦�?BR>
再考虑一下char*�c�d��Q�假如它是in参数�Q�那么它是要传递一个字�W�还是一个字�W�串�Q�C�Q�＋语言没有对它�q�行描述�?BR>
所以要实现一个分布式服务包装�Q�或代理�Q�库�Q�必��让发布者提供这些信息�?BR>
我们知道�Q�要查询一个远�E�服务，必须查询相应��L��端口�Q�获取服务信息。最��单的服务信息包括�Q�服务列表，每个服务中的�Ҏ��列表�Q�方法的�c�d��Q�包括参数和�q�回值类型，in/out信息�{�）�?BR>
实际上，我们是要为C�Q�＋增加一些简单的自省能力。上面那个服务发布接口，实际上离�q�个要求�q�有很远�Q�再来看一下：

struct TestService
{
    void test1 (in<int> v1, in<int> v2);
    int test2 (in<int> v1, out<int> v2);
    int test_func (in<int> v1, inout<string> v2);
};

可以惌��Q�它是没有一点自省能力的�Q�我们如何向它查询，它的名字�Q�它的方法列表？�Ҏ��的类型？它如何与Test�cȝ��成员函数以及test_func函数兌��Q?/P>
二、方向�?BR>
要让上面那个服务��h��自省能力�Q�要做的扩充其实�q�不多。考虑下面的代码：

struct TestService : public Service
{
    TestService ();
    Method <void(in<int>, in<int>)> test1;
    Method <int(in<int>, out<int>)> test2;
    Method <int(in<int>, inout<string>) test_func;
};

�q�几个Method可以用自己写的委托类来做�?BR>
1、假如我们在TestService的构造函数里�l�它分配一个“TestService”名字，�q�且Service�c�d��C��查询名字的接口，那么它就知道它自��q��名字了�?BR>
2、假如在TestService的构造函数里为各个Method分配名字�Q��ƈ且注册到TestService�Q�那么它��p��够查询方法列表�?BR>
3、方法的�c�d��Q�通过模板方式�Q�把各个参数�c�d��攉��h��Q�给个字�W�串名称��可以了�?BR>
使用宏来实现�Q�大概可以写成这��P��

BEGIN_SERVICE (TestService)
    METHOD (void(in<int>, in<int>), test1, &Test::test1)
    METHOD (int(in<int>, out<int>), test2, &Test::test2)
    METHOD (int<in<int>, inout<string>), test_func, test_func)
END_SERVICE ()

通过上面�q�几个宏�Q�我们能够生成TestService声明�?BR>
不过�Q�有几个问题�Q�罗列如下，�q�一一解决它：

1、如何把函数指针传给它？如何把方法名�U�C��l�它�Q?BR>�q�个只是C�Q�＋语言为我们增加了一些麻烦，我们无法在定义成员的地方调用它的构造函敎ͼ�不过�q��ƈ不会造成多大障碍�?BR>上面的METHOD宏如果只是生成类的声明，那么函数指针可以省略。我把它加上的原因是�Q�它可以被我用Ctrl+C, Ctrl+V�q�种世界上最先进的技术原��h��贝下来，�q�且通过��单修改的�Ҏ��实现�q�种世界上最先进的重用�?BR>
上面的代码经�q�修改，�l�果��成�q�样�Q?/P>

BEGIN_SERVICE (TestService)
    METHOD (void(in<int>, in<int>), test1, &Test::test1)
    METHOD (int(in<int>, out<int>), test2, &Test::test2)
    METHOD (int<in<int>, inout<string>), test_func, test_func)

    BEGIN_DEFINE (TestService)
        METHOD_DEFINE (void(in<int>, in<int>), test1, &Test::test1)
        METHOD_DEFINE(int(in<int>, out<int>), test2, &Test::test2)
        METHOD_DEFINE(int(in<int>, inout<string>), test_func, test_func)
    END_DEFINE ()

END_SERVICE ()

看上��d��应得非常整齐�Q�修改�v来也比较��单。上面那部分被扩充�ؓ如下代码�Q?/P>

struct TestService : public Service
{
    Method <void(in<int>, in<int>)> test1;
    Method <int(in<int>, out<int>)> test2;
    Method <int(in<int>, inout<string>) test_func;
    TestService ()
    : Service ("TestService")
    {
        test1.setName ("test1");
        test1.setMethod (&Test::test1);
        this->registerMethod (&test1);
        test2.setName ("test2");
        test2.setMethod (&Test::test2);
        this->registerMethod (&test2);
        test_func.setName ("test_func");
        test_func.setMethod (test_func);
        this->registerMethod (&test3);
    }
};

基本上需要的东西都在�q�里了�?BR>
2、客��L��的问题�?BR>

上面�q�种映射�Q�直接拿到客��L��会有问题�Q�Test�c�d��test_func函数我们�q�不打算交给客户端，所以��用函数指针会出现链接错误�?BR>
实际上客��L��不需要这个，我们惛_��法把它拿掉就行了。客��L��实际需要生成的代码如下�Q?BR>

struct TestService : public Service
{
    Method <void(in<int>, in<int>)> test1;
    Method <int(in<int>, out<int>)> test2;
    Method <int(in<int>, inout<string>) test_func;
    TestService ()
    : Service ("TestService")
    {
        test1.setName ("test1");
        this->registerMethod (&test1);
        test2.setName ("test2");
        this->registerMethod (&test2);
        test_func.setName ("test_func");
        this->registerMethod (&test3);
    }
};

�q�是上面提到的，C++�l�我们带来的�ȝ��。这�ơ需要另一�l�宏来完成它�Q?/P>

BEGIN_SERVICE_D (TestService)
    METHOD_D (void(in<int>, in<int>), test1)
    METHOD_D (int(in<int>, out<int>), test2)
    METHOD_D (int(in<int>, inout<string>), test_func)

    BEGIN_DEFINE_D (TestService)
        METHOD_DEFINE_D (void(in<int>, in<int>), test1)
        METHOD_DEFINE_D(int(in<int>, out<int>), test2)
        METHOD_DEFINE_D(int(in<int>, inout<string>), test_func)
    END_DEFINE_D ()

END_SERVICE_D ()

METHOD*和METHOD_DEFINE*宏的参数都有一些多余的信息�Q�没有去掉是因�ؓ攑֜�一起容易看到写错的地方。（�q�个技巧来源于前几天看的一��BLOG�Q�很报歉没有��C��地址�Q?BR>
3、��用的问题�?BR>
如何才能比较方便��C��用？我考虑了下面这�U�方式：

template <class T>
struct IProxy;

template <class T>
struct SOAPProxy;

SOAPProxy <TestService> service;
service.connect (5000, "localhost");
int a=0;
int *n = &a;
service.test1 (3, n);
service.test1 (3, *n);
service.test2 (3, n);
service.test2 (3, *n);
service.test2 (3, NONE);
//

Method::operator ()的各个参数都��可以接受相容的�c�d��Q�像上面一��P��因�ؓ在TestService中我们已�l�定义了它要传输的值的�c�d��?BR>
a.NONE是什么？其实是�ؓ异步调用考虑的。假如指定某个OUT参数为NONE�Q�则�q�个参数的值�ƈ不真正的OUT�Q�而是保存在Method中。实际上Method中保存每个参数的倹{�?BR>
b.Method与Service如何发生关系�Q?BR>从TestService的定义中我们知道�Q�Method向Service注册自己以实现自省，但它同时也会保存Service的指向�?BR>我们的Proxy实际上是一个��承模板，上面�q�没有把它指出来。它的定义是�Q?/P>

template <class T>
class XProxy : public T
{
    //
};

所以我们的TestService其实也是模板�c�，它将使用XProxy中定义的序列化类。XProxy��实现Service基类中序列化虚函��C��及调用虚函数�?BR>
当一个Method调用�Ӟ��它会调用Service的序列化�Q�由于被重写了，所以调用的是XProxy中的序列化方法。这个方法会把这个Method的各in/inout参数序列化，然后执行�q�程调用�Q�再把调用结果反序列化给inout/out参数�?BR>
4、其它想法�?BR>
在考虑上面的定义方式时�Q�我也考虑了其它方式，主要是返回值处理的�Ҏ��Q�简�q�如下�?BR>
前面我们假设了一�D�将被开放�ؓ�q�程服务的代码：

struct Test
{
    void test1 (/*in*/ int v1, /*in*/ int* v2);
    int test2 (/*in*/ int& v1, /*out*/ int* v2);
};

int test_func (/*in*/ int* v1, /*inout*/ string* v2);

在前面的做法中，我们的服务描�q�是攑֜�那一�l�宏里面�Q�好处是不用改这�D�代码，坏处��是代码定义的地方和描述不在一��P��协调可能会有一些不�ѝ�?BR>
我也考虑了另一�U�做法：

struct Test
{
    idl <void(in<int>, in<int>)> test1 (int v1, int* v2);
    idl <int(in<int>, out<int>)> test2 (int& v1, int* v2);
};

idl <int(in<int>, inout<string>) test_func int* v1, string* v2);

对于实现代码�Q�只需要修改返回��gؓvoid的函敎ͼ�把return;修改为return VOID;�Q��ƈ且�ؓ没有写此语句的分支加上此句�?BR>
VOID是一个特�D�类型的静态变量，专�ؓvoid�q�回值的函数讑֮��?BR>
�q�种做法修改了原有的代码�Q�不�q�在定义服务时可以节省一些工作：

BEGIN_SERVICE (TestService)
    METHOD (test1, &Test::test1)
    METHOD (test2, &Test::test2)
    METHOD (test_func, test_func)

    BEGIN_DEFINE (TestService)
        METHOD_DEFINE (test1, &Test::test1)
        METHOD_DEFINE (test2, &Test::test2)
        METHOD_DEFINE (test_func, test_func)
    END_DEFINE ()

END_SERVICE ()

它所需要的函数�c�d��Q�将由函数指针推对{�?BR>
在G�Q�＋�~�译器下�Q�可以��用typeof来获得函数指针的�c�d��而不需要真得获得函数指针��|��不过目前仅仅在G�Q�＋下可用。（��Z��说一下，typeof已经列入c++0x�Q?BR>
最�l�我攑ּ�了这个想法，毕竟它要修改现有的代码，某些情况下这是不可能的，而且typeof目前也不能跨�~�译器�?BR>
三、实现�?BR>
老实说我现在�q�没有一份完整的或半完整的实玎ͼ�大部分想法还在头脑中�Q�测试代码倒是写了不少�Q�主要是用来��试上述��x��能否实现�Q�我惛_��部分情况都已�l�测试了�Q�只需要有旉��来把它实现出来�?BR>
�q�是我近期要做的事之一�Q�争取月内把它做完�Ş�?/P>

qiezi 2005-09-15 01:27 发表评论