From ec05778d5718a7912e506764d443a78d6a6179e3 Mon Sep 17 00:00:00 2001 From: Mike Buland Date: Mon, 5 Nov 2012 22:41:51 +0000 Subject: Converted tabs to spaces with tabconv. --- src/stable/plugger.h | 420 +++++++++++++++++++++++++-------------------------- 1 file changed, 210 insertions(+), 210 deletions(-) (limited to 'src/stable/plugger.h') diff --git a/src/stable/plugger.h b/src/stable/plugger.h index d9eaf34..424613f 100644 --- a/src/stable/plugger.h +++ b/src/stable/plugger.h @@ -24,59 +24,59 @@ namespace Bu { - subExceptionDecl( PluginException ); + subExceptionDecl( PluginException ); - typedef struct PluginInfo - { - const char *sID; - const char *sAuthor; - unsigned short nVersion; - unsigned short nRevision; - void *(*createPlugin)(); - void (*destroyPlugin)( void * ); - } PluginInfo; + typedef struct PluginInfo + { + const char *sID; + const char *sAuthor; + unsigned short nVersion; + unsigned short nRevision; + void *(*createPlugin)(); + void (*destroyPlugin)( void * ); + } PluginInfo; - typedef struct PluginReg - { - bool bBuiltin; + typedef struct PluginReg + { + bool bBuiltin; #ifdef WIN32 - HMODULE dlHandle; + HMODULE dlHandle; #else - void *dlHandle; + void *dlHandle; #endif - PluginInfo *pInfo; - } PluginReg; + PluginInfo *pInfo; + } PluginReg; -#define PluginInterface( classname, baseclass, name, ver, rev ) \ - extern "C" { \ - baseclass *create ##classname() \ - { \ - return new classname(); \ - } \ - void destroy ##classname( baseclass *pCls ) \ - { \ - delete pCls; \ - } \ - Bu::PluginInfo classname = { \ - #classname, name, ver, rev, \ - create ##classname, destroy ##classname }; \ - } +#define PluginInterface( classname, baseclass, name, ver, rev ) \ + extern "C" { \ + baseclass *create ##classname() \ + { \ + return new classname(); \ + } \ + void destroy ##classname( baseclass *pCls ) \ + { \ + delete pCls; \ + } \ + Bu::PluginInfo classname = { \ + #classname, name, ver, rev, \ + create ##classname, destroy ##classname }; \ + } #define PluginInterface2( pluginname, classname, baseclass, name, ver, rev ) \ - extern "C" { \ - baseclass *create ##classname() \ - { \ - return new classname(); \ - } \ - void destroy ##classname( baseclass *pCls ) \ - { \ - delete pCls; \ - } \ - Bu::PluginInfo pluginname = { \ - #pluginname, name, ver, rev, \ - (void *(*)())(create ##classname), \ - (void (*)( void * ))(destroy ##classname) }; \ - } + extern "C" { \ + baseclass *create ##classname() \ + { \ + return new classname(); \ + } \ + void destroy ##classname( baseclass *pCls ) \ + { \ + delete pCls; \ + } \ + Bu::PluginInfo pluginname = { \ + #pluginname, name, ver, rev, \ + (void *(*)())(create ##classname), \ + (void (*)( void * ))(destroy ##classname) }; \ + } // // This is probably the main interface to use, I'll describe it some here... @@ -93,197 +93,197 @@ namespace Bu // rev - an integer revision number for the plugin // #define PluginInterface3( structname, pluginname, classname, baseclass, name, ver, rev ) \ - extern "C" { \ - baseclass *create ##classname() \ - { \ - return new classname(); \ - } \ - void destroy ##classname( baseclass *pCls ) \ - { \ - delete pCls; \ - } \ - Bu::PluginInfo structname = { \ - #pluginname, name, ver, rev, \ - (void *(*)())(create ##classname), \ - (void (*)( void * ))(destroy ##classname) }; \ - } + extern "C" { \ + baseclass *create ##classname() \ + { \ + return new classname(); \ + } \ + void destroy ##classname( baseclass *pCls ) \ + { \ + delete pCls; \ + } \ + Bu::PluginInfo structname = { \ + #pluginname, name, ver, rev, \ + (void *(*)())(create ##classname), \ + (void (*)( void * ))(destroy ##classname) }; \ + } - /** - * A complete dynamic plugin manager system. This will allow you to design - * and use plugins that are compiled into your program and dynamically - * linked to your program interchangably. It works on windows and on *nix - * and bsd type systems (anything that supports dlopen). Basically you - * create a base class that will be the basic interface of your plugins. - * Then you create some classes that inherit from it, and use the - * PluginInterface3 macro to create the required data structures for it. - * - * Once you have plugins you can create a Plugger, by passing in the base - * class as it's template parameter. Once it's created, you can register - * plugins. To register a plugin that is builtin, you just need to pass - * a pointer to it's interface structure to the registerBuiltinPlugin - * function. To register a plugin that is in a shared object or dll file - * you just pass the filename (with path, probably), and the name of the - * structure to load and you're all set. - * - * To instantiate an object from a plugin simply call instantiate with the - * name of the plugin as specified in the interface macro. To destroy an - * object crated with the plugger do not delete it, instead pass it into - * Plugger's destroy function. - * - * Any objects not destroyed when the plugger is deleted will be destroyed - * automatically. - * - * It is important to note that some systems (linux at least) partition off - * the memory allocated by objects linked in at run time into a seperate - * segment that, while it can be accessed by the main program, cannot be - * safely or reliably freed by the main program. With that in mind it is - * a good idea to free all memory allocated by a plugin object in the plugin - * object and not allow the calling program to delete it. - */ - template - class Plugger - { - public: - typedef Bu::Hash PluginHash; - typedef Bu::Hash InstHash; + /** + * A complete dynamic plugin manager system. This will allow you to design + * and use plugins that are compiled into your program and dynamically + * linked to your program interchangably. It works on windows and on *nix + * and bsd type systems (anything that supports dlopen). Basically you + * create a base class that will be the basic interface of your plugins. + * Then you create some classes that inherit from it, and use the + * PluginInterface3 macro to create the required data structures for it. + * + * Once you have plugins you can create a Plugger, by passing in the base + * class as it's template parameter. Once it's created, you can register + * plugins. To register a plugin that is builtin, you just need to pass + * a pointer to it's interface structure to the registerBuiltinPlugin + * function. To register a plugin that is in a shared object or dll file + * you just pass the filename (with path, probably), and the name of the + * structure to load and you're all set. + * + * To instantiate an object from a plugin simply call instantiate with the + * name of the plugin as specified in the interface macro. To destroy an + * object crated with the plugger do not delete it, instead pass it into + * Plugger's destroy function. + * + * Any objects not destroyed when the plugger is deleted will be destroyed + * automatically. + * + * It is important to note that some systems (linux at least) partition off + * the memory allocated by objects linked in at run time into a seperate + * segment that, while it can be accessed by the main program, cannot be + * safely or reliably freed by the main program. With that in mind it is + * a good idea to free all memory allocated by a plugin object in the plugin + * object and not allow the calling program to delete it. + */ + template + class Plugger + { + public: + typedef Bu::Hash PluginHash; + typedef Bu::Hash InstHash; - public: - Plugger() - { - } + public: + Plugger() + { + } - virtual ~Plugger() - { - for( InstHash::iterator i = hObj.begin(); i != hObj.end(); i++ ) - { - T *pPlug = (T *)i.getKey(); - PluginReg *pReg = (PluginReg *)*i; - pReg->pInfo->destroyPlugin( pPlug ); - } + virtual ~Plugger() + { + for( InstHash::iterator i = hObj.begin(); i != hObj.end(); i++ ) + { + T *pPlug = (T *)i.getKey(); + PluginReg *pReg = (PluginReg *)*i; + pReg->pInfo->destroyPlugin( pPlug ); + } - for( PluginHash::iterator i = hPlugin.begin(); - i != hPlugin.end(); i++ ) - { - if( (*i)->bBuiltin == false ) - { + for( PluginHash::iterator i = hPlugin.begin(); + i != hPlugin.end(); i++ ) + { + if( (*i)->bBuiltin == false ) + { #ifdef WIN32 - FreeLibrary( (*i)->dlHandle ); + FreeLibrary( (*i)->dlHandle ); #else - dlclose( (*i)->dlHandle ); + dlclose( (*i)->dlHandle ); #endif - } - delete (*i); - } - } + } + delete (*i); + } + } - void registerBuiltinPlugin( PluginInfo *pInfo ) - { - PluginReg *pReg = new PluginReg; - pReg->bBuiltin = true; - pReg->pInfo = pInfo; - hPlugin.insert( pInfo->sID, pReg ); - } + void registerBuiltinPlugin( PluginInfo *pInfo ) + { + PluginReg *pReg = new PluginReg; + pReg->bBuiltin = true; + pReg->pInfo = pInfo; + hPlugin.insert( pInfo->sID, pReg ); + } - void registerExternalPlugin( const Bu::String &sFName, - const Bu::String &sPluginName ) - { - PluginReg *pReg; - if( hPlugin.has( sPluginName ) ) - throw Bu::ExceptionBase("A plugin with name '%s' is already " - "loaded.", sPluginName.getStr() ); + void registerExternalPlugin( const Bu::String &sFName, + const Bu::String &sPluginName ) + { + PluginReg *pReg; + if( hPlugin.has( sPluginName ) ) + throw Bu::ExceptionBase("A plugin with name '%s' is already " + "loaded.", sPluginName.getStr() ); - pReg = new PluginReg; + pReg = new PluginReg; - pReg->bBuiltin = false; + pReg->bBuiltin = false; #ifdef WIN32 - pReg->dlHandle = LoadLibrary( sFName.getStr() ); - if( pReg->dlHandle == NULL ) - { - throw PluginException( 1, "Error opening %s: %s", - sFName.getStr(), Bu::getLastWinError().getStr() ); - } - pReg->pInfo = (PluginInfo *)GetProcAddress( pReg->dlHandle, - sPluginName.getStr() ); - if( pReg->pInfo == NULL ) - { - throw PluginException( 2, "Error mapping %s: %s", - sFName.getStr(), Bu::getLastWinError().getStr() ); - } + pReg->dlHandle = LoadLibrary( sFName.getStr() ); + if( pReg->dlHandle == NULL ) + { + throw PluginException( 1, "Error opening %s: %s", + sFName.getStr(), Bu::getLastWinError().getStr() ); + } + pReg->pInfo = (PluginInfo *)GetProcAddress( pReg->dlHandle, + sPluginName.getStr() ); + if( pReg->pInfo == NULL ) + { + throw PluginException( 2, "Error mapping %s: %s", + sFName.getStr(), Bu::getLastWinError().getStr() ); + } #else - pReg->dlHandle = dlopen( sFName.getStr(), RTLD_NOW ); - if( pReg->dlHandle == NULL ) - { - throw PluginException( 1, "Error opening %s: %s", - sFName.getStr(), dlerror() ); - } - pReg->pInfo = (PluginInfo *)dlsym( pReg->dlHandle, - sPluginName.getStr() ); - if( pReg->pInfo == NULL ) - { - throw PluginException( 2, "Error mapping %s: %s", - sFName.getStr(), dlerror() ); - } + pReg->dlHandle = dlopen( sFName.getStr(), RTLD_NOW ); + if( pReg->dlHandle == NULL ) + { + throw PluginException( 1, "Error opening %s: %s", + sFName.getStr(), dlerror() ); + } + pReg->pInfo = (PluginInfo *)dlsym( pReg->dlHandle, + sPluginName.getStr() ); + if( pReg->pInfo == NULL ) + { + throw PluginException( 2, "Error mapping %s: %s", + sFName.getStr(), dlerror() ); + } #endif - hPlugin.insert( pReg->pInfo->sID, pReg ); - } + hPlugin.insert( pReg->pInfo->sID, pReg ); + } - T *instantiate( const Bu::String &lpName ) - { - PluginReg *pReg = (PluginReg *)hPlugin[lpName]; - if( pReg == NULL ) - return NULL; + T *instantiate( const Bu::String &lpName ) + { + PluginReg *pReg = (PluginReg *)hPlugin[lpName]; + if( pReg == NULL ) + return NULL; - T *p = (T *)pReg->pInfo->createPlugin(); - hObj.insert( (ptrdiff_t)p, pReg ); - //printf("pReg: %08X, pPlug: %08X\n", pReg, p ); - - return p; - } + T *p = (T *)pReg->pInfo->createPlugin(); + hObj.insert( (ptrdiff_t)p, pReg ); + //printf("pReg: %08X, pPlug: %08X\n", pReg, p ); + + return p; + } - bool hasPlugin( const Bu::String &lpName ) - { - return hPlugin.has( lpName ); - } + bool hasPlugin( const Bu::String &lpName ) + { + return hPlugin.has( lpName ); + } - void destroy( T *pPlug ) - { - PluginReg *pReg = (PluginReg *)hObj.get((ptrdiff_t)pPlug); - //printf("pReg: %08X, pPlug: %08X\n", pReg, pPlug ); - if( pReg == NULL ) - return; + void destroy( T *pPlug ) + { + PluginReg *pReg = (PluginReg *)hObj.get((ptrdiff_t)pPlug); + //printf("pReg: %08X, pPlug: %08X\n", pReg, pPlug ); + if( pReg == NULL ) + return; - pReg->pInfo->destroyPlugin( pPlug ); + pReg->pInfo->destroyPlugin( pPlug ); - hObj.erase( (ptrdiff_t)pPlug ); - } + hObj.erase( (ptrdiff_t)pPlug ); + } - void unloadAll() - { - for( PluginHash::iterator i = hPlugin.begin(); - i != hPlugin.end(); i++ ) - { - if( (*i)->bBuiltin == false ) - { + void unloadAll() + { + for( PluginHash::iterator i = hPlugin.begin(); + i != hPlugin.end(); i++ ) + { + if( (*i)->bBuiltin == false ) + { #ifdef WIN32 - FreeLibrary( (*i)->dlHandle ); + FreeLibrary( (*i)->dlHandle ); #else - dlclose( (*i)->dlHandle ); + dlclose( (*i)->dlHandle ); #endif - } - delete (*i); - } - hPlugin.clear(); - } + } + delete (*i); + } + hPlugin.clear(); + } - Bu::List getPluginList() - { - return hPlugin.getKeys(); - } + Bu::List getPluginList() + { + return hPlugin.getKeys(); + } - private: - PluginHash hPlugin; - InstHash hObj; - }; + private: + PluginHash hPlugin; + InstHash hObj; + }; } #endif -- cgit v1.2.3