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

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


前2篇乱七八糟地讲了一些，有一个遗留问题，函数原型的推导。

简要描述如下：

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种函数形式。参数类型如何转换，是以后的话题，本篇主要解决异步调用的函数原形推导问题。本篇也不讨论Method的模板参数（即那个函数类型）返回类型不为void的情况。

第一种形式，同步调用，比较好处理，参数个数和模板参数的数量相同。

后2种形式，如何让编译器根据in/out来推导出函数原型？

我们需要编译器做这样的处理，async_call的参数类型中，in类型的参数将保留，out类型的参数不需要，inout类型也需要保留。

要用到的Loki头文件：

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

using   namespace  Loki;
using   namespace  Loki::TL;

首先看看in/inout/out的声明。为了简化，这里去掉了跟类型推导无关的部分。

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模板类的声明，使用偏特化来产生代码。为了简化，我只取函数参数个数为4个参数的版本，比照着上面的代码来解释，只解释method.async_call (3, 'a', "hello", test_func);这个版本，因为另一个比它简单。

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<int>, in<char>, inout<string>, out<short>) > ，async_call函数的类型将是：

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

实际上FUNC_TYPE应该能够接受更广泛的类型，比如void(int, char, char*, short)，这可以在内部做一些转换，不过本篇的重点不在这里，所以只讲上面的那种形式。

直接在Method类中实现有些麻烦，所以我把这个函数放在一个基类中实现，只要编译器能帮我们推导出下面这种形式就行了：

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

注意，这里是以Method < void(in<int>, in<char>, inout<string>, out<short>) >这种形式来讲的，才会有上面那种继承关系。而实际上，由于in/out在参数中的位置、数量都是未知的，要到定义时才能确定，所以使用模板来推导。（入正题了）

也就是说，只要我们能使用静态推导方式，获得A,B,C,D这四个参数中所有的in类型，把它交给Base作为模板参数就成了。

这里需要一个辅助的模板类，用来在编译时帮助推导：

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类型，它的结果是一个Typelist。为了方便以后使用，我把out类型产生器也做了一个OutList。

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模板类来判断一个类型是不是in类型，是的话就把它加入到Typelist中，不是就排除它。

InList <in<int>, in<char>, inout<string>, out<short>::Result是一个Typelist <in<int>, Typelist<in<char>, Typelist<inout<string>, NullType> > >类型，说简单点，它和MakeTypelist < in<int>, in<char>, inout<stirng> >::Result是等价的。

现在Base模板类将接受一个模板参数，它是一个Typelist类型，这个不详细讲了，把它的定义写出来：

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

这部分有点多，其实还是比较清晰的。注意这个Base的版本已经不是上面所讲的那个了。

函数原形推导问题就讲完了。上面的代码不一定还能编译，昨天是能编译的，被我修改了一些，为了解释，又改成昨天那样子。