DoType.h

// Copyright (c) 2007, Arne Steinarson
// Licensing for DynObj project - see DynObj-license.txt in this folder

#ifndef DOTYPE_H
#define DOTYPE_H

#include  <stddef.h>    // NULL defined

// Three main classes (in base to derived order)
class VObj;
class DynI;
class DynObj;
class DoModuleC;

#include "utils/StructHeader.h"


enum doCastAlgo {
    doCastLocal = 1,
    doCastCross = 2,
    doCastFull = 3,
};

// Create instances during setup
typedef void* (*CreateVObjFn)(int *pvts);
// Destroy instances during setup
typedef void (*DestroyVObjFn)(void *pv);

class DynObjTypeLinks;
class DoModuleNode;
class DoCompoundNode;
struct DoTypeItem; 
struct DynObjType;

// This is one node in a list of base classes.
struct DoBaseNode {
    enum { IsUnresolved=1, IsDynObjType=2, IsSideBaseDecl=4, IsAllocated=8 };

    DoBaseNode( const DynObjType *base, short offset, int flags );
    DoBaseNode( const char *base_type, int flags );
    ~DoBaseNode(){ Release(); }

    void Release();
    bool Unresolved() const { return _flags&IsUnresolved; }
    void ClearUnresolved(){ _flags&=~IsUnresolved; }

    union { DynObjType* _base;
            const char* _base_type; };
    short  _offset;
    short  _flags;
    DoBaseNode* _nxt;
};


// A structure to identify the type of the DynObj (or another type not derived
// from DynObj).
// All objects of the same class returns the same DynObjType - a static instance.
//
// Both _type_id and _type identify the type of the object (they say the
// same thing). It's purpose is to more strongly identify the implemented
// interface (if someone else has implemented your 'vehicle' class and you
// accidently open that library, then chances are they have not given their
// 'vehicle' class the type_id==0x51b7de00).
//

struct DynObjType{
public:
    DynObjType( const char *type, int type_id, int flags, int size, const void *_this=NULL, const void *_base_ptr=NULL, const char *header=NULL );
    // For this constructor, both type and base are expected to be constant strings and are stored internally.
    DynObjType( const char *type, const char *base, int type_id, int flags, int size, const void *_this=NULL, const void *_base_ptr=NULL, const char *header=NULL );
    void Ctor( const char *type, const char *base, int type_id, int flags, int size, const void *_this, const void *_base_ptr, const char *header );
    ~DynObjType( );

    StructHeader _sh;       // Verifies that this is a DynObjType data struct
    const char* _type;      // Name of the class/interface. Base class names are not present here.
    int         _type_id;   // same as ID in CreateFn
    short       _vtbl_size; // Number of entries in VTable or -1 if not known
    short       _size;      // sizeof(DynObj) - size of an object of this type
    int         _flags;     // See below

//protected:
    DoBaseNode        _base;       // Primary base, but also first node in full base list
    void**            _vtbl;       // VTable for this type or NULL if unknown or an object with no virtual funcs
    DoCompoundNode*   _compounds;  // List of compound types for this type
    DoModuleNode*     _mod_fst;    // The module that creates this type, allows for tracking back an object
                                   // on destruction.
    const char*  _header;   // Header file name (where type info is declared)

    DoTypeItem*  _pext;     // Extension items (rarely used fields added here)

    bool IsOk();

    bool operator == (const char *type) const { return MatchesTypeName(type); }
    bool operator == (void **vtbl) const { return vtbl && vtbl==_vtbl; }
    bool operator == (int type_id) const { return type_id==_type_id; }

    bool IsA( int type_id, const char* pcaller_addr ) const;
    bool CanBeA( int type_id, const void* pobj, const char* pcaller_addr ) const;
    bool IsSideBase( const void *pvo ) const;
    bool MatchesTypeName( const char* type ) const;
    bool IsSameType( DynObjType* opdt ) const;
    bool IsSameTypeAndCompatible( DynObjType *opdt ) const;
    enum { AmbigEither=3, AmbigId=1, AmbigName=2 };
    bool IsAmbigous( int amb_type=AmbigEither ) const;
    int HasNestedSideBases();
    DynObjType *GetOuterMost( const void* pobj, int *poff=NULL ) const;
    DoCompoundNode* GetCompound( void** vtbl, int* poff=NULL ) const;
    DynObjType *GetTypeAtOffset( int off ) const;

