dobasei.h

The library provides supports for run-time loaded plugin classes in C++

// 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 STATEI_TYPE_ID      0xE0025000
#define PATHI_TYPE_ID       0xBC8E3000
#define NAMEDREFI_TYPE_ID   0xAABF9000

// --- Forward class declarations ---
class NotDataI;
class NotifierI;
class NotifiableI;
class MutexI;
class MallocI;
class TextIoI;
class StateI;
class PathI;
class NamedRefI;
class DoModuleC;
class DoRunTimeI;

// --- For each declared class, doTypeInfo template specializations ---
DO_DECL_TYPE_INFO(NotDataI,NOTDATAI_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(StateI,STATEI_TYPE_ID);
DO_DECL_TYPE_INFO(PathI,PATHI_TYPE_ID);
DO_DECL_TYPE_INFO(NamedRefI,NAMEDREFI_TYPE_ID);
DO_DECL_TYPE_INFO(DoModuleC,DOMODULEC_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
// If needed we know they should be implemented somewhere
// Import NotifierI and NotifiableI classes
#include "utils/NotifiableI.hpp"
// %%DYNOBJ class(vobj) name(NotDataI) bases(VObj)  flags(notypeid)
// %%DYNOBJ class(vobj) name(NotifierI) bases(VObj)  flags(notypeid)
// %%DYNOBJ class(vobj) name(NotifiableI) bases(VObj)  flags(notypeid)


/** @ingroup VObj
 * Interface to a mutex object
 * Assumption: a recursive mutex since it can be created on most platforms 
 * @see MutexLocker
 */
// %%DYNOBJ class(vobj) 
class MutexI {
public:
    /** @name Virtuals
     *  Interface members */
    //@{ 
	virtual bool docall Lock() = 0;
	virtual bool docall Unlock() = 0;
	virtual bool docall TryLock() { return false; }
    //@}
};

// Utility class
/** @ingroup Utils
 * Utility class to hold a mutex in a local variable.
 */
class MutexLocker {
public:
	MutexLocker(MutexI *pmi) : m_pmi(pmi) { if(m_pmi) m_pmi->Lock(); }
	~MutexLocker() { if(m_pmi) m_pmi->Unlock(); }
protected:
	MutexI *m_pmi;
};


/** @ingroup VObj
 * Interface to a memory allocator
 */
// %%DYNOBJ class(vobj) 
class MallocI {
public:
    /** @name Virtuals
     *  Interface members */
    //@{ 
	virtual void* docall malloc( int size ) = 0;
	virtual void  docall free( void *pv ) = 0;
    //@}
};

class DynStr;

/** @ingroup VObj
 * Interface to a memory allocator
 */
// %%DYNOBJ class(vobj) 
class TextIoI {
public:
    /** @name Virtuals
     *  Interface members */
    //@{ 
	virtual int docall puts(const char *ps) = 0;
	virtual int docall puterr(const char *pe) = 0;
	virtual int docall gets(DynStr& ds, bool sync=true) = 0;
    //@}
};


/** @ingroup VObj
 * Interface for object with a state that can be stored as text
 */
// %%DYNOBJ class(vobj) 
class StateI {
public:
    /** @name Virtuals
     *  Interface members */
    //@{ 
	/** Fill in a current state (often XML) */
	virtual bool docall GetState( DynStr &ds ) = 0;
	/** Set state from previous GetState */
	virtual bool docall SetState( const char *state ) = 0;
	/** Called when all items/objects have received their state */
	virtual void docall LateInit( ) = 0;
    //@}
};

/** @ingroup VObj
 * Interface for object with that uses a 'current path'
 */
// %%DYNOBJ class(vobj) 
class PathI {
public:
    /** @name Virtuals
     *  Interface members */
    //@{ 
	virtual bool docall GetPath( DynStr &ds ) = 0;
	virtual bool docall SetPath( const char *path ) = 0;
    //@}
};


/** @ingroup DynI
 * This interface allows for retrieving named 'related objects' to an object. 
 * A Tree browser may have a "contents" related object ,...etc. 
 * The sibling object is usually an object with its own life span.
 * If the object implementing NamedRefI also implements NotifiableI
 * there is no need for the Remove function, since we get destructor 
 * notifications.*/
// %%DYNOBJ class(dyni) flags(inst2reg)
class NamedRefI : public DynI {
public:
    /** @name Virtuals
     *  Interface members */
    //@{ 
	virtual DynObjType* docall doGetType( const DynI **pself=0 ) const;
	
    /** Lookup a named object.
      * @param name is the name which the object is known by
      * @param type_id is the type of the object or 0 if don't care
      * @return An interface pointer or NULL if not found */
	virtual DynI* docall GetByName( const char *name, int type_id ){ return NULL; }
    
    /** Lookup a named object using index.
      * @param index lookup the n:th object of this type
      * @param ds store name of object here
      * @param type_id is the type of the object or 0 if don't care
      * @return An interface pointer or NULL if not found */
	virtual DynI* docall GetByIndex( int index, DynStr &ds, int type_id=0 ){ return NULL; }
    
    /** Store a named object.
      * An implementation is free to return false if the object is not 
      * accepted (i.e. it does not implement NotifierI)
      * @param name is the name by which the object can later be looked up 
      * @param pdi the object to be known with this name
      * @return true on success */
	virtual bool  docall Set( const char *name, DynI *pdi ){ return false; }
    
    /** Manually remove a named object.
      * @param pdi the object to be removed
      * @return true on success */
	virtual bool  docall Remove( DynI *pdi ){ return false; }
    //@}

    /** @name Inlines
     *  Inline convenience functions */
    // 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); }
};


/** @ingroup DynI
 * A DynObj module (internal use). Represents one currently loaded library */
// %%DYNOBJ class(Dyni) flags(NoTypeId)
class DoModuleC : public DynI {
public:
    DoModuleC() : m_pv1(0), m_pv2(0) { }
	virtual DynObjType* docall doGetType( const DynI **pself=0 ) const;
	
    /** @name Virtuals
     *  Interface members */
    //@{ 
	virtual DynObjType* docall FindType( void** vtbl ){ return NULL; }
	virtual DynObjType* docall FindType( const char *type ){ return NULL; }
	virtual DynObjType* docall FindType( int type_id ){ return NULL; }
    //@}
    void *m_pv1, *m_pv2;
};


#ifdef DO_USE_RUNTIME

/** @ingroup DynI
 * Global DoRunTime class. Gives access to shared resources, a named object
 * pool and types in other loaded libraries */
// %%DYNOBJ class(dyni) flags(notypeid) 
class DoRunTimeI : public DynI {
public:
	// Base DynObj functions
	virtual DynObjType* docall doGetType( const DynI **pself=0 ) const;
	
    /** @name Virtuals
     *  Interface members */
    //@{ 
	// Access shared functionality
	virtual MutexI*  docall  GetMutex() const { return NULL; }
	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, int obj_size=0 ){ 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; }

	// DynObj module registration 	
	virtual bool docall RegisterModule( DoModuleC *pmi ){ return false; }
	virtual bool docall UnRegisterModule( DoModuleC *pmi ){ return false; }

	// Manage types based on VTable pointer
	virtual bool        docall RegisterType( void **vtbl, DynObjType *pdt ){ return false; }
	virtual bool        docall UnRegisterType( void **vtbl ){ return false; }
	virtual DynObjType* docall GetTypeOf( void **vtbl ){ return NULL; }

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

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

#endif // DO_USE_RUNTIME 

// %%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_NotDataI("NotDataI:VObj",NOTDATAI_TYPE_ID,1,sizeof(NotDataI));
DynObjType g_do_vtype_NotifierI("NotifierI:VObj",NOTIFIERI_TYPE_ID,1,sizeof(NotifierI));
DynObjType g_do_vtype_NotifiableI("NotifiableI:VObj",NOTIFIABLEI_TYPE_ID,1,sizeof(NotifiableI));
DynObjType g_do_vtype_MutexI("MutexI:VObj",MUTEXI_TYPE_ID,1,sizeof(MutexI));
DynObjType g_do_vtype_MallocI("MallocI:VObj",MALLOCI_TYPE_ID,1,sizeof(MallocI));
DynObjType g_do_vtype_TextIoI("TextIoI:VObj",TEXTIOI_TYPE_ID,1,sizeof(TextIoI));
DynObjType g_do_vtype_StateI("StateI:VObj",STATEI_TYPE_ID,1,sizeof(StateI));
DynObjType g_do_vtype_PathI("PathI:VObj",PATHI_TYPE_ID,1,sizeof(PathI));
DynObjTypeI2R<NamedRefI,DynI,false> g_do_vtype_NamedRefI("NamedRefI:DynI",NAMEDREFI_TYPE_ID,1);
DynObjType* NamedRefI::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_NamedRefI;
}
DynObjType g_do_vtype_DoModuleC("DoModuleC:DynI",DOMODULEC_TYPE_ID,1,sizeof(DoModuleC));
DynObjType* DoModuleC::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DoModuleC;
}

#ifdef DO_USE_RUNTIME
DynObjType g_do_vtype_DoRunTimeI("DoRunTimeI:DynI",DORUNTIMEI_TYPE_ID,1,sizeof(DoRunTimeI));
DynObjType* DoRunTimeI::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DoRunTimeI;
}
#endif
#endif //DO_IMPLEMENT_...
// %%DYNOBJ section end

#endif //DOBASE_I