Runtime Concept 的模拟(5)

Runtime Concept 的模拟(5)
简化使用方法！
用链式的单继承解决多继承方法的调用不明确的问题。
支持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. 没考虑异常安全。

另：
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, set_value,  void , ( int  Value), (Value));
CONCEPT_MEMBER_FUNCTION(c_set_value1, set_value1,  void , ( int  Value), (Value));
CONCEPT_MEMBER_FUNCTION(c_set_value2, set_value2,  void , ( int  Value), (Value));
CONCEPT_MEMBER_FUNCTION(c_set_value3, set_value3,  void , ( int  Value), (Value));
CONCEPT_MEMBER_FUNCTION(c_set_value4, set_value4,  void , ( int  Value), (Value));
CONCEPT_MEMBER_FUNCTION(c_draw, draw,  void , (monitor device)  const , (device));
CONCEPT_FUNCTION(g_set_value, set_value,  void , (ObjectType  & t,  int  Value), (t, Value));
CONCEPT_FUNCTION(g_drawShape, 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, 
                     c_set_value4 >  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, FNAME, RTYPE, FTYPE, PARA) 
struct  CONCEPTNAME 
... { 
    template <class BaseFrom = concept_base, bool isvtable = true, class ObjectType = concept_object> 
    struct table : public concept_bind_with<typename BaseFrom::Base, typename BaseFrom::DeriveFrom, isvtable, ObjectType>::type 
    ...{ 
        typedef CONCEPTNAME Base; 
        typedef BaseFrom DeriveFrom; 
        typedef typename get_type<RTYPE (*)FTYPE>::type function_type; 
        function_type p##FNAME; 
        table() : p##FNAME(&::FNAME) ...{} 
    }; 
    template <class BaseFrom, class ObjectType> 
    struct table<BaseFrom, false, ObjectType> : public concept_bind_with<typename BaseFrom::Base, typename BaseFrom::DeriveFrom, false, ObjectType>::type 
    ...{ 
        typedef CONCEPTNAME Base; 
        typedef BaseFrom DeriveFrom; 
        const void* CONCEPTNAME##_index() const ...{return this;} 
        static RTYPE FNAME FTYPE 
        ...{ 
            return (*t.ptable->p##FNAME)PARA; 
        } 
    }; 
} ;

#define  CONCEPT_MEMBER_FUNCTION(CONCEPTNAME, FNAME, RTYPE, FTYPE, PARA) 
struct  CONCEPTNAME 
... { 
    template <class BaseFrom = concept_base, bool isvtable = true, class ObjectType = concept_object> 
    struct table : public concept_bind_with<typename BaseFrom::Base, typename BaseFrom::DeriveFrom, isvtable, ObjectType>::type 
    ...{ 
        typedef CONCEPTNAME Base; 
        typedef BaseFrom DeriveFrom; 
        typedef typename get_type<RTYPE (ObjectType::*)FTYPE>::type function_type; 
        function_type p##FNAME; 
        table() : p##FNAME(MEMFUNCCAST(function_type)(&ObjectType::FNAME)) ...{} 
    }; 
    template <class BaseFrom, class ObjectType> 
    struct table<BaseFrom, false, ObjectType> : public concept_bind_with<typename BaseFrom::Base, typename BaseFrom::DeriveFrom, false, ObjectType>::type 
    ...{ 
        typedef CONCEPTNAME Base; 
        typedef BaseFrom DeriveFrom; 
        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_base;
struct  concept_object ... {} ;
template  < class  conceptT  =   int ,  class  T  =   int >   struct  concept_map  ... {int t[2];} ;

template  < class  conceptT,  class  BaseFrom  =  concept_base,  bool  isvtable  =   true ,  class  ObjectType  =  concept_object >
struct  concept_bind_with
... {
    typedef typename conceptT::template table<BaseFrom, isvtable, ObjectType> type;
} ;

struct  concept_base
... {
    typedef concept_base Base;
    typedef concept_base DeriveFrom;
    template <class BaseFrom = concept_base, bool isvtable = true, class ObjectType = concept_object>
    struct table : public concept_bind_with<typename BaseFrom::Base, typename BaseFrom::DeriveFrom, isvtable, ObjectType>::type
    ...{
        typedef concept_base Base;
        typedef BaseFrom DeriveFrom;
    };
    template <bool isvtable, class ObjectType>
    struct table<concept_base, isvtable, ObjectType>
    ...{
        typedef concept_base Base;
        typedef concept_base DeriveFrom;
    };
} ;

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 <class BaseFrom = concept_base, bool isvtable = true, class T = concept_object>
    struct table : public
                 concept_bind_with< C0,typename concept_bind_with< C1,typename concept_bind_with< C2,typename concept_bind_with< C3,typename concept_bind_with< C4,
        typename concept_bind_with< C5,typename concept_bind_with< C6,typename concept_bind_with< C7,typename concept_bind_with< C8,typename concept_bind_with< C9,
        typename concept_bind_with<C10,typename concept_bind_with<C11,typename concept_bind_with<C12,typename concept_bind_with<C13,typename concept_bind_with<C14,
        typename concept_bind_with<C15,typename concept_bind_with<C16,typename concept_bind_with<C17,typename concept_bind_with<C18,typename concept_bind_with<C19,
        BaseFrom
        >::type>::type>::type>::type>::type>::type>::type>::type>::type>::type
        >::type>::type>::type>::type>::type>::type>::type>::type>::type, isvtable, T>::type
    ...{
        typedef concept_list Base;
        typedef BaseFrom DeriveFrom;
    };
} ;

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  concept_bind_with < conceptT, concept_base,  true , T > ::type
... {
    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  concept_bind_with < conceptT, concept_base,  false , concept_class_base < concept_table < conceptT >   >   > ::type
... {
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) ...{}
} ;