Runtime Concept 的模拟(4)

Runtime Concept 的模拟(4)
简化使用方法！
支持auto concept和non-auto concept。
支持引用类型concept和值类型concept。
已测试支持的编译器：
VC 7.1 (VC 2003)
VC 8.0 (VC 2005)
VC 9.0 (VC 2008)
GCC 3.4.2
GCC 4.2.3

基本原理：
1. 用类继承的方法生成vtable。
2. 用多继承来组合concept。

缺陷：
1. 成员函数的调用方法不知道是不是符合标准，不过估计移植性没什么问题。
2. static应该改为多线程安全的Singleton。
3. 没考虑异常安全。
4. 继承自两个有相同约束的concept的时候，产生调用不明确的问题。
   可用重新声明约束的方法来解决。

另：
1. 关于非虚成员函数指针可以指向虚函数并正常调用的问题：
   i) VC 如果指向的是没有基类的类的虚函数就可以。
   ii) GCC 总是可以调用的。
2. VC6 不支持偏特化，不支持类模板参数的成员类模板。

// main.cpp

//  main.cpp
#include  < stdio.h >
#include  < vector >
#include  < string >
#include  " shape.hpp "
#include  " concept.hpp "

CONCEPT_MEMBER_FUNCTION(c_set_value, concept_base, set_value,  void , ( int  Value), (Value));
CONCEPT_MEMBER_FUNCTION(c_set_value1, concept_base, set_value1,  void , ( int  Value), (Value));
CONCEPT_MEMBER_FUNCTION(c_set_value2, concept_base, set_value2,  void , ( int  Value), (Value));
CONCEPT_MEMBER_FUNCTION(c_set_value3, concept_base, set_value3,  void , ( int  Value), (Value));
CONCEPT_MEMBER_FUNCTION(c_set_value4, concept_base, set_value4,  void , ( int  Value), (Value));
CONCEPT_MEMBER_FUNCTION(c_draw, concept_base, draw,  void , (monitor device)  const , (device));
CONCEPT_FUNCTION(g_set_value, concept_base, set_value,  void , (ObjectType  & t,  int  Value), (t, Value));
CONCEPT_FUNCTION(g_drawShape, concept_base, drawShape,  void , ( const  ObjectType  & t, monitor device), (t, device));
typedef concept_list < g_drawShape, c_draw, c_set_value, c_set_value1, c_set_value2, c_set_value3 >  Shape;

template  <>   struct  concept_map < Shape, Rectangle >   ... {} ;

/**/ ////

typedef auto_concept < Shape >  auto_Shape;

void  DrawShapes(monitor device, std::vector < auto_Shape >   const &  g)
... {
    std::vector<auto_Shape>::const_iterator b(g.begin()), e(g.end());
    for(; b != e; ++b)
    ...{
        b->draw(device);
        auto_Shape::drawShape(*b, device);
    }
}

template  < class  T >
void  DrawShape(monitor device,  const  T &  t)
... {
    if (0) concept<Shape> tmp = t;         //static non-auto concept
    t.draw(device);
}

int  main( int  argc,  char *  argv[])
... {
    auto_Shape as = Rectangle();
    int sizeofShape = sizeof(Shape), sizeofconceptShape = sizeof(auto_Shape);
    as.draw(stdout);
    as.set_value(1);
    as.draw(stdout);
    as.set_value1(sizeofShape);
    as.draw(stdout);
    as.set_value2(sizeofconceptShape);
    as.draw(stdout);
    as.set_value3(1);
    as.draw(stdout);

    std::vector<auto_Shape> vg;
    vg.push_back(Rectangle());
    vg.push_back(Ellipse());
    vg.push_back(vg[0]);
    vg.push_back(vg[2]);
    vg[2] = vg[0];
    vg[3] = vg[1];
    //vg.push_back(Triangle());            //错误，不符合Shape concept // OK in GCC
    //vg.push_back(std::string("xxx"));    //错误，不符合Shape concept
    DrawShapes(stdout, vg);

    Rectangle rect;
    Ellipse elli;
    EllipseChild ellichild;
    DrawShape(stdout, rect);
    //DrawShape(stdout, elli);             //错误，不符合Shape static concept
    //DrawShape(stdout, ellichild);        //错误，不符合Shape static concept
    ref_concept<Shape> ref_non_auto_Shape = rect;
    ref_non_auto_Shape = rect;
    //ref_non_auto_Shape = elli;           //错误，不符合Shape non-auto concept
    printf("rect.value = %d ", rect.value);
    ref_non_auto_Shape.set_value(1);
    printf("rect.value = %d ", rect.value);
    ref_auto_concept<c_set_value>(rect).set_value(2);
    ref_auto_concept<g_set_value> x(rect);
    ref_auto_concept<g_set_value>::set_value(x, 2);
    printf("rect.value = %d ", rect.value);

    return 0;
}

