DoBaseI.h

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

#ifndef DOBASE_I
#define DOBASE_I

//%%DYNOBJ options(vtabcorr)

// %%DYNOBJ section general
// This section is auto-generated and manual changes will be lost when regenerated!!
#ifdef DO_IMPLEMENT_DOBASEI
    #define DO_IMPLEMENTING     // If app has not defined it already
#endif
#include "dynobj/DynObj.h"

// --- Integer type ids for defined interfaces/classes ---
#define MUTEXI_TYPE_ID           0xD98ED000
#define MALLOCI_TYPE_ID          0x9F46B000
#define TEXTIOI_TYPE_ID          0xB5C14000
#define NAMEDREFI_TYPE_ID        0xAABF9000

// --- Forward class declarations ---
class NotifDataI;
class NotifierI;
class NotifiableI;
class MutexI;
class MallocI;
class TextIoI;
class NotifDataWithPtr;
class NamedRefI;
class DynObjLibI;
class DoRunTimeI;

// --- For each declared class, doTypeInfo template specializations ---
DO_DECL_TYPE_INFO(NotifDataI,NOTIFDATAI_TYPE_ID);
DO_DECL_TYPE_INFO(NotifierI,NOTIFIERI_TYPE_ID);
DO_DECL_TYPE_INFO(NotifiableI,NOTIFIABLEI_TYPE_ID);
DO_DECL_TYPE_INFO(MutexI,MUTEXI_TYPE_ID);
DO_DECL_TYPE_INFO(MallocI,MALLOCI_TYPE_ID);
DO_DECL_TYPE_INFO(TextIoI,TEXTIOI_TYPE_ID);
DO_DECL_TYPE_INFO(NotifDataWithPtr,NOTIFDATAWITHPTR_TYPE_ID);
DO_DECL_TYPE_INFO(NamedRefI,NAMEDREFI_TYPE_ID);
DO_DECL_TYPE_INFO(DynObjLibI,DYNOBJLIBI_TYPE_ID);
DO_DECL_TYPE_INFO(DoRunTimeI,DORUNTIMEI_TYPE_ID);

// %%DYNOBJ section end


// These are practical to have here, even if we don't own them.
// Import NotifierI and NotifiableI classes
#include "utils/NotifierI.h"

// %%DYNOBJ class(vobj) name(NotifDataI) bases(VObj)  flags(notypeid)
// %%DYNOBJ class(vobj) name(NotifierI) bases(VObj)  flags(notypeid)
// %%DYNOBJ class(vobj) name(NotifiableI) bases(VObj)  flags(notypeid)


// %%DYNOBJ class(vobj) 
class MutexI {
public:
    virtual bool docall Lock() = 0;
    virtual bool docall Unlock() = 0;
    virtual bool docall TryLock() { return false; }
};

class MutexLocker {
public:
    MutexLocker(MutexI *pmi, bool try_only=false) : m_pmi(pmi), m_locked(false) { 
        if( m_pmi ){
            if( !try_only )
                m_locked = m_pmi->Lock(); 
            else 
                m_locked = m_pmi->TryLock(); 
        }
    }
    ~MutexLocker() { if( m_locked && m_pmi ) m_pmi->Unlock(); }
protected:
    MutexI *m_pmi;
    bool    m_locked;
};


// %%DYNOBJ class(vobj) 
class MallocI {
public:
    virtual void* docall Malloc( unsigned int size ) = 0;
    virtual bool  docall Free( void *pv ) = 0;
    virtual void* docall ReAlloc( void* pv, unsigned int size ) = 0;
    virtual int   docall GetNumberAlloc( ) = 0;
    virtual bool  docall GetSumAlloced( unsigned int& i64_hi, unsigned int& i64_lo ) = 0;
};

class DynStr;

// %%DYNOBJ class(vobj) 
class TextIoI {
public:
    virtual int docall puts(const char *ps) = 0;
    virtual int docall puterr(const char *pe) = 0;
    virtual int docall gets(DynStr& ds, bool sync_wait=true) = 0;
};



