DynObj.h

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


#ifndef DYNOBJ_H
#define DYNOBJ_H

// These are directives to preprocessing tool that auto-generates some of the required code 
// %%DYNOBJ options generate(implement)
    
// Defines and config options are in here
#include "DoSetup.h"

// Type system
#include "DoType.h"

// Error logging
#include "DoError.h"


// Preprocessor symbols controlling how DynObj.h and related files:
//
// DO_IMPLEMENTING    - from a C++ source file that implements a DynObj type
// DO_MAIN            - from the main program (that loads other DynObjs and has the DoRunTimeI instance)
// DO_MODULE          - Set when compiling a library/loadable module (that does not own DoRunTimeI)
// DO_IMPLEMENTED_TYPES - Define before compiling DynObj.cpp to set to a list of implemented
//                        type names /type IDs. This how types are made 'public'. Example
//
//                            "string,0xB314DA4,Car:VehicleI,0xBA618F23"
//
//                        Another method is to use doAddImplemented or global instances of
//                        class DoImplDecl (below).
//                        

#ifdef DO_MODULE
    #ifdef DO_MAIN 
        #error Both DO_MODULE and DO_MAIN are defined
    #endif
#elif defined(DO_MAIN)
    // Fine, do nothing
#else
    // Proceed until the defs are needed, give warning there
#endif

#if DO_USE_RUNTIME==1
    #if DO_FAT_VOBJ!=1 
        #error DO_USE_RUNTIME requires DO_FAT_VOBJ=1 !
    #endif 
#endif 

// Doxygen stuff
// Object type IDs: 
// They can be generated automatically from the "pdoh" tool (Parse DynObj Header). 
// Layout of ID field:
// Bit 0..11   - C++ type attribute mask - Set to 0 for now
// Bit 12..31  - Custom type ID bits
// Bit 31      - If set, then this ID is private (i.e. ID<0 are private)
// Custom public ID range: 
//    BASE_CUSTOM_TYPE_ID   ... MAX_CUSTOM_TYPE_ID        
//    0x00100000            ... 0x7FFFF000
// Private compile-time ID range:
//    BASE_APPSPEC_TYPE_ID  ... MAX_APPSPEC_TYPE_ID
//    0x80000000            ... 0xEFFFF000
// Run-time auto generated type ID range:
//    MIN_AUTO_TYPE_ID      ... BASE_AUTO_TYPE_ID  
//    0xFFF00000            ... 0xF0000000  (allocates with negative step)

#define TYPE_ID_MASK          0xFFFFF000        // Bits 12..31

// Base type IDs:
#define INVALID_TYPE_ID       0xFFFFF000        // Type error / non existing type

// Used for casting 
#define SIDEBASE_TYPE_ID      0xFFFFE000        // All side bas classes have this type ID (cannot be addressed individually from outside)
#define COMPOUND_TYPE_ID      0xFFFFD000        // When casting to a compound object (the container object) (string COMPOUND)
#define OUTERMOST_TYPE_ID     0xFFFFC000        // When casting to the outermost object (the container object) (string OUTERMOST)

#define RUNTIME_TYPE_ID       0xFFFFB000        // Set type ID at run-time for this type
#define UNKNOWN_TYPE_ID       0                 // Not known yet.

// Predefined public DynObj type IDs
#define VOBJ_TYPE_ID          0x00001000
#define DYNI_TYPE_ID          0x00002000
#define DYNOBJ_TYPE_ID        0x00003000
#define REFCOUNTI_TYPE_ID     0x00004000
#define DYNSHAREDI_TYPE_ID    0x00005000

#define DYNDATA_TYPE_ID       0x00006000
#define RTDYNSHARED_TYPE_ID   0x00008000

#define DORUNTIMEI_TYPE_ID    0x00010000
#define DORT_TYPE_ID          DORUNTIMEI_TYPE_ID
#define DORTINTERNALI_TYPE_ID 0x00011000
#define DOMODULEC_TYPE_ID     0x00012000
#define DYNOBJLIBI_TYPE_ID    0x00013000

#define DYNSTR_TYPE_ID        0x00018000

// Dynamic arrays
#define DYNARRCHAR_TYPE_ID     0x00020000
#define DYNARRWCHART_TYPE_ID   0x00021000
#define DYNARRSHORT_TYPE_ID    0x00022000
#define DYNARRINT_TYPE_ID      0x00023000
#define DYNARRINT64_TYPE_ID    0x00024000
#define DYNARRPTR_TYPE_ID      0x00025000
#define DYNARRPTRVOBJ_TYPE_ID  0x00026000
#define DYNARRPTRDYNI_TYPE_ID  0x00027000

