First step on the road of module loader rewriting. So far this only really removes...

[user/henk/code/inspircd.git] / include / modules.h

diff --git a/include/modules.h b/include/modules.h
index df857d506b67a6465041a178935467a93786ef7b..e5596430f7b5f99ae15d6db5cccc715d8d0185e4 100644 (file)
--- a/include/modules.h
+++ b/include/modules.h
@@ -93,6 +93,7 @@ class ServerConfig;
 /* Forward-delacare module for ModuleMessage etc
  */
 class Module;
+class InspIRCd;
 
 /** Low level definition of a FileReader classes file cache area -
  * a text file seperated into lines.
@@ -361,68 +362,6 @@ class CoreExport Event : public ModuleMessage
        char* Send(InspIRCd* ServerInstance);
 };
 
-/** This class can be used on its own to represent an exception, or derived to represent a module-specific exception.
- * When a module whishes to abort, e.g. within a constructor, it should throw an exception using ModuleException or
- * a class derived from ModuleException. If a module throws an exception during its constructor, the module will not
- * be loaded. If this happens, the error message returned by ModuleException::GetReason will be displayed to the user
- * attempting to load the module, or dumped to the console if the ircd is currently loading for the first time.
- */
-class CoreExport CoreException : public std::exception
-{
- protected:
-       /** Holds the error message to be displayed
-        */
-       const std::string err;
-       /** Source of the exception
-        */
-       const std::string source;
- public:
-       /** Default constructor, just uses the error mesage 'Core threw an exception'.
-        */
-       CoreException() : err("Core threw an exception"), source("The core") {}
-       /** This constructor can be used to specify an error message before throwing.
-        */
-       CoreException(const std::string &message) : err(message), source("The core") {}
-       /** This constructor can be used to specify an error message before throwing,
-        * and to specify the source of the exception.
-        */
-       CoreException(const std::string &message, const std::string &src) : err(message), source(src) {}
-       /** This destructor solves world hunger, cancels the world debt, and causes the world to end.
-        * Actually no, it does nothing. Never mind.
-        * @throws Nothing!
-        */
-       virtual ~CoreException() throw() {};
-       /** Returns the reason for the exception.
-        * The module should probably put something informative here as the user will see this upon failure.
-        */
-       virtual const char* GetReason()
-       {
-               return err.c_str();
-       }
-
-       virtual const char* GetSource()
-       {
-               return source.c_str();
-       }
-};
-
-class CoreExport ModuleException : public CoreException
-{
- public:
-       /** Default constructor, just uses the error mesage 'Module threw an exception'.
-        */
-       ModuleException() : CoreException("Module threw an exception", "A Module") {}
-
-       /** This constructor can be used to specify an error message before throwing.
-        */
-       ModuleException(const std::string &message) : CoreException(message, "A Module") {}
-       /** This destructor solves world hunger, cancels the world debt, and causes the world to end.
-        * Actually no, it does nothing. Never mind.
-        * @throws Nothing!
-        */
-       virtual ~ModuleException() throw() {};
-};
-
 /** Priority types which can be returned from Module::Prioritize()
  */
 enum Priority { PRIORITY_FIRST, PRIORITY_DONTCARE, PRIORITY_LAST, PRIORITY_BEFORE, PRIORITY_AFTER };
@@ -1639,32 +1578,10 @@ class CoreExport FileReader : public classbase
        int FileSize();
 };
 
-
-/** Instantiates classes inherited from Module.
- * This class creates a class inherited from type Module, using new. This is to allow for modules
- * to create many different variants of Module, dependent on architecture, configuration, etc.
- * In most cases, the simple class shown in the example module m_foobar.so will suffice for most
- * modules.
- */
-class CoreExport ModuleFactory : public classbase
-{
- public:
-       /** The default constructor does nothing.
-        */
-       ModuleFactory() { }
-       /** The default destructor does nothing
-        */
-       virtual ~ModuleFactory() { }
-       /** Creates a new module.
-        * Your inherited class of ModuleFactory must return a pointer to your Module class
-        * using this method.
-        */
-       virtual Module * CreateModule(InspIRCd* Me) = 0;
-};
-
-/** A DLLFactory (designed to load shared objects) containing a ModuleFactory.
+/** A DLLFactory (designed to load shared objects) containing a
+ * handle to a module's init_module() function.
  */
-typedef DLLFactory<ModuleFactory> ircd_module;
+typedef DLLFactory<Module> ircd_module;
 
 /** A list of loaded Modules
  */
@@ -1679,18 +1596,9 @@ typedef std::vector<ircd_module*> FactoryList;
  * It defines the class factory and external init_module function.
  */
 #define MODULE_INIT(y) \
-       class Factory : public ModuleFactory \
+       extern "C" DllExport Module * init_module(InspIRCd* Me) \
        { \
-        public: \
-               virtual Module * CreateModule(InspIRCd* Me) \
-               { \
-                       return new y(Me); \
-               } \
-       }; \
-       extern "C" DllExport void * init_module(void) \
-       { \
-               return new Factory; \
+               return new y(Me); \
        }
 
 #endif
-