-class Extensible;
-class Module;
+/*
+ * InspIRCd -- Internet Relay Chat Daemon
+ *
+ * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
+ *
+ * This file is part of InspIRCd. InspIRCd is free software: you can
+ * redistribute it and/or modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation, version 2.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#pragma once
+
+#include <stdint.h>
enum SerializeFormat
{
/** Class represnting an extension of some object
*/
-class CoreExport ExtensionItem
+class CoreExport ExtensionItem : public ServiceProvider, public usecountbase
{
public:
- 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
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
*/
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;
+
+ /** True if this Extensible has been culled.
+ * A warning is generated if false on destruction.
+ */
+ unsigned int culled:1;
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;
+ /**
+ * Free all extension items attached to this Extensible
+ */
+ void FreeAllExtItems();
+};
+
+class CoreExport ExtensionManager
+{
+ std::map<std::string, reference<ExtensionItem> > types;
+ public:
+ bool 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 */
{
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
+template <typename T, typename Del = stdalgo::defaultdeleter<T> >
+class SimpleExtItem : public LocalExtItem
{
public:
SimpleExtItem(const std::string& Key, Module* parent) : LocalExtItem(Key, parent)
{
}
- inline T* get(const Extensible* container)
+ virtual ~SimpleExtItem()
{
- return static_cast<T*>(get_raw(container));
}
- inline T* getNew(Extensible* container)
+ inline T* get(const Extensible* container) const
{
- T* ptr = get(container);
- if (!ptr)
- {
- ptr = new T;
- set_raw(container, ptr);
- }
- return ptr;
+ return static_cast<T*>(get_raw(container));
}
inline void set(Extensible* container, const T& value)
{
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)
{
- delete static_cast<T*>(item);
+ Del del;
+ del(static_cast<T*>(item));
}
};
{
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 unset(Extensible* container) { set(container, 0); }
void free(void* item);
};
{
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);