*/
const Class type_id;
- /** The prefix char needed on channel to use this mode,
- * only checked for channel modes
- */
- int levelrequired;
+ /** The prefix rank required to set this mode on channels. */
+ unsigned int ranktoset;
+
+ /** The prefix rank required to unset this mode on channels. */
+ unsigned int ranktounset;
public:
/**
* @param mclass The object type of this mode handler, one of ModeHandler::Class
*/
ModeHandler(Module* me, const std::string& name, char modeletter, ParamSpec params, ModeType type, Class mclass = MC_OTHER);
- virtual CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
virtual ~ModeHandler();
/** Register this object in the ModeParser
*/
PrefixMode* IsPrefixMode();
+ /**
+ * Check whether this mode is a prefix mode
+ * @return non-NULL if this mode is a prefix mode, NULL otherwise
+ */
+ const PrefixMode* IsPrefixMode() const;
+
/**
* Check whether this mode handler inherits from ListModeBase
* @return non-NULL if this mode handler inherits from ListModeBase, NULL otherwise
/**
* Check whether this mode handler inherits from ListModeBase
+ * @return non-NULL if this mode handler inherits from ListModeBase, NULL otherwise
+ */
+ const ListModeBase* IsListModeBase() const;
+
+ /**
+ * Check whether this mode handler inherits from ParamModeBase
* @return non-NULL if this mode handler inherits from ParamModeBase, NULL otherwise
*/
ParamModeBase* IsParameterMode();
+ /**
+ * Check whether this mode handler inherits from ParamModeBase
+ * @return non-NULL if this mode handler inherits from ParamModeBase, NULL otherwise
+ */
+ const ParamModeBase* IsParameterMode() const;
+
/**
* Returns the mode's type
*/
* Returns the mode character this handler handles.
* @return The mode character
*/
- inline char GetModeChar() { return mode; }
+ char GetModeChar() const { return mode; }
/** Return the id of this mode which is used in User::modes and
* Channel::modes as the index to determine whether a mode is set.
/** For user modes, return the current parameter, if any
*/
- virtual std::string GetUserParameter(User* useor);
+ virtual std::string GetUserParameter(const User* user) const;
/**
* Called when a channel mode change access check for your mode occurs.
*/
virtual void RemoveMode(Channel* channel, Modes::ChangeList& changelist);
- inline unsigned int GetLevelRequired() const { return levelrequired; }
+ /** Retrieves the level required to modify this mode.
+ * @param adding Whether the mode is being added or removed.
+ */
+ inline unsigned int GetLevelRequired(bool adding) const
+ {
+ return adding ? ranktoset : ranktounset;
+ }
friend class ModeParser;
};
*/
unsigned int prefixrank;
+ /** Whether a client with this prefix can remove it from themself. */
+ bool selfremove;
+
public:
/**
* Constructor
*/
PrefixMode(Module* Creator, const std::string& Name, char ModeLetter, unsigned int Rank = 0, char PrefixChar = 0);
+ /**
+ * 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
+ */
+ ModResult AccessCheck(User* source, Channel* channel, std::string ¶meter, bool adding) CXX11_OVERRIDE;
+
/**
* Handles setting and unsetting the prefix mode.
* Finds the given member of the given channel, if it's not found an error message is sent to 'source'
* The latter occurs either when the member cannot be found or when the member already has this prefix set
* (when setting) or doesn't have this prefix set (when unsetting).
*/
- ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& param, bool adding);
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& param, bool adding) CXX11_OVERRIDE;
+
+ /**
+ * Updates the configuration of this prefix.
+ * @param rank The prefix rank of this mode.
+ * @param setrank The prefix rank required to set this mode on channels.
+ * @param unsetrank The prefix rank required to set this unmode on channels.
+ * @param selfrm Whether a client with this prefix can remove it from themself.
+ */
+ void Update(unsigned int rank, unsigned int setrank, unsigned int unsetrank, bool selfrm);
/**
* Removes this prefix mode from all users on the given channel
- * @param chan The channel which the server wants to remove your mode from
+ * @param channel The channel which the server wants to remove your mode from
* @param changelist Mode change list to populate with the removal of this mode
*/
- void RemoveMode(Channel* channel, Modes::ChangeList& changelist);
+ void RemoveMode(Channel* channel, Modes::ChangeList& changelist) CXX11_OVERRIDE;
+
+
+ /**
+ * Determines whether a user with this prefix mode can remove it.
+ */
+ bool CanSelfRemove() const { return selfremove; }
/**
* Mode prefix or 0. If this is defined, you should
public:
SimpleUserModeHandler(Module* Creator, const std::string& Name, char modeletter)
: ModeHandler(Creator, Name, modeletter, PARAM_NONE, MODETYPE_USER) {}
- virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding) CXX11_OVERRIDE;
};
/** A prebuilt mode handler which handles a simple channel mode, e.g. no parameters, usable by any user, with no extra
public:
SimpleChannelModeHandler(Module* Creator, const std::string& Name, char modeletter)
: ModeHandler(Creator, Name, modeletter, PARAM_NONE, MODETYPE_CHANNEL) {}
- virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding) CXX11_OVERRIDE;
};
/**
* Get the mode type being watched
* @return The mode type being watched (user or channel)
*/
- ModeType GetModeType();
+ ModeType GetModeType() const { return m_type; }
/**
* Before the mode character is processed by its handler, this method will be called.
*/
ModeAction TryMode(User* user, User* targu, Channel* targc, Modes::Change& mcitem, bool SkipACL);
- /** Returns a list of user or channel mode characters.
- * Used for constructing the parts of the mode list in the 004 numeric.
- * @param mt Controls whether to list user modes or channel modes
- * @param needparam Return modes only if they require a parameter to be set
- * @return The available mode letters that satisfy the given conditions
- */
- std::string CreateModeList(ModeType mt, bool needparam = false);
-
- /** Recreate the cached mode list that is displayed in the 004 numeric
- * in Cached004ModeList.
- * Called when a mode handler is added or removed.
- */
- void RecreateModeListFor004Numeric();
-
/** Allocates an unused id for the given mode type, throws a ModuleException if out of ids.
* @param mt The type of the mode to allocate the id for
* @return The id
*/
ModeHandler::Id AllocateModeId(ModeType mt);
- /** The string representing the last set of modes to be parsed.
- * Use GetLastParse() to get this value, to be used for display purposes.
- */
- std::string LastParse;
-
- /** Cached mode list for use in 004 numeric
- */
- std::string Cached004ModeList;
-
public:
typedef std::vector<ListModeBase*> ListModeList;
typedef std::vector<PrefixMode*> PrefixModeList;
/** If this flag is set then the mode change will be subject to access checks.
* For more information see the documentation of the PrefixMode class,
- * ModeHandler::levelrequired and ModeHandler::AccessCheck().
+ * ModeHandler::ranktoset and ModeHandler::AccessCheck().
* Modules may explicitly allow a mode change regardless of this flag by returning
* MOD_RES_ALLOW from the OnPreMode hook. Only affects channel mode changes.
*/
ModeParser();
~ModeParser();
- /** Initialize all built-in modes
- */
- static void InitBuiltinModes();
+ static bool IsModeChar(char chr);
/** Tidy a banmask. This makes a banmask 'acceptable' if fields are left out.
* E.g.
* This method can be used on both IPV4 and IPV6 user masks.
*/
static void CleanMask(std::string &mask);
- /** Get the last string to be processed, as it was sent to the user or channel.
- * Use this to display a string you just sent to be parsed, as the actual output
- * may be different to what you sent after it has been 'cleaned up' by the parser.
- * @return Last parsed string, as seen by users.
- */
- const std::string& GetLastParse() const { return LastParse; }
+
+ /** Gets the last mode change to be processed. */
+ const Modes::ChangeList& GetLastChangeList() const { return LastChangeList; }
/** Add a mode to the mode parser.
* Throws a ModuleException if the mode cannot be added.
*/
PrefixMode* FindPrefix(unsigned const char pfxletter);
- /** Returns a list of modes, space seperated by type:
- * 1. User modes
- * 2. Channel modes
- * 3. Channel modes that require a parameter when set
- * This is sent to users as the last part of the 004 numeric
- */
- const std::string& GetModeListFor004Numeric();
-
/** Generates a list of modes, comma seperated by type:
* 1; Listmodes EXCEPT those with a prefix
* 2; Modes that take a param when adding or removing
void ShowListModeList(User* user, Channel* chan, ModeHandler* mh);
};
-inline const std::string& ModeParser::GetModeListFor004Numeric()
+inline PrefixMode* ModeHandler::IsPrefixMode()
{
- return Cached004ModeList;
+ return (this->type_id == MC_PREFIX ? static_cast<PrefixMode*>(this) : NULL);
}
-inline PrefixMode* ModeHandler::IsPrefixMode()
+inline const PrefixMode* ModeHandler::IsPrefixMode() const
{
- return (this->type_id == MC_PREFIX ? static_cast<PrefixMode*>(this) : NULL);
+ return (this->type_id == MC_PREFIX ? static_cast<const PrefixMode*>(this) : NULL);
}
inline ListModeBase* ModeHandler::IsListModeBase()
return (this->type_id == MC_LIST ? reinterpret_cast<ListModeBase*>(this) : NULL);
}
+inline const ListModeBase* ModeHandler::IsListModeBase() const
+{
+ return (this->type_id == MC_LIST ? reinterpret_cast<const ListModeBase*>(this) : NULL);
+}
+
inline ParamModeBase* ModeHandler::IsParameterMode()
{
return (this->type_id == MC_PARAM ? reinterpret_cast<ParamModeBase*>(this) : NULL);
}
+
+inline const ParamModeBase* ModeHandler::IsParameterMode() const
+{
+ return (this->type_id == MC_PARAM ? reinterpret_cast<const ParamModeBase*>(this) : NULL);
+}
projects / user / henk / code / inspircd.git / blobdiff