GCCs warnings for this are much better than Clangs.
static const std::string::size_type maxkeylen = 32;
public:
ModeChannelKey();
- ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
- void SerializeParam(Channel* chan, const std::string* key, std::string& out);
- ModeAction OnSet(User* source, Channel* chan, std::string& param);
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding) CXX11_OVERRIDE;
+ void SerializeParam(Channel* chan, const std::string* key, std::string& out) ;
+ ModeAction OnSet(User* source, Channel* chan, std::string& param) CXX11_OVERRIDE;
};
/** Channel mode +l
{
public:
ModeChannelLimit();
- bool ResolveModeConflict(std::string &their_param, const std::string &our_param, Channel* channel);
+ bool ResolveModeConflict(std::string& their_param, const std::string& our_param, Channel* channel) CXX11_OVERRIDE;
void SerializeParam(Channel* chan, intptr_t n, std::string& out);
- ModeAction OnSet(User* source, Channel* channel, std::string& parameter);
+ ModeAction OnSet(User* source, Channel* channel, std::string& parameter) CXX11_OVERRIDE;
};
/** Channel mode +o
{
public:
ModeUserOperator();
- ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding) CXX11_OVERRIDE;
};
#define caller8 Caller
#define DEFINE_HANDLER0(NAME, RETURN) \
- class CoreExport NAME : public Handler<RETURN> { public: NAME() { } virtual RETURN Call(); }
+ class CoreExport NAME : public Handler<RETURN> { public: RETURN Call() CXX11_OVERRIDE; }
#define DEFINE_HANDLER1(NAME, RETURN, V1) \
- class CoreExport NAME : public Handler<RETURN, V1> { public: NAME() { } virtual RETURN Call(V1); }
+ class CoreExport NAME : public Handler<RETURN, V1> { public: RETURN Call(V1) CXX11_OVERRIDE; }
#define DEFINE_HANDLER2(NAME, RETURN, V1, V2) \
- class CoreExport NAME : public Handler<RETURN, V1, V2> { public: NAME() { } virtual RETURN Call(V1, V2); }
+ class CoreExport NAME : public Handler<RETURN, V1, V2> { public: RETURN Call(V1, V2) CXX11_OVERRIDE; }
#define DEFINE_HANDLER3(NAME, RETURN, V1, V2, V3) \
- class CoreExport NAME : public Handler<RETURN, V1, V2, V3> { public: NAME() { } virtual RETURN Call(V1, V2, V3); }
+ class CoreExport NAME : public Handler<RETURN, V1, V2, V3> { public: RETURN Call(V1, V2, V3) CXX11_OVERRIDE; }
#define DEFINE_HANDLER4(NAME, RETURN, V1, V2, V3, V4) \
- class CoreExport NAME : public Handler<RETURN, V1, V2, V3, V4> { public: NAME() { } virtual RETURN Call(V1, V2, V3, V4); }
+ class CoreExport NAME : public Handler<RETURN, V1, V2, V3, V4> { public: RETURN Call(V1, V2, V3, V4) CXX11_OVERRIDE; }
#define DEFINE_HANDLER5(NAME, RETURN, V1, V2, V3, V4, V5) \
- class CoreExport NAME : public Handler<RETURN, V1, V2, V3, V4, V5> { public: NAME() { } virtual RETURN Call(V1, V2, V3, V4, V5); }
+ class CoreExport NAME : public Handler<RETURN, V1, V2, V3, V4, V5> { public: RETURN Call(V1, V2, V3, V4, V5) CXX11_OVERRIDE; }
#define DEFINE_HANDLER6(NAME, RETURN, V1, V2, V3, V4, V5, V6) \
- class CoreExport NAME : public Handler<RETURN, V1, V2, V3, V4, V5, V6> { public: NAME() { } virtual RETURN Call(V1, V2, V3, V4, V5, V6); }
+ class CoreExport NAME : public Handler<RETURN, V1, V2, V3, V4, V5, V6> { public: RETURN Call(V1, V2, V3, V4, V5, V6) CXX11_OVERRIDE; }
#define DEFINE_HANDLER7(NAME, RETURN, V1, V2, V3, V4, V5, V6, V7) \
- class CoreExport NAME : public Handler<RETURN, V1, V2, V3, V4, V5, V6, V7> { public: NAME() { } virtual RETURN Call(V1, V2, V3, V4, V5, V6, V7); }
+ class CoreExport NAME : public Handler<RETURN, V1, V2, V3, V4, V5, V6, V7> { public: RETURN Call(V1, V2, V3, V4, V5, V6, V7) CXX11_OVERRIDE; }
#define DEFINE_HANDLER8(NAME, RETURN, V1, V2, V3, V4, V5, V6, V7, V8) \
- class CoreExport NAME : public Handler<RETURN, V1, V2, V3, V4, V5, V6, V7, V8> { public: NAME() { } virtual RETURN Call(V1, V2, V3, V4, V5, V6, V7, V8); }
+ class CoreExport NAME : public Handler<RETURN, V1, V2, V3, V4, V5, V6, V7, V8> { public: RETURN Call(V1, V2, V3, V4, V5, V6, V7, V8) CXX11_OVERRIDE; }
#else
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
delete Config;
}
- void Run();
+ void Run() CXX11_OVERRIDE;
/** Run in the main thread to apply the configuration */
void Finish();
bool IsDone() { return done; }
public:
SplitCommand(Module* me, const std::string &cmd, unsigned int minpara = 0, unsigned int maxpara = 0)
: Command(me, cmd, minpara, maxpara) {}
- virtual CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
virtual CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user);
virtual CmdResult HandleRemote(const std::vector<std::string>& parameters, RemoteUser* user);
virtual CmdResult HandleServer(const std::vector<std::string>& parameters, FakeUser* user);
inline const ExtensibleStore& GetExtList() const { return extensions; }
Extensible();
- virtual CullResult cull() CXX11_OVERRIDE;
+ CullResult cull() CXX11_OVERRIDE;
virtual ~Extensible();
void doUnhookExtensions(const std::vector<reference<ExtensionItem> >& toRemove);
public:
LocalExtItem(const std::string& key, ExtensibleType exttype, Module* owner);
virtual ~LocalExtItem();
- virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
- virtual void unserialize(SerializeFormat format, Extensible* container, const std::string& value);
- virtual void free(void* item) = 0;
+ std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE;
+ void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE;
+ void free(void* item) CXX11_OVERRIDE = 0;
};
template <typename T, typename Del = stdalgo::defaultdeleter<T> >
del(old);
}
- virtual void free(void* item)
+ void free(void* item) CXX11_OVERRIDE
{
Del del;
del(static_cast<T*>(item));
public:
LocalStringExt(const std::string& key, ExtensibleType exttype, Module* owner);
virtual ~LocalStringExt();
- std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
- void unserialize(SerializeFormat format, Extensible* container, const std::string& value);
+ std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE;
+ void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE;
};
class CoreExport LocalIntExt : public LocalExtItem
public:
LocalIntExt(const std::string& key, ExtensibleType exttype, Module* owner);
virtual ~LocalIntExt();
- std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
- void unserialize(SerializeFormat format, Extensible* container, const std::string& value);
+ std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE;
+ void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE;
intptr_t get(const Extensible* container) const;
intptr_t set(Extensible* container, intptr_t value);
void unset(Extensible* container) { set(container, 0); }
- void free(void* item);
+ void free(void* item) CXX11_OVERRIDE;
};
class CoreExport StringExtItem : public ExtensionItem
StringExtItem(const std::string& key, ExtensibleType exttype, Module* owner);
virtual ~StringExtItem();
std::string* get(const Extensible* container) const;
- std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
- void unserialize(SerializeFormat format, Extensible* container, const std::string& value);
+ std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE;
+ void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE;
void set(Extensible* container, const std::string& value);
void unset(Extensible* container);
- void free(void* item);
+ void free(void* item) CXX11_OVERRIDE;
};
virtual ~FileLogStream();
- virtual void OnLog(LogLevel loglevel, const std::string &type, const std::string &msg);
+ void OnLog(LogLevel loglevel, const std::string& type, const std::string& msg) CXX11_OVERRIDE;
};
{
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version(cmd.name, VF_VENDOR|VF_CORE);
}
/** Handle tick event
*/
- virtual bool Tick(time_t now);
+ bool Tick(time_t now) CXX11_OVERRIDE;
};
/**
*/
virtual void Close();
/** This ensures that close is called prior to destructor */
- virtual CullResult cull() CXX11_OVERRIDE;
+ CullResult cull() CXX11_OVERRIDE;
/** Get the IOHook of a module attached to this socket
* @param mod Module whose IOHook to return
/** When there is data waiting to be read on a socket, the OnDataReady()
* method is called.
*/
- virtual void OnDataReady() CXX11_OVERRIDE = 0;
+ void OnDataReady() CXX11_OVERRIDE = 0;
/**
* When an outbound connection fails, and the attempt times out, you
* @param user The user to send the list to
* @param channel The channel the user is requesting the list for
*/
- virtual void DisplayList(User* user, Channel* channel);
+ void DisplayList(User* user, Channel* channel) CXX11_OVERRIDE;
/** Tell a user that a list contains no elements.
* Sends 'eolnum' numeric with text 'eolstr', unless overridden (see constructor)
* @param channel The channel that has the empty list
* See mode.h
*/
- virtual void DisplayEmptyList(User* user, Channel* channel);
+ void DisplayEmptyList(User* user, Channel* channel) CXX11_OVERRIDE;
/** Remove all instances of the mode from a channel.
* Populates the given modestack with modes that remove every instance of
* @param channel The channel to remove all instances of the mode from
* @param changelist Mode change list to populate with the removal of this mode
*/
- virtual void RemoveMode(Channel* channel, Modes::ChangeList& changelist);
+ void RemoveMode(Channel* channel, Modes::ChangeList& changelist) CXX11_OVERRIDE;
/** Perform a rehash of this mode's configuration data
*/
/** Handle the list mode.
* See mode.h
*/
- virtual ModeAction OnModeChange(User* source, User*, Channel* channel, std::string ¶meter, bool adding);
+ ModeAction OnModeChange(User* source, User*, Channel* channel, std::string ¶meter, bool adding) CXX11_OVERRIDE;
/** Validate parameters.
* Overridden by implementing module.
* @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() CXX11_OVERRIDE;
+ CullResult cull() CXX11_OVERRIDE;
virtual ~ModeHandler();
/** Register this object in the ModeParser
* 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 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;
/**
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;
};
/**
/** Clean up prior to destruction
* If you override, you must call this AFTER your module's cleanup
*/
- virtual CullResult cull() CXX11_OVERRIDE;
+ CullResult cull() CXX11_OVERRIDE;
/** Default destructor.
* destroys a module class
{
public:
ExtItem(Module* mod);
- std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
- void unserialize(SerializeFormat format, Extensible* container, const std::string& value);
+ std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE;
+ void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE;
};
class Capability;
/** Used to time out the query, calls OnError and asks the TimerManager
* to delete this request
*/
- bool Tick(time_t now)
+ bool Tick(time_t now) CXX11_OVERRIDE
{
Query rr(this->question);
rr.error = ERROR_TIMEDOUT;
queue.Wakeup();
queue.Unlock();
}
- virtual void SetExitFlag()
+ void SetExitFlag() CXX11_OVERRIDE
{
queue.Lock();
Thread::SetExitFlag();
queue.Wakeup();
queue.Unlock();
}
- virtual void SetExitFlag()
+ void SetExitFlag() CXX11_OVERRIDE
{
queue.Lock();
Thread::SetExitFlag();
/** Default destructor
*/
virtual ~User();
- virtual CullResult cull() CXX11_OVERRIDE;
+ CullResult cull() CXX11_OVERRIDE;
};
class CoreExport UserIOHandler : public StreamSocket
public:
LocalUser* const user;
UserIOHandler(LocalUser* me) : user(me) {}
- void OnDataReady();
- void OnError(BufferedSocketError error);
+ void OnDataReady() CXX11_OVERRIDE;
+ void OnError(BufferedSocketError error) CXX11_OVERRIDE;
/** Adds to the user's write buffer.
* You may add any amount of text up to this users sendq value, if you exceed the
nick = sname;
}
- virtual CullResult cull() CXX11_OVERRIDE;
- virtual const std::string& GetFullHost() CXX11_OVERRIDE;
- virtual const std::string& GetFullRealHost() CXX11_OVERRIDE;
+ CullResult cull() CXX11_OVERRIDE;
+ const std::string& GetFullHost() CXX11_OVERRIDE;
+ const std::string& GetFullRealHost() CXX11_OVERRIDE;
};
/* Faster than dynamic_cast */
{
}
- virtual bool Matches(User *u);
+ bool Matches(User* u) CXX11_OVERRIDE;
- virtual bool Matches(const std::string &str);
+ bool Matches(const std::string& str) CXX11_OVERRIDE;
- virtual void Apply(User* u);
+ void Apply(User* u) CXX11_OVERRIDE;
- virtual const std::string& Displayable();
+ const std::string& Displayable() CXX11_OVERRIDE;
- virtual bool IsBurstable();
+ bool IsBurstable() CXX11_OVERRIDE;
/** Ident mask (ident part only)
*/
{
}
- virtual bool Matches(User *u);
+ bool Matches(User* u) CXX11_OVERRIDE;
- virtual bool Matches(const std::string &str);
+ bool Matches(const std::string& str) CXX11_OVERRIDE;
- virtual void Apply(User* u);
+ void Apply(User* u) CXX11_OVERRIDE;
- virtual const std::string& Displayable();
+ const std::string& Displayable() CXX11_OVERRIDE;
/** Ident mask (ident part only)
*/
{
}
- virtual bool Matches(User *u);
+ bool Matches(User* u) CXX11_OVERRIDE;
- virtual bool Matches(const std::string &str);
+ bool Matches(const std::string& str) CXX11_OVERRIDE;
- virtual void Unset();
+ void Unset() CXX11_OVERRIDE;
- virtual void OnAdd();
+ void OnAdd() CXX11_OVERRIDE;
- virtual const std::string& Displayable();
+ const std::string& Displayable() CXX11_OVERRIDE;
/** Ident mask (ident part only)
*/
{
}
- virtual bool Matches(User *u);
+ bool Matches(User* u) CXX11_OVERRIDE;
- virtual bool Matches(const std::string &str);
+ bool Matches(const std::string& str) CXX11_OVERRIDE;
- virtual void Apply(User* u);
+ void Apply(User* u) CXX11_OVERRIDE;
- virtual const std::string& Displayable();
+ const std::string& Displayable() CXX11_OVERRIDE;
/** IP mask (no ident part)
*/
~QLine()
{
}
- virtual bool Matches(User *u);
+ bool Matches(User* u) CXX11_OVERRIDE;
- virtual bool Matches(const std::string &str);
+ bool Matches(const std::string& str) CXX11_OVERRIDE;
- virtual void Apply(User* u);
+ void Apply(User* u) CXX11_OVERRIDE;
- virtual const std::string& Displayable();
+ const std::string& Displayable() CXX11_OVERRIDE;
/** Nickname mask
*/
}
// Generate the MAXLIST token from the limits map.
- std::string& buffer = tokens["MAXLIST"];
+ std::string& buffer = tokens["MAX LIST"];
for (insp::flat_map<int, std::string>::const_iterator iter = limits.begin(); iter != limits.end(); ++iter)
{
if (!buffer.empty())
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User*user);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
/** Handle /JOIN.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user);
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
};
/** Handle /TOPIC.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user);
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
};
/** Handle /NAMES.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user);
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
/** Spool the NAMES list for a given channel to the given user
* @param user User to spool the NAMES list to
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
* if a previous result has already come back.
* @param r The finished query
*/
- void OnLookupComplete(const DNS::Query* r)
+ void OnLookupComplete(const DNS::Query* r) CXX11_OVERRIDE
{
LocalUser* bound_user = (LocalUser*)ServerInstance->FindUUID(uuid);
if (!bound_user)
/** Called on failed lookup
* @param query The errored query
*/
- void OnError(const DNS::Query* query)
+ void OnError(const DNS::Query* query) CXX11_OVERRIDE
{
LocalUser* bound_user = (LocalUser*)ServerInstance->FindUUID(uuid);
if (bound_user)
{
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
/** Handle /ADMIN.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /COMMANDS.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /INFO.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /MODULES.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /MOTD.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /TIME.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /VERSION.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user);
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
};
class IsonReplyBuilder : public Numeric::Builder<' ', true>
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /LOADMODULE
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
CmdResult CommandUnloadmodule::Handle(const std::vector<std::string>& parameters, User* user)
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /LUSERS
{
}
- void AfterMode(User* source, User* dest, Channel* channel, const std::string& parameter, bool adding)
+ void AfterMode(User* source, User* dest, Channel* channel, const std::string& parameter, bool adding) CXX11_OVERRIDE
{
if (dest->registered != REG_ALL)
return;
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /KILL.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
- void EncodeParameter(std::string& param, unsigned int index);
+ void EncodeParameter(std::string& param, unsigned int index) CXX11_OVERRIDE;
};
/** Handle /OPER.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user);
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
};
/** Handle /REHASH.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /RESTART
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
*/
CmdResult HandleMessage(const std::vector<std::string>& parameters, User* user, MessageType mt);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
if (IS_LOCAL(user))
// This is handled by the OnUserMessage hook to split the LoopCall pieces
{
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
return HandleMessage(parameters, user, MT);
}
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
namespace ReloadModule
{
}
- void Call()
+ void Call() CXX11_OVERRIDE
{
ReloadModule::DataKeeper datakeeper;
datakeeper.Save(mod);
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
if ((parameters.size() > 1) && (parameters[1].find('.') != std::string::npos))
return ROUTE_UNICAST(parameters[1]);
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
/*
* This is handled by the server linking module, if necessary. Do not remove this stub.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
user->WriteNumeric(RPL_LINKS, ServerInstance->Config->ServerName, ServerInstance->Config->ServerName, InspIRCd::Format("0 %s", ServerInstance->Config->ServerDesc.c_str()));
user->WriteNumeric(RPL_ENDOFLINKS, '*', "End of /LINKS list.");
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (user->registered == REG_ALL)
{
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
user->WriteNotice("Look into loading a linking module (like m_spanningtree) if you want this to do anything useful.");
return CMD_FAILURE;
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser *user)
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
{
// Check to make sure they haven't registered -- Fix by FCS
if (user->registered == REG_ALL)
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
user->WriteServ("PONG %s :%s", ServerInstance->Config->ServerName.c_str(), parameters[0].c_str());
return CMD_SUCCESS;
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
// set the user as alive so they survive to next ping
LocalUser* localuser = IS_LOCAL(user);
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
class CommandMode : public Command
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
/** Handle /NICK.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user);
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
};
/** Handle /PART.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
/** Handle /QUIT.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User*user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
/** Handle /USER.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser *user);
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
/** Run the OnUserRegister hook if the user has sent both NICK and USER. Called after an unregistered user
* successfully executes the USER or the NICK command.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
CmdResult CommandUserhost::Handle (const std::vector<std::string>& parameters, User *user)
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User *user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
bool whomatch(User* cuser, User* user, const char* matchtext);
};
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user);
- CmdResult HandleRemote(const std::vector<std::string>& parameters, RemoteUser* target);
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
+ CmdResult HandleRemote(const std::vector<std::string>& parameters, RemoteUser* target) CXX11_OVERRIDE;
};
class WhoisNumericSink
class Matcher : public MatcherBase
{
public:
- long Run(const std::string& mask)
+ long Run(const std::string& mask) CXX11_OVERRIDE
{
long matches = 0;
const T* c = static_cast<T*>(this);
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /GLINE.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /KLINE.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /QLINE.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
/** Handle /ZLINE.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
{
Module* const mod;
UnloadAction(Module* m) : mod(m) {}
- void Call()
+ void Call() CXX11_OVERRIDE
{
DLLManager* dll = mod->ModuleDLLManager;
ServerInstance->Modules->DoSafeUnload(mod);
public:
DispatcherThread(ModuleSQL* CreatorModule) : Parent(CreatorModule) { }
~DispatcherThread() { }
- void Run();
- void OnNotify();
+ void Run() CXX11_OVERRIDE;
+ void OnNotify() CXX11_OVERRIDE;
};
#if !defined(MYSQL_VERSION_ID) || MYSQL_VERSION_ID<32224
}
- int Rows()
+ int Rows() CXX11_OVERRIDE
{
return rows;
}
- void GetCols(std::vector<std::string>& result)
+ void GetCols(std::vector<std::string>& result) CXX11_OVERRIDE
{
result.assign(colnames.begin(), colnames.end());
}
return SQLEntry();
}
- bool GetRow(SQLEntries& result)
+ bool GetRow(SQLEntries& result) CXX11_OVERRIDE
{
if (currentrow < rows)
{
mysql_close(connection);
}
- void submit(SQLQuery* q, const std::string& qs)
+ void submit(SQLQuery* q, const std::string& qs) CXX11_OVERRIDE
{
Parent()->Dispatcher->LockQueue();
Parent()->qq.push_back(QQueueItem(q, qs, this));
Parent()->Dispatcher->UnlockQueueWakeup();
}
- void submit(SQLQuery* call, const std::string& q, const ParamL& p)
+ void submit(SQLQuery* call, const std::string& q, const ParamL& p) CXX11_OVERRIDE
{
std::string res;
unsigned int param = 0;
submit(call, res);
}
- void submit(SQLQuery* call, const std::string& q, const ParamM& p)
+ void submit(SQLQuery* call, const std::string& q, const ParamM& p) CXX11_OVERRIDE
{
std::string res;
for(std::string::size_type i = 0; i < q.length(); i++)
ReconnectTimer(ModulePgSQL* m) : Timer(5, false), mod(m)
{
}
- bool Tick(time_t TIME);
+ bool Tick(time_t TIME) CXX11_OVERRIDE;
};
struct QueueItem
PQclear(res);
}
- int Rows()
+ int Rows() CXX11_OVERRIDE
{
return rows;
}
- void GetCols(std::vector<std::string>& result)
+ void GetCols(std::vector<std::string>& result) CXX11_OVERRIDE
{
result.resize(PQnfields(res));
for(unsigned int i=0; i < result.size(); i++)
return SQLEntry(std::string(v, PQgetlength(res, row, column)));
}
- bool GetRow(SQLEntries& result)
+ bool GetRow(SQLEntries& result) CXX11_OVERRIDE
{
if (currentrow >= PQntuples(res))
return false;
{
}
- int Rows()
+ int Rows() CXX11_OVERRIDE
{
return rows;
}
- bool GetRow(SQLEntries& result)
+ bool GetRow(SQLEntries& result) CXX11_OVERRIDE
{
if (currentrow < rows)
{
}
}
- void GetCols(std::vector<std::string>& result)
+ void GetCols(std::vector<std::string>& result) CXX11_OVERRIDE
{
result.assign(columns.begin(), columns.end());
}
sqlite3_finalize(stmt);
}
- void submit(SQLQuery* query, const std::string& q)
+ void submit(SQLQuery* query, const std::string& q) CXX11_OVERRIDE
{
Query(query, q);
delete query;
}
- void submit(SQLQuery* query, const std::string& q, const ParamL& p)
+ void submit(SQLQuery* query, const std::string& q, const ParamL& p) CXX11_OVERRIDE
{
std::string res;
unsigned int param = 0;
submit(query, res);
}
- void submit(SQLQuery* query, const std::string& q, const ParamM& p)
+ void submit(SQLQuery* query, const std::string& q, const ParamM& p) CXX11_OVERRIDE
{
std::string res;
for(std::string::size_type i = 0; i < q.length(); i++)
class RandGen : public HandlerBase2<void, char*, size_t>
{
public:
- void Call(char* buffer, size_t len)
+ void Call(char* buffer, size_t len) CXX11_OVERRIDE
{
#ifdef GNUTLS_HAS_RND
gnutls_rnd(GNUTLS_RND_RANDOM, buffer, len);
flags_needed = 'o';
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
const std::string fmtdate = InspIRCd::TimeString(ServerInstance->Time(), "%Y-%m-%d %H:%M:%S", true);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_BCAST;
}
return mh ? mh->IsPrefixMode() : NULL;
}
- ModResult AccessCheck(User* source, Channel* channel, std::string ¶meter, bool adding)
+ ModResult AccessCheck(User* source, Channel* channel, std::string ¶meter, bool adding) CXX11_OVERRIDE
{
std::string::size_type pos = parameter.find(':');
if (pos == 0 || pos == std::string::npos)
{
}
- bool BeforeMode(User* source, User* dest, Channel* channel, std::string ¶m, bool adding)
+ bool BeforeMode(User* source, User* dest, Channel* channel, std::string& param, bool adding) CXX11_OVERRIDE
{
/* nick!ident@host -> nick!ident@host
* nick!ident@host#chan -> nick!ident@host#chan
{
}
- std::string serialize(SerializeFormat format, const Extensible* container, void* item) const
+ std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE
{
std::string ret;
if (format != FORMAT_NETWORK)
return ret;
}
- void unserialize(SerializeFormat format, Extensible* container, const std::string& value)
+ void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE
{
if (format == FORMAT_NETWORK)
return;
return dat;
}
- void free(void* item)
+ void free(void* item) CXX11_OVERRIDE
{
callerid_data* dat = static_cast<callerid_data*>(item);
TRANSLATE1(TR_CUSTOM);
}
- void EncodeParameter(std::string& parameter, unsigned int index)
+ void EncodeParameter(std::string& parameter, unsigned int index) CXX11_OVERRIDE
{
// Send lists as-is (part of 2.0 compat)
if (parameter.find(',') != std::string::npos)
* /accept nick1,nick2,nick3,*
* to add 3 nicks and then show your list
*/
- CmdResult Handle(const std::vector<std::string> ¶meters, User* user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (CommandParser::LoopCall(user, this, parameters, 0))
return CMD_SUCCESS;
return (RemoveAccept(user, action.first) ? CMD_SUCCESS : CMD_FAILURE);
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
// There is a list in parameters[0] in two cases:
// Either when the source is remote, this happens because 2.0 servers send comma seperated uuid lists,
}
// XXX I shouldn't have to define this
- bool Matches(User *u)
+ bool Matches(User* u) CXX11_OVERRIDE
{
return false;
}
- bool Matches(const std::string &s)
+ bool Matches(const std::string& s) CXX11_OVERRIDE
{
return irc::equals(matchtext, s);
}
- const std::string& Displayable()
+ const std::string& Displayable() CXX11_OVERRIDE
{
return matchtext;
}
/** Generate a CBAN
*/
- XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
+ XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask) CXX11_OVERRIDE
{
return new CBan(set_time, duration, source, reason, xline_specific_mask);
}
- bool AutoApplyToUserList(XLine *x)
+ bool AutoApplyToUserList(XLine* x) CXX11_OVERRIDE
{
return false; // No, we apply to channels.
}
flags_needed = 'o'; this->syntax = "<channel> [<duration> :<reason>]";
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
/* syntax: CBAN #channel time :reason goes here */
/* 'time' is a human-readable timestring, like 2d3h2s. */
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
if (IS_LOCAL(user))
return ROUTE_LOCALONLY; // spanningtree will send ADDLINE
public:
ChanFilter(Module* Creator) : ListModeBase(Creator, "filter", 'g', "End of channel spamfilter list", 941, 940, false, "chanfilter") { }
- bool ValidateParam(User* user, Channel* chan, std::string &word)
- {
+ bool ValidateParam(User* user, Channel* chan, std::string& word) CXX11_OVERRIDE {
if (word.length() > 35)
{
user->WriteNumeric(935, chan->name, word, "%word is too long for censor list");
return true;
}
- void TellListTooLong(User* user, Channel* chan, std::string &word)
+ void TellListTooLong(User* user, Channel* chan, std::string& word) CXX11_OVERRIDE
{
user->WriteNumeric(939, chan->name, word, "Channel spamfilter list is full");
}
- void TellAlreadyOnList(User* user, Channel* chan, std::string &word)
+ void TellAlreadyOnList(User* user, Channel* chan, std::string& word) CXX11_OVERRIDE
{
user->WriteNumeric(937, chan->name, InspIRCd::Format("The word %s is already on the spamfilter list", word.c_str()));
}
- void TellNotSet(User* user, Channel* chan, std::string &word)
+ void TellNotSet(User* user, Channel* chan, std::string& word) CXX11_OVERRIDE
{
user->WriteNumeric(938, chan->name, "No such spamfilter word is set");
}
{
}
- ModeAction OnSet(User* source, Channel* channel, std::string& parameter)
+ ModeAction OnSet(User* source, Channel* channel, std::string& parameter) CXX11_OVERRIDE
{
std::string::size_type colon = parameter.find(':');
if (colon == std::string::npos)
class NewIsChannelHandler : public HandlerBase1<bool, const std::string&>
{
public:
- bool Call(const std::string&);
+ bool Call(const std::string&) CXX11_OVERRIDE;
};
bool NewIsChannelHandler::Call(const std::string& channame)
return ret;
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (parameters.size() > 1 && parameters[1] != ServerInstance->Config->ServerName)
return CMD_SUCCESS;
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
if ((parameters.size() > 1) && (parameters[1].find('.') != std::string::npos))
return ROUTE_OPT_UCAST(parameters[1]);
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (parameters[1].length() > ServerInstance->Config->Limits.MaxHost)
{
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
User* dest = ServerInstance->FindNick(parameters[0]);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
User* dest = ServerInstance->FindNick(parameters[0]);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
force_manual_route = true;
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
Channel* chan = activechan = ServerInstance->FindChan(parameters[0]);
if (!chan)
{
}
- 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
{
LocalUser* user = IS_LOCAL(dest);
syntax = "<host>";
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User *user);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
};
class ModuleCloaking : public Module
flags_needed = 'o'; syntax = "<limit>";
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
std::string clonesstr = "CLONES ";
flags_needed = 'o';
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *src)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* src) CXX11_OVERRIDE
{
std::map<std::string,int> closed;
syntax = "<user> <password>";
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User* user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
const std::string userHost = user->ident + "@" + user->GetRealHost();
const std::string userIP = user->ident + "@" + user->GetIPString();
Penalty = 3; syntax = "<channel> :[reason]";
}
- CmdResult HandleLocal(const std::vector<std::string> ¶meters, LocalUser* user)
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
{
Channel* channel = ServerInstance->FindChan(parameters[0]);
std::string reason = "Cycling";
/* XXX we need to fix this so it can work with translation stuff (i.e. move +- into a seperate param */
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
/* syntax: DCCALLOW [+|-]<nick> (<time>) */
if (!parameters.size())
return CMD_FAILURE;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
public:
User_d(Module* Creator) : ModeHandler(Creator, "deaf", 'd', PARAM_NONE, MODETYPE_USER) { }
- 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
{
if (adding == dest->IsModeSet(this))
return MODEACTION_DENY;
ranktoset = ranktounset = OP_VALUE;
}
- 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;
};
class ModuleDelayJoin : public Module
ranktoset = ranktounset = OP_VALUE;
}
- bool ResolveModeConflict(std::string &their_param, const std::string &our_param, Channel*)
+ bool ResolveModeConflict(std::string& their_param, const std::string& our_param, Channel*) CXX11_OVERRIDE
{
return (atoi(their_param.c_str()) < atoi(our_param.c_str()));
}
- ModeAction OnSet(User* source, Channel* chan, std::string& parameter);
+ ModeAction OnSet(User* source, Channel* chan, std::string& parameter) CXX11_OVERRIDE;
void OnUnset(User* source, Channel* chan);
void SerializeParam(Channel* chan, int n, std::string& out)
public:
ExemptChanOps(Module* Creator) : ListModeBase(Creator, "exemptchanops", 'X', "End of channel exemptchanops list", 954, 953, false, "exemptchanops") { }
- bool ValidateParam(User* user, Channel* chan, std::string &word)
- {
+ bool ValidateParam(User* user, Channel* chan, std::string& word) CXX11_OVERRIDE {
std::string::size_type p = word.find(':');
if (p == std::string::npos)
{
return true;
}
- void TellListTooLong(User* user, Channel* chan, std::string &word)
+ void TellListTooLong(User* user, Channel* chan, std::string& word) CXX11_OVERRIDE
{
user->WriteNumeric(959, chan->name, word, "Channel exemptchanops list is full");
}
- void TellAlreadyOnList(User* user, Channel* chan, std::string &word)
+ void TellAlreadyOnList(User* user, Channel* chan, std::string& word) CXX11_OVERRIDE
{
user->WriteNumeric(957, chan->name, InspIRCd::Format("The word %s is already on the exemptchanops list", word.c_str()));
}
- void TellNotSet(User* user, Channel* chan, std::string &word)
+ void TellNotSet(User* user, Channel* chan, std::string& word) CXX11_OVERRIDE
{
user->WriteNumeric(958, chan->name, "No such exemptchanops word is set");
}
flags_needed = 'o';
this->syntax = "<filter-definition> <action> <flags> [<gline-duration>] :<reason>";
}
- CmdResult Handle(const std::vector<std::string>&, User*);
+ CmdResult Handle(const std::vector<std::string>& , User* ) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
syntax = "<modulename> [servermask]";
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
std::string servername = parameters.size() > 1 ? parameters[1] : "*";
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
syntax = "<modulename> [servermask]";
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (!ServerInstance->Config->ConfValue("security")->getBool("allowcoreunload") &&
InspIRCd::Match(parameters[0], "core_*.so", ascii_case_insensitive_map))
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
flags_needed = 'o'; syntax = "<modulename> [servermask]";
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
std::string servername = parameters.size() > 1 ? parameters[1] : "*";
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
flags_needed = 'o'; syntax = "<any-text>";
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
ServerInstance->SNO->WriteGlobalSno('g', "From " + user->nick + ": " + parameters[0]);
return CMD_SUCCESS;
syntax = "<any-text>";
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
const std::string& parameter = (!parameters.empty() ? parameters[0] : startkey);
{
}
- bool BeforeMode(User* user, User* destuser, Channel* chan, std::string& param, bool adding)
+ bool BeforeMode(User* user, User* destuser, Channel* chan, std::string& param, bool adding) CXX11_OVERRIDE
{
// Only handle listmode list requests
if (!param.empty())
oper = true;
}
- ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding)
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding) CXX11_OVERRIDE
{
if (SimpleUserModeHandler::OnModeChange(source, dest, channel, parameter, adding) == MODEACTION_DENY)
return MODEACTION_DENY;
{
}
- ModeAction OnSet(User* source, Channel* channel, std::string& parameter)
+ ModeAction OnSet(User* source, Channel* channel, std::string& parameter) CXX11_OVERRIDE
{
std::string::size_type colon = parameter.find(':');
if ((colon == std::string::npos) || (parameter.find('-') != std::string::npos))
redirect_new_users = false;
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
int n_done = 0;
reason = (parameters.size() < 4) ? "Please use this server/port instead" : parameters[3];
{
}
- ModeAction OnSet(User* source, Channel* channel, std::string& parameter)
+ ModeAction OnSet(User* source, Channel* channel, std::string& parameter) CXX11_OVERRIDE
{
int v = ConvToInt(parameter);
if (v <= 0)
Penalty = 5;
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
Channel* c = ServerInstance->FindChan(parameters[0]);
if (!c)
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_BCAST;
}
flags_needed = 'o';
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (!locked.empty())
{
flags_needed = 'o';
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (locked.empty())
{
}
public:
- std::string GenerateRaw(const std::string& data)
+ std::string GenerateRaw(const std::string& data) CXX11_OVERRIDE
{
char res[16];
MyMD5(res, (void*)data.data(), data.length());
{
}
- ModeAction OnSet(User* source, Channel* channel, std::string& parameter)
+ ModeAction OnSet(User* source, Channel* channel, std::string& parameter) CXX11_OVERRIDE
{
std::string::size_type colon = parameter.find(':');
if ((colon == std::string::npos) || (parameter.find('-') != std::string::npos))
flags_needed = 'o';
}
- CmdResult Handle(const std::vector<std::string>& parameters, User *src)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* src) CXX11_OVERRIDE
{
std::string msg = "*** From " + src->nick + ": " + parameters[1];
int mlen = parameters[0].length();
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_BCAST;
}
free(unset_raw(container));
}
- std::string serialize(SerializeFormat format, const Extensible* container, void* item) const
+ std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE
{
std::string ret;
if (format == FORMAT_NETWORK)
return ret;
}
- void unserialize(SerializeFormat format, Extensible* container, const std::string& value);
+ void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE;
- void free(void* item)
+ void free(void* item) CXX11_OVERRIDE
{
delete static_cast<ExtData*>(item);
}
syntax = "[C|L|S|+ <nick1>[,<nick2>]|- <nick1>[,<nick2>]";
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
{
char subcmd = toupper(parameters[0][0]);
if (subcmd == '+')
syntax = "<user|channel> {[+-]<mode> [<value>]}*";
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* src)
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* src) CXX11_OVERRIDE
{
Channel* const chan = ServerInstance->FindChan(parameters[0]);
if (!chan)
}
// Handle /MODE #chan Z
- void DisplayList(User* user, Channel* chan)
+ void DisplayList(User* user, Channel* chan) CXX11_OVERRIDE
{
if (IS_LOCAL(user))
::DisplayList(static_cast<LocalUser*>(user), chan);
class lwbNickHandler : public HandlerBase1<bool, const std::string&>
{
public:
- bool Call(const std::string&);
+ bool Call(const std::string&) CXX11_OVERRIDE;
};
/*,m_reverse_additionalUp[256];*/
{
}
- ModeAction OnSet(User* source, Channel* channel, std::string& parameter)
+ ModeAction OnSet(User* source, Channel* channel, std::string& parameter) CXX11_OVERRIDE
{
std::string::size_type colon = parameter.find(':');
if ((colon == std::string::npos) || (parameter.find('-') != std::string::npos))
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
User* target = ServerInstance->FindNick(parameters[0]);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
TRANSLATE1(TR_NICK);
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
User* target = ServerInstance->FindNick(parameters[0]);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
active = false;
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
{
// Make sure the channel name is allowable.
if (!ServerInstance->IsChannel(parameters[0]))
ranktoset = ranktounset = UINT_MAX;
}
- ModResult AccessCheck(User* source, Channel* channel, std::string ¶meter, bool adding)
+ ModResult AccessCheck(User* source, Channel* channel, std::string ¶meter, bool adding) CXX11_OVERRIDE
{
User* theuser = ServerInstance->FindNick(parameter);
// remove own privs?
flags_needed = 'o'; syntax = "[<servername>]";
}
- CmdResult Handle (const std::vector<std::string>& parameters, User* user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if ((parameters.empty()) || (parameters[0] == ServerInstance->Config->ServerName))
ShowOperMOTD(user);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
if ((!parameters.empty()) && (parameters[0].find('.') != std::string::npos))
return ROUTE_OPT_UCAST(parameters[0]);
public:
HideOperWatcher(ModuleOperPrefixMode* parent);
- void AfterMode(User* source, User* dest, Channel* channel, const std::string ¶meter, bool adding);
+ void AfterMode(User* source, User* dest, Channel* channel, const std::string ¶meter, bool adding) CXX11_OVERRIDE;
};
class ModuleOperPrefixMode : public Module
}
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
MakeHash(user, parameters[0], parameters[1]);
oper = true;
}
- ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding)
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding) CXX11_OVERRIDE
{
if (adding == channel->IsModeSet(this))
return MODEACTION_DENY;
Redirect(Module* Creator)
: ParamMode<Redirect, LocalStringExt>(Creator, "redirect", 'L') { }
- ModeAction OnSet(User* source, Channel* channel, std::string& parameter)
+ ModeAction OnSet(User* source, Channel* channel, std::string& parameter) CXX11_OVERRIDE
{
if (IS_LOCAL(source))
{
TRANSLATE3(TR_NICK, TR_TEXT, TR_TEXT);
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
return HandleRMB(parameters, user, false);
}
TRANSLATE3(TR_TEXT, TR_NICK, TR_TEXT);
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
return HandleRMB(parameters, user, true);
}
MemberInfoExt.unset(i->second);
}
- ModeAction OnSet(User* source, Channel* channel, std::string& parameter)
+ ModeAction OnSet(User* source, Channel* channel, std::string& parameter) CXX11_OVERRIDE
{
ChannelSettings settings;
if (!ParseSettings(source, parameter, settings))
return (byte *)hashcode;
}
public:
- std::string GenerateRaw(const std::string& data)
+ std::string GenerateRaw(const std::string& data) CXX11_OVERRIDE
{
char* rv = (char*)RMD((byte*)data.data(), data.length(), NULL);
return std::string(rv, RMDsize / 8);
delete regex;
}
- bool Matches(User *u)
+ bool Matches(User* u) CXX11_OVERRIDE
{
LocalUser* lu = IS_LOCAL(u);
if (lu && lu->exempt)
return (regex->Matches(host) || regex->Matches(ip));
}
- bool Matches(const std::string &compare)
+ bool Matches(const std::string& compare) CXX11_OVERRIDE
{
return regex->Matches(compare);
}
- void Apply(User* u)
+ void Apply(User* u) CXX11_OVERRIDE
{
if (ZlineOnMatch)
{
DefaultApply(u, "R", false);
}
- const std::string& Displayable()
+ const std::string& Displayable() CXX11_OVERRIDE
{
return matchtext;
}
/** Generate a RLine
*/
- XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
+ XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask) CXX11_OVERRIDE
{
if (!rxfactory)
{
flags_needed = 'o'; this->syntax = "<regex> [<rline-duration>] :<reason>";
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (parameters.size() >= 3)
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
if (IS_LOCAL(user))
return ROUTE_LOCALONLY; // spanningtree will send ADDLINE
syntax = "<channel> <mode> [pattern]";
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
ModeHandler* mh;
Channel* chan = ServerInstance->FindChan(parameters[0]);
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
const unsigned int channelindex = (parameters.size() > 1) ? 1 : 0;
if (CommandParser::LoopCall(user, this, parameters, channelindex))
}
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
TRANSLATE3(TR_TEXT, TR_NICK, TR_TEXT);
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
User* dest = ServerInstance->FindNick(parameters[1]);
Channel* channel = ServerInstance->FindChan(parameters[0]);
return CMD_FAILURE;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[1]);
}
active = false;
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (parameters[0].c_str()[0] != '#')
{
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
User* target = ServerInstance->FindNick(parameters[0]);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
TRANSLATE3(TR_NICK, TR_TEXT, TR_TEXT);
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (CommandParser::LoopCall(user, this, parameters, 1))
return CMD_FAILURE;
return CMD_FAILURE;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
User* dest = ServerInstance->FindNick(parameters[0]);
if ((dest) && (dest->registered == REG_ALL))
}
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
allow_empty_last_param = false;
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
{
{
if (!cap.get(user))
this->flags_needed = FLAG_SERVERONLY; // should not be called by users
}
- CmdResult Handle(const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
User* target = ServerInstance->FindUUID(parameters[1]);
if (!target)
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
flags_needed = 'o'; syntax = "<target> <topic>";
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
/*
* Handles a SATOPIC request. Notifies all +s users.
public:
Channel_r(Module* Creator) : ModeHandler(Creator, "c_registered", 'r', PARAM_NONE, MODETYPE_CHANNEL) { }
- 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
{
// only a u-lined server may add or remove the +r mode.
if (!IS_LOCAL(source))
public:
User_r(Module* Creator) : ModeHandler(Creator, "u_registered", 'r', PARAM_NONE, MODETYPE_USER) { }
- 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
{
if (!IS_LOCAL(source))
{
{
}
- void unserialize(SerializeFormat format, Extensible* container, const std::string& value)
+ void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE
{
User* user = static_cast<User*>(container);
public:
ServProtectMode(Module* Creator) : ModeHandler(Creator, "servprotect", 'k', PARAM_NONE, MODETYPE_USER) { oper = true; }
- 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
{
/* Because this returns MODEACTION_DENY all the time, there is only ONE
* way to add this mode and that is at client introduction in the UID command,
flags_needed = 'o'; syntax = "<new-hostname>";
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (parameters[0].length() > ServerInstance->Config->Limits.MaxHost)
{
flags_needed = 'o'; syntax = "<new-ident>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (parameters[0].size() > ServerInstance->Config->Limits.IdentMax)
{
flags_needed = 'o'; syntax = "<duration>";
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
{
int idle = InspIRCd::Duration(parameters[0]);
if (idle < 1)
syntax = "<new-gecos>";
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (parameters[0].size() > ServerInstance->Config->Limits.MaxGecos)
{
{
}
- std::string GenerateRaw(const std::string& data)
+ std::string GenerateRaw(const std::string& data) CXX11_OVERRIDE
{
SHA1Context ctx;
ctx.Update(reinterpret_cast<const unsigned char*>(data.data()), data.length());
}
public:
- std::string GenerateRaw(const std::string& data)
+ std::string GenerateRaw(const std::string& data) CXX11_OVERRIDE
{
unsigned char bytes[SHA256_DIGEST_SIZE];
SHA256(data.data(), bytes, data.length());
") did a /whois on you");
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
User* dest = ServerInstance->FindNick(parameters[0]);
if (!dest)
{
}
- bool Matches(User *u)
+ bool Matches(User* u) CXX11_OVERRIDE
{
// E: overrides shun
LocalUser* lu = IS_LOCAL(u);
return false;
}
- bool Matches(const std::string &s)
+ bool Matches(const std::string& s) CXX11_OVERRIDE
{
if (matchtext == s)
return true;
return false;
}
- const std::string& Displayable()
+ const std::string& Displayable() CXX11_OVERRIDE
{
return matchtext;
}
/** Generate a shun
*/
- XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
+ XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask) CXX11_OVERRIDE
{
return new Shun(set_time, duration, source, reason, xline_specific_mask);
}
- bool AutoApplyToUserList(XLine *x)
+ bool AutoApplyToUserList(XLine* x) CXX11_OVERRIDE
{
return false;
}
flags_needed = 'o'; this->syntax = "<nick!user@hostmask> [<shun-duration>] :<reason>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
/* syntax: SHUN nick!user@host time :reason goes here */
/* 'time' is a human-readable timestring, like 2d3h2s. */
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
if (IS_LOCAL(user))
return ROUTE_LOCALONLY; // spanningtree will send ADDLINE
TRANSLATE3(TR_NICK, TR_TEXT, TR_TEXT);
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
/*
* XXX: thought occurs to me
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
syntax = "{[+|-]<mask> <p|c|i|n|t|a|x>}";
}
- CmdResult Handle (const std::vector<std::string>& parameters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (!parameters.size())
{
{
public:
CacheRefreshTimer();
- bool Tick(time_t TIME);
+ bool Tick(time_t TIME) CXX11_OVERRIDE;
};
{
public:
CommandRConnect(Module* Creator);
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
class CommandRSQuit : public Command
{
public:
CommandRSQuit(Module* Creator);
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
class CommandMap : public Command
{
public:
CommandMap(Module* Creator);
- CmdResult Handle(const std::vector<std::string>& parameters, User* user);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
class CommandSVSJoin : public ServerCommand
{
public:
CommandSVSJoin(Module* Creator) : ServerCommand(Creator, "SVSJOIN", 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& params);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
class CommandSVSPart : public ServerCommand
{
public:
CommandSVSPart(Module* Creator) : ServerCommand(Creator, "SVSPART", 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& params);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
class CommandSVSNick : public ServerCommand
{
public:
CommandSVSNick(Module* Creator) : ServerCommand(Creator, "SVSNICK", 3) { }
- CmdResult Handle(User* user, std::vector<std::string>& params);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
class CommandMetadata : public ServerCommand
{
public:
CommandMetadata(Module* Creator) : ServerCommand(Creator, "METADATA", 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& params);
+ CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
class Builder : public CmdBuilder
{
void ProcessModeUUIDPair(const std::string& item, TreeServer* sourceserver, Channel* chan, Modes::ChangeList* modechangelist, FwdFJoinBuilder& fwdfjoin);
public:
CommandFJoin(Module* Creator) : ServerCommand(Creator, "FJOIN", 3) { }
- CmdResult Handle(User* user, std::vector<std::string>& params);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_LOCALONLY; }
+ CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE { return ROUTE_LOCALONLY; }
class Builder : public CmdBuilder
{
{
public:
CommandFMode(Module* Creator) : ServerCommand(Creator, "FMODE", 3) { }
- CmdResult Handle(User* user, std::vector<std::string>& params);
+ CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
};
class CommandFTopic : public ServerCommand
{
public:
CommandFTopic(Module* Creator) : ServerCommand(Creator, "FTOPIC", 4, 5) { }
- CmdResult Handle(User* user, std::vector<std::string>& params);
+ CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
class Builder : public CmdBuilder
{
public:
CommandResync(Module* Creator) : ServerOnlyServerCommand<CommandResync>(Creator, "RESYNC", 1) { }
CmdResult HandleServer(TreeServer* server, std::vector<std::string>& parameters);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_LOCALONLY; }
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE { return ROUTE_LOCALONLY; }
};
class SpanningTree::CommandAway : public UserOnlyServerCommand<SpanningTree::CommandAway>
{
public:
CommandAddLine(Module* Creator) : ServerCommand(Creator, "ADDLINE", 6, 6) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters);
+ CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE;
class Builder : public CmdBuilder
{
{
public:
CommandDelLine(Module* Creator) : ServerCommand(Creator, "DELLINE", 2, 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters);
+ CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
class CommandEncap : public ServerCommand
{
public:
CommandEncap(Module* Creator) : ServerCommand(Creator, "ENCAP", 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
class CommandIdle : public UserOnlyServerCommand<CommandIdle>
public:
CommandIdle(Module* Creator) : UserOnlyServerCommand<CommandIdle>(Creator, "IDLE", 1) { }
CmdResult HandleRemote(RemoteUser* user, std::vector<std::string>& parameters);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_UNICAST(parameters[0]); }
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE { return ROUTE_UNICAST(parameters[0]); }
};
class SpanningTree::CommandNick : public UserOnlyServerCommand<SpanningTree::CommandNick>
{
public:
CommandPing(Module* Creator) : ServerCommand(Creator, "PING", 1) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_UNICAST(parameters[0]); }
+ CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE { return ROUTE_UNICAST(parameters[0]); }
};
class SpanningTree::CommandPong : public ServerOnlyServerCommand<SpanningTree::CommandPong>
public:
CommandPong(Module* Creator) : ServerOnlyServerCommand<SpanningTree::CommandPong>(Creator, "PONG", 1) { }
CmdResult HandleServer(TreeServer* server, std::vector<std::string>& parameters);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_UNICAST(parameters[0]); }
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE { return ROUTE_UNICAST(parameters[0]); }
};
class CommandSave : public ServerCommand
static const time_t SavedTimestamp = 100;
CommandSave(Module* Creator) : ServerCommand(Creator, "SAVE", 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters);
+ CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
class SpanningTree::CommandServer : public ServerOnlyServerCommand<SpanningTree::CommandServer>
{
public:
CommandSNONotice(Module* Creator) : ServerCommand(Creator, "SNONOTICE", 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters);
+ CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE;
};
class CommandEndBurst : public ServerOnlyServerCommand<CommandEndBurst>
public:
CommandNum(Module* Creator) : ServerOnlyServerCommand<CommandNum>(Creator, "NUM", 3) { }
CmdResult HandleServer(TreeServer* server, std::vector<std::string>& parameters);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
class Builder : public CmdBuilder
{
void RegisterService() CXX11_OVERRIDE;
virtual CmdResult Handle(User* user, std::vector<std::string>& parameters) = 0;
- virtual RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
/**
* Extract the TS from a string.
UserOnlyServerCommand(Module* Creator, const std::string& Name, unsigned int MinPara = 0, unsigned int MaxPara = 0)
: ServerCommand(Creator, Name, MinPara, MaxPara) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters)
+ CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE
{
RemoteUser* remoteuser = IS_REMOTE(user);
if (!remoteuser)
ServerOnlyServerCommand(Module* Creator, const std::string& Name, unsigned int MinPara = 0, unsigned int MaxPara = 0)
: ServerCommand(Creator, Name, MinPara, MaxPara) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters)
+ CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE
{
if (!IS_SERVER(user))
throw ProtocolException("Invalid source");
delete old;
}
- std::string serialize(SerializeFormat format, const Extensible* container, void* item) const
+ std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE
{
return static_cast<ssl_cert*>(item)->GetMetaLine();
}
- void unserialize(SerializeFormat format, Extensible* container, const std::string& value)
+ void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE
{
ssl_cert* cert = new ssl_cert;
set(container, cert);
}
}
- void free(void* item)
+ void free(void* item) CXX11_OVERRIDE
{
ssl_cert* old = static_cast<ssl_cert*>(item);
if (old && old->refcount_dec())
this->syntax = "<nick>";
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
User* target = ServerInstance->FindNickOnly(parameters[0]);
{
}
- 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
{
if (adding)
{
works_before_reg = true;
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
{
if (!ssl)
{
this->nickname = nick;
}
- bool Matches(User *u)
+ bool Matches(User* u) CXX11_OVERRIDE
{
if (u->nick == nickname)
return true;
return false;
}
- bool Matches(const std::string &s)
+ bool Matches(const std::string& s) CXX11_OVERRIDE
{
return InspIRCd::Match(s, nickname);
}
- void DisplayExpiry()
+ void DisplayExpiry() CXX11_OVERRIDE
{
if (!silent)
{
}
}
- const std::string& Displayable()
+ const std::string& Displayable() CXX11_OVERRIDE
{
return nickname;
}
/** Generate a shun
*/
- XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
+ XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask) CXX11_OVERRIDE
{
return new SVSHold(set_time, duration, source, reason, xline_specific_mask);
}
- bool AutoApplyToUserList(XLine *x)
+ bool AutoApplyToUserList(XLine* x) CXX11_OVERRIDE
{
return false;
}
flags_needed = 'o'; this->syntax = "<nickname> [<duration> :<reason>]";
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
/* syntax: svshold nickname time :reason goes here */
/* 'time' is a human-readable timestring, like 2d3h2s. */
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User* user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
User* dest = ServerInstance->FindNick(parameters[0]);
syntax = "<channel> <duration> <banmask>";
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
Channel* channel = ServerInstance->FindChan(parameters[0]);
if (!channel)
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
{
}
- void AfterMode(User* source, User* dest, Channel* chan, const std::string& banmask, bool adding)
+ void AfterMode(User* source, User* dest, Channel* chan, const std::string& banmask, bool adding) CXX11_OVERRIDE
{
if (adding)
return;
flags_needed = 'o'; this->syntax = "<mask>";
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
unsigned int n_matched = 0;
unsigned int n_match_host = 0;
flags_needed = FLAG_SERVERONLY;
}
- CmdResult Handle(const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
if (!user->server->IsULine())
{
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
return (get_raw(container) != NULL);
}
- std::string serialize(SerializeFormat format, const Extensible* container, void* item) const
+ std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE
{
if (format == FORMAT_USER)
return "true";
return "1";
}
- void unserialize(SerializeFormat format, Extensible* container, const std::string& value)
+ void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE
{
if (value == "1")
set_raw(container, this);
unset_raw(container);
}
- void free(void* item)
+ void free(void* item) CXX11_OVERRIDE
{
// nothing to free
}
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
User* u;
if (IS_LOCAL(user))
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
+ RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
syntax = "<nick> [<nick> ...]";
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
std::string retbuf;
int nicks = 0;
syntax = "<username> <password>";
}
- CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
+ CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
{
ConfigTagList tags = ServerInstance->Config->ConfTags("vhost");
for(ConfigIter i = tags.first; i != tags.second; ++i)
syntax = "[<C|L|S|l|+<nick1>|-<nick>>]";
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
+ CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
{
if (parameters.empty())
{
/** Generate a GLine
*/
- XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
+ XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask) CXX11_OVERRIDE
{
IdentHostPair ih = ServerInstance->XLines->IdentSplit(xline_specific_mask);
return new GLine(set_time, duration, source, reason, ih.first, ih.second);
/** Generate an ELine
*/
- XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
+ XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask) CXX11_OVERRIDE
{
IdentHostPair ih = ServerInstance->XLines->IdentSplit(xline_specific_mask);
return new ELine(set_time, duration, source, reason, ih.first, ih.second);
/** Generate a KLine
*/
- XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
+ XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask) CXX11_OVERRIDE
{
IdentHostPair ih = ServerInstance->XLines->IdentSplit(xline_specific_mask);
return new KLine(set_time, duration, source, reason, ih.first, ih.second);
/** Generate a QLine
*/
- XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
+ XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask) CXX11_OVERRIDE
{
return new QLine(set_time, duration, source, reason, xline_specific_mask);
}
/** Generate a ZLine
*/
- XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
+ XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask) CXX11_OVERRIDE
{
return new ZLine(set_time, duration, source, reason, xline_specific_mask);
}
projects / user / henk / code / inspircd.git / commitdiff