New event system

39 files changed, 1845 insertions, 1200 deletions

diff --git a/include/base.h b/include/base.h
index a28695c5f..ad2b3cee6 100644
--- a/include/base.h
+++ b/include/base.h
@@ -32,13 +32,14 @@ class CoreExport Base
 
 class ReferenceBase
 {
- protected:
-	bool invalid;
+	static std::set<ReferenceBase *> *references;
  public:
-	ReferenceBase() : invalid(false) { }
-	ReferenceBase(const ReferenceBase &other) : invalid(other.invalid) { }
-	virtual ~ReferenceBase() { }
-	inline void Invalidate() { this->invalid = true; }
+	static void ResetAll();
+
+	ReferenceBase();
+	virtual ~ReferenceBase();
+	virtual void Invalidate() anope_abstract;
+	virtual void Reset() { }
 };
 
 /** Used to hold pointers to objects that may be deleted. A Reference will
@@ -49,8 +50,11 @@ class Reference : public ReferenceBase
 {
  protected:
 	T *ref;
+
+	virtual void Check() { }
+
  public:
- 	Reference() : ref(NULL)
+ 	Reference() : ref(nullptr)
 	{
 	}
 
@@ -60,19 +64,24 @@ class Reference : public ReferenceBase
 			ref->AddReference(this);
 	}
 
-	Reference(const Reference<T> &other) : ReferenceBase(other), ref(other.ref)
+	Reference(const Reference<T> &other) : ref(other.ref)
 	{
-		if (operator bool())
+		if (ref)
 			ref->AddReference(this);
 	}
 
 	virtual ~Reference()
 	{
-		if (operator bool())
-			ref->DelReference(this);
+		if (*this)
+			this->ref->DelReference(this);
 	}
 
-	inline Reference<T>& operator=(const Reference<T> &other)
+	void Invalidate() override
+	{
+		ref = nullptr;
+	}
+
+	Reference<T>& operator=(const Reference<T> &other)
 	{
 		if (this != &other)
 		{
@@ -80,7 +89,6 @@ class Reference : public ReferenceBase
 				this->ref->DelReference(this);
 
 			this->ref = other.ref;
-			this->invalid = other.invalid;
 
 			if (*this)
 				this->ref->AddReference(this);
@@ -88,36 +96,31 @@ class Reference : public ReferenceBase
 		return *this;
 	}
 
-	/* We explicitly call operator bool here in several places to prevent other
-	 * operators, such operator T*, from being called instead, which will mess
-	 * with any class inheriting from this that overloads this operator.
-	 */
-	virtual operator bool()
+	explicit operator bool()
 	{
-		if (!this->invalid)
-			return this->ref != NULL;
-		return false;
+		Check();
+		return this->ref != nullptr;
 	}
 
-	inline operator T*()
+	operator T*()
 	{
-		if (operator bool())
+		if (*this)
 			return this->ref;
-		return NULL;
+		return nullptr;
 	}
 
-	inline T* operator->()
+	T* operator->()
 	{
-		if (operator bool())
+		if (*this)
 			return this->ref;
-		return NULL;
+		return nullptr;
 	}
 
-	inline T* operator*()
+	T* operator*()
 	{
-		if (operator bool())
+		if (*this)
 			return this->ref;
-		return NULL;
+		return nullptr;
 	}
 
 	/** Note that we can't have an operator< that returns this->ref < other.ref
@@ -132,9 +135,9 @@ class Reference : public ReferenceBase
 	 * actually referred to.
 	 */
 
-	inline bool operator==(const Reference<T> &other)
+	bool operator==(const Reference<T> &other)
 	{
-		if (!this->invalid)
+		if (*this)
 			return this->ref == other;
 		return false;
 	}
diff --git a/include/defs.h b/include/defs.h
index 3d8ebf4ff..b53e512d6 100644
--- a/include/defs.h
+++ b/include/defs.h
@@ -14,7 +14,6 @@
 class AccessGroup;
 class AutoKick;
 class BotInfo;
-class CallBack;
 class ChanAccess;
 class Channel;
 class ChannelInfo;
@@ -25,7 +24,6 @@ class Command;
 class CommandSource;
 namespace Configuration { struct Conf; }
 class ConnectionSocket;
-namespace DNS { struct Query; }
 class Entry;
 class IdentifyRequest;
 class InfoFormatter;
