InspIRCd
3.0
|
#include <command_parse.h>
Public Types | |
typedef TR1NS::unordered_map< std::string, Command *, irc::insensitive, irc::StrHashComp > | CommandMap |
Public Member Functions | |
CommandParser () | |
const CommandMap & | GetCommands () const |
CmdResult | CallHandler (const std::string &commandname, const CommandBase::Params ¶meters, User *user, Command **cmd=NULL) |
Command * | GetHandler (const std::string &commandname) |
void | ProcessBuffer (LocalUser *user, const std::string &buffer) |
bool | AddCommand (Command *f) |
void | RemoveCommand (Command *x) |
Static Public Member Functions | |
static bool | LoopCall (User *user, Command *handler, const CommandBase::Params ¶meters, unsigned int splithere, int extra=-1, bool usemax=true) |
static void | TranslateSingleParam (TranslateType to, const std::string &item, std::string &dest, CommandBase *custom_translator=NULL, unsigned int paramnumber=0) |
static std::string | TranslateUIDs (const std::vector< TranslateType > &to, const CommandBase::Params &source, bool prefix_final=false, CommandBase *custom_translator=NULL) |
This class handles command management and parsing. It allows you to add and remove commands from the map, call command handlers by name, and chop up comma separated parameters into multiple calls.
CommandParser::CommandParser | ( | ) |
Default constructor.
bool CommandParser::AddCommand | ( | Command * | f | ) |
Add a new command to the commands hash
f | The new Command to add to the list |
CmdResult CommandParser::CallHandler | ( | const std::string & | commandname, |
const CommandBase::Params & | parameters, | ||
User * | user, | ||
Command ** | cmd = NULL |
||
) |
Calls the handler for a given command.
commandname | The command to find. This should be in uppercase. |
parameters | Parameter list |
user | The user to call the handler on behalf of |
cmd | If non-NULL and the command was executed it is set to the command handler, otherwise it isn't written to. |
|
inline |
Get a command name -> Command* map containing all client to server commands
Command * CommandParser::GetHandler | ( | const std::string & | commandname | ) |
Get the handler function for a command.
commandname | The command required. Always use uppercase for this parameter. |
|
static |
LoopCall is used to call a command handler repeatedly based on the contents of a comma separated list. There are two ways to call this method, either with one potential list or with two potential lists. We need to handle two potential lists for JOIN, because a JOIN may contain two lists of items at once: the channel names and their keys as follows:
JOIN #chan1,#chan2,#chan3 key1,,key3
Therefore, we need to deal with both lists concurrently. If there are two lists then the method reads them both together until the first runs out of tokens. With one list it is much simpler, and is used in NAMES, WHOIS, PRIVMSG etc.
If there is only one list and there are duplicates in it, then the command handler is only called for unique items. Entries are compared using "irc comparison". If the usemax parameter is true (the default) the function only parses until it reaches ServerInstance->Config->MaxTargets number of targets, to stop abuse via spam.
The OnPostCommand hook is executed for each item after it has been processed by the handler, with the original line parameter being empty (to indicate that the command in that form was created by this function). This only applies if the user executing the command is local.
If there are two lists and the second list runs out of tokens before the first list then parameters[extra] will be an EMPTY string when Handle() is called for the remaining tokens in the first list, even if it is in the middle of parameters[]! Moreover, empty tokens in the second list are allowed, and those will also result in the appropriate entry being empty in parameters[]. This is different than what command handlers usually expect; the command parser only allows an empty param as the last item in the vector.
user | The user who sent the command |
handler | The command handler to call for each parameter in the list |
parameters | Parameter list as a vector of strings |
splithere | The first parameter index to split as a comma separated list |
extra | The second parameter index to split as a comma separated list, or -1 (the default) if there is only one list |
usemax | True to limit the command to MaxTargets targets (default), or false to process all tokens |
Some lame ircds will weed out dupes using some shitty O(n^2) algorithm. By using std::set (thanks for the idea w00t) we can cut this down a ton. ...VOOODOOOO!
Only check for duplicates if there is one list (allow them in JOIN).
void CommandParser::ProcessBuffer | ( | LocalUser * | user, |
const std::string & | buffer | ||
) |
Take a raw input buffer from a recvq, and process it on behalf of a user.
buffer | The buffer line to process |
user | The user to whom this line belongs |
void CommandParser::RemoveCommand | ( | Command * | x | ) |
Removes a command.
|
static |
Translate a single item based on the TranslationType given.
to | The translation type to use for the process |
item | The input string |
dest | The output string. The translation result will be appended to this string |
custom_translator | Used to translate the parameter if the translation type is TR_CUSTOM, if NULL, TR_CUSTOM will act like TR_TEXT |
paramnumber | The index of the parameter we are translating. |
|
static |
Translate nicknames in a list of strings into UIDs, based on the TranslateTypes given.
to | The translation types to use for the process. If this list is too short, TR_TEXT is assumed for the rest. |
source | The strings to translate |
prefix_final | True if the final source argument should have a colon prepended (if it could contain a space) |
custom_translator | Used to translate the parameter if the translation type is TR_CUSTOM, if NULL, TR_CUSTOM will act like TR_TEXT |