Merge usefulness of Flags and Extensible classes into Extensible, made most flags we have juse strings instead of defines/enums

1 files changed, 28 insertions, 57 deletions

diff --git a/include/extensible.h b/include/extensible.h
index 75ab6f5ca..d47690da6 100644
--- a/include/extensible.h
+++ b/include/extensible.h
@@ -11,6 +11,7 @@
 #define EXTENSIBLE_H
 
 #include "anope.h"
+#include "serialize.h"
 
 /* All items added to Extensible must inherit from this.
  */
@@ -19,20 +20,29 @@ class CoreExport ExtensibleItem
  public:
 	virtual ~ExtensibleItem() { }
 
-	/* Called when this ExtensibleItem is being deleted. This should
-	 * clean up things (eg, delete this;) if necessary.
-	 */
-	virtual void OnDelete() { delete this; }
+	virtual const Anope::string *Serialize() { return NULL; }
 };
 
-/** Common class used to Extensible::Extend non-pointers from, as it doesn't delete
- * itself when removed. Eg, obj->Extend(key, new ExtensibleItemClass<Anope::string>(value));
+/** Common class used to Extensible::Extend as it inherits from both ExtensibleItem
+ * and whatever basic object you're trying to store.
+ * Eg, obj->Extend(key, new ExtensibleItemClass<Anope::string>(value));
  */
 template<typename T> struct CoreExport ExtensibleItemClass : T, ExtensibleItem
 {
 	ExtensibleItemClass(const T& t) : T(t) { }
 };
 
+/* Used to attach metadata to this object that is automatically saved
+ * when the object is saved (assuming the object's Serialize method
+ * correcly calls Extensible::ExtensibleSerialize).
+ */
+struct CoreExport ExtensibleMetadata : ExtensibleItemClass<Anope::string>
+{
+	ExtensibleMetadata(const Anope::string &t) : ExtensibleItemClass<Anope::string>(t) { }
+
+	const Anope::string *Serialize() anope_override { return this; }
+};
+
 /* Used to attach arbitrary objects to this object using unique keys */
 class CoreExport Extensible
 {
@@ -43,21 +53,12 @@ class CoreExport Extensible
  public:
 	/** Default constructor
 	 */
-	Extensible() : extension_items(NULL) { }
+	Extensible();
 
 	/** Destructor, deletes all of the extensible items in this object
 	 * then clears the map
 	 */
-	virtual ~Extensible()
-	{
-		if (extension_items)
-		{
-			for (extensible_map::iterator it = extension_items->begin(), it_end = extension_items->end(); it != it_end; ++it)
-				if (it->second)
-					it->second->OnDelete();
-			delete extension_items;
-		}
-	}
+	virtual ~Extensible();
 
 	/** Extend an Extensible class.
 	 *
@@ -65,18 +66,11 @@ class CoreExport Extensible
 	 * @param p This parameter is a pointer to an ExtensibleItem or ExtensibleItemBase derived class
 	 *
 	 * You must provide a key to store the data as via the parameter 'key'.
-	 * 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
+	 * The data will be inserted into the map. If the data already exists, it will be overwritten.
 	 */
-	void Extend(const Anope::string &key, ExtensibleItem *p)
-	{
-		this->Shrink(key);
-		if (!extension_items)
-			extension_items = new extensible_map();
-		(*this->extension_items)[key] = p;
-	}
+	void Extend(const Anope::string &key, ExtensibleItem *p = NULL);
+
+	void ExtendMetadata(const Anope::string &key, const Anope::string &value = "");
 
 	/** Shrink an Extensible class.
 	 *
@@ -86,25 +80,7 @@ class CoreExport Extensible
 	 * you provide a nonexistent key (case is important) then the function will return false.
 	 * @return Returns true on success.
 	 */
-	bool Shrink(const Anope::string &key)
-	{
-		if (!extension_items)
-			return false;
-
-		extensible_map::iterator it = this->extension_items->find(key);
-		if (it != this->extension_items->end())
-		{
-			if (it->second != NULL)
-				it->second->OnDelete();
-			/* map::size_type map::erase( const key_type& key );
-			 * returns the number of elements removed, std::map
-			 * is single-associative so this should only be 0 or 1
-			 */
-			return this->extension_items->erase(key) > 0;
-		}
-
-		return false;
-	}
+	bool Shrink(const Anope::string &key);
 
 	/** Get an extension item.
 	 *
@@ -128,22 +104,17 @@ class CoreExport Extensible
 	 * @param key The key parameter is an arbitary string which identifies the extension data
 	 * @return True if the item was found.
 	 */
-	bool HasExt(const Anope::string &key) const
-	{
-		return this->extension_items != NULL && this->extension_items->count(key) > 0;
-	}
+	bool HasExt(const Anope::string &key) const;
 
 	/** Get a list of all extension items names.
 	 * @param list A deque of strings to receive the list
 	 * @return This function writes a list of all extension items stored
 	 *	 in this object by name into the given deque and returns void.
 	 */
-	void GetExtList(std::deque<Anope::string> &list) const
-	{
-		if (extension_items)
-			for (extensible_map::const_iterator it = extension_items->begin(), it_end = extension_items->end(); it != it_end; ++it)
-				list.push_back(it->first);
-	}
+	void GetExtList(std::deque<Anope::string> &list) const;
+
+	void ExtensibleSerialize(Serialize::Data &data) const;
+	void ExtensibleUnserialize(Serialize::Data &data);
 };
 
 #endif // EXTENSIBLE_H