diff --git a/include/event.h b/include/event.h
new file mode 100644
index 000000000..b55559b48
--- /dev/null
+++ b/include/event.h
@@ -0,0 +1,1018 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+#pragma once
+
+#include "service.h"
+#include "modules.h"
+
+struct Events
+{
+	virtual ~Events() { }
+};
+
+/* uninstantiated */
+template<typename EventHandler, typename Func, typename Return, typename... Args>
+struct Caller;
+
+/* specialization for void */
+template<typename EventHandler, typename Func, typename... Args>
+struct Caller<EventHandler, Func, void, Args...>
+{
+	void operator()(const std::vector<EventHandler *> &handlers, Func func, Args&&... args)
+	{
+		for (EventHandler *eh : handlers)
+			(eh->*func)(std::forward<Args>(args)...);
+	}
+};
+
+/* specialization for EventReturn */
+template<typename EventHandler, typename Func, typename... Args>
+struct Caller<EventHandler, Func, EventReturn, Args...>
+{
+	EventReturn operator()(const std::vector<EventHandler *> &handlers, Func func, Args&&... args)
+	{
+		EventReturn ret = EVENT_CONTINUE;
+
+		for (EventHandler *eh : handlers)
+		{
+			ret = (eh->*func)(std::forward<Args>(args)...);
+			if (ret != EVENT_CONTINUE)
+				return ret;
+		}
+
+		return ret;
+	}
+};
+
+template<typename EventHandler>
+class EventHook;
+
+template<typename EventHandler>
+class EventHandlers : public Service
+{
+	std::vector<EventHandler *> handlers;
+	friend class EventHook<EventHandler>;
+
+ public:
+	EventHandlers(Module *o, const Anope::string &ename) : Service(o, "EventHandlers", ename)
+	{
+	}
+
+	template<typename Func, typename... Args>
+	auto operator()(Func func, Args&&... args) -> decltype(((static_cast<EventHandler*>(nullptr))->*func)(args...))
+	{
+		return Caller<EventHandler, Func, decltype(((static_cast<EventHandler*>(nullptr))->*func)(args...)), Args...>()(this->handlers, func, std::forward<Args>(args)...);
+	}
+};
+
+template<typename EventHandler>
+class EventHandlersReference
+{
+	ServiceReference<EventHandlers<EventHandler>> ref;
+ public:
+	EventHandlersReference(const Anope::string &name) : ref("EventHandlers", name) { }
+
+	explicit operator bool()
+	{
+		return !!ref;
+	}
+
+	template<typename Func, typename... Args>
+	auto operator()(Func func, Args&&... args) -> decltype(((static_cast<EventHandler*>(nullptr))->*func)(args...))
+	{
+		return (**ref)(func, std::forward<Args>(args)...);
+	}
+};
+
+template<typename EventHandler>
+class EventHook : public EventHandler
+{
+
+	struct ServiceReferenceListener : ServiceReference<EventHandlers<EventHandler>>
+	{
+		EventHook<EventHandler> *eh;
+
+		ServiceReferenceListener(EventHook<EventHandler> *t, const Anope::string &sname) : ServiceReference<EventHandlers<EventHandler>>("EventHandlers", sname), eh(t)
+		{
+		}
+
+		void OnAcquire() override
+		{
+			if (std::find((*this)->handlers.begin(), (*this)->handlers.end(), eh) == (*this)->handlers.end())
+			{
+				if (eh->priority == Priority::LAST)
+					(*this)->handlers.push_back(eh);
+				else
+					(*this)->handlers.insert((*this)->handlers.begin(), eh);
+			}
+		}
+	} handlers;
+
+ public:
+	enum class Priority
+	{
+		FIRST,
+		LAST
+	}
+	priority;
+
+	EventHook(const Anope::string &name, Priority p = Priority::LAST) : handlers(this, name)
+	{
+		handlers.Check();
+	}
+
+	~EventHook()
+	{
+		if (!handlers)
+			return;
+
+		auto it = std::find(handlers->handlers.begin(), handlers->handlers.end(), this);
+		if (it != handlers->handlers.end())
+			handlers->handlers.erase(it);
+	}
+};
+
+namespace Event
+{
+	struct CoreExport PreUserKicked : Events
+	{
+		/** Called before a user has been kicked from a channel.
+		 * @param source The kicker
+		 * @param cu The user, channel, and status of the user being kicked
+		 * @param kickmsg The reason for the kick.
+		 */
+		virtual void OnPreUserKicked(const MessageSource &source, ChanUserContainer *cu, const Anope::string &kickmsg) anope_abstract;
+	};
+	extern CoreExport EventHandlers<PreUserKicked> OnPreUserKicked;
+
+	struct CoreExport UserKicked : Events
+	{
+		/** Called when a user has been kicked from a channel.
+		 * @param source The kicker
+		 * @param target The user being kicked
+		 * @param channel The channel the user was kicked from, which may no longer exist
+		 * @param status The status the kicked user had on the channel before they were kicked
+		 * @param kickmsg The reason for the kick.
+		 */
+		virtual void OnUserKicked(const MessageSource &source, User *target, const Anope::string &channel, ChannelStatus &status, const Anope::string &kickmsg) anope_abstract;
+	};
+	extern CoreExport EventHandlers<UserKicked> OnUserKicked;
+
+	struct CoreExport PreBotAssign : Events
+	{
+		/** Called before a bot is assigned to a channel.
+		 * @param sender The user assigning the bot
+		 * @param ci The channel the bot is to be assigned to.
+		 * @param bi The bot being assigned.
+		 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to deny the assign.
+		 */
+		virtual EventReturn OnPreBotAssign(User *sender, ChannelInfo *ci, BotInfo *bi) anope_abstract;
+	};
+	extern CoreExport EventHandlers<PreBotAssign> OnPreBotAssign;
+
+	struct CoreExport BotAssign : Events
+	{
+		/** Called when a bot is assigned ot a channel
+		 */
+		virtual void OnBotAssign(User *sender, ChannelInfo *ci, BotInfo *bi) anope_abstract;
+	};
+	extern CoreExport EventHandlers<BotAssign> OnBotAssign;
+
+	struct CoreExport BotUnAssign : Events
+	{
+		/** Called before a bot is unassigned from a channel.
+		 * @param sender The user unassigning the bot
+		 * @param ci The channel the bot is being removed from
+		 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to deny the unassign.
+		 */
+		virtual EventReturn OnBotUnAssign(User *sender, ChannelInfo *ci) anope_abstract;
+	};
+	extern CoreExport EventHandlers<BotUnAssign> OnBotUnAssign;
+
+	struct CoreExport UserConnect : Events
+	{
+		/** Called when a new user connects to the network.
+		 * @param u The connecting user.
+		 * @param exempt set to true/is true if the user should be excepted from bans etc
+		 */
+		virtual void OnUserConnect(User *u, bool &exempt) anope_abstract;
+	};
+	extern CoreExport EventHandlers<UserConnect> OnUserConnect;
+
+	struct CoreExport NewServer : Events
+	{
+		/** Called when a new server connects to the network.
+		 * @param s The server that has connected to the network
+		 */
+		virtual void OnNewServer(Server *s) anope_abstract;
+	};
+	extern CoreExport EventHandlers<NewServer> OnNewServer;
+
+	struct CoreExport UserNickChange : Events
+	{
+		/** Called after a user changed the nick
+		 * @param u The user.
+		 * @param oldnick The old nick of the user
+		 */
+		virtual void OnUserNickChange(User *u, const Anope::string &oldnick) anope_abstract;
+	};
+	extern CoreExport EventHandlers<UserNickChange> OnUserNickChange;
+
+
+	struct CoreExport PreCommand : Events
+	{
+		/** Called before a command is due to be executed.
+		 * @param source The source of the command
+		 * @param command The command the user is executing
+		 * @param params The parameters the user is sending
+		 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to halt the command and not process it
+		 */
+		virtual EventReturn OnPreCommand(CommandSource &source, Command *command, std::vector<Anope::string> &params) anope_abstract;
+	};
+	extern CoreExport EventHandlers<PreCommand> OnPreCommand;
+
+	struct CoreExport PostCommand : Events
+	{
+		/** Called after a command has been executed.
+		 * @param source The source of the command
+		 * @param command The command the user executed
+		 * @param params The parameters the user sent
+		 */
+		virtual void OnPostCommand(CommandSource &source, Command *command, const std::vector<Anope::string> &params) anope_abstract;
+	};
+	extern CoreExport EventHandlers<PostCommand> OnPostCommand;
+
+	struct CoreExport SaveDatabase : Events
+	{
+		/** Called when the databases are saved
+		 */
+		virtual void OnSaveDatabase() anope_abstract;
+	};
+	extern CoreExport EventHandlers<SaveDatabase> OnSaveDatabase;
+
+	struct CoreExport LoadDatabase : Events
+	{
+		/** Called when the databases are loaded
+		 * @return EVENT_CONTINUE to let other modules continue loading, EVENT_STOP to stop
+		 */
+		virtual EventReturn OnLoadDatabase() anope_abstract;
+	};
+	extern CoreExport EventHandlers<LoadDatabase> OnLoadDatabase;
+
+	struct CoreExport Encrypt : Events
+	{
+		/** Called when anope needs to check passwords against encryption
+		 *  see src/encrypt.c for detailed informations
+		 */
+		virtual EventReturn OnEncrypt(const Anope::string &src, Anope::string &dest) anope_abstract;
+	};
+	extern CoreExport EventHandlers<Encrypt> OnEncrypt;
+
+	struct CoreExport Decrypt : Events
+	{
+		virtual EventReturn OnDecrypt(const Anope::string &hashm, const Anope::string &src, Anope::string &dest) anope_abstract;
+	};
+	extern CoreExport EventHandlers<Decrypt> OnDecrypt;
+
+
+
+	struct CoreExport CreateBot : Events
+	{
+		/** Called when a bot is created or destroyed
+		 */
+		virtual void OnCreateBot(BotInfo *bi) anope_abstract;
+	};
+	extern CoreExport EventHandlers<CreateBot> OnCreateBot;
+
+	struct CoreExport DelBot : Events
+	{
+		virtual void OnDelBot(BotInfo *bi) anope_abstract;
+	};
+	extern CoreExport EventHandlers<DelBot> OnDelBot;
+
+	struct CoreExport BotKick : Events
+	{
+		/** Called before a bot kicks a user
+		 * @param bi The bot sending the kick
+		 * @param c The channel the user is being kicked on
+		 * @param u The user being kicked
+		 * @param reason The reason
+		 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to halt the command and not process it
+		 */
+		virtual EventReturn OnBotKick(BotInfo *bi, Channel *c, User *u, const Anope::string &reason) anope_abstract;
+	};
+	extern CoreExport EventHandlers<BotKick> OnBotKick;
+
+	struct CoreExport PrePartChannel : Events
+	{
+		/** Called before a user parts a channel
+		 * @param u The user
+		 * @param c The channel
+		 */
+		virtual void OnPrePartChannel(User *u, Channel *c) anope_abstract;
+	};
+	extern CoreExport EventHandlers<PrePartChannel> OnPrePartChannel;
+
+	struct CoreExport PartChannel : Events
+	{
+		/** Called when a user parts a channel
+		 * @param u The user
+		 * @param c The channel, may be NULL if the channel no longer exists
+		 * @param channel The channel name
+		 * @param msg The part reason
+		 */
+		virtual void OnPartChannel(User *u, Channel *c, const Anope::string &channel, const Anope::string &msg) anope_abstract;
+	};
+	extern CoreExport EventHandlers<PartChannel> OnPartChannel;
+
+	struct CoreExport LeaveChannel : Events
+	{
+		/** Called when a user leaves a channel.
+		 * From either parting, being kicked, or quitting/killed!
+		 * @param u The user
+		 * @param c The channel
+		 */
+		virtual void OnLeaveChannel(User *u, Channel *c) anope_abstract;
+	};
+	extern CoreExport EventHandlers<LeaveChannel> OnLeaveChannel;
+
+	struct CoreExport JoinChannel : Events
+	{
+		/** Called after a user joins a channel
+		 * If this event triggers the user is allowed to be in the channel, and will
+		 * not be kicked for restricted/akick/forbidden, etc. If you want to kick the user,
+		 * use the CheckKick event instead.
+		 * @param u The user
+		 * @param channel The channel
+		 */
+		virtual void OnJoinChannel(User *u, Channel *c) anope_abstract;
+	};
+	extern CoreExport EventHandlers<JoinChannel> OnJoinChannel;
+
+	struct CoreExport TopicUpdated : Events
+	{
+		/** Called when a new topic is set
+		 * @param c The channel
+		 * @param setter The user who set the new topic
+		 * @param topic The new topic
+		 */
+		virtual void OnTopicUpdated(Channel *c, const Anope::string &user, const Anope::string &topic) anope_abstract;
+	};
+	extern CoreExport EventHandlers<TopicUpdated> OnTopicUpdated;
+
+	struct CoreExport PreServerConnect : Events
+	{
+		/** Called before Anope connecs to its uplink
+		 */
+		virtual void OnPreServerConnect() anope_abstract;
+	};
+	extern CoreExport EventHandlers<PreServerConnect> OnPreServerConnect;
+
+	struct CoreExport ServerConnect : Events
+	{
+		/** Called when Anope connects to its uplink
+		 */
+		virtual void OnServerConnect() anope_abstract;
+	};
+	extern CoreExport EventHandlers<ServerConnect> OnServerConnect;
+
+	struct CoreExport PreUplinkSync : Events
+	{
+		/** Called when we are almost done synching with the uplink, just before we send the EOB
+		 */
+		virtual void OnPreUplinkSync(Server *serv) anope_abstract;
+	};
+	extern CoreExport EventHandlers<PreUplinkSync> OnPreUplinkSync;
+
+	struct CoreExport ServerDisconnect : Events
+	{
+		/** Called when Anope disconnects from its uplink, before it tries to reconnect
+		 */
+		virtual void OnServerDisconnect() anope_abstract;
+	};
+	extern CoreExport EventHandlers<ServerDisconnect> OnServerDisconnect;
+
+	struct CoreExport Restart : Events
+	{
+		/** Called when services restart
+		*/
+		virtual void OnRestart() anope_abstract;
+	};
+	extern CoreExport EventHandlers<Restart> OnRestart;
+
+	struct CoreExport Shutdown : Events
+	{
+		/** Called when services shutdown
+		 */
+		virtual void OnShutdown() anope_abstract;
+	};
+	extern CoreExport EventHandlers<Shutdown> OnShutdown;
+
+	struct CoreExport AddXLine : Events
+	{
+		/** Called before a XLine is added
+		 * @param source The source of the XLine
+		 * @param x The XLine
+		 * @param xlm The xline manager it was added to
+		 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to halt the command and not process it
+		 */
+		virtual EventReturn OnAddXLine(CommandSource &source, const XLine *x, XLineManager *xlm) anope_abstract;
+	};
+	extern CoreExport EventHandlers<AddXLine> OnAddXLine;
+
+	struct CoreExport DelXLine : Events
+	{
+		/** Called before a XLine is deleted
+		 * @param source The source of the XLine
+		 * @param x The XLine
+		 * @param xlm The xline manager it was deleted from
+		 */
+		virtual void OnDelXLine(CommandSource &source, const XLine *x, XLineManager *xlm) anope_abstract;
+	};
+	extern CoreExport EventHandlers<DelXLine> OnDelXLine;
+
+	struct CoreExport IsServicesOperEvent : Events
+	{
+		/** Called when a user is checked for whether they are a services oper
+		 * @param u The user
+		 * @return EVENT_ALLOW to allow, anything else to deny
+		 */
+		virtual EventReturn IsServicesOper(User *u) anope_abstract;
+	};
+	extern CoreExport EventHandlers<IsServicesOperEvent> OnIsServicesOper;
+
+	struct CoreExport ServerQuit : Events
+	{
+		/** Called when a server quits
+		 * @param server The server
+		 */
+		virtual void OnServerQuit(Server *server) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ServerQuit> OnServerQuit;
+
+	struct CoreExport UserQuit : Events
+	{
+		/** Called when a user quits, or is killed
+		 * @param u The user
+		 * @param msg The quit message
+		 */
+		virtual void OnUserQuit(User *u, const Anope::string &msg) anope_abstract;
+	};
+	extern CoreExport EventHandlers<UserQuit> OnUserQuit;
+
+	struct CoreExport PreUserLogoff : Events
+	{
+		/** Called when a user is quit, before and after being internally removed from
+		 * This is different from OnUserQuit, which takes place at the time of the quit.
+		 * This happens shortly after when all message processing is finished.
+		 * all lists (channels, user list, etc)
+		 * @param u The user
+		 */
+		virtual void OnPreUserLogoff(User *u) anope_abstract;
+	};
+	extern CoreExport EventHandlers<PreUserLogoff> OnPreUserLogoff;
+
+	struct CoreExport PostUserLogoff : Events
+	{
+		virtual void OnPostUserLogoff(User *u) anope_abstract;
+	};
+	extern CoreExport EventHandlers<PostUserLogoff> OnPostUserLogoff;
+
+	struct CoreExport AccessDel : Events
+	{
+		/** Called after an access entry is deleted from a channel
+		 * @param ci The channel
+		 * @param source The source of the command
+		 * @param access The access entry that was removed
+		 */
+		virtual void OnAccessDel(ChannelInfo *ci, CommandSource &source, ChanAccess *access) anope_abstract;
+	};
+	extern CoreExport EventHandlers<AccessDel> OnAccessDel;
+
+	struct CoreExport AccessAdd : Events
+	{
+		/** Called when access is added
+		 * @param ci The channel
+		 * @param source The source of the command
+		 * @param access The access changed
+		 */
+		virtual void OnAccessAdd(ChannelInfo *ci, CommandSource &source, ChanAccess *access) anope_abstract;
+	};
+	extern CoreExport EventHandlers<AccessAdd> OnAccessAdd;
+
+	struct CoreExport AccessClear : Events
+	{
+		/** Called when the access list is cleared
+		 * @param ci The channel
+		 * @param u The user who cleared the access
+		 */
+		virtual void OnAccessClear(ChannelInfo *ci, CommandSource &source) anope_abstract;
+	};
+	extern CoreExport EventHandlers<AccessClear> OnAccessClear;
+
+	struct CoreExport ChanRegistered : Events
+	{
+		/** Called when a channel is registered
+		 * @param ci The channel
+		 */
+		virtual void OnChanRegistered(ChannelInfo *ci) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ChanRegistered> OnChanRegistered;
+
+
+	struct CoreExport CreateChan : Events
+	{
+		/** Called when a channel is being created, for any reason
+		 * @param ci The channel
+		 */
+		virtual void OnCreateChan(ChannelInfo *ci) anope_abstract;
+	};
+	extern CoreExport EventHandlers<CreateChan> OnCreateChan;
+
+	struct CoreExport DelChan : Events
+	{
+		/** Called when a channel is being deleted, for any reason
+		 * @param ci The channel
+		 */
+		virtual void OnDelChan(ChannelInfo *ci) anope_abstract;
+	};
+	extern CoreExport EventHandlers<DelChan> OnDelChan;
+
+	struct CoreExport ChannelCreate : Events
+	{
+		/** Called when a new channel is created
+		 * Note that this channel may not be introduced to the uplink at this point.
+		 * @param c The channel
+		 */
+		virtual void OnChannelCreate(Channel *c) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ChannelCreate> OnChannelCreate;
+
+	struct CoreExport ChannelDelete : Events
+	{
+		/** Called when a channel is deleted
+		 * @param c The channel
+		 */
+		virtual void OnChannelDelete(Channel *c) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ChannelDelete> OnChannelDelete;
+
+
+	struct CoreExport CheckKick : Events
+	{
+		/** Called after a user join a channel when we decide whether to kick them or not
+		 * @param u The user
+		 * @param c The channel
+		 * @param kick Set to true to kick
+		 * @param mask The mask to ban, if any
+		 * @param reason The reason for the kick
+		 * @return EVENT_STOP to prevent the user from joining by kicking/banning the user
+		 */
+		virtual EventReturn OnCheckKick(User *u, Channel *c, Anope::string &mask, Anope::string &reason) anope_abstract;
+	};
+	extern CoreExport EventHandlers<CheckKick> OnCheckKick;
+
+	struct CoreExport CheckPriv : Events
+	{
+		/** Checks if access has the channel privilege 'priv'.
+		 * @param access THe access struct
+		 * @param priv The privilege being checked for
+		 * @return EVENT_ALLOW for yes, EVENT_STOP to stop all processing
+		 */
+		virtual EventReturn OnCheckPriv(const ChanAccess *access, const Anope::string &priv) anope_abstract;
+	};
+	extern CoreExport EventHandlers<CheckPriv> OnCheckPriv;
+
+	struct CoreExport GroupCheckPriv : Events
+	{
+		/** Check whether an access group has a privilege
+		 * @param group The group
+		 * @param priv The privilege
+		 * @return MOD_ALLOW to allow, MOD_STOP to stop
+		 */
+		virtual EventReturn OnGroupCheckPriv(const AccessGroup *group, const Anope::string &priv) anope_abstract;
+	};
+	extern CoreExport EventHandlers<GroupCheckPriv> OnGroupCheckPriv;
+
+	struct CoreExport NickIdentify : Events
+	{
+		/** Called when a user identifies to a nick
+		 * @param u The user
+		 */
+		virtual void OnNickIdentify(User *u) anope_abstract;
+	};
+	extern CoreExport EventHandlers<NickIdentify> OnNickIdentify;
+
+	struct CoreExport UserLogin : Events
+	{
+		/** Called when a user is logged into an account
+		 * @param u The user
+		 */
+		virtual void OnUserLogin(User *u) anope_abstract;
+	};
+	extern CoreExport EventHandlers<UserLogin> OnUserLogin;
+
+	struct CoreExport NickLogout : Events
+	{
+		/** Called when a nick logs out
+		 * @param u The nick
+		 */
+		virtual void OnNickLogout(User *u) anope_abstract;
+	};
+	extern CoreExport EventHandlers<NickLogout> OnNickLogout;
+
+	struct CoreExport DelNick : Events
+	{
+		/** Called on delnick()
+		 * @ param na pointer to the nickalias
+		 */
+		virtual void OnDelNick(NickAlias *na) anope_abstract;
+	};
+	extern CoreExport EventHandlers<DelNick> OnDelNick;
+
+	struct CoreExport NickCoreCreate : Events
+	{
+		/** Called when a nickcore is created
+		 * @param nc The nickcore
+		 */
+		virtual void OnNickCoreCreate(NickCore *nc) anope_abstract;
+	};
+	extern CoreExport EventHandlers<NickCoreCreate> OnNickCoreCreate;
+
+	struct CoreExport DelCore : Events
+	{
+		/** Called on delcore()
+		 * @param nc pointer to the NickCore
+		 */
+		virtual void OnDelCore(NickCore *nc) anope_abstract;
+	};
+	extern CoreExport EventHandlers<DelCore> OnDelCore;
+
+	struct CoreExport ChangeCoreDisplay : Events
+	{
+		/** Called on change_core_display()
+		 * @param nc pointer to the NickCore
+		 * @param newdisplay the new display
+		 */
+		virtual void OnChangeCoreDisplay(NickCore *nc, const Anope::string &newdisplay) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ChangeCoreDisplay> OnChangeCoreDisplay;
+
+	struct CoreExport NickClearAccess : Events
+	{
+		/** called from NickCore::ClearAccess()
+		 * @param nc pointer to the NickCore
+		 */
+		virtual void OnNickClearAccess(NickCore *nc) anope_abstract;
+	};
+	extern CoreExport EventHandlers<NickClearAccess> OnNickClearAccess;
+
+	struct CoreExport NickAddAccess : Events
+	{
+		/** Called when a user adds an entry to their access list
+		 * @param nc The nick
+		 * @param entry The entry
+		 */
+		virtual void OnNickAddAccess(NickCore *nc, const Anope::string &entry) anope_abstract;
+	};
+	extern CoreExport EventHandlers<NickAddAccess> OnNickAddAccess;
+
+	struct CoreExport NickEraseAccess : Events
+	{
+		/** Called from NickCore::EraseAccess()
+		 * @param nc pointer to the NickCore
+		 * @param entry The access mask
+		 */
+		virtual void OnNickEraseAccess(NickCore *nc, const Anope::string &entry) anope_abstract;
+	};
+	extern CoreExport EventHandlers<NickEraseAccess> OnNickEraseAccess;
+
+
+
+	struct CoreExport CheckAuthentication : Events
+	{
+		/** Check whether a username and password is correct
+		 * @param u The user trying to identify, if applicable.
+		 * @param req The login request
+		 */
+		virtual void OnCheckAuthentication(User *u, IdentifyRequest *req) anope_abstract;
+	};
+	extern CoreExport EventHandlers<CheckAuthentication> OnCheckAuthentication;
+
+	struct CoreExport Fingerprint : Events
+	{
+		/** Called when we get informed about a users SSL fingerprint
+		 *  when we call this, the fingerprint should already be stored in the user struct
+		 * @param u pointer to the user
+		 */
+		virtual void OnFingerprint(User *u) anope_abstract;
+	};
+	extern CoreExport EventHandlers<Fingerprint> OnFingerprint;
+
+	struct CoreExport UserAway : Events
+	{
+		/** Called when a user becomes (un)away
+		 * @param message The message, is .empty() if unaway
+		 */
+		virtual void OnUserAway(User *u, const Anope::string &message) anope_abstract;
+	};
+	extern CoreExport EventHandlers<UserAway> OnUserAway;
+
+	struct CoreExport Invite : Events
+	{
+		/** Called when a user invites one of our users to a channel
+		 * @param source The user doing the inviting
+		 * @param c The channel the user is inviting to
+		 * @param targ The user being invited
+		 */
+		virtual void OnInvite(User *source, Channel *c, User *targ) anope_abstract;
+	};
+	extern CoreExport EventHandlers<Invite> OnInvite;
+
+	struct CoreExport SetVhost : Events
+	{
+		/** Called when a vhost is set
+		 * @param na The nickalias of the vhost
+		 */
+		virtual void OnSetVhost(NickAlias *na) anope_abstract;
+	};
+	extern CoreExport EventHandlers<SetVhost> OnSetVhost;
+
+	struct CoreExport SetDisplayedHost : Events
+	{
+		/** Called when a users host changes
+		 * @param u The user
+		 */
+		virtual void OnSetDisplayedHost(User *) anope_abstract;
+	};
+	extern CoreExport EventHandlers<SetDisplayedHost> OnSetDisplayedHost;
+
+	struct CoreExport ChannelModeSet : Events
+	{
+		/** Called when a mode is set on a channel
+		 * @param c The channel
+		 * @param setter The user or server that is setting the mode
+		 * @param mode The mode
+		 * @param param The mode param, if there is one
+		 * @return EVENT_STOP to make mlock/secureops etc checks not happen
+		 */
+		virtual EventReturn OnChannelModeSet(Channel *c, MessageSource &setter, ChannelMode *mode, const Anope::string &param) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ChannelModeSet> OnChannelModeSet;
+
+	struct CoreExport ChannelModeUnset : Events
+	{
+		/** Called when a mode is unset on a channel
+		 * @param c The channel
+		 * @param setter The user or server that is unsetting the mode
+		 * @param mode The mode
+		 * @param param The mode param, if there is one
+		 * @return EVENT_STOP to make mlock/secureops etc checks not happen
+		 */
+		virtual EventReturn OnChannelModeUnset(Channel *c, MessageSource &setter, ChannelMode *mode, const Anope::string &param) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ChannelModeUnset> OnChannelModeUnset;
+
+	struct CoreExport UserModeSet : Events
+	{
+		/** Called when a mode is set on a user
+		 * @param setter who/what is setting the mode
+		 * @param u The user
+		 * @param mname The mode name
+		 */
+		virtual void OnUserModeSet(const MessageSource &setter, User *u, const Anope::string &mname) anope_abstract;
+	};
+	extern CoreExport EventHandlers<UserModeSet> OnUserModeSet;
+
+	struct CoreExport UserModeUnset : Events
+	{
+		/** Called when a mode is unset from a user
+		 * @param setter who/what is setting the mode
+		 * @param u The user
+		 * @param mname The mode name
+		 */
+		virtual void OnUserModeUnset(const MessageSource &setter, User *u, const Anope::string &mname) anope_abstract;
+	};
+	extern CoreExport EventHandlers<UserModeUnset> OnUserModeUnset;
+
+	struct CoreExport ChannelModeAdd : Events
+	{
+		/** Called when a channel mode is introducted into Anope
+		 * @param cm The mode
+		 */
+		virtual void OnChannelModeAdd(ChannelMode *cm) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ChannelModeAdd> OnChannelModeAdd;
+
+	struct CoreExport UserModeAdd : Events
+	{
+		/** Called when a user mode is introducted into Anope
+		 * @param um The mode
+		 */
+		virtual void OnUserModeAdd(UserMode *um) anope_abstract;
+	};
+	extern CoreExport EventHandlers<UserModeAdd> OnUserModeAdd;
+
+	struct CoreExport ModuleLoad : Events
+	{
+		/** Called after a module is loaded
+		 * @param u The user loading the module, can be NULL
+		 * @param m The module
+		 */
+		virtual void OnModuleLoad(User *u, Module *m) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ModuleLoad> OnModuleLoad;
+
+	struct CoreExport ModuleUnload : Events
+	{
+		/** Called before a module is unloaded
+		 * @param u The user, can be NULL
+		 * @param m The module
+		 */
+		virtual void OnModuleUnload(User *u, Module *m) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ModuleUnload> OnModuleUnload;
+
+	struct CoreExport ServerSync : Events
+	{
+		/** Called when a server is synced
+		 * @param s The server, can be our uplink server
+		 */
+		virtual void OnServerSync(Server *s) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ServerSync> OnServerSync;
+
+	struct CoreExport UplinkSync : Events
+	{
+		/** Called when we sync with our uplink
+		 * @param s Our uplink
+		 */
+		virtual void OnUplinkSync(Server *s) anope_abstract;
+	};
+	extern CoreExport EventHandlers<UplinkSync> OnUplinkSync;
+
+	struct CoreExport BotPrivmsg : Events
+	{
+		/** Called when we receive a PRIVMSG for one of our clients
+		 * @param u The user sending the PRIVMSG
+		 * @param bi The target of the PRIVMSG
+		 * @param message The message
+		 * @return EVENT_STOP to halt processing
+		 */
+		virtual EventReturn OnBotPrivmsg(User *u, BotInfo *bi, Anope::string &message) anope_abstract;
+	};
+	extern CoreExport EventHandlers<BotPrivmsg> OnBotPrivmsg;
+
+	struct CoreExport BotNotice : Events
+	{
+		/** Called when we receive a NOTICE for one of our clients
+		 * @param u The user sending the NOTICE
+		 * @param bi The target of the NOTICE
+		 * @param message The message
+		 */
+		virtual void OnBotNotice(User *u, BotInfo *bi, Anope::string &message) anope_abstract;
+	};
+	extern CoreExport EventHandlers<BotNotice> OnBotNotice;
+
+	struct CoreExport Privmsg : Events
+	{
+		/** Called when we receive a PRIVMSG for a registered channel we are in
+		 * @param u The source of the message
+		 * @param c The channel
+		 * @param msg The message
+		 */
+		virtual void OnPrivmsg(User *u, Channel *c, Anope::string &msg) anope_abstract;
+	};
+	extern CoreExport EventHandlers<Privmsg> OnPrivmsg;
+
+	struct CoreExport Log : Events
+	{
+		/** Called when a message is logged
+		 * @param l The log message
+		 */
+		virtual void OnLog(::Log *l) anope_abstract;
+	};
+	extern CoreExport EventHandlers<Log> OnLog;
+
+	struct CoreExport LogMessage : Events
+	{
+		/** Called when a log message is actually logged to a given log info
+		 * The message has already passed validation checks by the LogInfo
+		 * @param li The loginfo whee the message is being logged
+		 * @param l The log message
+		 * @param msg The final formatted message, derived from 'l'
+		 */
+		virtual void OnLogMessage(LogInfo *li, const ::Log *l, const Anope::string &msg) anope_abstract;
+	};
+	extern CoreExport EventHandlers<LogMessage> OnLogMessage;
+
+	struct CoreExport CheckModes : Events
+	{
+		/** Called when a channels modes are being checked to see if they are allowed,
+		 * mostly to ensure mlock/+r are set.
+		 * @param c The channel
+		 */
+		virtual void OnCheckModes(Reference<Channel> &c) anope_abstract;
+	};
+	extern CoreExport EventHandlers<CheckModes> OnCheckModes;
+
+	struct CoreExport ChannelSync : Events
+	{
+		/** Called when a channel is synced.
+		 * Channels are synced after a sjoin is finished processing
+		 * for a newly created channel to set the correct modes, topic,
+		 * set.
+		 */
+		virtual void OnChannelSync(Channel *c) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ChannelSync> OnChannelSync;
+
+	struct CoreExport SetCorrectModes : Events
+	{
+		/** Called to set the correct modes on the user on the given channel
+		 * @param user The user
+		 * @param chan The channel
+		 * @param access The user's access on the channel
+		 * @param give_modes If giving modes is desired
+		 * @param take_modes If taking modes is desired
+		 */
+		virtual void OnSetCorrectModes(User *user, Channel *chan, AccessGroup &access, bool &give_modes, bool &take_modes) anope_abstract;
+	};
+	extern CoreExport EventHandlers<SetCorrectModes> OnSetCorrectModes;
+
+	struct CoreExport SerializeCheck : Events
+	{
+		virtual void OnSerializeCheck(Serialize::Type *) anope_abstract;
+	};
+	extern CoreExport EventHandlers<SerializeCheck> OnSerializeCheck;
+
+	struct CoreExport SerializableConstruct : Events
+	{
+		virtual void OnSerializableConstruct(Serializable *) anope_abstract;
+	};
+	extern CoreExport EventHandlers<SerializableConstruct> OnSerializableConstruct;
+
+	struct CoreExport SerializableDestruct : Events
+	{
+		virtual void OnSerializableDestruct(Serializable *) anope_abstract;
+	};
+	extern CoreExport EventHandlers<SerializableDestruct> OnSerializableDestruct;
+
+	struct CoreExport SerializableUpdate : Events
+	{
+		virtual void OnSerializableUpdate(Serializable *) anope_abstract;
+	};
+	extern CoreExport EventHandlers<SerializableUpdate> OnSerializableUpdate;
+
+	struct CoreExport SerializeTypeCreate : Events
+	{
+		virtual void OnSerializeTypeCreate(Serialize::Type *) anope_abstract;
+	};
+	extern CoreExport EventHandlers<SerializeTypeCreate> OnSerializeTypeCreate;
+
+	struct CoreExport Message : Events
+	{
+		/** Called whenever a message is received from the uplink
+		 * @param source The source of the message
+		 * @param command The command being executed
+		 * @param params Parameters
+		 * @return EVENT_STOP to prevent the protocol module from processing this message
+		 */
+		virtual EventReturn OnMessage(MessageSource &source, Anope::string &command, std::vector<Anope::string> &param) anope_abstract;
+	};
+	extern CoreExport EventHandlers<Message> OnMessage;
+
+	struct CoreExport CanSet : Events
+	{
+		/** Called to determine if a chnanel mode can be set by a user
+		 * @param u The user
+		 * @param cm The mode
+		 */
+		virtual EventReturn OnCanSet(User *u, const ChannelMode *cm) anope_abstract;
+	};
+	extern CoreExport EventHandlers<CanSet> OnCanSet;
+
+	struct CoreExport CheckDelete : Events
+	{
+		virtual EventReturn OnCheckDelete(Channel *) anope_abstract;
+	};
+	extern CoreExport EventHandlers<CheckDelete> OnCheckDelete;
+
+	struct CoreExport ExpireTick : Events
+	{
+		/** Called every options:expiretimeout seconds. Should be used to expire nicks,
+		 * channels, etc.
+		 */
+		virtual void OnExpireTick() anope_abstract;
+	};
+	extern CoreExport EventHandlers<ExpireTick> OnExpireTick;
+
+}
+
diff --git a/include/module.h b/include/module.h
index 571cf4a6a..0efbb7334 100644
--- a/include/module.h
+++ b/include/module.h
@@ -19,6 +19,7 @@
 #include "channels.h"
 #include "commands.h"
 #include "config.h"
+#include "event.h"
 #include "extensible.h"
 #include "hashcomp.h"
 #include "language.h"
@@ -43,9 +44,3 @@
 #include "uplink.h"
 #include "users.h"
 #include "xline.h"
-
-#include "modules/pseudoclients/chanserv.h"
-#include "modules/pseudoclients/global.h"
-#include "modules/pseudoclients/memoserv.h"
-#include "modules/pseudoclients/nickserv.h"
-
diff --git a/include/modules.h b/include/modules.h
index 05a763b00..56778d4e2 100644
--- a/include/modules.h
+++ b/include/modules.h
@@ -51,77 +51,6 @@
 	}
 #endif
 
-/**
- * This #define allows us to call a method in all
- * loaded modules in a readable simple way, e.g.:
- * 
- * FOREACH_MOD(OnUserConnect, (user, exempt));
- */
-#define FOREACH_MOD(ename, args) \
-if (true) \
-{ \
-	std::vector<Module *> &_modules = ModuleManager::EventHandlers[I_ ## ename]; \
-	for (std::vector<Module *>::iterator _i = _modules.begin(); _i != _modules.end();) \
-	{ \
-		try \
-		{ \
-			(*_i)->ename args; \
-		} \
-		catch (const ModuleException &modexcept) \
-		{ \
-			Log() << "Exception caught: " << modexcept.GetReason(); \
-		} \
-		catch (const NotImplementedException &) \
-		{ \
-			_i = _modules.erase(_i); \
-			continue; \
-		} \
-		++_i; \
-	} \
-} \
-else \
-	static_cast<void>(0)
-
-/**
- * This define is similar to the one above but returns a result.
- * The first module to return a result other than EVENT_CONTINUE is the value to be accepted,
- * and any modules after are ignored. This is used like:
- * 
- * EventReturn MOD_RESULT;
- * FOREACH_RESULT(OnUserConnect, MOD_RESULT, (user, exempt));
- */
-#define FOREACH_RESULT(ename, ret, args) \
-if (true) \
-{ \
-	ret = EVENT_CONTINUE; \
-	std::vector<Module *> &_modules = ModuleManager::EventHandlers[I_ ## ename]; \
-	for (std::vector<Module *>::iterator _i = _modules.begin(); _i != _modules.end();) \
-	{ \
-		try \
-		{ \
-			EventReturn res = (*_i)->ename args; \
-			if (res != EVENT_CONTINUE) \
-			{ \
-				ret = res; \
-				break; \
-			} \
-		} \
-		catch (const ModuleException &modexcept) \
-		{ \
-			Log() << "Exception caught: " << modexcept.GetReason(); \
-		} \
-		catch (const NotImplementedException &) \
-		{ \
-			_i = _modules.erase(_i); \
-			continue; \
-		} \
-		++_i; \
-	} \
-} \
-else \
-	static_cast<void>(0)
-
-
 /** Possible return types from events.
  */
 enum EventReturn
@@ -144,9 +73,6 @@ enum ModuleReturn
 	MOD_ERR_VERSION
 };
 
-/** Priority types which can be returned from Module::Prioritize()
- */
-enum Priority { PRIORITY_FIRST, PRIORITY_DONTCARE, PRIORITY_LAST, PRIORITY_BEFORE, PRIORITY_AFTER };
 /* Module types, in the order in which they are unloaded. The order these are in is IMPORTANT */
 enum
 {
@@ -205,8 +131,6 @@ class ModuleVersion
 	int GetPatch() const;
 };
 
-class NotImplementedException : public CoreException { };
-
 /** Every module in Anope is actually a class.
  */
 class CoreExport Module : public Extensible
@@ -283,827 +207,11 @@ class CoreExport Module : public Extensible
 	 */
 	ModuleVersion GetVersion() const;
 
-	/* Everything below here are events. Modules must ModuleManager::Attach to these events
-	 * before they will be called.
-	 */
-
-	/** Called before a user has been kicked from a channel.
-	 * @param source The kicker
-	 * @param cu The user, channel, and status of the user being kicked
-	 * @param kickmsg The reason for the kick.
-	 */
-	virtual void OnPreUserKicked(const MessageSource &source, ChanUserContainer *cu, const Anope::string &kickmsg) { throw NotImplementedException(); }
-
-	/** Called when a user has been kicked from a channel.
-	 * @param source The kicker
-	 * @param target The user being kicked
-	 * @param channel The channel the user was kicked from, which may no longer exist
-	 * @param status The status the kicked user had on the channel before they were kicked
-	 * @param kickmsg The reason for the kick.
-	 */
-	virtual void OnUserKicked(const MessageSource &source, User *target, const Anope::string &channel, ChannelStatus &status, const Anope::string &kickmsg) { throw NotImplementedException(); }
-
 	/** Called when Services' configuration is being (re)loaded.
 	 * @param conf The config that is being built now and will replace the global Config object
 	 * @throws A ConfigException to abort the config (re)loading process.
 	 */
-	virtual void OnReload(Configuration::Conf *conf) { throw NotImplementedException(); }
-
-	/** Called before a bot is assigned to a channel.
-	 * @param sender The user assigning the bot
-	 * @param ci The channel the bot is to be assigned to.
-	 * @param bi The bot being assigned.
-	 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to deny the assign.
-	 */
-	virtual EventReturn OnPreBotAssign(User *sender, ChannelInfo *ci, BotInfo *bi) { throw NotImplementedException(); }
-
-	/** Called when a bot is assigned ot a channel
-	 */
-	virtual void OnBotAssign(User *sender, ChannelInfo *ci, BotInfo *bi) { throw NotImplementedException(); }
-
-	/** Called before a bot is unassigned from a channel.
-	 * @param sender The user unassigning the bot
-	 * @param ci The channel the bot is being removed from
-	 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to deny the unassign.
-	 */
-	virtual EventReturn OnBotUnAssign(User *sender, ChannelInfo *ci) { throw NotImplementedException(); }
-
-	/** Called when a new user connects to the network.
-	 * @param u The connecting user.
-	 * @param exempt set to true/is true if the user should be excepted from bans etc
-	 */
-	virtual void OnUserConnect(User *u, bool &exempt) { throw NotImplementedException(); }
-
-	/** Called when a new server connects to the network.
-	 * @param s The server that has connected to the network
-	 */
-	virtual void OnNewServer(Server *s) { throw NotImplementedException(); }
-
-	/** Called after a user changed the nick
-	 * @param u The user.
-	 * @param oldnick The old nick of the user
-	 */
-	virtual void OnUserNickChange(User *u, const Anope::string &oldnick) { throw NotImplementedException(); }
-
-	/** Called when someone uses the generic/help command
-	 * @param source Command source
-	 * @param params Params
-	 * @return EVENT_STOP to stop processing
-	 */
-	virtual EventReturn OnPreHelp(CommandSource &source, const std::vector<Anope::string> &params) { throw NotImplementedException(); }
-
-	/** Called when someone uses the generic/help command
-	 * @param source Command source
-	 * @param params Params
-	 */
-	virtual void OnPostHelp(CommandSource &source, const std::vector<Anope::string> &params) { throw NotImplementedException(); }
-
-	/** Called before a command is due to be executed.
-	 * @param source The source of the command
-	 * @param command The command the user is executing
-	 * @param params The parameters the user is sending
-	 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to halt the command and not process it
-	 */
-	virtual EventReturn OnPreCommand(CommandSource &source, Command *command, std::vector<Anope::string> &params) { throw NotImplementedException(); }
-
-	/** Called after a command has been executed.
-	 * @param source The source of the command
-	 * @param command The command the user executed
-	 * @param params The parameters the user sent
-	 */
-	virtual void OnPostCommand(CommandSource &source, Command *command, const std::vector<Anope::string> &params) { throw NotImplementedException(); }
-
-	/** Called when the databases are saved
-	 */
-	virtual void OnSaveDatabase() { throw NotImplementedException(); }
-
-	/** Called when the databases are loaded
-	 * @return EVENT_CONTINUE to let other modules continue loading, EVENT_STOP to stop
-	 */
-	virtual EventReturn OnLoadDatabase() { throw NotImplementedException(); }
-
-	/** Called when anope needs to check passwords against encryption
-	 *  see src/encrypt.c for detailed informations
-	 */
-	virtual EventReturn OnEncrypt(const Anope::string &src, Anope::string &dest) { throw NotImplementedException(); }
-	virtual EventReturn OnDecrypt(const Anope::string &hashm, const Anope::string &src, Anope::string &dest) { throw NotImplementedException(); }
-
-	/** Called on fantasy command
-	 * @param source The source of the command
-	 * @param c The command
-	 * @param ci The channel it's being used in
-	 * @param params The params
-	 * @return EVENT_STOP to halt processing and not run the command, EVENT_ALLOW to allow the command to be executed
-	 */
-	virtual EventReturn OnBotFantasy(CommandSource &source, Command *c, ChannelInfo *ci, const std::vector<Anope::string> &params) { throw NotImplementedException(); }
-
-	/** Called on fantasy command without access
-	 * @param source The source of the command
-	 * @param c The command
-	 * @param ci The channel it's being used in
-	 * @param params The params
-	 * @return EVENT_STOP to halt processing and not run the command, EVENT_ALLOW to allow the command to be executed
-	 */
-	virtual EventReturn OnBotNoFantasyAccess(CommandSource &source, Command *c, ChannelInfo *ci, const std::vector<Anope::string> &params) { throw NotImplementedException(); }
-
-	/** Called when a bot places a ban
-	 * @param u User being banned
-	 * @param ci Channel the ban is placed on
-	 * @param mask The mask being banned
-	 */
-	virtual void OnBotBan(User *u, ChannelInfo *ci, const Anope::string &mask) { throw NotImplementedException(); }
-
-	/** Called before a badword is added to the badword list
-	 * @param ci The channel
-	 * @param bw The badword
-	 */
-	virtual void OnBadWordAdd(ChannelInfo *ci, const BadWord *bw) { throw NotImplementedException(); }
-
-	/** Called before a badword is deleted from a channel
-	 * @param ci The channel
-	 * @param bw The badword
-	 */
-	virtual void OnBadWordDel(ChannelInfo *ci, const BadWord *bw) { throw NotImplementedException(); }
-
-	/** Called when a bot is created or destroyed
-	 */
-	virtual void OnCreateBot(BotInfo *bi) { throw NotImplementedException(); }
-	virtual void OnDelBot(BotInfo *bi) { throw NotImplementedException(); }
-
-	/** Called before a bot kicks a user
-	 * @param bi The bot sending the kick
-	 * @param c The channel the user is being kicked on
-	 * @param u The user being kicked
-	 * @param reason The reason
-	 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to halt the command and not process it
-	 */
-	virtual EventReturn OnBotKick(BotInfo *bi, Channel *c, User *u, const Anope::string &reason) { throw NotImplementedException(); }
-
-	/** Called before a user parts a channel
-	 * @param u The user
-	 * @param c The channel
-	 */
-	virtual void OnPrePartChannel(User *u, Channel *c) {}
-
-	/** Called when a user parts a channel
-	 * @param u The user
-	 * @param c The channel, may be NULL if the channel no longer exists
-	 * @param channel The channel name
-	 * @param msg The part reason
-	 */
-	virtual void OnPartChannel(User *u, Channel *c, const Anope::string &channel, const Anope::string &msg) { throw NotImplementedException(); }
-
-	/** Called when a user leaves a channel.
-	 * From either parting, being kicked, or quitting/killed!
-	 * @param u The user
-	 * @param c The channel
-	 */
-	virtual void OnLeaveChannel(User *u, Channel *c) { throw NotImplementedException(); }
-
-	/** Called after a user joins a channel
-	 * If this event triggers the user is allowed to be in the channel, and will
-	 * not be kicked for restricted/akick/forbidden, etc. If you want to kick the user,
-	 * use the CheckKick event instead.
-	 * @param u The user
-	 * @param channel The channel
-	 */
-	virtual void OnJoinChannel(User *u, Channel *c) { throw NotImplementedException(); }
-
-	/** Called when a new topic is set
-	 * @param c The channel
-	 * @param setter The user who set the new topic
-	 * @param topic The new topic
-	 */
-	virtual void OnTopicUpdated(Channel *c, const Anope::string &user, const Anope::string &topic) { throw NotImplementedException(); }
-
-	/** Called before a channel expires
-	 * @param ci The channel
-	 * @param expire Set to true to allow the chan to expire
-	 */
-	virtual void OnPreChanExpire(ChannelInfo *ci, bool &expire) { throw NotImplementedException(); }
-
-	/** Called before a channel expires
-	 * @param ci The channel
-	 */
-	virtual void OnChanExpire(ChannelInfo *ci) { throw NotImplementedException(); }
-
-	/** Called before Anope connecs to its uplink
-	 */
-	virtual void OnPreServerConnect() { throw NotImplementedException(); }
-
-	/** Called when Anope connects to its uplink
-	 */
-	virtual void OnServerConnect() { throw NotImplementedException(); }
-
-	/** Called when we are almost done synching with the uplink, just before we send the EOB
-	 */
-	virtual void OnPreUplinkSync(Server *serv) { throw NotImplementedException(); }
-
-	/** Called when Anope disconnects from its uplink, before it tries to reconnect
-	 */
-	virtual void OnServerDisconnect() { throw NotImplementedException(); }
-
-	/** Called when services restart
-	*/
-	virtual void OnRestart() { throw NotImplementedException(); }
-
-	/** Called when services shutdown
-	 */
-	virtual void OnShutdown() { throw NotImplementedException(); }
-
-	/** Called before a nick expires
-	 * @param na The nick
-	 * @param expire Set to true to allow the nick to expire
-	 */
-	virtual void OnPreNickExpire(NickAlias *na, bool &expire) { throw NotImplementedException(); }
-
-	/** Called when a nick drops
-	 * @param na The nick
-	 */
-	virtual void OnNickExpire(NickAlias *na) { throw NotImplementedException(); }
-
-	/** Called when defcon level changes
-	 * @param level The level
-	 */
-	virtual void OnDefconLevel(int level) { throw NotImplementedException(); }
-
-	/** Called after an exception has been added
-	 * @param ex The exception
-	 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to halt the command and not process it
-	 */
-	virtual EventReturn OnExceptionAdd(Exception *ex) { throw NotImplementedException(); }
-
-	/** Called before an exception is deleted
-	 * @param source The source deleting it
-	 * @param ex The exceotion
-	 */
-	virtual void OnExceptionDel(CommandSource &source, Exception *ex) { throw NotImplementedException(); }
-
-	/** Called before a XLine is added
-	 * @param source The source of the XLine
-	 * @param x The XLine
-	 * @param xlm The xline manager it was added to
-	 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to halt the command and not process it
-	 */
-	virtual EventReturn OnAddXLine(CommandSource &source, const XLine *x, XLineManager *xlm) { throw NotImplementedException(); }
-
-	/** Called before a XLine is deleted
-	 * @param source The source of the XLine
-	 * @param x The XLine
-	 * @param xlm The xline manager it was deleted from
-	 */
-	virtual void OnDelXLine(CommandSource &source, const XLine *x, XLineManager *xlm) { throw NotImplementedException(); }
-
-	/** Called when a user is checked for whether they are a services oper
-	 * @param u The user
-	 * @return EVENT_ALLOW to allow, anything else to deny
-	 */
-	virtual EventReturn IsServicesOper(User *u) { throw NotImplementedException(); }
-
-	/** Called when a server quits
-	 * @param server The server
-	 */
-	virtual void OnServerQuit(Server *server) { throw NotImplementedException(); }
-
-	/** Called when a user quits, or is killed
-	 * @param u The user
-	 * @param msg The quit message
-	 */
-	virtual void OnUserQuit(User *u, const Anope::string &msg) { throw NotImplementedException(); }
-
-	/** Called when a user is quit, before and after being internally removed from
-	 * This is different from OnUserQuit, which takes place at the time of the quit.
-	 * This happens shortly after when all message processing is finished.
-	 * all lists (channels, user list, etc)
-	 * @param u The user
-	 */
-	virtual void OnPreUserLogoff(User *u) { throw NotImplementedException(); }
-	virtual void OnPostUserLogoff(User *u) { throw NotImplementedException(); }
-
-	/** Called when a new bot is made
-	 * @param bi The bot
-	 */
-	virtual void OnBotCreate(BotInfo *bi) { throw NotImplementedException(); }
-
-	/** Called when a bot is changed
-	 * @param bi The bot
-	 */
-	virtual void OnBotChange(BotInfo *bi) { throw NotImplementedException(); }
-
-	/** Called when a bot is deleted
-	 * @param bi The bot
-	 */
-	virtual void OnBotDelete(BotInfo *bi) { throw NotImplementedException(); }
-
-	/** Called after an access entry is deleted from a channel
-	 * @param ci The channel
-	 * @param source The source of the command
-	 * @param access The access entry that was removed
-	 */
-	virtual void OnAccessDel(ChannelInfo *ci, CommandSource &source, ChanAccess *access) { throw NotImplementedException(); }
-
-	/** Called when access is added
-	 * @param ci The channel
-	 * @param source The source of the command
-	 * @param access The access changed
-	 */
-	virtual void OnAccessAdd(ChannelInfo *ci, CommandSource &source, ChanAccess *access) { throw NotImplementedException(); }
-
-	/** Called when the access list is cleared
-	 * @param ci The channel
-	 * @param u The user who cleared the access
-	 */
-	virtual void OnAccessClear(ChannelInfo *ci, CommandSource &source) { throw NotImplementedException(); }
-
-	/** Called when a level for a channel is changed
-	 * @param source The source of the command
-	 * @param ci The channel the level was changed on
-	 * @param priv The privilege changed
-	 * @param what The new level
-	 */
-	virtual void OnLevelChange(CommandSource &source, ChannelInfo *ci, const Anope::string &priv, int16_t what) { throw NotImplementedException(); }
-
-	/** Called right before a channel is dropped
-	 * @param source The user dropping the channel
-	 * @param ci The channel
-	 */
-	virtual EventReturn OnChanDrop(CommandSource &source, ChannelInfo *ci) { throw NotImplementedException(); }
-
-	/** Called when a channel is registered
-	 * @param ci The channel
-	 */
-	virtual void OnChanRegistered(ChannelInfo *ci) { throw NotImplementedException(); }
-
-	/** Called when a channel is suspended
-	 * @param ci The channel
-	 */
-	virtual void OnChanSuspend(ChannelInfo *ci) { throw NotImplementedException(); }
-
-	/** Called when a channel is unsuspended
-	 * @param ci The channel
-	 */
-	virtual void OnChanUnsuspend(ChannelInfo *ci) { throw NotImplementedException(); }
-
-	/** Called when a channel is being created, for any reason
-	 * @param ci The channel
-	 */
-	virtual void OnCreateChan(ChannelInfo *ci) { throw NotImplementedException(); }
-
-	/** Called when a channel is being deleted, for any reason
-	 * @param ci The channel
-	 */
-	virtual void OnDelChan(ChannelInfo *ci) { throw NotImplementedException(); }
-
-	/** Called when a new channel is created
-	 * Note that this channel may not be introduced to the uplink at this point.
-	 * @param c The channel
-	 */
-	virtual void OnChannelCreate(Channel *c) { throw NotImplementedException(); }
-
-	/** Called when a channel is deleted
-	 * @param c The channel
-	 */
-	virtual void OnChannelDelete(Channel *c) { throw NotImplementedException(); }
-
-	/** Called after adding an akick to a channel
-	 * @param source The source of the command
-	 * @param ci The channel
-	 * @param ak The akick
-	 */
-	virtual void OnAkickAdd(CommandSource &source, ChannelInfo *ci, const AutoKick *ak) { throw NotImplementedException(); }
-
-	/** Called before removing an akick from a channel
-	 * @param source The source of the command
-	 * @param ci The channel
-	 * @param ak The akick
-	 */
-	virtual void OnAkickDel(CommandSource &source, ChannelInfo *ci, const AutoKick *ak) { throw NotImplementedException(); }
-
-	/** Called after a user join a channel when we decide whether to kick them or not
-	 * @param u The user
-	 * @param c The channel
-	 * @param kick Set to true to kick
-	 * @param mask The mask to ban, if any
-	 * @param reason The reason for the kick
-	 * @return EVENT_STOP to prevent the user from joining by kicking/banning the user
-	 */
-	virtual EventReturn OnCheckKick(User *u, Channel *c, Anope::string &mask, Anope::string &reason) { throw NotImplementedException(); }
-
-	/** Called when a user requests info for a channel
-	 * @param source The user requesting info
-	 * @param ci The channel the user is requesting info for
-	 * @param info Data to show the user requesting information
-	 * @param show_hidden true if we should show the user everything
-	 */
-	virtual void OnChanInfo(CommandSource &source, ChannelInfo *ci, InfoFormatter &info, bool show_hidden) { throw NotImplementedException(); }
-
-	/** Checks if access has the channel privilege 'priv'.
-	 * @param access THe access struct
-	 * @param priv The privilege being checked for
-	 * @return EVENT_ALLOW for yes, EVENT_STOP to stop all processing
-	 */
-	virtual EventReturn OnCheckPriv(const ChanAccess *access, const Anope::string &priv) { throw NotImplementedException(); }
-
-	/** Check whether an access group has a privilege
-	 * @param group The group
-	 * @param priv The privilege
-	 * @return MOD_ALLOW to allow, MOD_STOP to stop
-	 */
-	virtual EventReturn OnGroupCheckPriv(const AccessGroup *group, const Anope::string &priv) { throw NotImplementedException(); }
-
-	/** Called when a nick is dropped
-	 * @param source The source of the command
-	 * @param na The nick
-	 */
-	virtual void OnNickDrop(CommandSource &source, NickAlias *na) { throw NotImplementedException(); }
-
-	/** Called when a nick is forbidden
-	 * @param na The nick alias of the forbidden nick
-	 */
-	virtual void OnNickForbidden(NickAlias *na) { throw NotImplementedException(); }
-
-	/** Called when a user groups their nick
-	 * @param u The user grouping
-	 * @param target The target they're grouping to
-	 */
-	virtual void OnNickGroup(User *u, NickAlias *target) { throw NotImplementedException(); }
-
-	/** Called when a user identifies to a nick
-	 * @param u The user
-	 */
-	virtual void OnNickIdentify(User *u) { throw NotImplementedException(); }
-
-	/** Called when a user is logged into an account
-	 * @param u The user
-	 */
-	virtual void OnUserLogin(User *u) { throw NotImplementedException(); }
-
-	/** Called when a nick logs out
-	 * @param u The nick
-	 */
-	virtual void OnNickLogout(User *u) { throw NotImplementedException(); }
-
-	/** Called when a nick is registered
-	 * @param user The user registering the nick, of any
-	 * @param The nick
-	 */
-	virtual void OnNickRegister(User *user, NickAlias *na) { throw NotImplementedException(); }
-
-	/** Called when a nick is suspended
-	 * @param na The nick alias
-	 */
-	virtual void OnNickSuspend(NickAlias *na) { throw NotImplementedException(); }
-
-	/** Called when a nick is unsuspneded
-	 * @param na The nick alias
-	 */
-	virtual void OnNickUnsuspended(NickAlias *na) { throw NotImplementedException(); }
-
-	/** Called on delnick()
-	 * @ param na pointer to the nickalias
-	 */
-	virtual void OnDelNick(NickAlias *na) { throw NotImplementedException(); }
-
-	/** Called when a nickcore is created
-	 * @param nc The nickcore
-	 */
-	virtual void OnNickCoreCreate(NickCore *nc) { throw NotImplementedException(); }
-
-	/** Called on delcore()
-	 * @param nc pointer to the NickCore
-	 */
-	virtual void OnDelCore(NickCore *nc) { throw NotImplementedException(); }
-
-	/** Called on change_core_display()
-	 * @param nc pointer to the NickCore
-	 * @param newdisplay the new display
-	 */
-	virtual void OnChangeCoreDisplay(NickCore *nc, const Anope::string &newdisplay) { throw NotImplementedException(); }
-
-	/** called from NickCore::ClearAccess()
-	 * @param nc pointer to the NickCore
-	 */
-	virtual void OnNickClearAccess(NickCore *nc) { throw NotImplementedException(); }
-
-	/** Called when a user adds an entry to their access list
-	 * @param nc The nick
-	 * @param entry The entry
-	 */
-	virtual void OnNickAddAccess(NickCore *nc, const Anope::string &entry) { throw NotImplementedException(); }
-
-	/** Called from NickCore::EraseAccess()
-	 * @param nc pointer to the NickCore
-	 * @param entry The access mask
-	 */
-	virtual void OnNickEraseAccess(NickCore *nc, const Anope::string &entry) { throw NotImplementedException(); }
-
-	/** called from NickCore::ClearCert()
-	 * @param nc pointer to the NickCore
-	 */
-	virtual void OnNickClearCert(NickCore *nc) { throw NotImplementedException(); }
-
-	/** Called when a user adds an entry to their cert list
-	 * @param nc The nick
-	 * @param entry The entry
-	 */
-	virtual void OnNickAddCert(NickCore *nc, const Anope::string &entry) { throw NotImplementedException(); }
-
-	/** Called from NickCore::EraseCert()
-	 * @param nc pointer to the NickCore
-	 * @param entry The fingerprint
-	 */
-	virtual void OnNickEraseCert(NickCore *nc, const Anope::string &entry) { throw NotImplementedException(); }
-
-	/** Called when a user requests info for a nick
-	 * @param source The user requesting info
-	 * @param na The nick the user is requesting info from
-	 * @param info Data to show the user requesting information
-	 * @param show_hidden true if we should show the user everything
-	 */
-	virtual void OnNickInfo(CommandSource &source, NickAlias *na, InfoFormatter &info, bool show_hidden) { throw NotImplementedException(); }
-
-	/** Called when a user uses botserv/info on a bot or channel.
-	 */
-	virtual void OnBotInfo(CommandSource &source, BotInfo *bi, ChannelInfo *ci, InfoFormatter &info) { throw NotImplementedException(); }
-
-	/** Check whether a username and password is correct
-	 * @param u The user trying to identify, if applicable.
-	 * @param req The login request
-	 */
-	virtual void OnCheckAuthentication(User *u, IdentifyRequest *req) { throw NotImplementedException(); }
-
-	/** Called when a user does /ns update
-	 * @param u The user
-	 */
-	virtual void OnNickUpdate(User *u) { throw NotImplementedException(); }
-
-	/** Called when we get informed about a users SSL fingerprint
-	 *  when we call this, the fingerprint should already be stored in the user struct
-	 * @param u pointer to the user
-	 */
-	virtual void OnFingerprint(User *u) { throw NotImplementedException(); }
-
-	/** Called when a user becomes (un)away
-	 * @param message The message, is .empty() if unaway
-	 */
-	virtual void OnUserAway(User *u, const Anope::string &message) { throw NotImplementedException(); }
-
-	/** Called when a user invites one of our users to a channel
-	 * @param source The user doing the inviting
-	 * @param c The channel the user is inviting to
-	 * @param targ The user being invited
-	 */
-	virtual void OnInvite(User *source, Channel *c, User *targ) { throw NotImplementedException(); }
-
-	/** Called when a vhost is deleted
-	 * @param na The nickalias of the vhost
-	 */
-	virtual void OnDeleteVhost(NickAlias *na) { throw NotImplementedException(); }
-
-	/** Called when a vhost is set
-	 * @param na The nickalias of the vhost
-	 */
-	virtual void OnSetVhost(NickAlias *na) { throw NotImplementedException(); }
-
-	/** Called when a users host changes
-	 * @param u The user
-	 */
-	virtual void OnSetDisplayedHost(User *) { throw NotImplementedException(); }
-
-	/** Called when a memo is sent
-	 * @param source The source of the memo
-	 * @param target The target of the memo
-	 * @param mi Memo info for target
-	 * @param m The memo
-	 */
-	virtual void OnMemoSend(const Anope::string &source, const Anope::string &target, MemoInfo *mi, Memo *m) { throw NotImplementedException(); }
-
-	/** Called when a memo is deleted
-	 * @param target The target the memo is being deleted from (nick or channel)
-	 * @param mi The memo info
-	 * @param m The memo
-	 */
-	virtual void OnMemoDel(const Anope::string &target, MemoInfo *mi, const Memo *m) { throw NotImplementedException(); }
-
-	/** Called when a mode is set on a channel
-	 * @param c The channel
-	 * @param setter The user or server that is setting the mode
-	 * @param mode The mode
-	 * @param param The mode param, if there is one
-	 * @return EVENT_STOP to make mlock/secureops etc checks not happen
-	 */
-	virtual EventReturn OnChannelModeSet(Channel *c, MessageSource &setter, ChannelMode *mode, const Anope::string &param) { throw NotImplementedException(); }
-
-	/** Called when a mode is unset on a channel
-	 * @param c The channel
-	 * @param setter The user or server that is unsetting the mode
-	 * @param mode The mode
-	 * @param param The mode param, if there is one
-	 * @return EVENT_STOP to make mlock/secureops etc checks not happen
-	 */
-	virtual EventReturn OnChannelModeUnset(Channel *c, MessageSource &setter, ChannelMode *mode, const Anope::string &param) { throw NotImplementedException(); }
-
-	/** Called when a mode is set on a user
-	 * @param setter who/what is setting the mode
-	 * @param u The user
-	 * @param mname The mode name
-	 */
-	virtual void OnUserModeSet(const MessageSource &setter, User *u, const Anope::string &mname) { throw NotImplementedException(); }
-
-	/** Called when a mode is unset from a user
-	 * @param setter who/what is setting the mode
-	 * @param u The user
-	 * @param mname The mode name
-	 */
-	virtual void OnUserModeUnset(const MessageSource &setter, User *u, const Anope::string &mname) { throw NotImplementedException(); }
-
-	/** Called when a channel mode is introducted into Anope
-	 * @param cm The mode
-	 */
-	virtual void OnChannelModeAdd(ChannelMode *cm) { throw NotImplementedException(); }
-
-	/** Called when a user mode is introducted into Anope
-	 * @param um The mode
-	 */
-	virtual void OnUserModeAdd(UserMode *um) { throw NotImplementedException(); }
-
-	/** Called when a mode is about to be mlocked
-	 * @param ci The channel the mode is being locked on
-	 * @param lock The mode lock
-	 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to deny the mlock.
-	 */
-	virtual EventReturn OnMLock(ChannelInfo *ci, ModeLock *lock) { throw NotImplementedException(); }
-
-	/** Called when a mode is about to be unlocked
-	 * @param ci The channel the mode is being unlocked from
-	 * @param lock The mode lock
-	 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to deny the mlock.
-	 */
-	virtual EventReturn OnUnMLock(ChannelInfo *ci, ModeLock *lock) { throw NotImplementedException(); }
-
-	/** Called after a module is loaded
-	 * @param u The user loading the module, can be NULL
-	 * @param m The module
-	 */
-	virtual void OnModuleLoad(User *u, Module *m) { throw NotImplementedException(); }
-
-	/** Called before a module is unloaded
-	 * @param u The user, can be NULL
-	 * @param m The module
-	 */
-	virtual void OnModuleUnload(User *u, Module *m) { throw NotImplementedException(); }
-
-	/** Called when a server is synced
-	 * @param s The server, can be our uplink server
-	 */
-	virtual void OnServerSync(Server *s) { throw NotImplementedException(); }
-
-	/** Called when we sync with our uplink
-	 * @param s Our uplink
-	 */
-	virtual void OnUplinkSync(Server *s) { throw NotImplementedException(); }
-
-	/** Called when we receive a PRIVMSG for one of our clients
-	 * @param u The user sending the PRIVMSG
-	 * @param bi The target of the PRIVMSG
-	 * @param message The message
-	 * @return EVENT_STOP to halt processing
-	 */
-	virtual EventReturn OnBotPrivmsg(User *u, BotInfo *bi, Anope::string &message) { throw NotImplementedException(); }
-
-	/** Called when we receive a NOTICE for one of our clients
-	 * @param u The user sending the NOTICE
-	 * @param bi The target of the NOTICE
-	 * @param message The message
-	 */
-	virtual void OnBotNotice(User *u, BotInfo *bi, Anope::string &message) { throw NotImplementedException(); }
-
-	/** Called when we receive a PRIVMSG for a registered channel we are in
-	 * @param u The source of the message
-	 * @param c The channel
-	 * @param msg The message
-	 */
-	virtual void OnPrivmsg(User *u, Channel *c, Anope::string &msg) { throw NotImplementedException(); }
-
-	/** Called when a message is logged
-	 * @param l The log message
-	 */
-	virtual void OnLog(Log *l) { throw NotImplementedException(); }
-
-	/** Called when a log message is actually logged to a given log info
-	 * The message has already passed validation checks by the LogInfo
-	 * @param li The loginfo whee the message is being logged
-	 * @param l The log message
-	 * @param msg The final formatted message, derived from 'l'
-	 */
-	virtual void OnLogMessage(LogInfo *li, const Log *l, const Anope::string &msg) { throw NotImplementedException(); }
-
-	/** Called when a DNS request (question) is recieved.
-	 * @param req The dns request
-	 * @param reply The reply that will be sent
-	 */
-	virtual void OnDnsRequest(DNS::Query &req, DNS::Query *reply) { throw NotImplementedException(); }
-
-	/** Called when a channels modes are being checked to see if they are allowed,
-	 * mostly to ensure mlock/+r are set.
-	 * @param c The channel
-	 */
-	virtual void OnCheckModes(Reference<Channel> &c) { throw NotImplementedException(); }
-
-	/** Called when a channel is synced.
-	 * Channels are synced after a sjoin is finished processing
-	 * for a newly created channel to set the correct modes, topic,
-	 * set.
-	 */
-	virtual void OnChannelSync(Channel *c) { throw NotImplementedException(); }
-
-	/** Called to set the correct modes on the user on the given channel
-	 * @param user The user
-	 * @param chan The channel
-	 * @param access The user's access on the channel
-	 * @param give_modes If giving modes is desired
-	 * @param take_modes If taking modes is desired
-	 */
-	virtual void OnSetCorrectModes(User *user, Channel *chan, AccessGroup &access, bool &give_modes, bool &take_modes) { throw NotImplementedException(); }
-
-	virtual void OnSerializeCheck(Serialize::Type *) { throw NotImplementedException(); }
-	virtual void OnSerializableConstruct(Serializable *) { throw NotImplementedException(); }
-	virtual void OnSerializableDestruct(Serializable *) { throw NotImplementedException(); }
-	virtual void OnSerializableUpdate(Serializable *) { throw NotImplementedException(); }
-	virtual void OnSerializeTypeCreate(Serialize::Type *) { throw NotImplementedException(); }
-
-	/** Called when a chanserv/set command is used
-	 * @param source The source of the command
-	 * @param cmd The command
-	 * @param ci The channel the command was used on
-	 * @param setting The setting passed to the command. Probably ON/OFF.
-	 * @return EVENT_ALLOW to bypass access checks, EVENT_STOP to halt immediately.
-	 */
-	virtual EventReturn OnSetChannelOption(CommandSource &source, Command *cmd, ChannelInfo *ci, const Anope::string &setting) { throw NotImplementedException(); }
-
-	/** Called when a nickserv/set command is used.
-	 * @param source The source of the command
-	 * @param cmd The command
-	 * @param nc The nickcore being modifed
-	 * @param setting The setting passed to the command. Probably ON/OFF.
-	 * @return EVENT_STOP to halt immediately
-	 */
-	virtual EventReturn OnSetNickOption(CommandSource &source, Command *cmd, NickCore *nc, const Anope::string &setting) { throw NotImplementedException(); }
-
-	/** Called whenever a message is received from the uplink
-	 * @param source The source of the message
-	 * @param command The command being executed
-	 * @param params Parameters
-	 * @return EVENT_STOP to prevent the protocol module from processing this message
-	 */
-	virtual EventReturn OnMessage(MessageSource &source, Anope::string &command, std::vector<Anope::string> &param) { throw NotImplementedException(); }
-
-	/** Called to determine if a chnanel mode can be set by a user
-	 * @param u The user
-	 * @param cm The mode
-	 */
-	virtual EventReturn OnCanSet(User *u, const ChannelMode *cm) { throw NotImplementedException(); }
-
-	virtual EventReturn OnCheckDelete(Channel *) { throw NotImplementedException(); }
-
-	/** Called every options:expiretimeout seconds. Should be used to expire nicks,
-	 * channels, etc.
-	 */
-	virtual void OnExpireTick() { throw NotImplementedException(); }
-
-	/** Called when a nick is validated. That is, to determine if a user is permissted
-	 * to be on the given nick.
-	 * @param u The user
-	 * @param na The nick they are on
-	 * @return EVENT_STOP to force the user off of the nick
-	 */
-	virtual EventReturn OnNickValidate(User *u, NickAlias *na) { throw NotImplementedException(); }
-};
-
-enum Implementation
-{
-	I_OnPreUserKicked, I_OnUserKicked, I_OnReload, I_OnPreBotAssign, I_OnBotAssign, I_OnBotUnAssign, I_OnUserConnect,
-	I_OnNewServer, I_OnUserNickChange, I_OnPreHelp, I_OnPostHelp, I_OnPreCommand, I_OnPostCommand, I_OnSaveDatabase,
-	I_OnLoadDatabase, I_OnEncrypt, I_OnDecrypt, I_OnBotFantasy, I_OnBotNoFantasyAccess, I_OnBotBan, I_OnBadWordAdd,
-	I_OnBadWordDel, I_OnCreateBot, I_OnDelBot, I_OnBotKick, I_OnPrePartChannel, I_OnPartChannel, I_OnLeaveChannel,
-	I_OnJoinChannel, I_OnTopicUpdated, I_OnPreChanExpire, I_OnChanExpire, I_OnPreServerConnect, I_OnServerConnect,
-	I_OnPreUplinkSync, I_OnServerDisconnect, I_OnRestart, I_OnShutdown, I_OnPreNickExpire, I_OnNickExpire, I_OnDefconLevel,
-	I_OnExceptionAdd, I_OnExceptionDel, I_OnAddXLine, I_OnDelXLine, I_IsServicesOper, I_OnServerQuit, I_OnUserQuit,
-	I_OnPreUserLogoff, I_OnPostUserLogoff, I_OnBotCreate, I_OnBotChange, I_OnBotDelete, I_OnAccessDel, I_OnAccessAdd,
-	I_OnAccessClear, I_OnLevelChange, I_OnChanDrop, I_OnChanRegistered, I_OnChanSuspend, I_OnChanUnsuspend,
-	I_OnCreateChan, I_OnDelChan, I_OnChannelCreate, I_OnChannelDelete, I_OnAkickAdd, I_OnAkickDel, I_OnCheckKick,
-	I_OnChanInfo, I_OnCheckPriv, I_OnGroupCheckPriv, I_OnNickDrop, I_OnNickForbidden, I_OnNickGroup, I_OnNickIdentify,
-	I_OnUserLogin, I_OnNickLogout, I_OnNickRegister, I_OnNickSuspend, I_OnNickUnsuspended, I_OnDelNick, I_OnNickCoreCreate,
-	I_OnDelCore, I_OnChangeCoreDisplay, I_OnNickClearAccess, I_OnNickAddAccess, I_OnNickEraseAccess, I_OnNickClearCert,
-	I_OnNickAddCert, I_OnNickEraseCert, I_OnNickInfo, I_OnBotInfo, I_OnCheckAuthentication, I_OnNickUpdate,
-	I_OnFingerprint, I_OnUserAway, I_OnInvite, I_OnDeleteVhost, I_OnSetVhost, I_OnSetDisplayedHost, I_OnMemoSend, I_OnMemoDel,
-	I_OnChannelModeSet, I_OnChannelModeUnset, I_OnUserModeSet, I_OnUserModeUnset, I_OnChannelModeAdd, I_OnUserModeAdd,
-	I_OnMLock, I_OnUnMLock, I_OnModuleLoad, I_OnModuleUnload, I_OnServerSync, I_OnUplinkSync, I_OnBotPrivmsg, I_OnBotNotice,
-	I_OnPrivmsg, I_OnLog, I_OnLogMessage, I_OnDnsRequest, I_OnCheckModes, I_OnChannelSync, I_OnSetCorrectModes,
-	I_OnSerializeCheck, I_OnSerializableConstruct, I_OnSerializableDestruct, I_OnSerializableUpdate,
-	I_OnSerializeTypeCreate, I_OnSetChannelOption, I_OnSetNickOption, I_OnMessage, I_OnCanSet, I_OnCheckDelete,
-	I_OnExpireTick, I_OnNickValidate,
-	I_SIZE
+	virtual void OnReload(Configuration::Conf *conf) { }
 };
 
 /** Used to manage modules.
@@ -1111,10 +219,6 @@ enum Implementation
 class CoreExport ModuleManager
 {
  public:
-	/** Event handler hooks.
-	 */
-	static std::vector<Module *> EventHandlers[I_SIZE];
-
  	/** List of all modules loaded in Anope
 	 */
 	static std::list<Module *> Modules;
@@ -1159,36 +263,6 @@ class CoreExport ModuleManager
 	 */
 	static void RequireVersion(int major, int minor, int patch);
 
-	/** Change the priority of one event in a module.
-	 * Each module event has a list of modules which are attached to that event type. If you wish to be called before or after other specific modules, you may use this
-	 * method (usually within void Module::Prioritize()) to set your events priority. You may use this call in other methods too, however, this is not supported behaviour
-	 * for a module.
-	 * @param mod The module to change the priority of
-	 * @param i The event to change the priority of
-	 * @param s The state you wish to use for this event. Use one of
-	 * PRIO_FIRST to set the event to be first called, PRIO_LAST to set it to be the last called, or PRIO_BEFORE and PRIO_AFTER
-	 * to set it to be before or after one or more other modules.
-	 * @param modules If PRIO_BEFORE or PRIO_AFTER is set in parameter 's', then this contains a list of one or more modules your module must be
-	 * placed before or after. Your module will be placed before the highest priority module in this list for PRIO_BEFORE, or after the lowest
-	 * priority module in this list for PRIO_AFTER.
-	 * @param sz The number of modules being passed for PRIO_BEFORE and PRIO_AFTER. Defaults to 1, as most of the time you will only want to prioritize your module
-	 * to be before or after one other module.
-	 */
-	static bool SetPriority(Module *mod, Implementation i, Priority s, Module **modules = NULL, size_t sz = 1);
-
-	/** Change the priority of all events in a module.
-	 * @param mod The module to set the priority of
-	 * @param s The priority of all events in the module.
-	 * Note that with this method, it is not possible to effectively use PRIO_BEFORE or PRIO_AFTER, you should use the more fine tuned
-	 * SetPriority method for this, where you may specify other modules to be prioritized against.
-	 */
-	static bool SetPriority(Module *mod, Priority s);
-
-	/** Detach all events from a module (used on unload)
-	 * @param mod Module to detach from
-	 */
-	static void DetachAll(Module *mod);
-
 	/** Unloading all modules except the protocol module.
 	 */
 	static void UnloadAll();
diff --git a/include/modules/bs_badwords.h b/include/modules/bs_badwords.h
index 678512c96..390e502c0 100644
--- a/include/modules/bs_badwords.h
+++ b/include/modules/bs_badwords.h
@@ -71,3 +71,21 @@ struct BadWords
 	virtual void Check() = 0;
 };
 
+namespace Event
+{
+	struct CoreExport BadWordEvents : Events
+	{
+		/** Called before a badword is added to the badword list
+		 * @param ci The channel
+		 * @param bw The badword
+		 */
+		virtual void OnBadWordAdd(ChannelInfo *ci, const BadWord *bw) anope_abstract;
+
+		/** Called before a badword is deleted from a channel
+		 * @param ci The channel
+		 * @param bw The badword
+		 */
+		virtual void OnBadWordDel(ChannelInfo *ci, const BadWord *bw) anope_abstract;
+	};
+}
+
diff --git a/include/modules/bs_bot.h b/include/modules/bs_bot.h
new file mode 100644
index 000000000..c6d670f35
--- /dev/null
+++ b/include/modules/bs_bot.h
@@ -0,0 +1,34 @@
+/*
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport BotCreate : Events
+	{
+		/** Called when a new bot is made
+		 * @param bi The bot
+		 */
+		virtual void OnBotCreate(BotInfo *bi) anope_abstract;
+	};
+
+	struct CoreExport BotChange : Events
+	{
+		/** Called when a bot is changed
+		 * @param bi The bot
+		 */
+		virtual void OnBotChange(BotInfo *bi) anope_abstract;
+	};
+
+	struct CoreExport BotDelete : Events
+	{
+		/** Called when a bot is deleted
+		 * @param bi The bot
+		 */
+		virtual void OnBotDelete(BotInfo *bi) anope_abstract;
+	};
+}
diff --git a/include/modules/bs_info.h b/include/modules/bs_info.h
new file mode 100644
index 000000000..c9f360dfc
--- /dev/null
+++ b/include/modules/bs_info.h
@@ -0,0 +1,20 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport BotInfoEvent : Events
+	{
+		/** Called when a user uses botserv/info on a bot or channel.
+		 */
+		virtual void OnBotInfo(CommandSource &source, BotInfo *bi, ChannelInfo *ci, InfoFormatter &info) anope_abstract;
+	};
+	extern CoreExport EventHandlers<BotInfoEvent> OnBotInfo;
+}
+
diff --git a/include/modules/bs_kick.h b/include/modules/bs_kick.h
index 61cd987d5..a783b6017 100644
--- a/include/modules/bs_kick.h
+++ b/include/modules/bs_kick.h
@@ -44,3 +44,17 @@ struct KickerData
 	virtual ~KickerData() { }
 	virtual void Check(ChannelInfo *ci) = 0;
 };
+
+namespace Event
+{
+	struct CoreExport BotBan : Events
+	{
+		/** Called when a bot places a ban
+		 * @param u User being banned
+		 * @param ci Channel the ban is placed on
+		 * @param mask The mask being banned
+		 */
+		virtual void OnBotBan(User *u, ChannelInfo *ci, const Anope::string &mask) anope_abstract;
+	};
+}
+
diff --git a/include/modules/chanserv.h b/include/modules/chanserv.h
new file mode 100644
index 000000000..37a96e9e7
--- /dev/null
+++ b/include/modules/chanserv.h
@@ -0,0 +1,46 @@
+/*
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace ChanServ
+{
+	class ChanServService : public Service
+	{
+	 public:
+		ChanServService(Module *m) : Service(m, "ChanServService", "ChanServ")
+		{
+		}
+
+		/* Have ChanServ hold the channel, that is, join and set +nsti and wait
+		 * for a few minutes so no one can join or rejoin.
+		 */
+		virtual void Hold(Channel *c) anope_abstract;
+	};
+	static ServiceReference<ChanServService> service("ChanServService", "ChanServ");
+
+	namespace Event
+	{
+		struct CoreExport PreChanExpire : Events
+		{
+			/** Called before a channel expires
+			 * @param ci The channel
+			 * @param expire Set to true to allow the chan to expire
+			 */
+			virtual void OnPreChanExpire(ChannelInfo *ci, bool &expire) anope_abstract;
+		};
+		static EventHandlersReference<PreChanExpire> OnPreChanExpire("OnPreChanExpire");
+
+		struct CoreExport ChanExpire : Events
+		{
+			/** Called before a channel expires
+			 * @param ci The channel
+			 */
+			virtual void OnChanExpire(ChannelInfo *ci) anope_abstract;
+		};
+		static EventHandlersReference<ChanExpire> OnChanExpire("OnChanExpire");
+	}
+}
diff --git a/include/modules/cs_access.h b/include/modules/cs_access.h
new file mode 100644
index 000000000..8c6778799
--- /dev/null
+++ b/include/modules/cs_access.h
@@ -0,0 +1,22 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport LevelChange : Events
+	{
+		/** Called when a level for a channel is changed
+		 * @param source The source of the command
+		 * @param ci The channel the level was changed on
+		 * @param priv The privilege changed
+		 * @param what The new level
+		 */
+		virtual void OnLevelChange(CommandSource &source, ChannelInfo *ci, const Anope::string &priv, int16_t what) anope_abstract;
+	};
+}
diff --git a/include/modules/cs_akick.h b/include/modules/cs_akick.h
new file mode 100644
index 000000000..ab02985c1
--- /dev/null
+++ b/include/modules/cs_akick.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport Akick : Events
+	{
+		/** Called after adding an akick to a channel
+		 * @param source The source of the command
+		 * @param ci The channel
+		 * @param ak The akick
+		 */
+		virtual void OnAkickAdd(CommandSource &source, ChannelInfo *ci, const AutoKick *ak) anope_abstract;
+
+		/** Called before removing an akick from a channel
+		 * @param source The source of the command
+		 * @param ci The channel
+		 * @param ak The akick
+		 */
+		virtual void OnAkickDel(CommandSource &source, ChannelInfo *ci, const AutoKick *ak) anope_abstract;
+	};
+}
diff --git a/include/modules/cs_drop.h b/include/modules/cs_drop.h
new file mode 100644
index 000000000..e2a9ace8a
--- /dev/null
+++ b/include/modules/cs_drop.h
@@ -0,0 +1,20 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport ChanDrop : Events
+	{
+		/** Called right before a channel is dropped
+		 * @param source The user dropping the channel
+		 * @param ci The channel
+		 */
+		virtual EventReturn OnChanDrop(CommandSource &source, ChannelInfo *ci) anope_abstract;
+	};
+}
diff --git a/include/modules/cs_info.h b/include/modules/cs_info.h
new file mode 100644
index 000000000..7f0429387
--- /dev/null
+++ b/include/modules/cs_info.h
@@ -0,0 +1,23 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport ChanInfo : Events
+	{
+		/** Called when a user requests info for a channel
+		 * @param source The user requesting info
+		 * @param ci The channel the user is requesting info for
+		 * @param info Data to show the user requesting information
+		 * @param show_hidden true if we should show the user everything
+		 */
+		virtual void OnChanInfo(CommandSource &source, ChannelInfo *ci, InfoFormatter &info, bool show_hidden) anope_abstract;
+	};
+}
+
diff --git a/include/modules/cs_mode.h b/include/modules/cs_mode.h
index 44ffd5a7f..4c1dc5d55 100644
--- a/include/modules/cs_mode.h
+++ b/include/modules/cs_mode.h
@@ -88,3 +88,23 @@ struct ModeLocks
 	virtual void Check() = 0;
 };
 