#define DYNARGS_TYPE_ID        0x00028000 // Wrapped up constructor args

#define NOTIFIERI_TYPE_ID     0x00030000
#define NOTIFIABLEI_TYPE_ID   0x00031000
#define NOTIFDATAI_TYPE_ID    0x00032000
#define NOTIFDATAWITHPTR_TYPE_ID 0x00033000   

#define BASE_CUSTOM_TYPE_ID   0x00400000    // Custom fix IDs goes after this 
#define MAX_CUSTOM_TYPE_ID    0x7FFFF000    // Custom fix IDs goes after this 
#define BASE_APPSPEC_TYPE_ID  0x80000000    // Custome type IDs start here
#define MAX_APPSPEC_TYPE_ID   0xEFFFF000    // Custom type IDs cannot go beyond this (clash with auto id)
#define BASE_AUTO_TYPE_ID     0xFFF00000    // Auto IDs start here and count down (run-time generated)
#define MIN_AUTO_TYPE_ID      0xF0000000    // Auto IDs start here and count down (run-time generated)

#define STEP_TYPE_ID          0x00001000    // How much to increment/decrement for each type


#if DO_NO_TYPEINFO!=1

template<class T>
struct doTypeInfo {
    static int Id( ){ return UNKNOWN_TYPE_ID; }
    static const char* Name( ){ return NULL; }
    //enum { TypeId=INVALID_TYPE_ID };
};

//  Peels off pointer
template<class T>
struct doTypeInfo<T*> {
public:
    static int Id( ){ return doTypeInfo<T>::Id(); }
    static const char* Name( ){ return doTypeInfo<T>::Name(); }
    //enum { TypeId=doTypeInfo<T>::TypeId };
};

//  Peels off ref
template<class T>
struct doTypeInfo<T&> {
public:
    static int Id( ){ return doTypeInfo<T>::Id(); }
    static const char* Name( ){ return doTypeInfo<T>::Name(); }
    //enum { TypeId=doTypeInfo<T>::TypeId };
};

// Peels off const
template<class T>
struct doTypeInfo<const T> {
public:
    static int Id( ){ return doTypeInfo<T>::Id(); }
    static const char* Name( ){ return doTypeInfo<T>::Name(); }
    //enum { TypeId=doTypeInfo<T>::TypeId };
};
#endif //DO_NO_TYPEINFO



#if DO_FAT_VOBJ==1
// Need these protos below
void* doGetObj( void* pobj, const char *type, DynObjType *self_type, doCastAlgo algo=doCastFull, DynObjType **found_type=NULL );
void* doGetObj( void* pobj, int type_id, DynObjType *self_type, doCastAlgo algo=doCastFull, DynObjType **found_type=NULL );
void* doGetObj( DynI* pdi, const char *type, doCastAlgo algo=doCastFull, DynObjType **found_type=NULL );
void* doGetObj( DynI* pdi, int type_id, doCastAlgo algo=doCastFull, DynObjType **found_type=NULL );
DynObjType* doGetType( const void* pobj );
DynObjType* doGetType( const DynI* pdi );
#endif


// %%DYNOBJ class(vobj)                <- Tag for header file preprocessing  
class VObj {
public:
    // With fat VObj we get a lot of non-virtual convenience functions for the base class. 
    // NOTE: Requires static linking to DynObj.cpp
    #if DO_FAT_VOBJ==1

    
    DynObjType* GetType( ) const;
    
    bool IsA( int type_id ) const       { return IsA(type_id,NULL); }
    
    bool CanBeA( int type_id ) const    { return CanBeA(type_id,NULL); }
    
    // Lookup is not done on custom addon types.
    bool IsA( const char *type ) const  { return IsA(type,NULL); }
    //bool CanBeA( const char *type )     { return CanBeA(type,NULL); }

    void* GetObj( int type_id, doCastAlgo algo=doCastFull ) { return ::doGetObj(this,type_id,NULL,algo); }

    void* GetObj( const char *type, doCastAlgo algo=doCastFull ) { return ::doGetObj(this,type,NULL,algo); }

    const char* GetError( int* perr_code=NULL ) const;
    
    void ClearError( );
    
    bool SetError( const char *err_str, int err_code=-1 ) const;

    bool IsA( int type_id, DynObjType *ptype ) const;
    bool CanBeA( int type_id, DynObjType *ptype ) const;
    bool IsA( const char *type, DynObjType *ptype ) const;
    //bool CanBeA( const char *type, DynObjType *ptype  );
    
