m_spanningtree Remove duplicate code for sending channel messages from RouteCommand()

[user/henk/code/inspircd.git] / src / modules / m_spanningtree / commands.h

diff --git a/src/modules/m_spanningtree/commands.h b/src/modules/m_spanningtree/commands.h
index 93455c8c4c0dcdcc0d2bb6101837355d3aad2832..e467cdc8b62e17328b68a10da95e7f7fd4316fa1 100644 (file)
--- a/src/modules/m_spanningtree/commands.h
+++ b/src/modules/m_spanningtree/commands.h
@@ -25,110 +25,259 @@
  */
 class CommandRConnect : public Command
 {
-        SpanningTreeUtilities* Utils;  /* Utility class */
  public:
-        CommandRConnect (Module* Callback, SpanningTreeUtilities* Util);
+        CommandRConnect(Module* Creator);
         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
                RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
 };
 
 class CommandRSQuit : public Command
 {
-        SpanningTreeUtilities* Utils;  /* Utility class */
  public:
-        CommandRSQuit(Module* Callback, SpanningTreeUtilities* Util);
+        CommandRSQuit(Module* Creator);
         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
                RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
-        void NoticeUser(User* user, const std::string &msg);
 };
 
-class CommandSVSJoin : public Command
+class CommandMap : public Command
 {
+       /** Show MAP output to a user (recursive)
+        */
+       void ShowMap(TreeServer* Current, User* user, int depth, int &line, char* names, int &maxnamew, char* stats);
+
+       /** Returns oper-specific MAP information
+        */
+       std::string MapOperInfo(TreeServer* Current);
+
  public:
-       CommandSVSJoin(Module* Creator) : Command(Creator, "SVSJOIN", 2) { flags_needed = FLAG_SERVERONLY; }
-       CmdResult Handle (const std::vector<std::string>& parameters, User *user);
+       CommandMap(Module* Creator);
+       CmdResult Handle(const std::vector<std::string>& parameters, User* user);
        RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
 };
-class CommandSVSPart : public Command
+
+class CommandSVSJoin : public ServerCommand
 {
  public:
-       CommandSVSPart(Module* Creator) : Command(Creator, "SVSPART", 2) { flags_needed = FLAG_SERVERONLY; }
-       CmdResult Handle (const std::vector<std::string>& parameters, User *user);
+       CommandSVSJoin(Module* Creator) : ServerCommand(Creator, "SVSJOIN", 2) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
        RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
 };
-class CommandSVSNick : public Command
+
+class CommandSVSPart : public ServerCommand
 {
  public:
-       CommandSVSNick(Module* Creator) : Command(Creator, "SVSNICK", 3) { flags_needed = FLAG_SERVERONLY; }
-       CmdResult Handle (const std::vector<std::string>& parameters, User *user);
+       CommandSVSPart(Module* Creator) : ServerCommand(Creator, "SVSPART", 2) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
        RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
 };
-class CommandMetadata : public Command
+
+class CommandSVSNick : public ServerCommand
 {
  public:
-       CommandMetadata(Module* Creator) : Command(Creator, "METADATA", 2) { flags_needed = FLAG_SERVERONLY; }
-       CmdResult Handle (const std::vector<std::string>& parameters, User *user);
-       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
+       CommandSVSNick(Module* Creator) : ServerCommand(Creator, "SVSNICK", 3) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
+       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
 };
-class CommandUID : public Command
+
+class CommandMetadata : public ServerCommand
 {
  public:
-       CommandUID(Module* Creator) : Command(Creator, "UID", 10) { flags_needed = FLAG_SERVERONLY; }
-       CmdResult Handle (const std::vector<std::string>& parameters, User *user);
-       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
+       CommandMetadata(Module* Creator) : ServerCommand(Creator, "METADATA", 2) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
 };
-class CommandOpertype : public Command
+
+class CommandUID : public ServerCommand
 {
  public:
-       CommandOpertype(Module* Creator) : Command(Creator, "OPERTYPE", 1) { flags_needed = FLAG_SERVERONLY; }
-       CmdResult Handle (const std::vector<std::string>& parameters, User *user);
-       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
+       CommandUID(Module* Creator) : ServerCommand(Creator, "UID", 10) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
 };