+namespace Event
+{
+	struct CoreExport MLockEvents : Events
+	{
+		/** Called when a mode is about to be mlocked
+		 * @param ci The channel the mode is being locked on
+		 * @param lock The mode lock
+		 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to deny the mlock.
+		 */
+		virtual EventReturn OnMLock(ChannelInfo *ci, ModeLock *lock) anope_abstract;
+
+		/** Called when a mode is about to be unlocked
+		 * @param ci The channel the mode is being unlocked from
+		 * @param lock The mode lock
+		 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to deny the mlock.
+		 */
+		virtual EventReturn OnUnMLock(ChannelInfo *ci, ModeLock *lock) anope_abstract;
+	};
+}
+
diff --git a/include/modules/cs_set.h b/include/modules/cs_set.h
new file mode 100644
index 000000000..3ddf2f41c
--- /dev/null
+++ b/include/modules/cs_set.h
@@ -0,0 +1,25 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport SetChannelOption : Events
+	{
+		/** Called when a chanserv/set command is used
+		 * @param source The source of the command
+		 * @param cmd The command
+		 * @param ci The channel the command was used on
+		 * @param setting The setting passed to the command. Probably ON/OFF.
+		 * @return EVENT_ALLOW to bypass access checks, EVENT_STOP to halt immediately.
+		 */
+		virtual EventReturn OnSetChannelOption(CommandSource &source, Command *cmd, ChannelInfo *ci, const Anope::string &setting) anope_abstract;
+	};
+	static EventHandlersReference<SetChannelOption> OnSetChannelOption("OnSetChannelOption");
+}
+
diff --git a/include/modules/dns.h b/include/modules/dns.h
index 59fc83e64..e340c3f2b 100644
--- a/include/modules/dns.h
+++ b/include/modules/dns.h
@@ -175,6 +175,20 @@ namespace DNS
 	};
 	
 } // namespace DNS
