commands.h

Go to the documentation of this file.

/* Declarations for command data.
 *
 * (C) 2003-2013 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.
 */

#ifndef COMMAND_H
#define COMMAND_H

#include "service.h"
#include "anope.h"
#include "channels.h"

struct CommandGroup
{
        Anope::string name, description;
};

/* Used in BotInfo::commands */
struct CommandInfo
{
        typedef Anope::map<CommandInfo> map;

        CommandInfo() : hide(false), prepend_channel(false) { }

        /* Service name of the command */
        Anope::string name;
        /* Permission required to execute the command */
        Anope::string permission;
        /* Group this command is in */
        Anope::string group;
        /* whether or not to hide this command in help output */
        bool hide;
        /* Only used with fantasy */
        bool prepend_channel;
};

/* Where the replies from commands go to. User inheits from this and is the normal
 * source of a CommandReply
 */
struct CoreExport CommandReply
{
        virtual ~CommandReply() { }
        virtual void SendMessage(const BotInfo *source, const Anope::string &msg) = 0;
};

/* The source for a command */
class CoreExport CommandSource
{
        /* The nick executing the command */
        Anope::string nick;
        /* User executing the command, may be NULL */
        Reference<User> u;
 public:
        /* The account executing the command */
        Reference<NickCore> nc;
        /* Where the reply should go */
        CommandReply *reply;
        /* Channel the command was executed on (fantasy) */
        Reference<Channel> c;
        /* The service this command is on */
        Reference<BotInfo> service;
        /* The actual name of the command being executed */
        Anope::string command;
        /* The permission of the command being executed */
        Anope::string permission;

        CommandSource(const Anope::string &n, User *user, NickCore *core, CommandReply *reply, BotInfo *bi);

        const Anope::string &GetNick() const;
        User *GetUser();
        NickCore *GetAccount();
        AccessGroup AccessFor(ChannelInfo *ci);
        bool IsFounder(ChannelInfo *ci);

        void Reply(const char *message, ...);
        void Reply(const Anope::string &message);

        bool HasCommand(const Anope::string &cmd);
        bool HasPriv(const Anope::string &cmd);
        bool IsServicesOper();
        bool IsOper();
};

class CoreExport Command : public Service
{
        Anope::string desc;
        std::vector<Anope::string> syntax;
        /* Allow unregistered users to use this command */
        bool allow_unregistered;
        /* Command requires that a user is executing it */
        bool require_user;

 public:
        /* Maximum paramaters accepted by this command */
        size_t max_params;
        /* Minimum parameters required to use this command */
        size_t min_params;

        /* Module which owns us */
        Module *module;

 protected:
        Command(Module *owner, const Anope::string &sname, size_t min_params, size_t max_params = 0);

 public:
        virtual ~Command();

 protected:
        void SetDesc(const Anope::string &d);

        void ClearSyntax();
        void SetSyntax(const Anope::string &s);
        void SendSyntax(CommandSource &);
        void SendSyntax(CommandSource &, const Anope::string &syntax);

        void AllowUnregistered(bool b);
        void RequireUser(bool b);

 public:
        bool AllowUnregistered() const;
        bool RequireUser() const;

        const Anope::string &GetDesc() const;

        virtual void Execute(CommandSource &source, const std::vector<Anope::string> &params) = 0;

        virtual void OnServHelp(CommandSource &source);

        virtual bool OnHelp(CommandSource &source, const Anope::string &subcommand);

        virtual void OnSyntaxError(CommandSource &source, const Anope::string &subcommand);
};

extern CoreExport void RunCommand(CommandSource &source, const Anope::string &message);

#endif // COMMANDS_H