    const char *GetTypeName( ) const { 
        DynObjType *pdt = ::doGetType(this);
        return pdt ? pdt->_type : NULL; 
    }

    bool doIsOk( ) const { return this && !GetError(); } 
    #endif // DO_FAT_VOBJ
};


// %%DYNOBJ class(dyni)             <- Tag for header file preprocessing
class DynI : public VObj {
public:
    
    virtual DynObjType* docall doGetType( const DynI **pself=NULL ) const;
    
    virtual void* docall doQueryI( const char *type );      // Works for all objects, even data structures

    virtual const char* docall doGetError( int* perr_code=NULL ) const;

    virtual void docall docall doClearError( );

    #if DO_FAT_VOBJ==1

    
    // Convenience functions for accesing DynI type info
    // Non virtual, inline, generated on both sides, therefore OK 
    DynObjType *GetType()         const { return ::doGetType(this); }
    bool        doIsOk( )             const { return this && !doGetError(); } 
    const char *GetTypeName( )    const { DynObjType *pdt=DI_GET_TYPE(this); return pdt ? pdt->_type : NULL; }
    int         GetTypeId( )      const { DynObjType *pdt=DI_GET_TYPE(this); return pdt ? pdt->_type_id : -1; }
    int         GetObjectSize( )  const { DynObjType *pdt=DI_GET_TYPE(this); return pdt ? pdt->_size : -1; }

    bool IsA( int type_id )            const { return VObj::IsA( type_id, DI_GET_TYPE(this) ); }
    bool CanBeA( int type_id )         const { return VObj::CanBeA( type_id, DI_GET_TYPE(this) ); }
    bool IsA( const char *type )       const { return VObj::IsA( type, DI_GET_TYPE(this) ); }
    //bool CanBeA( const char *type )     { return VObj::CanBeA( type, DI_GET_TYPE(this) ); }
    
    void* GetObj( int type_id, doCastAlgo algo=doCastFull ) { return ::doGetObj(this,type_id,algo); }

    void* GetObj( const char *type, doCastAlgo algo=doCastFull ) { return ::doGetObj(this,type,algo); }

    // Backwards compatibility: Route back to doQueryI
    void* doGetObj( const char* type ){ return doQueryI( type ); } 
    

    // This is only intended for user of a DynObj to be able to use ordinary
    // delete on the object and route the call back to the creator. 
    // NOTE: When an application defines its own operator new and/or redefines
    // the new/delete keywords (to support memory tracking), this may not work.
    // To be safe its best to call doDestroy directly from the app.
    #if DO_ENABLE_OPERATOR_DELETE==1 
    void operator delete( void *pv ){ 
        SetError( "DynObj::operator delete on a DynI", DOERR_DELETE_ON_DYNI );
    }
    #endif // DO_ENABLE_OPERATOR_DELETE

    #endif // DO_FAT_VOBJ
};

// Used as a NULL object 
#define DynINull (*(DynI*)(0))

// %%DYNOBJ class(dyni)                   <- Tag for header file preprocessing
class DynObj : public DynI {
public:
    
    // All DynI derived types overrides this
    virtual DynObjType* docall doGetType( const DynI **pself=0 ) const;
    
    virtual void    docall doDestroy( ) { };
    
protected:    
    virtual void    docall doDtor( ){ }
public:
    

    #if DO_FAT_VOBJ==1

    DynObj();
    ~DynObj();
    #endif // DO_FAT_VOBJ
    
    #if DO_ENABLE_OPERATOR_DELETE==1

    void operator delete( void *pv ){ 
        if( !pv ) return;
        if( pv!=this )
            SetError( "DynObj::operator delete on wrong object", DOERR_DELETE_ON_WRONG_OBJECT );
        else
            doDestroy();
    }
    #endif // DO_ENABLE_OPERATOR_DELETE

};

#if DO_USE_DYNSHARED==1

#include "RefCount.h"
// Declare type info for RefCountI 
// %% DYNOBJ class(vobj) name(RefCountI) flags(notypeid)  

// %% DYNOBJ class(dyni)                  <- Tag for header file preprocessing 
class DynSharedI : public DynObj, public RefCountI {
public:
    // All DynI derived types overrides this
    virtual DynObjType* docall doGetType( const DynI **pself=0 ) const;
    
    virtual int docall doAddRef( ) = 0;
    
    virtual int docall doRelease( ) = 0;


    virtual int docall IncRef(){ return doAddRef(); } 
    virtual int docall DecRef(){ return doRelease(); } 
    
    // Utility function 
    //int doRelease(){ return doDecRef(); } 
};

#endif // DO_USE_DYNSHARED==1


#if DO_RETURN_STRUCT_WITH_DTOR_SAFE==1 