// shape.hpp

//  shape.hpp
#include  < stdio.h >
typedef FILE *  monitor;

struct  ShapeBase
... {
    int value;
    ShapeBase() : value(0) ...{}
    void set_value(int Value)
    ...{
        value = Value;
    }
    void set_value1(int Value)
    ...{
        value = Value;
    }
    void set_value2(int Value)
    ...{
        value = Value;
    }
    void set_value3(int Value)
    ...{
        value = Value;
    }
    void set_value4(int Value)
    ...{
        value = Value;
    }
} ;

struct  Rectangle :  public  ShapeBase
... {
    void draw(monitor device) const
    ...{
        fprintf(device, "Rectangle.draw: %d ", value);
    }
    void draw() const
    ...{
        printf("Rectangle.draw ?: %d ", value);
    }
} ;

struct  Ellipse
... {
    int value;
    Ellipse() : value(0) ...{}
    void set_value(int Value)
    ...{
        value = Value;
    }
    void set_value1(int Value)
    ...{
        value = Value;
    }
    void set_value2(int Value)
    ...{
        value = Value;
    }
    void set_value3(int Value)
    ...{
        value = Value;
    }
    void set_value4(int Value)
    ...{
        value = Value;
    }
    virtual void draw(monitor device) const
    ...{
        fprintf(device, "Ellipse.draw: %d ", value);
    }
} ;

struct  EllipseChild :  public  Ellipse
... {
    virtual void draw(monitor device) const
    ...{
        fprintf(device, "EllipseChild.draw?: %d ", value);
    }
} ;

struct  Triangle :  public  ShapeBase
... {
    virtual void draw(monitor device) const
    ...{
        fprintf(device, "Triangle.draw virtual: %d ", value);
    }
} ;

void  drawShape( const  Rectangle  & refShape, monitor device)
... {
    refShape.draw(device);
}

void  drawShape( const  Ellipse  & refShape, monitor device)
... {
    refShape.draw(device);
}

void  drawShape( const  Triangle  & refShape, monitor device)
... {
    refShape.draw(device);
}

template  < class  T >
void  set_value(T  & refShape,  int  Value)
... {
    refShape.value = Value;
}

// concept.hpp

//  concept.hpp
#ifdef _MSC_VER
#define  MEMFUNCCAST(A)          reinterpret_cast<A>
#else
#define  MEMFUNCCAST(A)
#endif