+
+namespace Event
+{
+	struct CoreExport DnsRequest : Events
+	{
+		/** Called when a DNS request (question) is recieved.
+		 * @param req The dns request
+		 * @param reply The reply that will be sent
+		 */
+		virtual void OnDnsRequest(DNS::Query &req, DNS::Query *reply) anope_abstract;
+	};
+	static EventHandlersReference<DnsRequest> OnDnsRequest("OnDnsRequest");
+}
+
 	
 #endif // DNS_H
 	
diff --git a/include/modules/fantasy.h b/include/modules/fantasy.h
new file mode 100644
index 000000000..a7944cef9
--- /dev/null
+++ b/include/modules/fantasy.h
@@ -0,0 +1,35 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct BotFantasy : Events
+	{
+		/** Called on fantasy command
+		 * @param source The source of the command
+		 * @param c The command
+		 * @param ci The channel it's being used in
+		 * @param params The params
+		 * @return EVENT_STOP to halt processing and not run the command, EVENT_ALLOW to allow the command to be executed
+		 */
+		virtual EventReturn OnBotFantasy(CommandSource &source, Command *c, ChannelInfo *ci, const std::vector<Anope::string> &params) anope_abstract;
+	};
+
+	struct CoreExport BotNoFantasyAccess : Events
+	{
+		/** Called on fantasy command without access
+		 * @param source The source of the command
+		 * @param c The command
+		 * @param ci The channel it's being used in
+		 * @param params The params
+		 * @return EVENT_STOP to halt processing and not run the command, EVENT_ALLOW to allow the command to be executed
+		 */
+		virtual EventReturn OnBotNoFantasyAccess(CommandSource &source, Command *c, ChannelInfo *ci, const std::vector<Anope::string> &params) anope_abstract;
+	};
+}
diff --git a/include/modules/global.h b/include/modules/global.h
new file mode 100644
index 000000000..f4f4989ae
--- /dev/null
+++ b/include/modules/global.h
@@ -0,0 +1,29 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Global
+{
+	class GlobalService : public Service
+	{
+	 public:
+		GlobalService(Module *m) : Service(m, "GlobalService", "Global")
+		{
+		}
+
+		/** Send out a global message to all users
+		 * @param sender Our client which should send the global
+		 * @param source The sender of the global
+		 * @param message The message
+		 */
+		virtual void SendGlobal(BotInfo *sender, const Anope::string &source, const Anope::string &message) = 0;
+	};
+	static ServiceReference<GlobalService> service("GlobalService", "Global");
+}
+
+
diff --git a/include/modules/help.h b/include/modules/help.h
new file mode 100644
index 000000000..333e5f9c8
--- /dev/null
+++ b/include/modules/help.h
@@ -0,0 +1,27 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport Help : Events
+	{
+		/** Called when someone uses the generic/help command
+		 * @param source Command source
+		 * @param params Params
+		 * @return EVENT_STOP to stop processing
+		 */
+		virtual EventReturn OnPreHelp(CommandSource &source, const std::vector<Anope::string> &params) anope_abstract;
+
+		/** Called when someone uses the generic/help command
+		 * @param source Command source
+		 * @param params Params
+		 */
+		virtual void OnPostHelp(CommandSource &source, const std::vector<Anope::string> &params) anope_abstract;
+	};
+}
diff --git a/include/modules/hs_del.h b/include/modules/hs_del.h
new file mode 100644
index 000000000..d4a5c7666
--- /dev/null
+++ b/include/modules/hs_del.h
@@ -0,0 +1,18 @@
+/*
+ *
+ * (C) 2003-2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ */
+
+namespace Event
+{
+	struct CoreExport DeleteVhost : Events
+	{
+		/** Called when a vhost is deleted
+		 * @param na The nickalias of the vhost
+		 */
+		virtual void OnDeleteVhost(NickAlias *na) anope_abstract;
+	};
+}
diff --git a/include/modules/memoserv.h b/include/modules/memoserv.h
new file mode 100644
index 000000000..4e5d67de6
--- /dev/null
+++ b/include/modules/memoserv.h
@@ -0,0 +1,66 @@
+/*
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace MemoServ
+{
+	class MemoServService : public Service
+	{
+	 public:
+		enum MemoResult
+		{
+			MEMO_SUCCESS,
+			MEMO_INVALID_TARGET,
+			MEMO_TOO_FAST,
+			MEMO_TARGET_FULL
+		};
+	
+		MemoServService(Module *m) : Service(m, "MemoServService", "MemoServ")
+		{
+		}
+	
+		/** Sends a memo.
+		 * @param source The source of the memo, can be anythin.
+		 * @param target The target of the memo, nick or channel.
+		 * @param message Memo text
+		 * @param force true to force the memo, restrictions/delays etc are not checked
+		 */
+		virtual MemoResult Send(const Anope::string &source, const Anope::string &target, const Anope::string &message, bool force = false) = 0;
+	
+		/** Check for new memos and notify the user if there are any
+		 * @param u The user
+		 */
+		virtual void Check(User *u) = 0;
+	};
+	static ServiceReference<MemoServService> service("MemoServService", "MemoServ");
+	
+	namespace Event
+	{
+		struct CoreExport MemoSend : Events
+		{
+			/** Called when a memo is sent
+			 * @param source The source of the memo
+			 * @param target The target of the memo
+			 * @param mi Memo info for target
+			 * @param m The memo
+			 */
+			virtual void OnMemoSend(const Anope::string &source, const Anope::string &target, MemoInfo *mi, Memo *m) anope_abstract;
+		};
+		static EventHandlersReference<MemoSend> OnMemoSend("OnMemoSend");
+	
+		struct CoreExport MemoDel : Events
+		{
+			/** Called when a memo is deleted
+			 * @param target The target the memo is being deleted from (nick or channel)
+			 * @param mi The memo info
+			 * @param m The memo
+			 */
+			virtual void OnMemoDel(const Anope::string &target, MemoInfo *mi, const Memo *m) anope_abstract;
+		};
+		static EventHandlersReference<MemoDel> OnMemoDel("OnMemoDel");
+	}
+}
diff --git a/include/modules/nickserv.h b/include/modules/nickserv.h
new file mode 100644
index 000000000..0ede4130e
--- /dev/null
+++ b/include/modules/nickserv.h
@@ -0,0 +1,68 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace NickServ
+{
+	class NickServService : public Service
+	{
+	 public:
+		NickServService(Module *m) : Service(m, "NickServService", "NickServ")
+		{
+		}
+
+		virtual void Validate(User *u) anope_abstract;
+		virtual void Collide(User *u, NickAlias *na) anope_abstract;
+		virtual void Release(NickAlias *na) anope_abstract;
+	};
+	static ServiceReference<NickServService> service("NickServService", "NickServ");
+
+	namespace Event
+	{
+		struct CoreExport PreNickExpire : Events
+		{
+			/** Called before a nick expires
+			 * @param na The nick
+			 * @param expire Set to true to allow the nick to expire
+			 */
+			virtual void OnPreNickExpire(NickAlias *na, bool &expire) anope_abstract;
+		};
+		static EventHandlersReference<PreNickExpire> OnPreNickExpire("OnPreNickExpire");
+
+		struct CoreExport NickExpire : Events
+		{
+			/** Called when a nick drops
+			 * @param na The nick
+			 */
+			virtual void OnNickExpire(NickAlias *na) anope_abstract;
+		};
+		static EventHandlersReference<NickExpire> OnNickExpire("OnNickExpire");
+
+		struct CoreExport NickRegister : Events
+		{
+			/** Called when a nick is registered
+			 * @param user The user registering the nick, of any
+			 * @param The nick
+			 */
+			virtual void OnNickRegister(User *user, NickAlias *na) anope_abstract;
+		};
+		static EventHandlersReference<NickRegister> OnNickRegister("OnNickRegister");
+
+		struct CoreExport NickValidate : Events
+		{
+			/** Called when a nick is validated. That is, to determine if a user is permissted
+			 * to be on the given nick.
+			 * @param u The user
+			 * @param na The nick they are on
+			 * @return EVENT_STOP to force the user off of the nick
+			 */
+			virtual EventReturn OnNickValidate(User *u, NickAlias *na) anope_abstract;
+		};
+		static EventHandlersReference<NickValidate> OnNickValidate("OnNickValidate");
+	}
+}
diff --git a/include/modules/ns_cert.h b/include/modules/ns_cert.h
index e02b9bd6e..b0614b2e6 100644
--- a/include/modules/ns_cert.h
+++ b/include/modules/ns_cert.h
@@ -69,3 +69,26 @@ class CertService : public Service
 	virtual NickCore* FindAccountFromCert(const Anope::string &cert) = 0;
 };
 