    DoTypeItem* LookupTypeItem( char type ) const;
    DoTypeItem* LookupTypeItemLinkFirst( char type );
    bool AddTypeItem( DoTypeItem *pitem );
    DoTypeItem* RemoveTypeItem( char type );

    // This is for hashing.
    inline void** GetKey( ){ return (void**)_vtbl; }

protected:
    //void AmbigUnlink();
    bool LinkAfter( DynObjType *after, bool is_name );
    void LinkModule( DoModuleC *pmod );
    void UnlinkModule( DoModuleC *pmod );
    DoModuleC* GetOriginalModule( );

    // Get object somewhere in self or in base classes
    void *GetObj( void *pself, const char *type, DynObjType **found_type=NULL, DynObjType *pdt_avoid=NULL );
    void *GetObj( void *pself, int type_id, const char* pcaller, DynObjType **found_type=NULL, DynObjType *pdt_avoid=NULL );

    bool CanBeAInternal( int type_id, const char* pcaller_addr ) const;

    // See if the caller can know this type
    bool IsTypeForCaller( const char* pcaller_addr ) const;

    friend void* doGetObj( void *obj, const char *type, DynObjType *self_type, doCastAlgo algo, DynObjType **pdt_found );
    friend void* doGetObj( void *obj, int type_id, DynObjType *self_type, doCastAlgo algo, DynObjType **pdt_found );
    friend void* doGetObj( DynI *pdi, const char *type, doCastAlgo algo, DynObjType **pdt_found, bool internal_from_dyni );

    friend class DoRunTimeC;
    friend class SideBaseDecl;
};




// Node in linked list of modules implementing this type
class DoModuleNode {
public:
    DoModuleNode( DoModuleC *pmod ) : _pmod(pmod), _nxt(0) { }
    ~DoModuleNode(){ delete _nxt; }
    DoModuleC    *_pmod;
    DoModuleNode *_nxt;
};

// Represent one added 'extra field' to a DynObjType - Used for 
// rarely occursing / temporary information
struct DoTypeItem { 
    DoTypeItem(char item_type, char flags, DoTypeItem* nxt) { Init(item_type,flags,nxt); } 
    ~DoTypeItem();

    void Init( char item_type, char flags, DoTypeItem* nxt );
    // Overridable by derived classes. Virtual destructor not safe across compiler boundaries.
    virtual void dtiDestroy(){ delete this; }

    enum { dotiMagic=0xA9 };
    enum { TypeCreateDestroy=1   // Store pointers to create/destroy functions 
           ,TypeReplacedBy=2     // Store a type which replaces this one
           ,TypeAmbigLinkId=3      // Type ambiguity resolve item for integer ID
           ,TypeAmbigLinkName=4    // Type ambiguity resolve item for names
           ,TypeCompundNode=5    // An owned DoCompoundNode
           ,TypeDelayedConstruct=6 // Delayed doConstruct call
           ,TypeFirstCustom=128  // Custom (app specific) IDs start here
    };

    char _magic;
    char _item_type;
    char _flags;
    char _check_sum;
    DoTypeItem *_nxt;

    bool IsOk(){ return this && _magic==(char)dotiMagic && _check_sum==(char)(_item_type^dotiMagic); } 
};

// Helper struct to implement side base classes
class DoCompoundNode : public DoTypeItem {
public:
    // Alloc like a raw data struct
    DoCompoundNode( void** vtbl, DynObjType* compound, DynObjType* user );
    virtual void dtiDestroy();
    DoCompoundNode *GetCompound( void** vtbl, int* poff, const DynObjType *ptd_from );

    DynObjType *_user;
    DynObjType *_compound;
    void **_vtbl;
    DoCompoundNode *_nxt_compound;

    // This is for caching last successful type lookup
    int _type_id_lookup;
    DynObjType *_pdt_lookup;
};


