Converted tabs to spaces with tabconv.

1 files changed, 210 insertions, 210 deletions

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 T>
-        class Plugger
-        {
-        public:
-                typedef Bu::Hash<Bu::String, PluginReg *> PluginHash;
-                typedef Bu::Hash<ptrdiff_t, void *> 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 T>
+    class Plugger
+    {
+    public:
+        typedef Bu::Hash<Bu::String, PluginReg *> PluginHash;
+        typedef Bu::Hash<ptrdiff_t, void *> 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<Bu::String> getPluginList()
-                {
-                        return hPlugin.getKeys();
-                }
+        Bu::List<Bu::String> getPluginList()
+        {
+            return hPlugin.getKeys();
+        }
 
-        private:
-                PluginHash hPlugin;
-                InstHash hObj;
-        };
+    private:
+        PluginHash hPlugin;
+        InstHash hObj;
+    };
 }
 
 #endif