-class CommandFJoin : public Command
+
+class CommandOpertype : public ServerCommand
 {
  public:
-       CommandFJoin(Module* Creator) : Command(Creator, "FJOIN", 3) { flags_needed = FLAG_SERVERONLY; }
-       CmdResult Handle (const std::vector<std::string>& parameters, User *user);
-       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
+       CommandOpertype(Module* Creator) : ServerCommand(Creator, "OPERTYPE", 1) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
+};
+
+class TreeSocket;
+class CommandFJoin : public ServerCommand
+{
        /** Remove all modes from a channel, including statusmodes (+qaovh etc), simplemodes, parameter modes.
         * This does not update the timestamp of the target channel, this must be done seperately.
         */
-       void RemoveStatus(User* source, parameterlist &params);
+       static void RemoveStatus(Channel* c);
+       static void ApplyModeStack(User* srcuser, Channel* c, irc::modestacker& stack);
+       bool ProcessModeUUIDPair(const std::string& item, TreeSocket* src_socket, Channel* chan, irc::modestacker* modestack);
+ public:
+       CommandFJoin(Module* Creator) : ServerCommand(Creator, "FJOIN", 3) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
+};
+
+class CommandFMode : public ServerCommand
+{
+ public:
+       CommandFMode(Module* Creator) : ServerCommand(Creator, "FMODE", 3) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
 };
-class CommandFMode : public Command
+
+class CommandFTopic : public ServerCommand
 {
  public:
-       CommandFMode(Module* Creator) : Command(Creator, "FMODE", 3) { flags_needed = FLAG_SERVERONLY; }
-       CmdResult Handle (const std::vector<std::string>& parameters, User *user);
-       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
+       CommandFTopic(Module* Creator) : ServerCommand(Creator, "FTOPIC", 5) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
 };
-class CommandFTopic : public Command
+
+class CommandFHost : public ServerCommand
 {
  public:
-       CommandFTopic(Module* Creator) : Command(Creator, "FTOPIC", 4) { flags_needed = FLAG_SERVERONLY; }
-       CmdResult Handle (const std::vector<std::string>& parameters, User *user);
-       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
+       CommandFHost(Module* Creator) : ServerCommand(Creator, "FHOST", 1) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
 };
-class CommandFHost : public Command
+
+class CommandFIdent : public ServerCommand
 {
  public:
-       CommandFHost(Module* Creator) : Command(Creator, "FHOST", 1) { flags_needed = FLAG_SERVERONLY; }
-       CmdResult Handle (const std::vector<std::string>& parameters, User *user);
-       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
+       CommandFIdent(Module* Creator) : ServerCommand(Creator, "FIDENT", 1) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
 };
-class CommandFIdent : public Command
+
+class CommandFName : public ServerCommand
 {
  public:
-       CommandFIdent(Module* Creator) : Command(Creator, "FIDENT", 1) { flags_needed = FLAG_SERVERONLY; }
-       CmdResult Handle (const std::vector<std::string>& parameters, User *user);
-       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
+       CommandFName(Module* Creator) : ServerCommand(Creator, "FNAME", 1) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
 };
