Move everything module-related out of InspIRCd and into ModuleManager, there is a ModuleManager instantiated as InspIRCd::Modules. Several of the function names have changed slightly as well. e.g. Instance->FindModule(m_foobar.so); is now Instance->Modules->Find(m_foobar.so);

All modules in the core distribution should also be updated in line with these changes.

git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@7985 e03df62e-2008-0410-955e-edbf42e46eb7

2 files changed, 259 insertions, 235 deletions

diff --git a/include/inspircd.h b/include/inspircd.h
index bc8055f67..2e5531567 100644
--- a/include/inspircd.h
+++ b/include/inspircd.h
@@ -259,26 +259,6 @@ class CoreExport InspIRCd : public classbase
 	 */
 	char current_uid[UUID_LENGTH];
 
-	/** Holds a string describing the last module error to occur
-	 */
-	char MODERR[MAXBUF];
-
-	/** Remove a ModuleFactory pointer
-	 * @param j Index number of the ModuleFactory to remove
-	 */
-	void EraseFactory(int j);
-
-	/** Remove a Module pointer
-	 * @param j Index number of the Module to remove
-	 */
-	void EraseModule(int j);
-
-	/** Move a given module to a specific slot in the list
-	 * @param modulename The module name to relocate
-	 * @param slot The slot to move the module into
-	 */
-	void MoveTo(std::string modulename,int slot);
-
 	/** Set up the signal handlers
 	 */
 	void SetSignals();
@@ -288,28 +268,6 @@ class CoreExport InspIRCd : public classbase
 	 */
 	bool DaemonSeed();
 
-	/** Moves the given module to the last slot in the list
-	 * @param modulename The module name to relocate
-	 */
-	void MoveToLast(std::string modulename);
-
-	/** Moves the given module to the first slot in the list
-	 * @param modulename The module name to relocate
-	 */
-	void MoveToFirst(std::string modulename);
-
-	/** Moves one module to be placed after another in the list
-	 * @param modulename The module name to relocate
-	 * @param after The module name to place the module after
-	 */
-	void MoveAfter(std::string modulename, std::string after);
-
-	/** Moves one module to be placed before another in the list
-	 * @param modulename The module name to relocate
-	 * @param after The module name to place the module before
-	 */
-	void MoveBefore(std::string modulename, std::string before);
-
 	/** Iterate the list of InspSocket objects, removing ones which have timed out
 	 * @param TIME the current time
 	 */
@@ -326,22 +284,10 @@ class CoreExport InspIRCd : public classbase
 	 */
 	bool AllModulesReportReady(userrec* user);
 
-	/** Total number of modules loaded into the ircd, minus one
-	 */
-	int ModCount;
-
 	/** Logfile pathname specified on the commandline, or empty string
 	 */
 	char LogFileName[MAXBUF];
 
-	/** The feature names published by various modules
-	 */
-	featurelist Features;
-
-	/** The interface names published by various modules
-	 */
-	interfacelist Interfaces;
-
 	/** The current time, updated in the mainloop
 	 */
 	time_t TIME;
@@ -381,7 +327,6 @@ class CoreExport InspIRCd : public classbase
 	 */
 	CullList GlobalCulls;
 
-
 	/**** Functors ****/
 
 	ProcessUserHandler HandleProcessUser;
@@ -453,6 +398,11 @@ class CoreExport InspIRCd : public classbase
 	/** Socket engine, handles socket activity events
 	 */
 	SocketEngine* SE;
+	
+	/** ModuleManager contains everything related to loading/unloading
+	 * modules.
+	 */
+	ModuleManager* Modules;
 
 	/** Stats class, holds miscellaneous stats counters
 	 */
@@ -508,18 +458,6 @@ class CoreExport InspIRCd : public classbase
 	 */
 	XLineManager* XLines;
 
-	/** A list of Module* module classes
-	 * Note that this list is always exactly 255 in size.
-	 * The actual number of loaded modules is available from GetModuleCount()
-	 */
-	ModuleList modules;
-
-	/** A list of ModuleFactory* module factories
-	 * Note that this list is always exactly 255 in size.
-	 * The actual number of loaded modules is available from GetModuleCount()
-	 */
-	FactoryList factory;
-
 	/** The time we next call our ping timeout and reg timeout checks
 	 */
 	time_t next_call;
