gemrb/core/PluginMgr.h

   1 /* GemRB - Infinity Engine Emulator
   2  * Copyright (C) 2003 The GemRB Project
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  *
  19  */
  20
  21 /**
  22  * @file PluginMgr.h
  23  * Declares PluginMgr, loader for GemRB plugins
  24  * @author The GemRB Project
  25  */
  26
  27 #ifndef PLUGINMGR_H
  28 #define PLUGINMGR_H
  29
  30 #include "SClassID.h" // For PluginID
  31 #include "exports.h"
  32 #include "globals.h"
  33 #include "iless.h"
  34 #include "win32def.h"
  35
  36 #include "ResourceDesc.h"
  37
  38 #include <cstring>
  39 #include <list>
  40 #include <map>
  41 #include <vector>
  42
  43 #ifdef WIN32
  44 typedef HINSTANCE LibHandle;
  45 #else
  46 typedef void *LibHandle;
  47 #endif
  48
  49 class Plugin;
  50 class Resource;
  51 class TypeID;
  52
  53 /**
  54  * @class PluginMgr
  55  * Class for loading GemRB plugins from shared libraries or DLLs.
  56  * It goes over all appropriately named files in PluginPath directory
  57  * and tries to load them one after another.
  58  */
  59
  60 class GEM_EXPORT PluginMgr {
  61 public:
  62         typedef Resource* (*ResourceFunc)(DataStream*);
  63         typedef Plugin* (*PluginFunc)();
  64 public:
  65         /** Return global instance of PluginMgr */
  66         static PluginMgr* Get();
  67         void LoadPlugins(char* pluginpath);
  68 private:
  69         PluginMgr();
  70 public: // HACK: MSVC6 is buggy.
  71         ~PluginMgr(void);
  72 private:
  73         struct PluginDesc {
  74                 LibHandle handle;
  75                 PluginID ID;
  76                 const char *Description;
  77                 bool (*Register)(PluginMgr*);
  78         };
  79         std::map< PluginID, PluginDesc> libs;
  80         std::map< SClass_ID, PluginFunc> plugins;
  81         std::map< const TypeID*, std::vector<ResourceDesc> > resources;
  82         /** Array of initializer functions */
  83         std::vector<void (*)(void)> intializerFunctions;
  84         /** Array of cleanup functions */
  85         std::vector<void (*)(void)> cleanupFunctions;
  86         typedef std::map<const char*, PluginFunc, iless> driver_map;
  87         std::map<const TypeID*, driver_map> drivers;
  88 public:
  89         /** Return names of all *.so or *.dll files in the given directory */
  90         bool FindFiles( char* path, std::list< char* > &files);
  91         bool IsAvailable(SClass_ID plugintype) const;
  92         Plugin* GetPlugin(SClass_ID plugintype) const;
  93
  94         size_t GetPluginCount() const { return plugins.size(); }
  95
  96         /**
  97          * Register class plugin.
  98          *
  99          * @param[in] id ID used to access plugin.
 100          * @param[in] create Function to create instance of plugin.
 101          */
 102         bool RegisterPlugin(SClass_ID id, PluginFunc create);
 103         /**
 104          * Register resource.
 105          *
 106          * @param[in] type Base class for resource.
 107          * @param[in] create Function to create resource from a stream.
 108          * @param[in] ext Extension used for resource files.
 109          * @param[in] keyType \iespecific Type identifier used in key/biff files.
 110          */
 111         void RegisterResource(const TypeID* type, ResourceFunc create, const char *ext, ieWord keyType = 0);
 112
 113         const std::vector<ResourceDesc>& GetResourceDesc(const TypeID*);
 114
 115         /**
 116          * Registers a static intializer.
 117          *
 118          * @param[in] init Function to call on startup.
 119          */
 120         void RegisterInitializer(void (*init)(void));
 121         /**
 122          * Registers a static cleanup.
 123          *
 124          * @param[in] cleanup Function to call on shutdown.
 125          */
 126         void RegisterCleanup(void (*cleanup)(void));
 127
 128         /** Run intializer functions. */
 129         void RunInitializers() const;
 130         /** Run cleanup functions */
 131         void RunCleanup() const;
 132
 133         /**
 134          * Registers a driver plugin
 135          *
 136          * @param[in] type Base class for driver.
 137          * @param[in] name Name of driver.
 138          * @param[in] create Function to create instance of plugin.
 139          */
 140         bool RegisterDriver(const TypeID* type, const char* name, PluginFunc create);
 141
 142         /**
 143          * Gets driver of specified type.
 144          *
 145          * @param[in] type Base class for driver.
 146          * @param[in] name Name of driver.
 147          *
 148          * Tries to get driver associated to name, or falls back to a random one.
 149          */
 150         Plugin* GetDriver(const TypeID* type, const char* name);
 151 };
 152
 153 #endif