1 /* +------------------------------------+
2 * | Inspire Internet Relay Chat Daemon |
3 * +------------------------------------+
5 * InspIRCd: (C) 2002-2007 InspIRCd Development Team
6 * See: http://www.inspircd.org/wiki/index.php/Credits
8 * This program is free but copyrighted software; see
9 * the file COPYING for details.
11 * ---------------------------------------------------
17 #include "inspircd_config.h"
23 /** Do we use this? -- Brain */
24 typedef void* VoidPointer;
26 /** A private data store for an Extensible class */
27 typedef std::map<std::string,char*> ExtensibleStore;
32 /** The base class for all inspircd classes.
33 * Wherever possible, all classes you create should inherit from this,
34 * giving them the ability to be passed to various core functions
35 * as 'anonymous' classes.
37 class CoreExport classbase
40 /** Time that the object was instantiated (used for TS calculation etc)
45 * Sets the object's time
52 virtual ~classbase() { }
55 /** class Extensible is the parent class of many classes such as User and Channel.
56 * class Extensible implements a system which allows modules to 'extend' the class by attaching data within
57 * a map associated with the object. In this way modules can store their own custom information within user
58 * objects, channel objects and server objects, without breaking other modules (this is more sensible than using
59 * a flags variable, and each module defining bits within the flag as 'theirs' as it is less prone to conflict and
60 * supports arbitary data storage).
62 class CoreExport Extensible : public classbase
64 /** Private data store.
65 * Holds all extensible metadata for the class.
67 ExtensibleStore Extension_Items;
71 /** Extend an Extensible class.
73 * @param key The key parameter is an arbitary string which identifies the extension data
74 * @param p This parameter is a pointer to any data you wish to associate with the object
76 * You must provide a key to store the data as via the parameter 'key' and store the data
77 * in the templated parameter 'p'.
78 * The data will be inserted into the map. If the data already exists, you may not insert it
79 * twice, Extensible::Extend will return false in this case.
81 * @return Returns true on success, false if otherwise
83 template<typename T> bool Extend(const std::string &key, T* p)
85 /* This will only add an item if it doesnt already exist,
86 * the return value is a std::pair of an iterator to the
87 * element, and a bool saying if it was actually inserted.
89 return this->Extension_Items.insert(std::make_pair(key, (char*)p)).second;
92 /** Extend an Extensible class.
94 * @param key The key parameter is an arbitary string which identifies the extension data
96 * You must provide a key to store the data as via the parameter 'key', this single-parameter
97 * version takes no 'data' parameter, this is used purely for boolean values.
98 * The key will be inserted into the map with a NULL 'data' pointer. If the key already exists
99 * then you may not insert it twice, Extensible::Extend will return false in this case.
101 * @return Returns true on success, false if otherwise
103 bool Extend(const std::string &key)
105 /* This will only add an item if it doesnt already exist,
106 * the return value is a std::pair of an iterator to the
107 * element, and a bool saying if it was actually inserted.
109 return this->Extension_Items.insert(std::make_pair(key, (char*)NULL)).second;
112 /** Shrink an Extensible class.
114 * @param key The key parameter is an arbitary string which identifies the extension data
116 * You must provide a key name. The given key name will be removed from the classes data. If
117 * you provide a nonexistent key (case is important) then the function will return false.
118 * @return Returns true on success.
120 bool Shrink(const std::string &key);
122 /** Get an extension item.
124 * @param key The key parameter is an arbitary string which identifies the extension data
125 * @param p If you provide a non-existent key, this value will be NULL. Otherwise a pointer to the item you requested will be placed in this templated parameter.
126 * @return Returns true if the item was found and false if it was nor, regardless of wether 'p' is NULL. This allows you to store NULL values in Extensible.
128 template<typename T> bool GetExt(const std::string &key, T* &p)
130 ExtensibleStore::iterator iter = this->Extension_Items.find(key); /* Find the item */
131 if(iter != this->Extension_Items.end())
133 p = (T*)iter->second; /* Item found */
138 p = NULL; /* Item not found */
143 /** Get an extension item.
145 * @param key The key parameter is an arbitary string which identifies the extension data
146 * @return Returns true if the item was found and false if it was not.
148 * This single-parameter version only checks if the key exists, it does nothing with
149 * the 'data' field and is probably only useful in conjunction with the single-parameter
150 * version of Extend().
152 bool GetExt(const std::string &key)
154 return (this->Extension_Items.find(key) != this->Extension_Items.end());
157 /** Get a list of all extension items names.
158 * @param list A deque of strings to receive the list
159 * @return This function writes a list of all extension items stored in this object by name into the given deque and returns void.
161 void GetExtList(std::deque<std::string> &list);
164 /** BoolSet is a utility class designed to hold eight bools in a bitmask.
165 * Use BoolSet::Set and BoolSet::Get to set and get bools in the bitmask,
166 * and Unset and Invert for special operations upon them.
168 class CoreExport BoolSet : public classbase
170 /** Actual bit values */
175 /** The default constructor initializes the BoolSet to all values unset.
179 /** This constructor copies the default bitmask from a char
181 BoolSet(char bitmask);
183 /** The Set method sets one bool in the set.
185 * @param number The number of the item to set. This must be between 0 and 7.
187 void Set(int number);
189 /** The Get method returns the value of one bool in the set
191 * @param number The number of the item to retrieve. This must be between 0 and 7.
193 * @return True if the item is set, false if it is unset.
195 bool Get(int number);
197 /** The Unset method unsets one value in the set
199 * @param number The number of the item to set. This must be between 0 and 7.
201 void Unset(int number);
203 /** The Unset method inverts (flips) one value in the set
205 * @param number The number of the item to invert. This must be between 0 and 7.
207 void Invert(int number);
209 /** Compare two BoolSets
211 bool operator==(BoolSet other);
213 /** OR two BoolSets together
215 BoolSet operator|(BoolSet other);
217 /** AND two BoolSets together
219 BoolSet operator&(BoolSet other);
221 /** Assign one BoolSet to another
223 bool operator=(BoolSet other);
226 /** This class can be used on its own to represent an exception, or derived to represent a module-specific exception.
227 * When a module whishes to abort, e.g. within a constructor, it should throw an exception using ModuleException or
228 * a class derived from ModuleException. If a module throws an exception during its constructor, the module will not
229 * be loaded. If this happens, the error message returned by ModuleException::GetReason will be displayed to the user
230 * attempting to load the module, or dumped to the console if the ircd is currently loading for the first time.
232 class CoreExport CoreException : public std::exception
235 /** Holds the error message to be displayed
237 const std::string err;
238 /** Source of the exception
240 const std::string source;
242 /** Default constructor, just uses the error mesage 'Core threw an exception'.
244 CoreException() : err("Core threw an exception"), source("The core") {}
245 /** This constructor can be used to specify an error message before throwing.
247 CoreException(const std::string &message) : err(message), source("The core") {}
248 /** This constructor can be used to specify an error message before throwing,
249 * and to specify the source of the exception.
251 CoreException(const std::string &message, const std::string &src) : err(message), source(src) {}
252 /** This destructor solves world hunger, cancels the world debt, and causes the world to end.
253 * Actually no, it does nothing. Never mind.
256 virtual ~CoreException() throw() {};
257 /** Returns the reason for the exception.
258 * The module should probably put something informative here as the user will see this upon failure.
260 virtual const char* GetReason()
265 virtual const char* GetSource()
267 return source.c_str();
271 class CoreExport ModuleException : public CoreException
274 /** Default constructor, just uses the error mesage 'Module threw an exception'.
276 ModuleException() : CoreException("Module threw an exception", "A Module") {}
278 /** This constructor can be used to specify an error message before throwing.
280 ModuleException(const std::string &message) : CoreException(message, "A Module") {}
281 /** This destructor solves world hunger, cancels the world debt, and causes the world to end.
282 * Actually no, it does nothing. Never mind.
285 virtual ~ModuleException() throw() {};