struct DynObjRetVal { 
    DynObjRetVal( DynObj *pdo ) : m_pdo(pdo) { } 
    ~DynObjRetVal(){ Free(); } 
    // Drop ownership and return object 
    DynObj *Release(){ DynObj *pdo=m_pdo; m_pdo=NULL; return pdo; } 
    DynObjRetVal& operator = (DynObjRetVal& other){ Free(); m_pdo=other.Release(); return *this; } 
    // Set to new object 
    //void Set( DynObj* pdo ){ Free(); m_pdo=pdo; } 
protected: 
    void Free(){ if(m_pdo) { m_pdo->doDestroy(); m_pdo=NULL; } }
    DynObj *m_pdo;
};


#if DO_USE_DYNSHARED==1

struct DynSharedRetVal { 
    DynSharedRetVal( DynSharedI *pds ) : m_pds(pds) { } 
    ~DynSharedRetVal(){ if(m_pds) m_pds->doRelease(); } 
    DynSharedI *Release(){ DynSharedI *pds=m_pds; m_pds=NULL; return pds; } 
protected: 
    DynSharedI *m_pds;
};
#endif // DO_USE_DYNSHARED==1

#endif // DO_RETURN_STRUCT_WITH_DTOR_SAFE==1  



#if DO_NO_TYPEINFO!=1


