6 /** Shown to a human (does not need to be unserializable) */
8 /** Passed internally to this process (i.e. for /RELOADMODULE) */
10 /** Passed to other servers on the network (i.e. METADATA s2s command) */
12 /** Stored on disk (i.e. permchannel database) */
16 /** Class represnting an extension of some object
18 class CoreExport ExtensionItem
21 const std::string key;
23 ExtensionItem(const std::string& key, Module* owner);
24 virtual ~ExtensionItem();
25 /** Serialize this item into a string
27 * @param format The format to serialize to
28 * @param container The object containing this item
29 * @param item The item itself
31 virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item) const = 0;
32 /** Convert the string form back into an item
33 * @param format The format to serialize from (not FORMAT_USER)
34 * @param container The object that this item applies to
35 * @param value The return from a serialize() call that was run elsewhere with this key
37 virtual void unserialize(SerializeFormat format, Extensible* container, const std::string& value) = 0;
39 virtual void free(void* item) = 0;
42 /** Get the item from the internal map */
43 void* get_raw(const Extensible* container) const;
44 /** Set the item in the internal map; returns old value */
45 void* set_raw(Extensible* container, void* value);
46 /** Remove the item from the internal map; returns old value */
47 void* unset_raw(Extensible* container);
50 /** class Extensible is the parent class of many classes such as User and Channel.
51 * class Extensible implements a system which allows modules to 'extend' the class by attaching data within
52 * a map associated with the object. In this way modules can store their own custom information within user
53 * objects, channel objects and server objects, without breaking other modules (this is more sensible than using
54 * a flags variable, and each module defining bits within the flag as 'theirs' as it is less prone to conflict and
55 * supports arbitary data storage).
57 class CoreExport Extensible : public classbase
60 typedef std::map<ExtensionItem*,void*> ExtensibleStore;
62 // Friend access for the protected getter/setter
63 friend class ExtensionItem;
65 /** Private data store.
66 * Holds all extensible metadata for the class.
68 ExtensibleStore extensions;
71 * Get the extension items for iteraton (i.e. for metadata sync during netburst)
73 inline const ExtensibleStore& GetExtList() const { return extensions; }
75 virtual ~Extensible();
76 void doUnhookExtensions(const std::vector<ExtensionItem*>& toRemove);
79 class CoreExport ExtensionManager
81 std::map<std::string, ExtensionItem*> types;
83 void Register(ExtensionItem* item);
84 void BeginUnregister(Module* module, std::vector<ExtensionItem*>& list);
85 ExtensionItem* GetItem(const std::string& name);
88 /** Base class for items that are NOT synchronized between servers */
89 class CoreExport LocalExtItem : public ExtensionItem
92 LocalExtItem(const std::string& key, Module* owner);
93 virtual ~LocalExtItem();
94 virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
95 virtual void unserialize(SerializeFormat format, Extensible* container, const std::string& value);
96 virtual void free(void* item) = 0;
100 class SimpleExtItem : public LocalExtItem
103 SimpleExtItem(const std::string& Key, Module* parent) : LocalExtItem(Key, parent)
107 virtual ~SimpleExtItem()
111 inline T* get(const Extensible* container) const
113 return static_cast<T*>(get_raw(container));
116 inline T* getNew(Extensible* container) const
118 T* ptr = get(container);
122 set_raw(container, ptr);
127 inline void set(Extensible* container, const T& value)
129 T* ptr = new T(value);
130 T* old = static_cast<T*>(set_raw(container, ptr));
134 inline void set(Extensible* container, T* value)
136 T* old = static_cast<T*>(set_raw(container, value));
140 inline void unset(Extensible* container)
142 T* old = static_cast<T*>(unset_raw(container));
146 virtual void free(void* item)
148 delete static_cast<T*>(item);
152 class CoreExport LocalStringExt : public SimpleExtItem<std::string>
155 LocalStringExt(const std::string& key, Module* owner);
156 virtual ~LocalStringExt();
157 std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
160 class CoreExport LocalIntExt : public LocalExtItem
163 LocalIntExt(const std::string& key, Module* owner);
164 virtual ~LocalIntExt();
165 std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
166 intptr_t get(const Extensible* container) const;
167 intptr_t set(Extensible* container, intptr_t value);
168 void free(void* item);
171 class CoreExport StringExtItem : public ExtensionItem
174 StringExtItem(const std::string& key, Module* owner);
175 virtual ~StringExtItem();
176 std::string* get(const Extensible* container) const;
177 std::string serialize(SerializeFormat format, const Extensible* container, void* item) const;
178 void unserialize(SerializeFormat format, Extensible* container, const std::string& value);
179 void set(Extensible* container, const std::string& value);
180 void unset(Extensible* container);
181 void free(void* item);