+namespace Event
+{
+	struct CoreExport NickCertEvents : Events
+	{
+		/** Called when a user adds an entry to their cert list
+		 * @param nc The nick
+		 * @param entry The entry
+		 */
+		virtual void OnNickAddCert(NickCore *nc, const Anope::string &entry) anope_abstract;
+
+		/** Called from NickCore::EraseCert()
+		 * @param nc pointer to the NickCore
+		 * @param entry The fingerprint
+		 */
+		virtual void OnNickEraseCert(NickCore *nc, const Anope::string &entry) anope_abstract;
+
+		/** called from NickCore::ClearCert()
+		 * @param nc pointer to the NickCore
+		 */
+		virtual void OnNickClearCert(NickCore *nc) anope_abstract;
+	};
+}
+
diff --git a/include/modules/ns_drop.h b/include/modules/ns_drop.h
new file mode 100644
index 000000000..2aef2b965
--- /dev/null
+++ b/include/modules/ns_drop.h
@@ -0,0 +1,21 @@
+/*
+ *
+ * (C) 2003-2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ */
+
+namespace Event
+{
+	struct CoreExport NickDrop : Events
+	{
+		/** Called when a nick is dropped
+		 * @param source The source of the command
+		 * @param na The nick
+		 */
+		virtual void OnNickDrop(CommandSource &source, NickAlias *na) anope_abstract;
+	};
+	extern CoreExport EventHandlers<NickDrop> OnNickDrop;
+}
+
diff --git a/include/modules/ns_group.h b/include/modules/ns_group.h
new file mode 100644
index 000000000..8b3fa49f9
--- /dev/null
+++ b/include/modules/ns_group.h
@@ -0,0 +1,20 @@
+/*
+ *
+ * (C) 2003-2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport NickGroup : Events
+	{
+		/** Called when a user groups their nick
+		 * @param u The user grouping
+		 * @param target The target they're grouping to
+		 */
+		virtual void OnNickGroup(User *u, NickAlias *target) anope_abstract;
+	};
+}
diff --git a/include/modules/ns_info.h b/include/modules/ns_info.h
new file mode 100644
index 000000000..8fae2b536
--- /dev/null
+++ b/include/modules/ns_info.h
@@ -0,0 +1,22 @@
+/*
+ *
+ * (C) 2003-2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport NickInfo : Events
+	{
+		/** Called when a user requests info for a nick
+		 * @param source The user requesting info
+		 * @param na The nick the user is requesting info from
+		 * @param info Data to show the user requesting information
+		 * @param show_hidden true if we should show the user everything
+		 */
+		virtual void OnNickInfo(CommandSource &source, NickAlias *na, InfoFormatter &info, bool show_hidden) anope_abstract;
+	};
+}
diff --git a/include/modules/ns_set.h b/include/modules/ns_set.h
new file mode 100644
index 000000000..a45fa0b5e
--- /dev/null
+++ b/include/modules/ns_set.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport SetNickOption : Events
+	{
+		/** Called when a nickserv/set command is used.
+		 * @param source The source of the command
+		 * @param cmd The command
+		 * @param nc The nickcore being modifed
+		 * @param setting The setting passed to the command. Probably ON/OFF.
+		 * @return EVENT_STOP to halt immediately
+		 */
+		virtual EventReturn OnSetNickOption(CommandSource &source, Command *cmd, NickCore *nc, const Anope::string &setting) anope_abstract;
+	};
+	static EventHandlersReference<SetNickOption> OnSetNickOption("OnSetNickOption");
+}
diff --git a/include/modules/ns_update.h b/include/modules/ns_update.h
new file mode 100644
index 000000000..d5d01320a
--- /dev/null
+++ b/include/modules/ns_update.h
@@ -0,0 +1,20 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport NickUpdate : Events
+	{
+		/** Called when a user does /ns update
+		 * @param u The user
+		 */
+		virtual void OnNickUpdate(User *u) anope_abstract;
+	};
+}
+
diff --git a/include/modules/os_defcon.h b/include/modules/os_defcon.h
new file mode 100644
index 000000000..81b220eb3
--- /dev/null
+++ b/include/modules/os_defcon.h
@@ -0,0 +1,20 @@
+/*
+ *
+ * (C) 2014 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ *
+ */
+
+namespace Event
+{
+	struct CoreExport DefconLevel : Events
+	{
+		/** Called when defcon level changes
+		 * @param level The level
+		 */
+		virtual void OnDefconLevel(int level) anope_abstract;
+	};
+}
+
diff --git a/include/modules/os_session.h b/include/modules/os_session.h
index ac6bf9395..91548a5c2 100644
--- a/include/modules/os_session.h
+++ b/include/modules/os_session.h
@@ -51,6 +51,24 @@ class SessionService : public Service
 
 static ServiceReference<SessionService> session_service("SessionService", "session");
 
