OP_VALUE = 30000
};
+enum ParamSpec
+{
+ /** No parameters */
+ PARAM_NONE,
+ /** Parameter required on mode setting only */
+ PARAM_SETONLY,
+ /** Parameter always required */
+ PARAM_ALWAYS
+};
+
/**
* Used by ModeHandler::ModeSet() to return the state of a mode upon a channel or user.
* The pair contains an activity flag, true if the mode is set with the given parameter,
class CoreExport ModeHandler : public classbase
{
protected:
- /**
- * Creator/owner pointer
- */
- InspIRCd* ServerInstance;
/**
* The mode letter you're implementing.
*/
char mode;
- /**
- * Number of parameters when being set
- */
- int n_params_on;
- /**
- * Number of parameters when being unset
+
+ /** What kind of parameters does the mode take?
*/
- int n_params_off;
+ ParamSpec parameters_taken;
/**
* Mode is a 'list' mode. The behaviour
* of your mode is now set entirely within
/** The prefix char needed on channel to use this mode,
* only checked for channel modes
*/
- char prefixneeded;
+ int levelrequired;
public:
/** Module that created this mode. NULL for core modes */
* and the rank values OP_VALUE, HALFOP_VALUE and VOICE_VALUE respectively. Any prefixes you define should have unique values proportional
* to these three defaults or proportional to another mode in a module you depend on. See src/cmode_o.cpp as an example.
* @param prefixrequired The prefix required to change this mode
- * @param translate The translation type for the argument(s) of this mode
*/
- ModeHandler(InspIRCd* Instance, Module* me, char modeletter, int parameters_on, int parameters_off,
- bool listmode, ModeType type, bool operonly, char mprefix = 0,
- char prefixrequired = '%', TranslateType translate = TR_TEXT);
+ ModeHandler(Module* me, char modeletter, ParamSpec params, ModeType type);
/**
* The default destructor does nothing
*/
* also implement GetPrefixRank() to return an integer
* value for this mode prefix.
*/
- char GetPrefix();
+ inline char GetPrefix() const { return prefix; }
/** Get number of items with this mode set on them
*/
virtual unsigned int GetCount();
/**
* Returns the mode's type
*/
- ModeType GetModeType();
+ inline ModeType GetModeType() const { return m_type; }
/**
* Returns the mode's parameter translation type
*/
- TranslateType GetTranslateType();
+ inline TranslateType GetTranslateType() const { return m_paramtype; }
/**
* Returns true if the mode can only be set/unset by an oper
*/
- bool NeedsOper();
+ inline bool NeedsOper() const { return oper; }
/**
* Returns the number of parameters for the mode. Any non-zero
* value should be considered to be equivalent to one.
*/
virtual std::string GetUserParameter(User* useor);
+ /**
+ * Called when a channel mode change access check for your mode occurs.
+ * @param source Contains the user setting the mode.
+ * @param channel contains the destination channel the modes are being set on.
+ * @param parameter The parameter for your mode. This is modifiable.
+ * @param adding This value is true when the mode is being set, or false when it is being unset.
+ * @return allow, deny, or passthru to check against the required level
+ */
+ virtual ModResult AccessCheck(User* source, Channel* channel, std::string ¶meter, bool adding);
+
/**
* Called when a mode change for your mode occurs.
* @param source Contains the user setting the mode.
* @param channel The channel we are checking against
* @return True if the other side wins the merge, false if we win the merge for this mode.
*/
- virtual bool CheckTimeStamp(std::string &their_param, const std::string &our_param, Channel* channel);
+ virtual bool ResolveModeConflict(std::string &their_param, const std::string &our_param, Channel* channel);
/**
* When a remote server needs to bounce a set of modes, it will call this method for every mode
*/
virtual void RemoveMode(Channel* channel, irc::modestacker* stack = NULL);
- char GetNeededPrefix();
-
- void SetNeededPrefix(char needsprefix);
+ inline unsigned int GetLevelRequired() const { return levelrequired; }
};
/** A prebuilt mode handler which handles a simple user mode, e.g. no parameters, usable by any user, with no extra
class CoreExport SimpleUserModeHandler : public ModeHandler
{
public:
- SimpleUserModeHandler(InspIRCd* Instance, Module* Creator, char modeletter)
- : ModeHandler(Instance, Creator, modeletter, 0, 0, false, MODETYPE_USER, false) {}
+ SimpleUserModeHandler(Module* Creator, char modeletter)
+ : ModeHandler(Creator, modeletter, PARAM_NONE, MODETYPE_USER) {}
virtual ~SimpleUserModeHandler() {}
virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
};
class CoreExport SimpleChannelModeHandler : public ModeHandler
{
public:
- SimpleChannelModeHandler(InspIRCd* Instance, Module* Creator, char modeletter)
- : ModeHandler(Instance, Creator, modeletter, 0, 0, false, MODETYPE_CHANNEL, false) {}
+ SimpleChannelModeHandler(Module* Creator, char modeletter)
+ : ModeHandler(Creator, modeletter, PARAM_NONE, MODETYPE_CHANNEL) {}
virtual ~SimpleChannelModeHandler() {}
virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
};
class CoreExport ModeWatcher : public classbase
{
protected:
- /**
- * Creator/owner pointer
- */
- InspIRCd* ServerInstance;
/**
* The mode letter this class is watching
*/
/**
* The constructor initializes the mode and the mode type
*/
- ModeWatcher(InspIRCd* Instance, char modeletter, ModeType type);
+ ModeWatcher(char modeletter, ModeType type);
/**
* The default destructor does nothing.
*/
class CoreExport ModeParser : public classbase
{
private:
- /**
- * Creator/owner pointer
- */
- InspIRCd* ServerInstance;
/** Mode handlers for each mode, to access a handler subtract
* 65 from the ascii value of the mode letter.
* The upper bit of the value indicates if its a usermode
/** The constructor initializes all the RFC basic modes by using ModeParserAddMode().
*/
- ModeParser(InspIRCd* Instance);
+ ModeParser();
~ModeParser();
/** Used to check if user 'd' should be allowed to do operation 'MASK' on channel 'chan'.