Code is all reorganized. We're about ready to release. I should write up a

little explenation of the arrangement.

1 files changed, 289 insertions, 0 deletions

diff --git a/src/stable/plugger.h b/src/stable/plugger.h
new file mode 100644
index 0000000..c22f964
--- /dev/null
+++ b/src/stable/plugger.h
@@ -0,0 +1,289 @@
+/*
+ * Copyright (C) 2007-2011 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef BU_PLUGGER_H
+#define BU_PLUGGER_H
+
+#include "bu/hash.h"
+#include "bu/list.h"
+#include "bu/exceptionbase.h"
+#include "bu/string.h"
+#include <stddef.h>
+
+#include "bu/config.h"
+
+#ifdef WIN32
+# include <windows.h>
+#else
+# include <dlfcn.h>
+#endif
+
+namespace Bu
+{
+        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 PluginReg
+        {
+                bool bBuiltin;
+#ifdef WIN32
+                HMODULE dlHandle;
+#else
+                void *dlHandle;
+#endif
+                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 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) };                                    \
+        }
+
+//
+// This is probably the main interface to use, I'll describe it some here...
+//   structname - The name of the structure, this is what you have to pass to
+//                register.  Depending on how you build your dll/so files this
+//                will need to be unique (generally not)
+//   pluginname - This is what will be used by the plugin system to refer to
+//                your plugin once it's loaded.  This should be unique, but not
+//                a string
+//   classname  - The name of the class that is the plugin
+//   baseclass  - The name of the base class that is the parent of the plugin
+//   name       - The name of the author of this class (or company)
+//   ver        - an integer version number for the plugin
+//   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) };                                    \
+        }
+
+        /**
+         * 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()
+                {
+                }
+
+                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 )
+                                {
+#ifdef WIN32
+                                        FreeLibrary( (*i)->dlHandle );
+#else
+                                        dlclose( (*i)->dlHandle );
+#endif
+                                }
+                                delete (*i);
+                        }
+                }
+
+                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() );
+
+                        pReg = new PluginReg;
+
+                        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() );
+                        }
+#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() );
+                        }
+#endif
+                        hPlugin.insert( pReg->pInfo->sID, pReg );
+                }
+
+                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;
+                }
+
+                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;
+
+                        pReg->pInfo->destroyPlugin( pPlug );
+
+                        hObj.erase( (ptrdiff_t)pPlug );
+                }
+
+                void unloadAll()
+                {
+                        for( PluginHash::iterator i = hPlugin.begin();
+                                 i != hPlugin.end(); i++ )
+                        {
+                                if( (*i)->bBuiltin == false )
+                                {
+#ifdef WIN32
+                                        FreeLibrary( (*i)->dlHandle );
+#else
+                                        dlclose( (*i)->dlHandle );
+#endif
+                                }
+                                delete (*i);
+                        }
+                        hPlugin.clear();
+                }
+
+                Bu::List<Bu::String> getPluginList()
+                {
+                        return hPlugin.getKeys();
+                }
+
+        private:
+                PluginHash hPlugin;
+                InstHash hObj;
+        };
+}
+
+#endif