// DynObjType extension item, hold pointers for 
// create/destroy functions until used.
struct DoReplacedByItem : public DoTypeItem { 
    DoReplacedByItem( DynObjType *pdt_replaced_by ) 
        : DoTypeItem(DoTypeItem::TypeReplacedBy,0,NULL), 
        _pdt_replaced_by(pdt_replaced_by) { } 
    DynObjType* _pdt_replaced_by;
};


// Struct to delay construction
struct DelayedConstruct : public DoTypeItem {
    DelayedConstruct( const void* pobj ) 
        : DoTypeItem(TypeDelayedConstruct,0,NULL), 
          _pobj(pobj) { }
    const void *_pobj;
};


#ifdef DO_IMPLEMENTING

// For flags field
// Input flags
#define DOT_DESTROY_SOFT    2  // For DynObj type, in a sub object, set DoDostroy to harmless method
#define DOT_USER_TYPE       4  // A user type (not internal, abstract or side base). Can be instantiated.
#define DOT_NO_VTABLE_CORR  8  // Do not correct VTable for this type
#define DOT_STATIC_TYPE     16 // Instances of this type are static

// Private state flags
#define DOT_HAS_NESTED_SIDE_BASE    0x0100  // This type, or one of its bases has a side base class
#define DOT_TESTED_NESTED_SIDE_BASE 0x0200  // After we know above, set this flag
#define DOT_DORT_MERGED     0x0400          // Merged with doRunTime type database
#define DOT_DID_INIT        0x0800          // Type initialized & registered (after calling doConstruct & DORT.RegisterType)
#define DOT_CONST_STRINGS   0x1000          // Type strings are not allocated
#define DOT_REPLACED_BY     0x2000          // Type has been replaced by other type (previously loaded)
#define DOT_IS_AMBIGOUS_ID    0x4000          // This type is ambigous (several share the same type ID or type name)
#define DOT_IS_AMBIGOUS_NAME  0x8000          // This type is ambigous (several share the same type ID or type name)

#define DOT_ALIVE           0x80800000      // Value to check that type is "alive"
#define DOT_ALIVE_MASK      0xC0C00000      // Mask to check that type is "alive"
#define DOT_CLEAR_IN_CTOR   0xFF00

#if DO_ENABLE_VTABLE_CORR==1
    #include "DoVTableInfo.hpp"
#endif


// Helper function to get instance of DynI/Vobj derived
template<class T>
void* VObjTempInstance( int *pvts ){
#if DO_ENABLE_VTABLE_CORR==1
    if( pvts )  *pvts = GetVTableSizeOf<T,void>();
#endif
    T* pt = new T;
    return pt;
}

template<class T>
void VObjTempInstanceDelete( void *pv ){
    ::delete (T*)pv;
}

// Helper to get temp instance of DynObj derived
class DynI;
template<class T>
void* DynObjTempInstance( int *pvts ){
#if DO_ENABLE_VTABLE_CORR==1
    if( pvts ) *pvts = GetVTableSizeOf<T,DynI*>();
#endif
    return new T((DynI*)NULL);
}

// DynObjType extension item, hold pointers for 
// create/destroy functions until used.
struct DoCreateDestroyItem : public DoTypeItem { 
    DoCreateDestroyItem( CreateVObjFn cfn, DestroyVObjFn dfn ) 
        : DoTypeItem(DoTypeItem::TypeCreateDestroy,0,NULL), 
        _cfn(cfn), _dfn(dfn) { } 
    CreateVObjFn _cfn;
    DestroyVObjFn _dfn;
};

// This is for the case when we instantiate a class to register it in the
// global constructor. The condition for doing this is that it has a
// constructor that takes no arguments (VObj/DynI derived) or that it has
// a DynObj constructor (one argument of type DynI*).
// This saves us from the trouple of calling doConstruct manually at a
// later point.
//#include <stdio.h>
template<class MainCl, class BaseCl=void, bool is_dynobj=false>
class DynObjTypeI2R;

