Make classbase and refcountbase uncopyable; expand comments on their indended uses

[user/henk/code/inspircd.git] / include / extensible.h

diff --git a/include/extensible.h b/include/extensible.h
index 3f59982318a2e14ce8783e872dd11eb71d2fd557..ca9c44546d2a88323a621965e6c72ddc73247d8e 100644 (file)
--- a/include/extensible.h
+++ b/include/extensible.h
@@ -21,13 +21,14 @@ class CoreExport ExtensionItem
        const std::string key;
        Module* const owner;
        ExtensionItem(const std::string& key, Module* owner);
+       virtual ~ExtensionItem();
        /** Serialize this item into a string
         *
         * @param format The format to serialize to
         * @param container The object containing this item
         * @param item The item itself
         */
-       virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item) = 0;
+       virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item) const = 0;
        /** Convert the string form back into an item
         * @param format The format to serialize from (not FORMAT_USER)
         * @param container The object that this item applies to
@@ -39,16 +40,13 @@ class CoreExport ExtensionItem
 
  protected:
        /** Get the item from the internal map */
-       void* get_raw(const Extensible* container);
+       void* get_raw(const Extensible* container) const;
        /** Set the item in the internal map; returns old value */
        void* set_raw(Extensible* container, void* value);
        /** Remove the item from the internal map; returns old value */
        void* unset_raw(Extensible* container);
 };
 
-/** A private data store for an Extensible class */
-typedef std::map<std::string,void*> ExtensibleStore;
-
 /** class Extensible is the parent class of many classes such as User and Channel.
  * class Extensible implements a system which allows modules to 'extend' the class by attaching data within
  * a map associated with the object. In this way modules can store their own custom information within user
@@ -58,33 +56,34 @@ typedef std::map<std::string,void*> ExtensibleStore;
  */
 class CoreExport Extensible : public classbase
 {
+ public:
+       typedef std::map<ExtensionItem*,void*> ExtensibleStore;
+
+       // Friend access for the protected getter/setter
+       friend class ExtensionItem;
+ private:
        /** Private data store.
         * Holds all extensible metadata for the class.
         */
        ExtensibleStore extensions;
-       typedef std::map<std::string, ExtensionItem*> ExtensibleTypes;
-       static ExtensibleTypes extension_types;
  public:
        /**
         * Get the extension items for iteraton (i.e. for metadata sync during netburst)
         */
        inline const ExtensibleStore& GetExtList() const { return extensions; }
-       static inline const ExtensibleTypes& GetTypeList() { return extension_types; }
-       static inline ExtensionItem* GetItem(const std::string& name)
-       {
-               ExtensibleTypes::iterator i = extension_types.find(name);
-               if (i == extension_types.end())
-                       return NULL;
-               return i->second;
-       }
 
+       virtual CullResult cull();
        virtual ~Extensible();
+       void doUnhookExtensions(const std::vector<ExtensionItem*>& toRemove);
+};
 
-       static bool Register(ExtensionItem* item);
-       static void UnRegister(Module* module);
-       
-       // Friend access for the protected getter/setter
-       friend class ExtensionItem;
+class CoreExport ExtensionManager
+{
+       std::map<std::string, ExtensionItem*> types;
+ public:
+       void Register(ExtensionItem* item);
+       void BeginUnregister(Module* module, std::vector<ExtensionItem*>& list);
+       ExtensionItem* GetItem(const std::string& name);
 };
 
 /** Base class for items that are NOT synchronized between servers */
@@ -92,25 +91,30 @@ class CoreExport LocalExtItem : public ExtensionItem
 {
  public:
        LocalExtItem(const std::string& key, Module* owner);
-       virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item);
+       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;
 };
 
 template<typename T>
-class CoreExport SimpleExtItem : public LocalExtItem
+class SimpleExtItem : public LocalExtItem
 {
  public:
        SimpleExtItem(const std::string& Key, Module* parent) : LocalExtItem(Key, parent)
        {
        }
 
-       inline T* get(const Extensible* container)
+       virtual ~SimpleExtItem()
+       {
+       }
+
+       inline T* get(const Extensible* container) const
        {
                return static_cast<T*>(get_raw(container));
        }
 
-       inline T* getNew(Extensible* container)
+       inline T* getNew(Extensible* container) const
        {
                T* ptr = get(container);
                if (!ptr)
@@ -150,15 +154,17 @@ class CoreExport LocalStringExt : public SimpleExtItem<std::string>
 {
  public:
        LocalStringExt(const std::string& key, Module* owner);
-       std::string serialize(SerializeFormat format, const Extensible* container, void* item);
+       virtual ~LocalStringExt();
+       std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
 };
 
 class CoreExport LocalIntExt : public LocalExtItem
 {
  public:
        LocalIntExt(const std::string& key, Module* owner);
-       std::string serialize(SerializeFormat format, const Extensible* container, void* item);
-       intptr_t get(const Extensible* container);
+       virtual ~LocalIntExt();
+       std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
+       intptr_t get(const Extensible* container) const;
        intptr_t set(Extensible* container, intptr_t value);
        void free(void* item);
 };
@@ -167,8 +173,9 @@ class CoreExport StringExtItem : public ExtensionItem
 {
  public:
        StringExtItem(const std::string& key, Module* owner);
-       std::string* get(const Extensible* container);
-       std::string serialize(SerializeFormat format, const Extensible* container, void* item);
+       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);
        void set(Extensible* container, const std::string& value);
        void unset(Extensible* container);