// %% DYNOBJ class(vobj) flags(notypeid,inst2reg)
class NotifDataWithPtr : public NotifDataI { 
public:
    NotifDataWithPtr( DynI *pdi=NULL, void *pv=NULL ) : m_pdi(pdi), m_pv(pv) { } 
    DynI *m_pdi;
    void *m_pv;
};


// %%DYNOBJ class(dyni) flags(inst2reg)
class NamedRefI : public DynI {
public:
    virtual DynObjType* docall doGetType( const DynI **pself=0 ) const;
    
    virtual DynI* docall GetByName( const char *name, int type_id ){ return NULL; }
    
    virtual DynI* docall GetByIndex( int index, DynStr &ds, int type_id=0 ){ return NULL; }
    
    virtual bool  docall Set( const char *name, DynI *pdi ){ return false; }
    
    virtual bool  docall Remove( DynI *pdi ){ return false; }

    // Get without a type ID 
    DynI* Get( const char *name ){ return GetByName(name,0); }
    //DynI *GetByName( const char *name, int type_id=0 ){ return Get(name,type_id); }
    //DynI *GetByIndex( int index, DynStr &ds, int type_id=0 ){ return Get(index,ds,type_id); }
};


// %% DYNOBJ class(dyni) flags(notypeid)
class DynObjLibI : public DynI { 
public:

    enum {
        NotLoaded = 0,  // DOLIB_NONE
        LoadFailed,     // DOLIB_LOAD_FAILED
        Loaded,         // DOLIB_LOADED
        Incompatible,   // DOLIB_INCOMPATIBLE
        InitFailed,     // DOLIB_INIT_FAILED
        CannotInit,     // DOLIB_NO_INIT
        Initialized,     // DOLIB_INIT
        InitializedWithoutDoInit // DOLIB_INIT
    };

    virtual DynObjType* docall doGetType( const DynI **pself=0 ) const;

    virtual int docall GetState() = 0;

    //virtual const char* docall GetError() = 0;

    virtual const char* docall GetLibName() = 0;

    virtual const char* docall GetLibFileName() = 0;

    virtual DynObj* docall Create( const char* type, int type_id, const DynI* pdi_init=NULL ) = 0;

    virtual bool docall Destroy( VObj *pvo ) = 0;

    virtual void docall OnObjectCreate( DynObj *pdo, DynObjType *pdt ) = 0;
    
    virtual void docall OnObjectDestroy( DynObj *pdo, DynObjType *pdt ) = 0;
    
    virtual bool docall MayUnload( ) = 0;

    
    template<class T>
    T* Create( const DynI* pdi_init=NULL ){
        DynObj *pdo = Create( doTypeInfo<T>::Name(), doTypeInfo<T>::Id(), pdi_init );
        return pdo ? (T*)pdo->doQueryI( doTypeInfo<T>::Name() ) : NULL;
    }
};


// %%DYNOBJ class(dyni) flags(static,notypeid) 
class DoRunTimeI : public DynI {
public:
    // Base DynObj functions
    virtual DynObjType* docall doGetType( const DynI **pself=0 ) const;
    
    // Access shared functionality
    virtual MallocI* docall  GetMalloc() const{ return NULL; }
    virtual TextIoI* docall  GetTextIo() const{ return NULL; }
    
    // Object creation, set lib to NULL to create with first library that knows the type.
    virtual DynObj*  docall  Create( const char *lib, const char *type, int type_id, const DynI* pdi_init=NULL ){ return NULL; }
    
    // A collection of named global objects handled here
    // This is delegated to NamedRefI

    // Set/Get last error (per thread, but that is transparent to caller)
    virtual int  docall GetLastErrCode( int thid=-1 ){ return -1; }
    virtual bool docall GetLastErrStr( DynStr& ds, int thid=-1 ){ return false; }
    virtual bool docall SetLastError( int err_code, const char *err_msg ){ return false; }
    virtual int  docall GetThreadId( ){ return -1; }

    // Central DynObjType  handling
    virtual DynObjType* docall GetTypeOf( void **vtbl ){ return NULL; }
    virtual DynObjType* docall FindTypeFromName( const char *type, const char *header=NULL ){ return NULL; }
    virtual DynObjType* docall FindTypeFromId( int type_id ){ return NULL; }
    
