Add Extensible class, which we will use for metadata, derive class User from it as a compile test.

Thanks to Insp for this code.

git-svn-id: http://anope.svn.sourceforge.net/svnroot/anope/trunk@1699 5417fbe8-f217-4b02-8779-1006273d7864

2 files changed, 97 insertions, 1 deletions

diff --git a/include/services.h b/include/services.h
index d53e18472..7b9c87471 100644
--- a/include/services.h
+++ b/include/services.h
@@ -219,6 +219,7 @@ extern int strncasecmp(const char *, const char *, size_t);
 
 /* pull in the various bits of STL to pull in */
 #include <string>
+#include <map>
 #include <exception>
 
 /** This class can be used on its own to represent an exception, or derived to represent a module-specific exception.
@@ -283,6 +284,101 @@ class CoreExport ModuleException : public CoreException
 	virtual ~ModuleException() throw() {};
 };
 
+/** Class with the ability to be extended with key:value pairs.
+ * Thanks to InspIRCd for this.
+ */
+class Extensible
+{
+ private:
+	std::map<std::string, void *> Extension_Items;
+
+ public:
+	/** Extend an Extensible class.
+	 *
+	 * @param key The key parameter is an arbitary string which identifies the extension data
+	 * @param p This parameter is a pointer to any data you wish to associate with the object
+	 *
+	 * You must provide a key to store the data as via the parameter 'key' and store the data
+	 * in the templated parameter 'p'.
+	 * The data will be inserted into the map. If the data already exists, you may not insert it
+	 * twice, Extensible::Extend will return false in this case.
+	 *
+	 * @return Returns true on success, false if otherwise
+	 */
+	template<typename T> bool Extend(const std::string &key, T* p)
+	{
+		/* This will only add an item if it doesnt already exist,
+		 * the return value is a std::pair of an iterator to the
+		 * element, and a bool saying if it was actually inserted.
+		 */
+		return this->Extension_Items.insert(std::make_pair(key, (char*)p)).second;
+	}
+
+	/** Extend an Extensible class.
+	 *
+	 * @param key The key parameter is an arbitary string which identifies the extension data
+	 *
+	 * You must provide a key to store the data as via the parameter 'key', this single-parameter
+	 * version takes no 'data' parameter, this is used purely for boolean values.
+	 * The key will be inserted into the map with a NULL 'data' pointer. If the key already exists
+	 * then you may not insert it twice, Extensible::Extend will return false in this case.
+	 *
+	 * @return Returns true on success, false if otherwise
+	 */
+	bool Extend(const std::string &key)
+	{
+		/* This will only add an item if it doesnt already exist,
+		 * the return value is a std::pair of an iterator to the
+		 * element, and a bool saying if it was actually inserted.
+		 */
+		return this->Extension_Items.insert(std::make_pair(key, (char*)NULL)).second;
+	}
+
+	/** Shrink an Extensible class.
+	 *
+	 * @param key The key parameter is an arbitary string which identifies the extension data
+	 *
+	 * You must provide a key name. The given key name will be removed from the classes data. If
+	 * you provide a nonexistent key (case is important) then the function will return false.
+	 * @return Returns true on success.
+	 */
+	bool Shrink(const std::string &key);
+	
+	/** Get an extension item.
+	 *
+	 * @param key The key parameter is an arbitary string which identifies the extension data
+	 * @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.
+	 * @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.
+	 */
+	template<typename T> bool GetExt(const std::string &key, T* &p)
+	{
+		std::map<std::string, void *>::iterator iter = this->Extension_Items.find(key); /* Find the item */
+		if(iter != this->Extension_Items.end())
+		{
+			p = (T*)iter->second;	/* Item found */
+			return true;
+		}
+		else
+		{
+			p = NULL;		/* Item not found */
+			return false;
+		}
+	}
+	
+	/** Get an extension item.
+	 *
+	 * @param key The key parameter is an arbitary string which identifies the extension data
+	 * @return Returns true if the item was found and false if it was not.
+	 * 
+	 * This single-parameter version only checks if the key exists, it does nothing with
+	 * the 'data' field and is probably only useful in conjunction with the single-parameter
+	 * version of Extend().
+	 */
+	bool GetExt(const std::string &key)
+	{
+		return (this->Extension_Items.find(key) != this->Extension_Items.end());
+	}
+};
 
 /*************************************************************************/
 
diff --git a/include/users.h b/include/users.h
index 185100f4d..db0d42818 100644
--- a/include/users.h
+++ b/include/users.h
@@ -20,7 +20,7 @@ struct u_chaninfolist {
 };
 
 /* Online user and channel data. */
-class User
+class User : public Extensible
 {
  public: // XXX: exposing a tiny bit too much
 	User *next, *prev;