+namespace Event
+{
+	struct CoreExport Exception : Events
+	{
+		/** Called after an exception has been added
+		 * @param ex The exception
+		 * @return EVENT_CONTINUE to let other modules decide, EVENT_STOP to halt the command and not process it
+		 */
+		virtual EventReturn OnExceptionAdd(::Exception *ex) anope_abstract;
+
+		/** Called before an exception is deleted
+		 * @param source The source deleting it
+		 * @param ex The exceotion
+		 */
+		virtual void OnExceptionDel(CommandSource &source, ::Exception *ex) anope_abstract;
+	};
+}
+
 void Exception::Serialize(Serialize::Data &data) const
 {
 	data["mask"] << this->mask;
diff --git a/include/modules/pseudoclients/chanserv.h b/include/modules/pseudoclients/chanserv.h
deleted file mode 100644
index e1c3849fd..000000000
--- a/include/modules/pseudoclients/chanserv.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef CHANSERV_H
-#define CHANSERV_H
-
-class ChanServService : public Service
-{
- public:
-	ChanServService(Module *m) : Service(m, "ChanServService", "ChanServ")
-	{
-	}
-
-	/* Have ChanServ hold the channel, that is, join and set +nsti and wait
-	 * for a few minutes so no one can join or rejoin.
-	 */
-	virtual void Hold(Channel *c) = 0;
-};
-
-#endif // CHANSERV_H
-
diff --git a/include/modules/pseudoclients/global.h b/include/modules/pseudoclients/global.h
deleted file mode 100644
index 1511214c9..000000000
--- a/include/modules/pseudoclients/global.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef GLOBAL_H
-#define GLOBAL_H
-
-class GlobalService : public Service
-{
- public:
-	GlobalService(Module *m) : Service(m, "GlobalService", "Global")
-	{
-	}
-
-	/** Send out a global message to all users
-	 * @param sender Our client which should send the global
-	 * @param source The sender of the global
-	 * @param message The message
-	 */
-	virtual void SendGlobal(BotInfo *sender, const Anope::string &source, const Anope::string &message) = 0;
-};
-
-#endif // GLOBAL_H
-
diff --git a/include/modules/pseudoclients/memoserv.h b/include/modules/pseudoclients/memoserv.h
deleted file mode 100644
index d35d3f8a0..000000000
--- a/include/modules/pseudoclients/memoserv.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef MEMOSERV_H
-#define MEMOSERV_H
-
-class MemoServService : public Service
-{
- public:
-	enum MemoResult
-	{
-		MEMO_SUCCESS,
-		MEMO_INVALID_TARGET,
-		MEMO_TOO_FAST,
-		MEMO_TARGET_FULL
-	};
-
-	MemoServService(Module *m) : Service(m, "MemoServService", "MemoServ")
-	{
-	}
-
-	/** Sends a memo.
-	 * @param source The source of the memo, can be anythin.
-	 * @param target The target of the memo, nick or channel.
-	 * @param message Memo text
-	 * @param force true to force the memo, restrictions/delays etc are not checked
-	 */
-	virtual MemoResult Send(const Anope::string &source, const Anope::string &target, const Anope::string &message, bool force = false) = 0;
-
-	/** Check for new memos and notify the user if there are any
-	 * @param u The user
-	 */
-	virtual void Check(User *u) = 0;
-};
-
-#endif // MEMOSERV_H
-
diff --git a/include/modules/pseudoclients/nickserv.h b/include/modules/pseudoclients/nickserv.h
deleted file mode 100644
index c0238ecfc..000000000
--- a/include/modules/pseudoclients/nickserv.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef NICKSERV_H
-#define NICKSERV_H
-
-class NickServService : public Service
-{
- public:
-	NickServService(Module *m) : Service(m, "NickServService", "NickServ")
-	{
-	}
-
-	virtual void Validate(User *u) = 0;
-	virtual void Collide(User *u, NickAlias *na) = 0;
-	virtual void Release(NickAlias *na) = 0;
-};
-
-#endif // NICKSERV_H
-
diff --git a/include/modules/suspend.h b/include/modules/suspend.h
index 1e49b8ad8..bd4eacd3b 100644
--- a/include/modules/suspend.h
+++ b/include/modules/suspend.h
@@ -1,11 +1,9 @@
 /*
- * (C) 2003-2014 Anope Team
+ * (C) 2014 Anope Team
  * Contact us at team@anope.org
  *
  * Please read COPYING and README for further details.
  *
- * Based on the original code of Epona by Lara.
- * Based on the original code of Services by Andy Church.
  */
 
 struct SuspendInfo
@@ -16,3 +14,39 @@ struct SuspendInfo
 	SuspendInfo() { }
 	virtual ~SuspendInfo() { }
 };
