Force heap allocation of refcountbase, create usecountbase for non-allocation referen...

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

diff --git a/include/extensible.h b/include/extensible.h
index b6e7da5d2a94218cefad02bb185590626e211bcb..487b67408e7b5b741db37e5a7afca3cd6141f8e1 100644 (file)
--- a/include/extensible.h
+++ b/include/extensible.h
@@ -1,6 +1,3 @@
-class Extensible;
-class Module;
-
 enum SerializeFormat
 {
        /** Shown to a human (does not need to be unserializable) */
@@ -15,11 +12,11 @@ enum SerializeFormat
 
 /** Class represnting an extension of some object
  */
-class CoreExport ExtensionItem
+class CoreExport ExtensionItem : public usecountbase
 {
  public:
        const std::string key;
-       Module* const owner;
+       ModuleRef owner;
        ExtensionItem(const std::string& key, Module* owner);
        virtual ~ExtensionItem();
        /** Serialize this item into a string
@@ -28,7 +25,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 +37,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,34 +53,35 @@ 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 */
@@ -95,13 +90,13 @@ 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;
 };
 
 template<typename T>
-class CoreExport SimpleExtItem : public LocalExtItem
+class SimpleExtItem : public LocalExtItem
 {
  public:
        SimpleExtItem(const std::string& Key, Module* parent) : LocalExtItem(Key, parent)
@@ -112,22 +107,11 @@ class CoreExport 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);
@@ -158,7 +142,7 @@ 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 CoreExport LocalIntExt : public LocalExtItem
@@ -166,8 +150,8 @@ 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);
 };
@@ -177,8 +161,8 @@ 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);