1 /* +------------------------------------+
2 * | Inspire Internet Relay Chat Daemon |
3 * +------------------------------------+
5 * InspIRCd: (C) 2002-2009 InspIRCd Development Team
6 * See: http://wiki.inspircd.org/Credits
8 * This program is free but copyrighted software; see
9 * the file COPYING for details.
11 * ---------------------------------------------------
16 #include "inspircd_config.h"
21 const int bitfields[] = {1,2,4,8,16,32,64,128};
22 const int inverted_bitfields[] = {~1,~2,~4,~8,~16,~32,~64,~128};
23 std::map<std::string, ExtensionItem*> Extensible::extension_types;
25 classbase::classbase()
29 bool classbase::cull()
34 classbase::~classbase()
38 refcountbase::refcountbase() : refcount(0)
42 bool refcountbase::cull()
44 return (refcount == 0);
47 refcountbase::~refcountbase()
51 ExtensionItem::ExtensionItem(const std::string& Key, Module* mod) : key(Key), owner(mod)
55 ExtensionItem::~ExtensionItem()
59 void* ExtensionItem::get_raw(const Extensible* container)
61 ExtensibleStore::const_iterator i = container->extensions.find(key);
62 if (i == container->extensions.end())
67 void* ExtensionItem::set_raw(Extensible* container, void* value)
69 std::pair<ExtensibleStore::iterator,bool> rv =
70 container->extensions.insert(std::make_pair(key, value));
77 void* old = rv.first->second;
78 rv.first->second = value;
83 void* ExtensionItem::unset_raw(Extensible* container)
85 ExtensibleStore::iterator i = container->extensions.find(key);
86 if (i == container->extensions.end())
89 container->extensions.erase(i);
93 bool Extensible::Register(ExtensionItem* item)
95 return Extensible::extension_types.insert(std::make_pair(item->key, item)).second;
98 std::vector<ExtensionItem*> Extensible::BeginUnregister(Module* module)
100 std::vector<ExtensionItem*> rv;
101 ExtensibleTypes::iterator i = extension_types.begin();
102 while (i != extension_types.end())
104 ExtensibleTypes::iterator c = i++;
105 if (c->second->owner == module)
107 rv.push_back(c->second);
108 extension_types.erase(c);
114 void Extensible::doUnhookExtensions(const std::vector<ExtensionItem*>& toRemove)
116 for(std::vector<ExtensionItem*>::const_iterator i = toRemove.begin(); i != toRemove.end(); i++)
118 ExtensibleStore::iterator e = extensions.find((**i).key);
119 if (e != extensions.end())
121 (**i).free(e->second);
127 Extensible::~Extensible()
129 for(ExtensibleStore::iterator i = extensions.begin(); i != extensions.end(); ++i)
131 ExtensionItem* type = GetItem(i->first);
133 type->free(i->second);
134 else if (ServerInstance && ServerInstance->Logs)
135 ServerInstance->Logs->Log("BASE", ERROR, "Extension type %s is not registered", i->first.c_str());
139 LocalExtItem::LocalExtItem(const std::string& Key, Module* mod) : ExtensionItem(Key, mod)
143 LocalExtItem::~LocalExtItem()
147 std::string LocalExtItem::serialize(SerializeFormat format, const Extensible* container, void* item)
152 void LocalExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
156 LocalStringExt::LocalStringExt(const std::string& Key, Module* Owner)
157 : SimpleExtItem<std::string>(Key, Owner) { }
159 LocalStringExt::~LocalStringExt()
163 std::string LocalStringExt::serialize(SerializeFormat format, const Extensible* container, void* item)
165 if (item && format == FORMAT_USER)
166 return *static_cast<std::string*>(item);
170 LocalIntExt::LocalIntExt(const std::string& Key, Module* mod) : LocalExtItem(Key, mod)
174 LocalIntExt::~LocalIntExt()
178 std::string LocalIntExt::serialize(SerializeFormat format, const Extensible* container, void* item)
180 if (format != FORMAT_USER)
182 return ConvToStr(reinterpret_cast<intptr_t>(item));
185 intptr_t LocalIntExt::get(const Extensible* container)
187 return reinterpret_cast<intptr_t>(get_raw(container));
190 intptr_t LocalIntExt::set(Extensible* container, intptr_t value)
193 return reinterpret_cast<intptr_t>(set_raw(container, reinterpret_cast<void*>(value)));
195 return reinterpret_cast<intptr_t>(unset_raw(container));
198 void LocalIntExt::free(void*)
202 StringExtItem::StringExtItem(const std::string& Key, Module* mod) : ExtensionItem(Key, mod)
206 StringExtItem::~StringExtItem()
210 std::string* StringExtItem::get(const Extensible* container)
212 return static_cast<std::string*>(get_raw(container));
215 std::string StringExtItem::serialize(SerializeFormat format, const Extensible* container, void* item)
217 return item ? *static_cast<std::string*>(item) : "";
220 void StringExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
225 set(container, value);
228 void StringExtItem::set(Extensible* container, const std::string& value)
230 void* old = set_raw(container, new std::string(value));
231 delete static_cast<std::string*>(old);
234 void StringExtItem::unset(Extensible* container)
236 void* old = unset_raw(container);
237 delete static_cast<std::string*>(old);
240 void StringExtItem::free(void* item)
242 delete static_cast<std::string*>(item);