#define DO_DECL_TYPE_INFO(CLASS,ID) \
template<>                          \
struct doTypeInfo<CLASS> { \
public:                             \
    static int Id( ){ return ID; }  \
    static const char* Name( ){ return #CLASS; } \
};

// Lookup (and possibly generate) type ID for "class" declared in "header" 
int doLookupTypeId( const char *header, const char *type );

#define DO_DECL_TYPE_INFO_AUTOID(CLASS) \
template<>                          \
struct doTypeInfo<CLASS> { \
public:                             \
    static int Id( ){ \
        static int st_id; \
        if( !st_id ) st_id=doLookupTypeId(__FILE__,#CLASS); \
        return st_id; \
        }  \
    static const char* Name( ){ return #CLASS; } \
};


#else   // DO_NO_TYPEINFO
#define DO_DECL_TYPE_INFO(CLASS,ID)
#define DO_DECL_TYPE_INFO_ALIAS(CLASS,REALCLASS)
#endif  // DO_NO_TYPEINFO


// doTypeInfo for VObj, DynI and DynObj and DynSharedI
DO_DECL_TYPE_INFO(VObj,VOBJ_TYPE_ID);
DO_DECL_TYPE_INFO(DynI,DYNI_TYPE_ID);
DO_DECL_TYPE_INFO(DynObj,DYNOBJ_TYPE_ID);
#if DO_USE_DYNSHARED==1
DO_DECL_TYPE_INFO(RefCountI,REFCOUNTI_TYPE_ID);
DO_DECL_TYPE_INFO(DynSharedI,DYNSHAREDI_TYPE_ID);
#endif


DynObjType* doGetType( const void* pobj );

DynObjType* doGetType( const DynI* pdi );


void* doGetObj( void* pobj, const char *type, DynObjType *self_type, doCastAlgo algo, DynObjType **found_type );

void* doGetObj( void* pobj, int type_id, DynObjType *self_type, doCastAlgo algo, DynObjType **found_type );

void* doGetObj( DynI* pdi, const char *type, doCastAlgo algo, DynObjType **found_type );

void* doGetObj( DynI* pdi, int type_id, doCastAlgo algo, DynObjType **found_type );


DynObjType *doFindType( const char *type, const char *header=NULL );

DynObjType *doFindType( int type_id );

int doIsMainObject( DynI* pdi );
int doIsMainObject( const void *pobj, DynObjType *pdt=NULL );


#ifdef DO_MAIN

bool doInit( const void* pmain_base=(const void*)-1 );
#endif // DO_MAIN


bool doConstruct( const void *obj, DynObjType *self_type, DynObjType *pdt_compound=NULL );


bool doConstruct( const void *obj, const char *type, const char *header=NULL );
bool doConstruct( const void *obj, int type_id, const char *header=NULL );

bool doConstructDelayed( const void *obj, DynObjType *self_type );

void doReleaseDestroy( DynObj *pdo );

bool doIsStatic( const void *pvo, DynObjType *type=NULL );
bool doIsStatic( const DynI *pdi );

class DoRunTimeI;
DoRunTimeI &doGetRunTime();


bool doAddImplemented( const char *type, int type_id );
const char *doGetImplemented( );

// Use global variable to automatically register exported type on module load
class doUserTypeDecl {
public: 
    doUserTypeDecl( const char *type, int type_id ) {
        doAddImplemented(type,type_id);
    }
};



//
//  Functionality implemented by DynObj libraries.
//


// Used in library init functions below
class DoRunTimeI;
struct doModuleData;


//
// The object creation function should be named 'CreateDynObj'.
//
// The object destroy function should be named 'DestroyDynObj'.
//
// Library init function is named 'InitDynLib' and returns a pointer to a 
// doModuleData structure (if library is compiled fromDynObj.cpp 
// this is not necessary, unless custom initialization must be done).
//
// Library exit function named 'ExitDynLib' (not mandatory).
// - This is not implemented - The set base creation function should 
// be named 'SetBaseCreate'.
// All these functions are exported with 'extern "C" SYM_EXPORT'. 

typedef DynObj* (*CreateDynObjFn)( const char *type, int type_id, const DynI* pdi_init );


typedef doModuleData* (*InitDynLibFn)( DynI* pdi_init );

typedef bool (*ExitDynLibFn)(bool is_query);

typedef bool (*DestroyDynObjFn)( void *pv, DynObjType *pdt );

class DoModuleC;

struct doModuleData {
    doModuleData(const char *cs, const char *impl, int dt, int pf);
  
    StructHeader _sh;           
    const char *_lib_name;      
    const char *_lib_descr;     
    const char *_lib_author;    
    const char *_call_str;      
    const char *_instantiates;  
    int   _do_traits;           
    int   _platform;            
    int   _lib_major_ver;       
    int   _lib_minor_ver;       
    DynObjType **_types;       
    DoModuleC  *_module;        
    const char *_compiler;      
    int        _comp_major_ver; 
    int        _comp_minor_ver; 
    int        _lib_flags;      
    int        _dynobj_major_ver; 
    int        _dynobj_minor_ver; 
    DynI       *_pdi_from_init;    
};

#define DOMD_USES_RUNTIME        1
#define DOMD_IS_MAIN             4 
#define DOMD_MAY_LOAD_MODULES    8  // May load other modules
#define DOMD_MAY_OVERRIDE_TYPES 16  // May override other types (become first instantiators)
#define DOMD_OBJECT_TRACKING    32  // The library supports object tracking
#define DOMD_DENY_EARLY_UNLOAD  64  // The library rejects being unloaded early (may expose globals that are not trackable)

#ifndef DO_BUILDING_DYNOBJ
    // Makes the doModuleData struct visible to other source files
    extern doModuleData g_do_lib_impl;
#endif 



// Macros to generate and extract platform info above
#define DO_PLATFORM_FLAGS ( PLATFORM_FLAGS | (PFM_INT_SIZE<<16) | (PFM_PTR_SIZE<<18) | (PFM_WCHART_SIZE<<20) )


// The compiler will likely set sizeof(VObj) to 0 or 1, however, we want 
// the VPTR to be part of the size
#define VOBJ_SIZE sizeof(void*)


// %%DYNOBJ section implement
// This section is auto-generated and manual changes will be lost when regenerated!!
#ifdef DO_IMPLEMENT_DYNOBJ

// Generate type information that auto-registers on module load
DynObjType g_do_vtype_VObj("VObj",(const char*)NULL,VOBJ_TYPE_ID,0,VOBJ_SIZE,NULL,NULL,__FILE__);
DynObjType g_do_vtype_DynI("DynI","VObj",DYNI_TYPE_ID,0,sizeof(DynI),NULL,NULL,__FILE__);
DynObjType* DynI::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynI;
}
DynObjType g_do_vtype_DynObj("DynObj","DynI",DYNOBJ_TYPE_ID,0,sizeof(DynObj),NULL,NULL,__FILE__);
DynObjType* DynObj::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynObj;
}

#if DO_USE_DYNSHARED==1
DynObjType g_do_vtype_RefCountI("RefCountI","VObj",REFCOUNTI_TYPE_ID,0,sizeof(RefCountI),NULL,NULL,__FILE__);
DynObjType g_do_vtype_DynSharedI("DynSharedI","DynObj",DYNSHAREDI_TYPE_ID,0,sizeof(DynSharedI),NULL,NULL,__FILE__);
SideBaseDecl g_do_vtype_sbd_DynSharedI_1("DynSharedI","RefCountI",sizeof(RefCountI),sidebase_offset<DynSharedI,RefCountI>(),NULL,-1,NULL);
DynObjType* DynSharedI::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynSharedI;
}
#endif
#endif //DO_IMPLEMENT_...
// %%DYNOBJ section end

#endif // DYNOBJ_H

---