2 * InspIRCd -- Internet Relay Chat Daemon
4 * Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
6 * This file is part of InspIRCd. InspIRCd is free software: you can
7 * redistribute it and/or modify it under the terms of the GNU General Public
8 * License as published by the Free Software Foundation, version 2.
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
12 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
26 /** Shown to a human (does not need to be unserializable) */
28 /** Passed internally to this process (i.e. for /RELOADMODULE) */
30 /** Passed to other servers on the network (i.e. METADATA s2s command) */
32 /** Stored on disk (i.e. permchannel database) */
36 /** Class represnting an extension of some object
38 class CoreExport ExtensionItem : public ServiceProvider, public usecountbase
41 /** Extensible subclasses
50 /** Type (subclass) of Extensible that this ExtensionItem is valid for
52 const ExtensibleType type;
54 ExtensionItem(const std::string& key, ExtensibleType exttype, Module* owner);
55 virtual ~ExtensionItem();
56 /** Serialize this item into a string
58 * @param format The format to serialize to
59 * @param container The object containing this item
60 * @param item The item itself
62 virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item) const = 0;
63 /** Convert the string form back into an item
64 * @param format The format to serialize from (not FORMAT_USER)
65 * @param container The object that this item applies to
66 * @param value The return from a serialize() call that was run elsewhere with this key
68 virtual void unserialize(SerializeFormat format, Extensible* container, const std::string& value) = 0;
70 virtual void free(void* item) = 0;
72 /** Register this object in the ExtensionManager
74 void RegisterService() CXX11_OVERRIDE;
77 /** Get the item from the internal map */
78 void* get_raw(const Extensible* container) const;
79 /** Set the item in the internal map; returns old value */
80 void* set_raw(Extensible* container, void* value);
81 /** Remove the item from the internal map; returns old value */
82 void* unset_raw(Extensible* container);
85 /** class Extensible is the parent class of many classes such as User and Channel.
86 * class Extensible implements a system which allows modules to 'extend' the class by attaching data within
87 * a map associated with the object. In this way modules can store their own custom information within user
88 * objects, channel objects and server objects, without breaking other modules (this is more sensible than using
89 * a flags variable, and each module defining bits within the flag as 'theirs' as it is less prone to conflict and
90 * supports arbitary data storage).
92 class CoreExport Extensible : public classbase
95 typedef insp::flat_map<reference<ExtensionItem>, void*> ExtensibleStore;
97 // Friend access for the protected getter/setter
98 friend class ExtensionItem;
100 /** Private data store.
101 * Holds all extensible metadata for the class.
103 ExtensibleStore extensions;
105 /** True if this Extensible has been culled.
106 * A warning is generated if false on destruction.
108 unsigned int culled:1;
111 * Get the extension items for iteraton (i.e. for metadata sync during netburst)
113 inline const ExtensibleStore& GetExtList() const { return extensions; }
116 virtual CullResult cull();
117 virtual ~Extensible();
118 void doUnhookExtensions(const std::vector<reference<ExtensionItem> >& toRemove);
121 * Free all extension items attached to this Extensible
123 void FreeAllExtItems();
126 class CoreExport ExtensionManager
129 typedef std::map<std::string, reference<ExtensionItem> > ExtMap;
131 bool Register(ExtensionItem* item);
132 void BeginUnregister(Module* module, std::vector<reference<ExtensionItem> >& list);
133 ExtensionItem* GetItem(const std::string& name);
135 /** Get all registered extensions keyed by their names
136 * @return Const map of ExtensionItem pointers keyed by their names
138 const ExtMap& GetExts() const { return types; }
144 /** Base class for items that are NOT synchronized between servers */
145 class CoreExport LocalExtItem : public ExtensionItem
148 LocalExtItem(const std::string& key, ExtensibleType exttype, Module* owner);
149 virtual ~LocalExtItem();
150 virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
151 virtual void unserialize(SerializeFormat format, Extensible* container, const std::string& value);
152 virtual void free(void* item) = 0;
155 template <typename T, typename Del = stdalgo::defaultdeleter<T> >
156 class SimpleExtItem : public LocalExtItem
159 SimpleExtItem(const std::string& Key, ExtensibleType exttype, Module* parent)
160 : LocalExtItem(Key, exttype, parent)
164 virtual ~SimpleExtItem()
168 inline T* get(const Extensible* container) const
170 return static_cast<T*>(get_raw(container));
173 inline void set(Extensible* container, const T& value)
175 T* ptr = new T(value);
176 T* old = static_cast<T*>(set_raw(container, ptr));
181 inline void set(Extensible* container, T* value)
183 T* old = static_cast<T*>(set_raw(container, value));
188 inline void unset(Extensible* container)
190 T* old = static_cast<T*>(unset_raw(container));
195 virtual void free(void* item)
198 del(static_cast<T*>(item));
202 class CoreExport LocalStringExt : public SimpleExtItem<std::string>
205 LocalStringExt(const std::string& key, ExtensibleType exttype, Module* owner);
206 virtual ~LocalStringExt();
207 std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
208 void unserialize(SerializeFormat format, Extensible* container, const std::string& value);
211 class CoreExport LocalIntExt : public LocalExtItem
214 LocalIntExt(const std::string& key, ExtensibleType exttype, Module* owner);
215 virtual ~LocalIntExt();
216 std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
217 void unserialize(SerializeFormat format, Extensible* container, const std::string& value);
218 intptr_t get(const Extensible* container) const;
219 intptr_t set(Extensible* container, intptr_t value);
220 void unset(Extensible* container) { set(container, 0); }
221 void free(void* item);
224 class CoreExport StringExtItem : public ExtensionItem
227 StringExtItem(const std::string& key, ExtensibleType exttype, Module* owner);
228 virtual ~StringExtItem();
229 std::string* get(const Extensible* container) const;
230 std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
231 void unserialize(SerializeFormat format, Extensible* container, const std::string& value);
232 void set(Extensible* container, const std::string& value);
233 void unset(Extensible* container);
234 void free(void* item);