    // Manage libraries
    virtual DynI* docall LoadLib( const char *lib_name, DynI* pdi_init ){ return NULL; }
    virtual bool docall UnloadLib( const char *lib_name, bool force_unload ){ return false; }
    virtual DynObjLibI* docall GetLib( const char *lib ){ return NULL; } 
    virtual const char* docall GetLoadError( ) { return "<no impl>"; }

    // Generate a new unique type ID at run-time 
    virtual int docall GenerateTypeId(){ return 0; }

    // Handle per object errors
    virtual bool docall SetObjectError( const void *pvo, const char *err_str, int err_code ){ return false; }
    virtual bool docall ClearObjectError( const void *pvo ){ return false; }
    virtual const char* docall GetObjectError( const void *pvo, int *perr_code ){ return NULL; }

    
    template<class T>
    T* Create( const DynI* pdi_init=NULL ){
        const char *type = doTypeInfo<T>::Name();
        DynObj *pdo = Create( NULL, type, doTypeInfo<T>::Id(), pdi_init );
        return pdo ? (T*)pdo->doQueryI( type ) : NULL;
    }


    // Assuming that DoRunTimeI implements NamedRefI (which is very convenient)
    bool  ObjectPublish( DynI *pdi, const char *name ){ 
        NamedRefI *pni = (NamedRefI*)doQueryI("NamedRefI");
        if( !pni ) return false;
        return pni->Set(name,pdi);
    }
    DynI* ObjectLookup( const char *name, int type_id=0 ){ 
        NamedRefI *pni = (NamedRefI*)doQueryI("NamedRefI");
        if( !pni ) return NULL;
        return pni->GetByName(name,type_id);
    }
};


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

// Generate type information that auto-registers on module load

DynObjType g_do_vtype_NotifDataI("NotifDataI","VObj",NOTIFDATAI_TYPE_ID,0,sizeof(NotifDataI),NULL,NULL,__FILE__);
DynObjType g_do_vtype_NotifierI("NotifierI","VObj",NOTIFIERI_TYPE_ID,0,sizeof(NotifierI),NULL,NULL,__FILE__);
DynObjType g_do_vtype_NotifiableI("NotifiableI","VObj",NOTIFIABLEI_TYPE_ID,0,sizeof(NotifiableI),NULL,NULL,__FILE__);

DynObjType g_do_vtype_MutexI("MutexI","VObj",MUTEXI_TYPE_ID,0,sizeof(MutexI),NULL,NULL,__FILE__);
DynObjType g_do_vtype_MallocI("MallocI","VObj",MALLOCI_TYPE_ID,0,sizeof(MallocI),NULL,NULL,__FILE__);
DynObjType g_do_vtype_TextIoI("TextIoI","VObj",TEXTIOI_TYPE_ID,0,sizeof(TextIoI),NULL,NULL,__FILE__);

DynObjTypeI2R<NotifDataWithPtr,NotifDataI,false> g_do_vtype_NotifDataWithPtr("NotifDataWithPtr:NotifDataI",NOTIFDATAWITHPTR_TYPE_ID,0,__FILE__);

DynObjTypeI2R<NamedRefI,DynI,false> g_do_vtype_NamedRefI("NamedRefI:DynI",NAMEDREFI_TYPE_ID,0,__FILE__);
DynObjType* NamedRefI::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_NamedRefI;
}
DynObjType g_do_vtype_DynObjLibI("DynObjLibI","DynI",DYNOBJLIBI_TYPE_ID,0,sizeof(DynObjLibI),NULL,NULL,__FILE__);
DynObjType* DynObjLibI::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynObjLibI;
}

DynObjType g_do_vtype_DoRunTimeI("DoRunTimeI","DynI",DORUNTIMEI_TYPE_ID,DOT_STATIC_TYPE,sizeof(DoRunTimeI),NULL,NULL,__FILE__);
DynObjType* DoRunTimeI::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DoRunTimeI;
}

#endif //DO_IMPLEMENT_...
// %%DYNOBJ section end

#endif //DOBASE_I

---