#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 &parameters, 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 &parameters, 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)

Detailed Description

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.

Constructor & Destructor Documentation

◆ CommandParser()

CommandParser::CommandParser ( )

Default constructor.

Member Function Documentation

◆ AddCommand()

bool CommandParser::AddCommand ( Command * f )

Add a new command to the commands hash

Parameters

f	The new Command to add to the list

Returns: True if the command was added

◆ CallHandler()

CmdResult CommandParser::CallHandler	(	const std::string &	commandname,
		const CommandBase::Params &	parameters,
		User *	user,
		Command **	cmd = `NULL`
	)

Calls the handler for a given command.

Parameters

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.

Returns: This method will return CMD_SUCCESS if the command handler was found and called, and the command completeld successfully. It will return CMD_FAILURE if the command handler was found and called, but the command did not complete successfully, and it will return CMD_INVALID if the command simply did not exist at all or the wrong number of parameters were given, or the user was not privileged enough to execute the command.

◆ GetCommands()

const CommandMap& CommandParser::GetCommands ( ) const

inline

Get a command name -> Command* map containing all client to server commands

Returns: A map of command handlers keyed by command names

◆ GetHandler()

Command * CommandParser::GetHandler ( const std::string & commandname )

Get the handler function for a command.

Parameters

commandname The command required. Always use uppercase for this parameter.

Returns: a pointer to the command handler, or NULL

◆ LoopCall()

bool CommandParser::LoopCall	(	User *	user,
		Command *	handler,
		const CommandBase::Params &	parameters,
		unsigned int	splithere,
		int	extra = `-1`,
		bool	usemax = `true`
	)

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.

Parameters

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

Returns: This function returns true when it identified a list in the given parameter and finished calling the command handler for each entry on the list. When this occurs, the caller should return without doing anything, otherwise it should continue into its main section of code.

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).

◆ ProcessBuffer()

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.

Parameters

buffer	The buffer line to process
user	The user to whom this line belongs

◆ RemoveCommand()

void CommandParser::RemoveCommand ( Command * x )

Removes a command.

◆ TranslateSingleParam()

void CommandParser::TranslateSingleParam	(	TranslateType	to,
		const std::string &	item,
		std::string &	dest,
		CommandBase *	custom_translator = `NULL`,
		unsigned int	paramnumber = `0`
	)

static

Translate a single item based on the TranslationType given.

Parameters

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.

◆ TranslateUIDs()

std::string CommandParser::TranslateUIDs	(	const std::vector< TranslateType > &	to,
		const CommandBase::Params &	source,
		bool	prefix_final = `false`,
		CommandBase *	custom_translator = `NULL`
	)

static

Translate nicknames in a list of strings into UIDs, based on the TranslateTypes given.

Parameters

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

Returns: dest The output string

The documentation for this class was generated from the following files:

include/command_parse.h
src/command_parse.cpp

Public Types

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ CommandParser()

Member Function Documentation

◆ AddCommand()

◆ CallHandler()

◆ GetCommands()

◆ GetHandler()

◆ LoopCall()

◆ ProcessBuffer()

◆ RemoveCommand()

◆ TranslateSingleParam()

◆ TranslateUIDs()