Add the override keyword in places that it is missing.

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

diff --git a/include/extensible.h b/include/extensible.h
index a0544bba1a8fa3156be969e92546e128bb9860b5..afb1cd5b66e0097def46c36c18e509e341152b19 100644 (file)
--- a/include/extensible.h
+++ b/include/extensible.h
@@ -19,8 +19,6 @@
 
 #pragma once
 
-#include <stdint.h>
-
 enum SerializeFormat
 {
        /** Shown to a human (does not need to be unserializable) */
@@ -38,7 +36,20 @@ enum SerializeFormat
 class CoreExport ExtensionItem : public ServiceProvider, public usecountbase
 {
  public:
-       ExtensionItem(const std::string& key, Module* owner);
+       /** Extensible subclasses
+        */
+       enum ExtensibleType
+       {
+               EXT_USER,
+               EXT_CHANNEL,
+               EXT_MEMBERSHIP
+       };
+
+       /** Type (subclass) of Extensible that this ExtensionItem is valid for
+        */
+       const ExtensibleType type;
+
+       ExtensionItem(const std::string& key, ExtensibleType exttype, Module* owner);
        virtual ~ExtensionItem();
        /** Serialize this item into a string
         *
@@ -56,6 +67,10 @@ class CoreExport ExtensionItem : public ServiceProvider, public usecountbase
        /** Free the item */
        virtual void free(void* item) = 0;
 
+       /** Register this object in the ExtensionManager
+        */
+       void RegisterService() CXX11_OVERRIDE;
+
  protected:
        /** Get the item from the internal map */
        void* get_raw(const Extensible* container) const;
@@ -75,7 +90,7 @@ class CoreExport ExtensionItem : public ServiceProvider, public usecountbase
 class CoreExport Extensible : public classbase
 {
  public:
-       typedef std::map<reference<ExtensionItem>,void*> ExtensibleStore;
+       typedef insp::flat_map<reference<ExtensionItem>, void*> ExtensibleStore;
 
        // Friend access for the protected getter/setter
        friend class ExtensionItem;
@@ -96,7 +111,7 @@ class CoreExport Extensible : public classbase
        inline const ExtensibleStore& GetExtList() const { return extensions; }
 
        Extensible();
-       virtual CullResult cull();
+       CullResult cull() CXX11_OVERRIDE;
        virtual ~Extensible();
        void doUnhookExtensions(const std::vector<reference<ExtensionItem> >& toRemove);
 
@@ -108,29 +123,39 @@ class CoreExport Extensible : public classbase
 
 class CoreExport ExtensionManager
 {
-       std::map<std::string, reference<ExtensionItem> > types;
  public:
+       typedef std::map<std::string, reference<ExtensionItem> > ExtMap;
+
        bool Register(ExtensionItem* item);
        void BeginUnregister(Module* module, std::vector<reference<ExtensionItem> >& list);
        ExtensionItem* GetItem(const std::string& name);
+
+       /** Get all registered extensions keyed by their names
+        * @return Const map of ExtensionItem pointers keyed by their names
+        */
+       const ExtMap& GetExts() const { return types; }
+
+ private:
+       ExtMap types;
 };
 
 /** Base class for items that are NOT synchronized between servers */
 class CoreExport LocalExtItem : public ExtensionItem
 {
  public:
-       LocalExtItem(const std::string& key, Module* owner);
+       LocalExtItem(const std::string& key, ExtensibleType exttype, Module* owner);
        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;
+       std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE;
+       void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE;
+       void free(void* item) CXX11_OVERRIDE = 0;
 };
 
-template<typename T>
+template <typename T, typename Del = stdalgo::defaultdeleter<T> >
 class SimpleExtItem : public LocalExtItem
 {
  public:
-       SimpleExtItem(const std::string& Key, Module* parent) : LocalExtItem(Key, parent)
+       SimpleExtItem(const std::string& Key, ExtensibleType exttype, Module* parent)
+               : LocalExtItem(Key, exttype, parent)
        {
        }
 
@@ -147,55 +172,62 @@ class SimpleExtItem : public LocalExtItem
        {
                T* ptr = new T(value);
                T* old = static_cast<T*>(set_raw(container, ptr));
-               delete old;
+               Del del;
+               del(old);
        }
 
        inline void set(Extensible* container, T* value)
        {
                T* old = static_cast<T*>(set_raw(container, value));
-               delete old;
+               Del del;
+               del(old);
        }
 
        inline void unset(Extensible* container)
        {
                T* old = static_cast<T*>(unset_raw(container));
-               delete old;
+               Del del;
+               del(old);
        }
 
-       virtual void free(void* item)
+       void free(void* item) CXX11_OVERRIDE
        {
-               delete static_cast<T*>(item);
+               Del del;
+               del(static_cast<T*>(item));
        }
 };
 
 class CoreExport LocalStringExt : public SimpleExtItem<std::string>
 {
  public:
-       LocalStringExt(const std::string& key, Module* owner);
+       LocalStringExt(const std::string& key, ExtensibleType exttype, Module* owner);
        virtual ~LocalStringExt();
-       std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
+       std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE;
+       void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE;
 };
 
 class CoreExport LocalIntExt : public LocalExtItem
 {
  public:
-       LocalIntExt(const std::string& key, Module* owner);
+       LocalIntExt(const std::string& key, ExtensibleType exttype, Module* owner);
        virtual ~LocalIntExt();
-       std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
+       std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE;
+       void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE;
        intptr_t get(const Extensible* container) const;
        intptr_t set(Extensible* container, intptr_t value);
-       void free(void* item);
+       void unset(Extensible* container) { set(container, 0); }
+       void free(void* item) CXX11_OVERRIDE;
 };
 
 class CoreExport StringExtItem : public ExtensionItem
 {
  public:
-       StringExtItem(const std::string& key, Module* owner);
+       StringExtItem(const std::string& key, ExtensibleType exttype, Module* owner);
        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);
+       std::string serialize(SerializeFormat format, const Extensible* container, void* item) const CXX11_OVERRIDE;
+       void unserialize(SerializeFormat format, Extensible* container, const std::string& value) CXX11_OVERRIDE;
        void set(Extensible* container, const std::string& value);
        void unset(Extensible* container);
-       void free(void* item);
+       void free(void* item) CXX11_OVERRIDE;
 };