@@ -553,7 +491,7 @@ class CoreExport InspIRCd : public classbase
 	 * @param user The user to add
 	 */
 	void AddGlobalClone(userrec* user);
-
+	
 	/** Number of users with a certain mode set on them
 	 */
 	int ModeCount(const char mode);
@@ -570,18 +508,6 @@ class CoreExport InspIRCd : public classbase
 	 */
 	caller1<void, userrec*> ProcessUser;
 
-	/** Get the total number of currently loaded modules
-	 * @return The number of loaded modules
-	 */
-	int GetModuleCount();
-
-	/** Find a module by name, and return a Module* to it.
-	 * This is preferred over iterating the module lists yourself.
-	 * @param name The module name to look up
-	 * @return A pointer to the module, or NULL if the module cannot be found
-	 */
-	Module* FindModule(const std::string &name);
-
 	/** Bind all ports specified in the configuration file.
 	 * @param bail True if the function should bail back to the shell on failure
 	 * @param found_ports The actual number of ports found in the config, as opposed to the number actually bound
@@ -669,10 +595,6 @@ class CoreExport InspIRCd : public classbase
 	 */
 	chanrec* FindChan(const char* chan);
 
-	/** Called by the constructor to load all modules from the config file.
-	 */
-	void LoadAllModules();
-
 	/** Check for a 'die' tag in the config file, and abort if found
 	 * @return Depending on the configuration, this function may never return
 	 */
@@ -789,129 +711,6 @@ class CoreExport InspIRCd : public classbase
 	 */
 	void SendError(const std::string &s);
 
