DynObjLib.h

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

#ifndef DYNOBJLIB_H
#define DYNOBJLIB_H

#include "DynObj.h"
#include "DoBaseI.h"
#include "pi/DynLib.h"
#include "utils/CharBuf.h"
#include "utils/HashTable.hpp" 
#include "dynobj/DynObjPtr.hpp"

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

// --- Integer type ids for defined interfaces/classes ---
#define DYNOBJLIB_TYPE_ID 0x68D85000

// --- Forward class declarations ---
class DynObjLib;

// --- For each declared class, doTypeInfo template specializations ---
DO_DECL_TYPE_INFO(DynObjLib,DYNOBJLIB_TYPE_ID);

// %%DYNOBJ section end

#if DO_ENABLE_OBJECT_TRACKING==1
    #include "utils/ExpArr.hpp"
#endif

#include "DORT.h"

struct DortInternalI;


// Utility class: Load, init, access and close a DynObj library
// %% DYNOBJ class(dyni) 
class DynObjLib : public DynObjLibI {
public:

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

    // Flags given in constructor to allow/deny a library capabilities
    enum { LibMayLoadModules=1, LibMayOverrideTypes=2, LibIsMain=4 };

   DynObjLib( const char *lib, 
              bool do_call_init, 
              DynI* pdi_init = NULL, 
              int mod_flags = 0, 
              int so_load_flags = -1 );
   
#ifdef DO_MAIN    
   // A constructor for the main program, which is not really a library. But we want it 
   // to look that way to DoRunTime
   DynObjLib( const char *name, CreateDynObjFn pcfn );
#endif              
   ~DynObjLib( );

   virtual int docall GetState() { return m_state; }
   //virtual const char* docall GetError( );

   virtual const char* docall GetLibName();
   virtual const char* docall GetLibFileName();

   virtual DynObj* docall Create( const char *type, int type_id, const DynI* pdi_init=NULL );
   virtual bool docall Destroy( VObj *pvo );
    
   virtual void docall OnObjectCreate( DynObj *pdo, DynObjType *pdt );
   virtual void docall OnObjectDestroy( DynObj *pdo, DynObjType *pdt );
    
   virtual bool docall MayUnload( );
   
    bool ExitDynLib( bool is_query );
   
    bool EnableObjectTracking( bool enable );

    bool IsOk() { return m_state>=Initialized; }
   
    const char *GetCallStr(){ return m_callstr; }
   
    const int GetPlatform(){ return m_platform; }   // Return pointer to platform integer
   
    const int GetDoTraits(){ return m_do_traits; }  // Return pointer to traits integer
   
    void *FindSymbol( const char *symb_name );
   
    void* GetBase( );
   
    
    int        Implements( const char *type );

    int        Implements( int type_id );

    const char *GetCallConv( );

    static bool AddLibPath( const char* path );

#ifdef DO_MAIN

    bool SetCreateDynObjFn( CreateDynObjFn cdofn );
#endif

    bool operator==(const char *name) { return m_name==name; }
    
    DynI *InitDynLib( DynI* pdi_init );
    DynI *GetInitDynLibRetVal( );

protected:              
    // Initialize the library.
    void Ctor( const char *lib, bool do_call_init, DynI* pdi_init );
    bool InitFromModuleData( doModuleData* impl );
    static void TrimLibName( CharBuf& name );
    static DynLib *LoadDynLib( const char *lib, int so_load_flags=-1, DynObjLib *plib=NULL );
    
    DortInternalI *m_pdorti;
    
    DynLib *m_pdlib;
    CharBuf m_name;     // To override name of library (for pseudo lib: Main module)
    int m_state;
    int m_lib_flags;    // Override for module permissions during load time
    
    CreateDynObjFn   m_pcfn;        // Pointer to CreateDynObjFn for this library 
    //CreateDynObjFn  m_pbcr;       // Pointer to base class creation function for this library 
    InitDynLibFn     m_pidlfn;  // Pointer to DoInitLib
    ExitDynLibFn     m_pedlfn;  // Pointer to DoExitLib
    DestroyDynObjFn  m_pdofn;
    
