Fix implementation of reference to const, use reference counting for ExtensibleItem

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

diff --git a/include/extensible.h b/include/extensible.h
index c491f99b9e6c022eac7e8bc89690471b4bb3cdef..e77c1cc305a1ed9f4303f24ab965ce242870f993 100644 (file)
--- a/include/extensible.h
+++ b/include/extensible.h
@@ -15,7 +15,7 @@ enum SerializeFormat
 
 /** Class represnting an extension of some object
  */
-class CoreExport ExtensionItem
+class CoreExport ExtensionItem : public refcountbase
 {
  public:
        const std::string key;
@@ -28,7 +28,7 @@ class CoreExport ExtensionItem
         * @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
@@ -40,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 */
-CoreExport 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
@@ -59,43 +56,44 @@ CoreExport typedef std::map<std::string,void*> ExtensibleStore;
  */
 class CoreExport Extensible : public classbase
 {
+ public:
+       typedef std::map<reference<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;
-       }
 
+       Extensible();
+       virtual CullResult cull();
        virtual ~Extensible();
+       void doUnhookExtensions(const std::vector<reference<ExtensionItem> >& toRemove);
+};
 
-       static bool Register(ExtensionItem* item);
-       static std::vector<ExtensionItem*> BeginUnregister(Module* module);
-       void doUnhookExtensions(const std::vector<ExtensionItem*>& toRemove);
-
-       // Friend access for the protected getter/setter
-       friend class ExtensionItem;
+class CoreExport ExtensionManager
+{
+       std::map<std::string, reference<ExtensionItem> > types;
+ public:
+       void Register(ExtensionItem* item);
+       void BeginUnregister(Module* module, std::vector<reference<ExtensionItem> >& list);
+       ExtensionItem* GetItem(const std::string& name);
 };
 
 /** Base class for items that are NOT synchronized between servers */
-class LocalExtItem : public ExtensionItem
+class CoreExport LocalExtItem : public ExtensionItem
 {
  public:
        LocalExtItem(const std::string& key, Module* owner);
        virtual ~LocalExtItem();
-       virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item);
+       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;
 };
@@ -112,22 +110,11 @@ class SimpleExtItem : public LocalExtItem
        {
        }
 
-       inline T* get(const Extensible* container)
+       inline T* get(const Extensible* container) const
        {
                return static_cast<T*>(get_raw(container));
        }
 
-       inline T* getNew(Extensible* container)
-       {
-               T* ptr = get(container);
-               if (!ptr)
-               {
-                       ptr = new T;
-                       set_raw(container, ptr);
-               }
-               return ptr;
-       }
-
        inline void set(Extensible* container, const T& value)
        {
                T* ptr = new T(value);
@@ -153,32 +140,32 @@ class SimpleExtItem : public LocalExtItem
        }
 };
 
-class LocalStringExt : public SimpleExtItem<std::string>
+class CoreExport LocalStringExt : public SimpleExtItem<std::string>
 {
  public:
        LocalStringExt(const std::string& key, Module* owner);
        virtual ~LocalStringExt();
-       std::string serialize(SerializeFormat format, const Extensible* container, void* item);
+       std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
 };
 
-class LocalIntExt : public LocalExtItem
+class CoreExport LocalIntExt : public LocalExtItem
 {
  public:
        LocalIntExt(const std::string& key, Module* owner);
        virtual ~LocalIntExt();
-       std::string serialize(SerializeFormat format, const Extensible* container, void* item);
-       intptr_t get(const Extensible* container);
+       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);
 };
 
-class StringExtItem : public ExtensionItem
+class CoreExport StringExtItem : public ExtensionItem
 {
  public:
        StringExtItem(const std::string& key, Module* owner);
        virtual ~StringExtItem();
-       std::string* get(const Extensible* container);
-       std::string serialize(SerializeFormat format, const Extensible* container, void* item);
+       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);