-	/** For use with Module::Prioritize().
-	 * When the return value of this function is returned from
-	 * Module::Prioritize(), this specifies that the module wishes
-	 * to be ordered exactly BEFORE 'modulename'. For more information
-	 * please see Module::Prioritize().
-	 * @param modulename The module your module wants to be before in the call list
-	 * @returns a priority ID which the core uses to relocate the module in the list
-	 */
-	long PriorityBefore(const std::string &modulename);
-
-	/** For use with Module::Prioritize().
-	 * When the return value of this function is returned from
-	 * Module::Prioritize(), this specifies that the module wishes
-	 * to be ordered exactly AFTER 'modulename'. For more information please
-	 * see Module::Prioritize().
-	 * @param modulename The module your module wants to be after in the call list
-	 * @returns a priority ID which the core uses to relocate the module in the list
-	 */
-	long PriorityAfter(const std::string &modulename);
-
-	/** Publish a 'feature'.
-	 * There are two ways for a module to find another module it depends on.
-	 * Either by name, using InspIRCd::FindModule, or by feature, using this
-	 * function. A feature is an arbitary string which identifies something this
-	 * module can do. For example, if your module provides SSL support, but other
-	 * modules provide SSL support too, all the modules supporting SSL should
-	 * publish an identical 'SSL' feature. This way, any module requiring use
-	 * of SSL functions can just look up the 'SSL' feature using FindFeature,
-	 * then use the module pointer they are given.
-	 * @param FeatureName The case sensitive feature name to make available
-	 * @param Mod a pointer to your module class
-	 * @returns True on success, false if the feature is already published by
-	 * another module.
-	 */
-	bool PublishFeature(const std::string &FeatureName, Module* Mod);
-
-	/** Publish a module to an 'interface'.
-	 * Modules which implement the same interface (the same way of communicating
-	 * with other modules) can publish themselves to an interface, using this
-	 * method. When they do so, they become part of a list of related or
-	 * compatible modules, and a third module may then query for that list
-	 * and know that all modules within that list offer the same API.
-	 * A prime example of this is the hashing modules, which all accept the
-	 * same types of Request class. Consider this to be similar to PublishFeature,
-	 * except for that multiple modules may publish the same 'feature'.
-	 * @param InterfaceName The case sensitive interface name to make available
-	 * @param Mod a pointer to your module class
-	 * @returns True on success, false on failure (there are currently no failure
-	 * cases)
-	 */
-	bool PublishInterface(const std::string &InterfaceName, Module* Mod);
-
-	/** Return a pair saying how many other modules are currently using the
-	 * interfaces provided by module m.
-	 * @param m The module to count usage for
-	 * @return A pair, where the first value is the number of uses of the interface,
-	 * and the second value is the interface name being used.
-	 */
-	std::pair<int,std::string> GetInterfaceInstanceCount(Module* m);
-
-	/** Mark your module as using an interface.
-	 * If you mark your module as using an interface, then that interface
-	 * module may not unload until your module has unloaded first.
-	 * This can be used to prevent crashes by ensuring code you depend on
-	 * is always in memory while your module is active.
-	 * @param InterfaceName The interface to use
-	 */
-	void UseInterface(const std::string &InterfaceName);
-
-	/** Mark your module as finished with an interface.
-	 * If you used UseInterface() above, you should use this method when
-	 * your module is finished with the interface (usually in its destructor)
-	 * to allow the modules which implement the given interface to be unloaded.
-	 * @param InterfaceName The interface you are finished with using.
-	 */
-	void DoneWithInterface(const std::string &InterfaceName);
-
-	/** Unpublish a 'feature'.
-	 * When your module exits, it must call this method for every feature it
-	 * is providing so that the feature table is cleaned up.
-	 * @param FeatureName the feature to remove
-	 */
-	bool UnpublishFeature(const std::string &FeatureName);
-
-	/** Unpublish your module from an interface
-	 * When your module exits, it must call this method for every interface
-	 * it is part of so that the interfaces table is cleaned up. Only when
-	 * the last item is deleted from an interface does the interface get
-	 * removed.
-	 * @param InterfaceName the interface to be removed from
-	 * @param Mod The module to remove from the interface list
-	 */
-	bool UnpublishInterface(const std::string &InterfaceName, Module* Mod);
-
-	/** Find a 'feature'.
-	 * There are two ways for a module to find another module it depends on.
-	 * Either by name, using InspIRCd::FindModule, or by feature, using the
-	 * InspIRCd::PublishFeature method. A feature is an arbitary string which
-	 * identifies something this module can do. For example, if your module
-	 * provides SSL support, but other modules provide SSL support too, all
-	 * the modules supporting SSL should publish an identical 'SSL' feature.
-	 * To find a module capable of providing the feature you want, simply
-	 * call this method with the feature name you are looking for.
-	 * @param FeatureName The feature name you wish to obtain the module for
-	 * @returns A pointer to a valid module class on success, NULL on failure.
-	 */
-	Module* FindFeature(const std::string &FeatureName);
-
-	/** Find an 'interface'.
-	 * An interface is a list of modules which all implement the same API.
-	 * @param InterfaceName The Interface you wish to obtain the module
-	 * list of.
-	 * @return A pointer to a deque of Module*, or NULL if the interface
-	 * does not exist.
-	 */
-	modulelist* FindInterface(const std::string &InterfaceName);
-
-	/** Given a pointer to a Module, return its filename
-	 * @param m The module pointer to identify
-	 * @return The module name or an empty string
-	 */
-	const std::string& GetModuleName(Module* m);
-
 	/** Return true if a nickname is valid
 	 * @param n A nickname to verify
 	 * @return True if the nick is valid
@@ -1168,23 +967,6 @@ class CoreExport InspIRCd : public classbase
 	 */
 	void WritePID(const std::string &filename);
 
-	/** Returns text describing the last module error
-	 * @return The last error message to occur
-	 */
-	char* ModuleError();
-
-	/** Load a given module file
-	 * @param filename The file to load
-	 * @return True if the module was found and loaded
-	 */
-	bool LoadModule(const char* filename);
-
-	/** Unload a given module file
-	 * @param filename The file to unload
-	 * @return True if the module was unloaded
-	 */
-	bool UnloadModule(const char* filename);
-
 	/** This constructor initialises all the subsystems and reads the config file.
 	 * @param argc The argument count passed to main()
 	 * @param argv The argument list passed to main()
@@ -1289,4 +1071,3 @@ class CoreExport InspIRCd : public classbase
 };
 
 #endif
-
diff --git a/include/modules.h b/include/modules.h
index e5596430f..03b15f5ae 100644
--- a/include/modules.h
+++ b/include/modules.h
@@ -122,11 +122,11 @@ typedef std::map<std::string, std::pair<int, modulelist> > interfacelist;
  * 'FOREACH_MOD(I_OnConnect,OnConnect(user));'
  */
 #define FOREACH_MOD(y,x) if (ServerInstance->Config->global_implementation[y] > 0) { \