    doModuleData *m_pdol_impl;
    DynObjPtr<DynI> m_idl_ret_val;
    const char  *m_instantiates;// Keep as a pointer to pointer, for main module
    const char  *m_callstr;     // Calling convention used by lib. Check against DO_CALLSTR
    int         m_platform;     // A pointer to g_do_platform imported or NULL if not found
    int         m_do_traits;    // A pointer to g_do_traits which stores VTable compatibility info of
    //const char *m_last_err;       // From library loader
    CharBuf     m_last_err;

#if DO_ENABLE_OBJECT_TRACKING==1
    bool  m_ot_has_unregistered;
    bool  m_ot_enable;
    HashTable<DynObj*,void> m_objs;
#endif

    friend class DoRunTimeC;
};


#define DOH_LIB_FIRST ((const char*)0)

// Templates for DynObj creation & temporary holding 

#if DO_USE_TEMPLATES==1     
#ifdef DO_USE_RUNTIME 
#ifdef DO_MAIN

// Included from main program. Just need protos. These are implemented in DoRunTime.h
template <class T, class A>
T *do_new( A arg );

template <class T, class A>
T *do_new( const char* lib_name, A arg );

template <class T>
T *do_new( );

#else // DO_MODULE

#include "DoBase.hpp"
#include "DORT.h"

// Make local version of do_new, still using DoRunTime
template<class T,class A, bool dyni_arg>
struct DoCreator;

template<class T,class A>
struct DoCreator<T,A,false> {
    static T *Create( A arg ){
        // Wrap arg
        DynData dd(arg);
        return DORT.Create<T>( &dd );
    }
    static T *Create( const char* lib_name, A arg ){
        DynObjLibI *plib = DORT.GetLib( lib_name );
        if( !plib ) return NULL;
        // Wrap arg
        DynData dd(arg);
        return plib->Create<T>( &dd );
    }
};

template<class T,class A>
struct DoCreator<T,A*,true> {
    static T *Create( A* parg){
        // Arg is already DynI
        return DORT.Create<T>( parg );
    }
    static T *Create( const char* lib_name, A* parg ){
        DynObjLibI *plib = DORT.GetLib( lib_name );
        if( !plib ) return NULL;
        return plib->Create<T>( parg );
    }
};

template<class T,class A>
struct DoCreator<T,A&,true> {
    static T *Create( A& arg ){
        // Arg is already DynI
        return DORT.Create<T>( &arg );
    }
    static T *Create( const char* lib_name, A& arg ){
        DynObjLibI *plib = DORT.GetLib( lib_name );
        if( !plib ) return NULL;
        return plib->Create<T>( &arg );
    }
};

// Take any argument, select way to create object
template <class T, class A>
T *do_new( A arg ){
    return DoCreator<T,A,DoIsTypeA<A,DynI>::v>::Create( arg );
}

template <class T, class A>
T *do_new( const char* lib_name, A arg ){
    return DoCreator<T,A,DoIsTypeA<A,DynI>::v>::Create( lib_name, arg );
}

template <class T>
T *do_new( ){
    return DoCreator<T,DynI*,true>::Create( (DynI*)NULL );
}

#endif // DO_MAIN + DO_MODULE
#endif // DO_USE_RUNTIME
#endif // DO_USE_TEMPLATES==1     

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

// Generate type information that auto-registers on module load
DynObjType g_do_vtype_DynObjLib("DynObjLib:DynObjLibI",DYNOBJLIB_TYPE_ID,0,sizeof(DynObjLib),NULL,NULL,__FILE__);
DynObjType* DynObjLib::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynObjLib;
}
#endif //DO_IMPLEMENT_...
// %%DYNOBJ section end

#endif // DYNOBJLIB_H

---