// Specialization for DynObj derived
template<class MainCl, class BaseCl>
class DynObjTypeI2R<MainCl,BaseCl,true> : public DynObjType {
public:
    DynObjTypeI2R( const char *type, int type_id, int flags, const char *header=NULL )
    : DynObjType( type, type_id, flags, sizeof(MainCl), NULL,NULL, header ) {
        DoCreateDestroyItem *pit = new DoCreateDestroyItem(
                (CreateVObjFn)DynObjTempInstance<MainCl>,
                VObjTempInstanceDelete<MainCl> );
        AddTypeItem(pit);
        /*
        MainCl mc;  // Local instance here
        _offset = short((char*)static_cast<BaseCl*>(&mc) - (char*)&mc);
#if DO_ENABLE_VTABLE_CORR==1
        _vtbl_size = GetVTableSizeOf<MainCl>( );
#endif
        _vtbl = *(void***)&mc;
        */
    }
};

// Specialization for VObj & DynI derived
template<class MainCl, class BaseCl>
class DynObjTypeI2R<MainCl,BaseCl,false> : public DynObjType {
public:
    DynObjTypeI2R( const char *type, int type_id, int ver, const char *header=NULL )
    : DynObjType( type, type_id, 0, sizeof(MainCl), NULL,NULL, header ) {
        DoCreateDestroyItem *pit = new DoCreateDestroyItem(
                VObjTempInstance<MainCl>,
                VObjTempInstanceDelete<MainCl> );
        AddTypeItem(pit);
    }
};



// To get offset to side bases in a type safe way
template <class Base, class SideBase>
int sidebase_offset( const Base *pb=NULL ){
    // It seems static_cast wants non-zero values to do its job of
    // converting on known class type offsets, even though it doesn't
    // use RTTI info. If NULL input, use arbitrary address
    if( !pb ) pb = reinterpret_cast<const Base*>(&pb);
    const SideBase *pcb = static_cast<const SideBase*>(pb);
    return (int)(reinterpret_cast<const char*>(pcb) - reinterpret_cast<const char*>(pb));
}


// Used when declaring side base classes
class SideBaseDecl : public DoBaseNode {
public:
    SideBaseDecl( const char *main_cl, const char *side_base_cl, int size, int offset, const void *_this, int vtbl_size, void **vtbl_o );
    void Ctor( const char *main_cl, const char *side_base_cl, int size, int offset, const void *_this, int vtbl_size, void **vtbl_o );
    const char* _main_cl;
};

// Macro to add side base classes in a type safe way
#define DO_ADD_SIDE_BASE(MainCl,SideBaseCl)\
        SideBaseDecl g_sbd_##MainCl##SideBaseCl( #MainCl,#SideBaseCl,sizeof(SideBaseCl),sidebase_offset<MainCl,SideBaseCl>(),NULL,GetVTableSizeOf<SideBaseCl>(),GetVTableOf<SideBaseCl>() )

// Macro to add side base classes in a type safe way inside doGetType (using this pointer)
// Used inside doGetType. Does not detect size of VTables.
// Forces doGetType on Side base class
#define DO_ADD_SIDE_BASE_THIS(MainCl,SideBaseCl) { \
        this->SideBaseCl::doGetType( const DynI **pself=0 ); \
        static SideBaseDecl sbdt(#MainCl,#SideBaseCl,sizeof(SideBaseCl),sidebase_offset<MainCl,SideBaseCl>(this),this,-1,NULL); \
    }

// Macro to add side base classes in a type safe way inside doGetType (using this pointer)
// Used inside doGetType. Detects size of VTables.
// Forces doGetType on Side base class
#define DO_ADD_SIDE_BASE_THIS_VTABLE_CORR(MainCl,SideBaseCl) { \
        this->SideBaseCl::doGetType( const DynI **pself=0 ); \
        static SideBaseDecl sbdt(#MainCl,#SideBaseCl,sizeof(SideBaseCl),sidebase_offset<MainCl,SideBaseCl>(this),this,GetVTableSizeOf<SideBaseCl>(),GetVTableOf<SideBaseCl>()); \
    }

#endif // DO_IMPLEMENTING


#endif // DOTYPE_H

---