-	for (int _i = 0; _i <= ServerInstance->GetModuleCount(); _i++) { \
+	for (int _i = 0; _i <= ServerInstance->Modules->GetCount(); _i++) { \
 	if (ServerInstance->Config->implement_lists[_i][y]) \
 		try \
 		{ \
-			ServerInstance->modules[_i]->x ; \
+			ServerInstance->Modules->modules[_i]->x ; \
 		} \
 		catch (CoreException& modexcept) \
 		{ \
@@ -142,11 +142,11 @@ typedef std::map<std::string, std::pair<int, modulelist> > interfacelist;
  * 'FOREACH_MOD_I(Instance, OnConnect, OnConnect(user));'
  */
 #define FOREACH_MOD_I(z,y,x) if (z->Config->global_implementation[y] > 0) { \
-	for (int _i = 0; _i <= z->GetModuleCount(); _i++) { \
+	for (int _i = 0; _i <= z->Modules->GetCount(); _i++) { \
 		if (z->Config->implement_lists[_i][y]) \
 		try \
 		{ \
-			z->modules[_i]->x ; \
+			z->Modules->modules[_i]->x ; \
 		} \
 		catch (CoreException& modexcept) \
 		{ \
@@ -161,11 +161,11 @@ typedef std::map<std::string, std::pair<int, modulelist> > interfacelist;
  */
 #define FOREACH_RESULT(y,x) { if (ServerInstance->Config->global_implementation[y] > 0) { \
 			MOD_RESULT = 0; \
-			for (int _i = 0; _i <= ServerInstance->GetModuleCount(); _i++) { \
+			for (int _i = 0; _i <= ServerInstance->Modules->GetCount(); _i++) { \
 			if (ServerInstance->Config->implement_lists[_i][y]) { \
 				try \
 				{ \
-					int res = ServerInstance->modules[_i]->x ; \
+					int res = ServerInstance->Modules->modules[_i]->x ; \
 					if (res != 0) { \
 						MOD_RESULT = res; \
 						break; \
@@ -187,11 +187,11 @@ typedef std::map<std::string, std::pair<int, modulelist> > interfacelist;
  */
 #define FOREACH_RESULT_I(z,y,x) { if (z->Config->global_implementation[y] > 0) { \
 			MOD_RESULT = 0; \
-			for (int _i = 0; _i <= z->GetModuleCount(); _i++) { \
+			for (int _i = 0; _i <= z->Modules->GetCount(); _i++) { \
 			if (z->Config->implement_lists[_i][y]) { \
 				try \
 				{ \
-					int res = z->modules[_i]->x ; \
+					int res = z->Modules->modules[_i]->x ; \
 					if (res != 0) { \
 						MOD_RESULT = res; \
 						break; \
@@ -1587,9 +1587,252 @@ typedef DLLFactory<Module> ircd_module;
  */
 typedef std::vector<Module*> ModuleList;
 
-/** A list of loaded ModuleFactories
+/** A list of loaded module handles (ircd_module)
  */
-typedef std::vector<ircd_module*> FactoryList;
+typedef std::vector<ircd_module*> ModuleHandleList;
+
+/** ModuleManager takes care of all things module-related
+ * in the core.
+ */
+class CoreExport ModuleManager : public classbase
+{
+ private:
+	/** Holds a string describing the last module error to occur
+	 */
+	char MODERR[MAXBUF];
+ 
+ 	/** The feature names published by various modules
+	 */
+	featurelist Features;
+
+	/** The interface names published by various modules
+	 */
+	interfacelist Interfaces;
+ 
+	/** Total number of modules loaded into the ircd, minus one
+	 */
+	int ModCount; 
+	
+	/** Our pointer to the main insp instance
+	 */
+	InspIRCd* Instance;
+
+ public:
+	/** A list of ircd_module* module handles
+	 * Note that this list is always exactly 255 in size.
+	 * The actual number of loaded modules is available from GetModuleCount()
+	 */
+	ModuleHandleList handles;
+ 
+  	/** A list of Module* module classes
+	 * Note that this list is always exactly 255 in size.
+	 * The actual number of loaded modules is available from GetModuleCount()
+	 */
+	ModuleList modules;	 
+ 
+	ModuleManager(InspIRCd* Ins);
+
+	~ModuleManager(); 
+ 
+	/** Returns text describing the last module error
+	 * @return The last error message to occur
+	 */
+	const char* LastError();
+
+	/** Load a given module file
+	 * @param filename The file to load
+	 * @return True if the module was found and loaded
+	 */
+	bool Load(const char* filename);
+
+	/** Unload a given module file
+	 * @param filename The file to unload
+	 * @return True if the module was unloaded
+	 */
+	bool Unload(const char* filename);
+	
+	/** Called by the InspIRCd constructor to load all modules from the config file.
+	 */
+	void LoadAll();
+	
+	/** Get the total number of currently loaded modules
+	 * @return The number of loaded modules
+	 */
+	int GetCount()
+	{
+		return this->ModCount;
+	}
+	
+	/** Find a module by name, and return a Module* to it.
+	 * This is preferred over iterating the module lists yourself.
+	 * @param name The module name to look up
+	 * @return A pointer to the module, or NULL if the module cannot be found
+	 */
+	Module* Find(const std::string &name);
+ 
+	/** Remove a module handle pointer
+	 * @param j Index number of the module handle to remove
+	 * @return True if a handle existed at the given index, false otherwise
+	 */
+	bool EraseHandle(unsigned int j);
+
+	/** Remove a Module pointer
+	 * @param j Index number of the Module to remove
+	 * @return True if a handle existed at the given index, false otherwise
+	 */
+	bool EraseModule(unsigned int j);
+
+	/** Move a given module to a specific slot in the list
+	 * @param modulename The module name to relocate
+	 * @param slot The slot to move the module into
+	 */
+	void MoveTo(std::string modulename,int slot);
+
+	/** Moves the given module to the last slot in the list
+	 * @param modulename The module name to relocate
+	 */
+	void MoveToLast(std::string modulename);
+
+	/** Moves the given module to the first slot in the list
+	 * @param modulename The module name to relocate
+	 */
+	void MoveToFirst(std::string modulename);
+
+	/** Moves one module to be placed after another in the list
+	 * @param modulename The module name to relocate
+	 * @param after The module name to place the module after
+	 */
+	void MoveAfter(std::string modulename, std::string after);
+
+	/** Moves one module to be placed before another in the list
+	 * @param modulename The module name to relocate
+	 * @param after The module name to place the module before
+	 */
+	void MoveBefore(std::string modulename, std::string before);
+	
+	/** For use with Module::Prioritize().
+	 * When the return value of this function is returned from
+	 * Module::Prioritize(), this specifies that the module wishes
+	 * to be ordered exactly BEFORE 'modulename'. For more information
+	 * please see Module::Prioritize().
+	 * @param modulename The module your module wants to be before in the call list
+	 * @returns a priority ID which the core uses to relocate the module in the list
+	 */
+	long PriorityBefore(const std::string &modulename);
+
+	/** For use with Module::Prioritize().
+	 * When the return value of this function is returned from
+	 * Module::Prioritize(), this specifies that the module wishes
+	 * to be ordered exactly AFTER 'modulename'. For more information please
+	 * see Module::Prioritize().
+	 * @param modulename The module your module wants to be after in the call list
+	 * @returns a priority ID which the core uses to relocate the module in the list
+	 */
+	long PriorityAfter(const std::string &modulename);
+
+	/** Publish a 'feature'.
+	 * There are two ways for a module to find another module it depends on.
+	 * Either by name, using InspIRCd::FindModule, or by feature, using this
+	 * function. A feature is an arbitary string which identifies something this
+	 * module can do. For example, if your module provides SSL support, but other
+	 * modules provide SSL support too, all the modules supporting SSL should
+	 * publish an identical 'SSL' feature. This way, any module requiring use
+	 * of SSL functions can just look up the 'SSL' feature using FindFeature,
+	 * then use the module pointer they are given.
+	 * @param FeatureName The case sensitive feature name to make available
+	 * @param Mod a pointer to your module class
+	 * @returns True on success, false if the feature is already published by
+	 * another module.
+	 */
+	bool PublishFeature(const std::string &FeatureName, Module* Mod);
+
+	/** Publish a module to an 'interface'.
+	 * Modules which implement the same interface (the same way of communicating
+	 * with other modules) can publish themselves to an interface, using this
+	 * method. When they do so, they become part of a list of related or
+	 * compatible modules, and a third module may then query for that list
+	 * and know that all modules within that list offer the same API.
+	 * A prime example of this is the hashing modules, which all accept the
+	 * same types of Request class. Consider this to be similar to PublishFeature,
+	 * except for that multiple modules may publish the same 'feature'.
+	 * @param InterfaceName The case sensitive interface name to make available
+	 * @param Mod a pointer to your module class
+	 * @returns True on success, false on failure (there are currently no failure
+	 * cases)
+	 */
+	bool PublishInterface(const std::string &InterfaceName, Module* Mod);
+
+	/** Return a pair saying how many other modules are currently using the
+	 * interfaces provided by module m.
+	 * @param m The module to count usage for
+	 * @return A pair, where the first value is the number of uses of the interface,
+	 * and the second value is the interface name being used.
+	 */
+	std::pair<int,std::string> GetInterfaceInstanceCount(Module* m);
+
+	/** Mark your module as using an interface.
+	 * If you mark your module as using an interface, then that interface
+	 * module may not unload until your module has unloaded first.
+	 * This can be used to prevent crashes by ensuring code you depend on
+	 * is always in memory while your module is active.
+	 * @param InterfaceName The interface to use
+	 */
+	void UseInterface(const std::string &InterfaceName);
+
+	/** Mark your module as finished with an interface.
+	 * If you used UseInterface() above, you should use this method when
+	 * your module is finished with the interface (usually in its destructor)
+	 * to allow the modules which implement the given interface to be unloaded.
+	 * @param InterfaceName The interface you are finished with using.
+	 */
+	void DoneWithInterface(const std::string &InterfaceName);
+
+	/** Unpublish a 'feature'.
+	 * When your module exits, it must call this method for every feature it
+	 * is providing so that the feature table is cleaned up.
+	 * @param FeatureName the feature to remove
+	 */
+	bool UnpublishFeature(const std::string &FeatureName);
+
+	/** Unpublish your module from an interface
+	 * When your module exits, it must call this method for every interface
+	 * it is part of so that the interfaces table is cleaned up. Only when
+	 * the last item is deleted from an interface does the interface get
+	 * removed.
+	 * @param InterfaceName the interface to be removed from
+	 * @param Mod The module to remove from the interface list
+	 */
+	bool UnpublishInterface(const std::string &InterfaceName, Module* Mod);
+
+	/** Find a 'feature'.
+	 * There are two ways for a module to find another module it depends on.
+	 * Either by name, using InspIRCd::FindModule, or by feature, using the
+	 * InspIRCd::PublishFeature method. A feature is an arbitary string which
+	 * identifies something this module can do. For example, if your module
+	 * provides SSL support, but other modules provide SSL support too, all
+	 * the modules supporting SSL should publish an identical 'SSL' feature.
+	 * To find a module capable of providing the feature you want, simply
+	 * call this method with the feature name you are looking for.
+	 * @param FeatureName The feature name you wish to obtain the module for
+	 * @returns A pointer to a valid module class on success, NULL on failure.
+	 */
+	Module* FindFeature(const std::string &FeatureName);
+
+	/** Find an 'interface'.
+	 * An interface is a list of modules which all implement the same API.
+	 * @param InterfaceName The Interface you wish to obtain the module
+	 * list of.
+	 * @return A pointer to a deque of Module*, or NULL if the interface
+	 * does not exist.
+	 */
+	modulelist* FindInterface(const std::string &InterfaceName);
+
+	/** Given a pointer to a Module, return its filename
+	 * @param m The module pointer to identify
+	 * @return The module name or an empty string
+	 */
+	const std::string& GetModuleName(Module* m);
+};
 
 /** This definition is used as shorthand for the various classes
  * and functions needed to make a module loadable by the OS.