#define  CONCEPT_FUNCTION(CONCEPTNAME, BASE, FNAME, RTYPE, FTYPE, PARA) 
struct  CONCEPTNAME 
... { 
    template <bool isvtable, class ObjectType> 
    struct table : public BASE::template table<isvtable, ObjectType> 
    ...{ 
        typedef typename get_type<RTYPE (*)FTYPE>::type function_type; 
        function_type p##FNAME; 
        table() : p##FNAME(&::FNAME) ...{} 
    }; 
    template <class ObjectType> 
    struct table<false, ObjectType> : public BASE::template table<false, ObjectType> 
    ...{ 
        const void* CONCEPTNAME##_index() const ...{return this;} 
        static RTYPE FNAME FTYPE 
        ...{ 
            return (*t.ptable->p##FNAME)PARA; 
        } 
    }; 
} ;

#define  CONCEPT_MEMBER_FUNCTION(CONCEPTNAME, BASE, FNAME, RTYPE, FTYPE, PARA) 
struct  CONCEPTNAME 
... { 
    template <bool isvtable, class ObjectType> 
    struct table : public BASE::template table<isvtable, ObjectType> 
    ...{ 
        typedef typename get_type<RTYPE (ObjectType::*)FTYPE>::type function_type; 
        function_type p##FNAME; 
        table() : p##FNAME(MEMFUNCCAST(function_type)(&ObjectType::FNAME)) ...{} 
    }; 
    template <class ObjectType> 
    struct table<false, ObjectType> : public BASE::template table<false, ObjectType> 
    ...{ 
        const void* CONCEPTNAME##_index() const ...{return this;} 
        RTYPE FNAME FTYPE 
        ...{ 
            typedef typename ObjectType::TableType TableType; 
            typedef typename TableType::conceptType conceptType; 
            typedef concept<conceptType> concept_Type; 
            ObjectType* This = reinterpret_cast<ObjectType*>( 
                reinterpret_cast<size_t>(this) - 
                reinterpret_cast<size_t>( 
                    reinterpret_cast<concept_Type*>(0)->CONCEPTNAME##_index())); 
            return (This->object_pointer->*This->ptable->p##FNAME)PARA; 
        } 
    }; 
} ;

template  < class  T >   struct  get_type  ... {typedef T type;} ;

struct  concept_object ... {} ;
template  < class  conceptT  =   int ,  class  T  =   int >   struct  concept_map  ... {int t[2];} ;

struct  concept_base
... {
    template <bool isvtable, class ObjectType>
    struct table
    ...{
    };
} ;

template  < class  First  =  concept_base,  class  Second  =  concept_base >
struct  concept_pair
... {
    typedef concept_pair type;
    template <bool isvtable = true, class ObjectType = concept_object>
    struct table : public First::template table<isvtable, ObjectType>, 
                          Second::template table<isvtable, ObjectType>
    ...{
    };
} ;

template  < class  SameType >
struct  concept_pair < SameType, SameType >
... {
    typedef concept_pair type;
    template <bool isvtable = true, class ObjectType = concept_object>
    struct table : public SameType::template table<isvtable, ObjectType>
    ...{
    };
} ;

template  < class  First >
struct  concept_pair < First, concept_base >
... {
    typedef First type;
} ;

template  < class  Second >
struct  concept_pair < concept_base, Second >
... {
    typedef Second type;
} ;

template  <>
struct  concept_pair < concept_base, concept_base >
... {
    typedef concept_base type;
} ;

template  < class  C0  =  concept_base,   class  C1  =  concept_base,   class  C2  =  concept_base,   class  C3  =  concept_base,   class  C4  =  concept_base,  
           class  C5  =  concept_base,   class  C6  =  concept_base,   class  C7  =  concept_base,   class  C8  =  concept_base,   class  C9  =  concept_base,  
           class  C10  =  concept_base,  class  C11  =  concept_base,  class  C12  =  concept_base,  class  C13  =  concept_base,  class  C14  =  concept_base, 
           class  C15  =  concept_base,  class  C16  =  concept_base,  class  C17  =  concept_base,  class  C18  =  concept_base,  class  C19  =  concept_base  >
struct  concept_list
... {
    template <bool isvtable = true, class ObjectType = concept_object>
    struct table : public
                 concept_pair< C0, typename concept_pair< C1, typename concept_pair< C2, typename concept_pair< C3, typename concept_pair< C4,
        typename concept_pair< C5, typename concept_pair< C6, typename concept_pair< C7, typename concept_pair< C8, typename concept_pair< C9,
        typename concept_pair<C10, typename concept_pair<C11, typename concept_pair<C12, typename concept_pair<C13, typename concept_pair<C14,
        typename concept_pair<C15, typename concept_pair<C16, typename concept_pair<C17, typename concept_pair<C18, C19>
        ::type>::type>::type>::type>::type>::type>::type>::type>::type>::type>
        ::type>::type>::type>::type>::type>::type>::type>::type>::type
        ::template table<isvtable, ObjectType>
    ...{
    };
} ;

template  < class  TableT >
struct  concept_class_base
... {
    typedef TableT TableType;

    concept_object *object_pointer;
    TableT *ptable;

    operator const concept_object&() const ...{ return *object_pointer; }
    operator concept_object&() ...{ return *object_pointer; }
} ;

template  < class  conceptT,  class  T  =  concept_object >
struct  concept_table :  public  conceptT::template table < true , T >
... {
    typedef conceptT conceptType;

    typedef T* (*tcloneT)(const T *p);
    typedef void (*tdeleteT)(T *p);
    tcloneT pcloneT;
    tdeleteT pdeleteT;
    concept_table() : 
        pcloneT(reinterpret_cast<tcloneT>(&concept_table::cloneT)), 
        pdeleteT(reinterpret_cast<tdeleteT>(&concept_table::deleteT))...{}

    static concept_table* vtable()
    ...{
        static concept_table static_table;
        return &static_table;
    }
    static T *cloneT(const T *p)
    ...{
        return new T(*p);
    }
    static void deleteT(T *p)
    ...{
        delete p;
    }
} ;

template  < class  conceptT >
class  auto_concept;
template  < class  conceptT >
class  ref_concept;
template  < class  conceptT >
class  ref_auto_concept;

template  < class  conceptT,  bool  isauto  =   false ,  bool  isref  =   false >
class  concept : 
     public  concept_class_base < concept_table < conceptT >   > , 
     public  conceptT::template table < false , concept_class_base < concept_table < conceptT >   >   >
... {
public:
    using concept_class_base<concept_table<conceptT> >::ptable;
    using concept_class_base<concept_table<conceptT> >::object_pointer;
    typedef concept_table<conceptT> TableType;
private:
    void init_with(concept_object* p, TableType* pTable)
    ...{
        ptable = pTable;
        if (isref)
        ...{
            object_pointer = p;
        }
        else
        ...{
            object_pointer = (*ptable->pcloneT)(p);
        }
    }
    concept_object *cloneT() const
    ...{
        return (*ptable->pcloneT)(object_pointer);
    }
    void deleteT()
    ...{
        (*ptable->pdeleteT)(object_pointer);
    }
public:
    template <class T>
    concept(const T& t)
    ...{
        if (0) char static_assert[isauto || sizeof(concept_map<>) != sizeof(concept_map<conceptT, T>) ? 1 : -1];
        typedef concept_table<conceptT, T> cTable;
        init_with(const_cast<concept_object *>(reinterpret_cast<const concept_object *>(&t)), 
                  (reinterpret_cast<TableType*>(cTable::vtable())));
    }

    concept(const concept& rhs) ...{ init_with(rhs.object_pointer, rhs.ptable); }
    concept(const concept<conceptT, isauto, !isref>& rhs) ...{ init_with(rhs.object_pointer, rhs.ptable); }
    concept(const concept<conceptT, !isauto, isref>& rhs) ...{ init_with(rhs.object_pointer, rhs.ptable); }
    concept(const concept<conceptT, !isauto, !isref>& rhs) ...{ init_with(rhs.object_pointer, rhs.ptable); }
    concept(const auto_concept<conceptT>& rhs) ...{ init_with(rhs.object_pointer, rhs.ptable); }
    concept(const ref_concept<conceptT>& rhs) ...{ init_with(rhs.object_pointer, rhs.ptable); }
    concept(const ref_auto_concept<conceptT>& rhs) ...{ init_with(rhs.object_pointer, rhs.ptable); }

    ~concept()
    ...{
        if (!isref) deleteT();
    }

    concept& operator = (const concept& rhs)
    ...{
        concept(rhs).swap(*this);
        return *this;
    }

    void swap(concept& rhs)
    ...{
        concept_object *pointer0 = object_pointer;
        TableType *ptable0 = ptable;
        object_pointer = rhs.object_pointer;
        ptable = rhs.ptable;
        rhs.object_pointer = pointer0;
        rhs.ptable = ptable0;
    }
} ;

template  < class  conceptT >
class  auto_concept :  public  concept < conceptT,  true ,  false >
... {
public:
    template <class T>
    auto_concept(const T& t) : concept<conceptT, true, false>(t) ...{}
} ;

template  < class  conceptT >
class  ref_concept :  public  concept < conceptT,  false ,  true >
... {
public:
    template <class T>
    ref_concept(const T& t) : concept<conceptT, false, true>(t) ...{}
} ;

template  < class  conceptT >
class  ref_auto_concept :  public  concept < conceptT,  true ,  true >
... {
public:
    template <class T>
    ref_auto_concept(const T& t) : concept<conceptT, true, true>(t) ...{}
} ;