-class CommandFName : public Command
+
+class CommandIJoin : public ServerCommand
+{
+ public:
+       CommandIJoin(Module* Creator) : ServerCommand(Creator, "IJOIN", 1) { }
+       CmdResult Handle(User* user, std::vector<std::string>& params);
+};
+
+class CommandResync : public ServerCommand
+{
+ public:
+       CommandResync(Module* Creator) : ServerCommand(Creator, "RESYNC", 1) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+};
+
+class CommandAway : public ServerCommand
+{
+ public:
+       CommandAway(Module* Creator) : ServerCommand(Creator, "AWAY", 0, 2) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+};
+
+class CommandAddLine : public ServerCommand
+{
+ public:
+       CommandAddLine(Module* Creator) : ServerCommand(Creator, "ADDLINE", 6, 6) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+};
+
+class CommandDelLine : public ServerCommand
+{
+ public:
+       CommandDelLine(Module* Creator) : ServerCommand(Creator, "DELLINE", 2, 2) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+};
+
+class CommandEncap : public ServerCommand
+{
+ public:
+       CommandEncap(Module* Creator) : ServerCommand(Creator, "ENCAP", 2) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+};
+
+class CommandIdle : public ServerCommand
+{
+ public:
+       CommandIdle(Module* Creator) : ServerCommand(Creator, "IDLE", 1) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_UNICAST(parameters[0]); }
+};
+
+class CommandNick : public ServerCommand
+{
+ public:
+       CommandNick(Module* Creator) : ServerCommand(Creator, "NICK", 2) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+};
+
+class CommandPing : public ServerCommand
+{
+ public:
+       CommandPing(Module* Creator) : ServerCommand(Creator, "PING", 1) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_UNICAST(parameters[0]); }
+};
+
+class CommandPong : public ServerCommand
+{
+ public:
+       CommandPong(Module* Creator) : ServerCommand(Creator, "PONG", 1) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_UNICAST(parameters[0]); }
+};
+
+class CommandPush : public ServerCommand
+{
+ public:
+       CommandPush(Module* Creator) : ServerCommand(Creator, "PUSH", 2) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_UNICAST(parameters[0]); }
+};
+
+class CommandSave : public ServerCommand
+{
+ public:
+       CommandSave(Module* Creator) : ServerCommand(Creator, "SAVE", 2) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+};
+
+class CommandServer : public ServerCommand
+{
+ public:
+       CommandServer(Module* Creator) : ServerCommand(Creator, "SERVER", 5) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+};
+
+class CommandSQuit : public ServerCommand
+{
+ public:
+       CommandSQuit(Module* Creator) : ServerCommand(Creator, "SQUIT", 2) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+};
+
+class CommandSNONotice : public ServerCommand
+{
+ public:
+       CommandSNONotice(Module* Creator) : ServerCommand(Creator, "SNONOTICE", 2) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+};
+
+class CommandVersion : public ServerCommand
+{
+ public:
+       CommandVersion(Module* Creator) : ServerCommand(Creator, "VERSION", 1) { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+};
+
+class CommandBurst : public ServerCommand
+{
+ public:
+       CommandBurst(Module* Creator) : ServerCommand(Creator, "BURST") { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
+};
+
+class CommandEndBurst : public ServerCommand
 {
  public:
-       CommandFName(Module* Creator) : Command(Creator, "FNAME", 1) { flags_needed = FLAG_SERVERONLY; }
-       CmdResult Handle (const std::vector<std::string>& parameters, User *user);
-       RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
+       CommandEndBurst(Module* Creator) : ServerCommand(Creator, "ENDBURST") { }
+       CmdResult Handle(User* user, std::vector<std::string>& parameters);
 };
 
 class SpanningTreeCommands
@@ -136,6 +285,7 @@ class SpanningTreeCommands
  public:
        CommandRConnect rconnect;
        CommandRSQuit rsquit;
+       CommandMap map;
        CommandSVSJoin svsjoin;
        CommandSVSPart svspart;
        CommandSVSNick svsnick;
@@ -143,10 +293,28 @@ class SpanningTreeCommands
        CommandUID uid;
        CommandOpertype opertype;
        CommandFJoin fjoin;
+       CommandIJoin ijoin;
+       CommandResync resync;
        CommandFMode fmode;
        CommandFTopic ftopic;
        CommandFHost fhost;
        CommandFIdent fident;
        CommandFName fname;
+       CommandAway away;
+       CommandAddLine addline;
+       CommandDelLine delline;
+       CommandEncap encap;
+       CommandIdle idle;
+       CommandNick nick;
+       CommandPing ping;
+       CommandPong pong;
+       CommandPush push;
+       CommandSave save;
+       CommandServer server;
+       CommandSQuit squit;
+       CommandSNONotice snonotice;
+       CommandVersion version;
+       CommandBurst burst;
+       CommandEndBurst endburst;
        SpanningTreeCommands(ModuleSpanningTree* module);
 };