+
+namespace Event
+{
+	struct CoreExport ChanSuspend : Events
+	{
+		/** Called when a channel is suspended
+		 * @param ci The channel
+		 */
+		virtual void OnChanSuspend(ChannelInfo *ci) anope_abstract;
+	};
+	struct CoreExport ChanUnsuspend : Events
+	{
+		/** Called when a channel is unsuspended
+		 * @param ci The channel
+		 */
+		virtual void OnChanUnsuspend(ChannelInfo *ci) anope_abstract;
+	};
+	extern CoreExport EventHandlers<ChanUnsuspend> OnChanUnsuspend;
+
+	struct CoreExport NickSuspend : Events
+	{
+		/** Called when a nick is suspended
+		 * @param na The nick alias
+		 */
+		virtual void OnNickSuspend(NickAlias *na) anope_abstract;
+	};
+
+	struct CoreExport NickUnsuspended : Events
+	{
+		/** Called when a nick is unsuspneded
+		 * @param na The nick alias
+		 */
+		virtual void OnNickUnsuspended(NickAlias *na) anope_abstract;
+	};
+}
+
diff --git a/include/serialize.h b/include/serialize.h
index 4bfdd0cb3..22a9766d2 100644
--- a/include/serialize.h
+++ b/include/serialize.h
@@ -247,7 +247,7 @@ class Serialize::Reference : public ReferenceBase
 	T *ref;
 
  public:
- 	Reference() : ref(NULL)
+ 	Reference() : ref(nullptr)
 	{
 	}
 
@@ -257,78 +257,55 @@ class Serialize::Reference : public ReferenceBase
 			obj->AddReference(this);
 	}
 
-	Reference(const Reference<T> &other) : ReferenceBase(other), ref(other.ref)
+	Reference(const Reference<T> &other) : ref(other)
 	{
-		if (ref && !invalid)
+		if (this->ref)
 			this->ref->AddReference(this);
 	}
 
 	~Reference()
 	{
-		if (ref && !invalid)
+		if (this->ref)
 			this->ref->DelReference(this);
 	}
 
-	inline Reference<T>& operator=(const Reference<T> &other)
+	void Invalidate() override
+	{
+		this->ref = nullptr;
+	}
+
+	Reference<T>& operator=(const Reference<T> &other)
 	{
 		if (this != &other)
 		{
-			if (ref && !invalid)
+			if (ref)
 				this->ref->DelReference(this);
 
 			this->ref = other.ref;
-			this->invalid = other.invalid;
 
-			if (ref && !invalid)
+			if (ref)
 				this->ref->AddReference(this);
 		}
 		return *this;
 	}
 
-	inline operator bool() const
+	explicit operator bool() const
 	{
-		if (!this->invalid)
-			return this->ref != NULL;
-		return false;
+		return this->ref != nullptr;
 	}
 
-	inline operator T*() const
-	{
-		if (!this->invalid)
-		{
-			if (this->ref)
-				// This can invalidate me
-				this->ref->QueueUpdate();
-			if (!this->invalid)
-				return this->ref;
-		}
-		return NULL;
-	}
+	operator T*() const { return Dereference(); }
 
-	inline T* operator*() const
-	{
-		if (!this->invalid)
-		{
-			if (this->ref)
-				// This can invalidate me
-				this->ref->QueueUpdate();
-			if (!this->invalid)
-				return this->ref;
-		}
-		return NULL;
-	}
+	T* operator*() const { return Dereference(); }
+	T* operator->() const { return Dereference(); }
 
-	inline T* operator->() const
+ private:
+	T* Dereference() const
 	{
-		if (!this->invalid)
-		{
-			if (this->ref)
-				// This can invalidate me
-				this->ref->QueueUpdate();
-			if (!this->invalid)
-				return this->ref;
-		}
-		return NULL;
+		if (this->ref)
+			// This can invalidate me
+			this->ref->QueueUpdate();
+		return this->ref;
 	}
 };
 
diff --git a/include/service.h b/include/service.h
index 32686afb5..d8287fc52 100644
--- a/include/service.h
+++ b/include/service.h
@@ -23,62 +23,21 @@
  */
 class CoreExport Service : public virtual Base
 {
-	static std::map<Anope::string, std::map<Anope::string, Service *> > Services;
-	static std::map<Anope::string, std::map<Anope::string, Anope::string> > Aliases;
+	static std::map<Anope::string, std::map<Anope::string, Service *> > *Services;
+	static std::map<Anope::string, std::map<Anope::string, Anope::string> > *Aliases;
 
-	static Service *FindService(const std::map<Anope::string, Service *> &services, const std::map<Anope::string, Anope::string> *aliases, const Anope::string &n)
-	{
-		std::map<Anope::string, Service *>::const_iterator it = services.find(n);
-		if (it != services.end())
-			return it->second;
+	static void check();
 
-		if (aliases != NULL)
-		{
-			std::map<Anope::string, Anope::string>::const_iterator it2 = aliases->find(n);
-			if (it2 != aliases->end())
-				return FindService(services, aliases, it2->second);
-		}
-
-		return NULL;
-	}
+	static Service *FindService(const std::map<Anope::string, Service *> &services, const std::map<Anope::string, Anope::string> *aliases, const Anope::string &n);
 
  public:
- 	static Service *FindService(const Anope::string &t, const Anope::string &n)
-	{
-		std::map<Anope::string, std::map<Anope::string, Service *> >::const_iterator it = Services.find(t);
-		if (it == Services.end())
-			return NULL;
-
-		std::map<Anope::string, std::map<Anope::string, Anope::string> >::const_iterator it2 = Aliases.find(t);
-		if (it2 != Aliases.end())
-			return FindService(it->second, &it2->second, n);
-
-		return FindService(it->second, NULL, n);
-	}
+ 	static Service *FindService(const Anope::string &t, const Anope::string &n);
 
-	static std::vector<Anope::string> GetServiceKeys(const Anope::string &t)
-	{
-		std::vector<Anope::string> keys;
-		std::map<Anope::string, std::map<Anope::string, Service *> >::iterator it = Services.find(t);
-		if (it != Services.end())
-			for (std::map<Anope::string, Service *>::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2)
-				keys.push_back(it2->first);
-		return keys;
-	}
+	static std::vector<Anope::string> GetServiceKeys(const Anope::string &t);
 
-	static void AddAlias(const Anope::string &t, const Anope::string &n, const Anope::string &v)
-	{
-		std::map<Anope::string, Anope::string> &smap = Aliases[t];
-		smap[n] = v;
-	}
+	static void AddAlias(const Anope::string &t, const Anope::string &n, const Anope::string &v);
 
-	static void DelAlias(const Anope::string &t, const Anope::string &n)
-	{
-		std::map<Anope::string, Anope::string> &smap = Aliases[t];
-		smap.erase(n);
-		if (smap.empty())
-			Aliases.erase(t);
-	}
+	static void DelAlias(const Anope::string &t, const Anope::string &n);
 
 	Module *owner;
 	/* Service type, which should be the class name (eg "Command") */
@@ -86,31 +45,15 @@ class CoreExport Service : public virtual Base
 	/* Service name, commands are usually named service/command */
 	Anope::string name;
 
-	Service(Module *o, const Anope::string &t, const Anope::string &n) : owner(o), type(t), name(n)
-	{
-		this->Register();
-	}
+	Service(Module *o, const Anope::string &t, const Anope::string &n);
 
-	virtual ~Service()
-	{
-		this->Unregister();
-	}
+	Service(const Service &) = delete;
 
-	void Register()
-	{
-		std::map<Anope::string, Service *> &smap = Services[this->type];
-		if (smap.find(this->name) != smap.end())
-			throw ModuleException("Service " + this->type + " with name " + this->name + " already exists");
-		smap[this->name] = this;
-	}
+	virtual ~Service();
 
-	void Unregister()
-	{
-		std::map<Anope::string, Service *> &smap = Services[this->type];
-		smap.erase(this->name);
-		if (smap.empty())
-			Services.erase(this->type);
-	}
+	void Register();
+
+	void Unregister();
 };
 
 /** Like Reference, but used to refer to Services.
@@ -120,6 +63,7 @@ class ServiceReference : public Reference<T>
 {
 	Anope::string type;
 	Anope::string name;
+	bool need_check = true;
 
  public:
  	ServiceReference() { }
@@ -128,45 +72,39 @@ class ServiceReference : public Reference<T>
 	{
 	}
 
-	inline void operator=(const Anope::string &n)
+	void operator=(const Anope::string &n)
 	{
 		this->name = n;
-		this->invalid = true;
 	}
 
-	operator bool() override
+	void Check() override
 	{
-		if (this->invalid)
-		{
-			this->invalid = false;
-			this->ref = NULL;
-		}
-		if (!this->ref)
+		if (need_check)
 		{
-			/* This really could be dynamic_cast in every case, except for when a module
-			 * creates its own service type (that other modules must include the header file
-			 * for), as the core is not compiled with it so there is no RTTI for it.
-			 */
-			this->ref = static_cast<T *>(::Service::FindService(this->type, this->name));
+			need_check = false;
+
+			this->ref = static_cast<T *>(Service::FindService(this->type, this->name));
 			if (this->ref)
+			{
 				this->ref->AddReference(this);
+				this->OnAcquire();
+			}
 		}
-		return this->ref;
 	}
+
+	void Reset() override
+	{
+		need_check = true;
+	}
+
+	virtual void OnAcquire() { }
 };
 
 class ServiceAlias
 {
 	Anope::string t, f;
  public:
-	ServiceAlias(const Anope::string &type, const Anope::string &from, const Anope::string &to) : t(type), f(from)
-	{
-		Service::AddAlias(type, from, to);
-	}
-
-	~ServiceAlias()
-	{
-		Service::DelAlias(t, f);
-	}
+	ServiceAlias(const Anope::string &type, const Anope::string &from, const Anope::string &to);
+	~ServiceAlias();
 };
 
diff --git a/include/services.h b/include/services.h
index 5965cea09..b29773242 100644
--- a/include/services.h
+++ b/include/services.h
@@ -56,3 +56,5 @@
 # include "anope_windows.h"
 #endif
 
+#define anope_abstract = 0
+