src/base.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2009 InspIRCd Development Team
   6  * See: http://wiki.inspircd.org/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *            the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 #include "inspircd_config.h"
  15 #include "base.h"
  16 #include <time.h>
  17 #include "inspircd.h"
  18 #include <typeinfo>
  19
  20 classbase::classbase()
  21 {
  22         if (ServerInstance && ServerInstance->Logs)
  23                 ServerInstance->Logs->Log("CULLLIST", DEBUG, "classbase::+%s @%p",
  24                         typeid(*this).name(), (void*)this);
  25 }
  26
  27 CullResult classbase::cull()
  28 {
  29         if (ServerInstance && ServerInstance->Logs)
  30                 ServerInstance->Logs->Log("CULLLIST", DEBUG, "classbase::-%s @%p",
  31                         typeid(*this).name(), (void*)this);
  32         return CullResult();
  33 }
  34
  35 classbase::~classbase()
  36 {
  37         if (ServerInstance && ServerInstance->Logs)
  38                 ServerInstance->Logs->Log("CULLLIST", DEBUG, "classbase::~%s @%p",
  39                         typeid(*this).name(), (void*)this);
  40 }
  41
  42 CullResult::CullResult()
  43 {
  44 }
  45
  46 refcountbase::refcountbase() : refcount(0)
  47 {
  48 }
  49
  50 refcountbase::~refcountbase()
  51 {
  52 }
  53
  54 ExtensionItem::ExtensionItem(const std::string& Key, Module* mod) : key(Key), owner(mod)
  55 {
  56 }
  57
  58 ExtensionItem::~ExtensionItem()
  59 {
  60 }
  61
  62 void* ExtensionItem::get_raw(const Extensible* container) const
  63 {
  64         Extensible::ExtensibleStore::const_iterator i =
  65                 container->extensions.find(const_cast<ExtensionItem*>(this));
  66         if (i == container->extensions.end())
  67                 return NULL;
  68         return i->second;
  69 }
  70
  71 void* ExtensionItem::set_raw(Extensible* container, void* value)
  72 {
  73         std::pair<Extensible::ExtensibleStore::iterator,bool> rv =
  74                 container->extensions.insert(std::make_pair(this, value));
  75         if (rv.second)
  76         {
  77                 return NULL;
  78         }
  79         else
  80         {
  81                 void* old = rv.first->second;
  82                 rv.first->second = value;
  83                 return old;
  84         }
  85 }
  86
  87 void* ExtensionItem::unset_raw(Extensible* container)
  88 {
  89         Extensible::ExtensibleStore::iterator i = container->extensions.find(this);
  90         if (i == container->extensions.end())
  91                 return NULL;
  92         void* rv = i->second;
  93         container->extensions.erase(i);
  94         return rv;
  95 }
  96
  97 void ExtensionManager::Register(ExtensionItem* item)
  98 {
  99         types.insert(std::make_pair(item->key, item));
 100 }
 101
 102 void ExtensionManager::BeginUnregister(Module* module, std::vector<ExtensionItem*>& list)
 103 {
 104         std::map<std::string, ExtensionItem*>::iterator i = types.begin();
 105         while (i != types.end())
 106         {
 107                 std::map<std::string, ExtensionItem*>::iterator me = i++;
 108                 ExtensionItem* item = me->second;
 109                 if (item->owner == module)
 110                 {
 111                         list.push_back(item);
 112                         types.erase(me);
 113                 }
 114         }
 115 }
 116
 117 ExtensionItem* ExtensionManager::GetItem(const std::string& name)
 118 {
 119         std::map<std::string, ExtensionItem*>::iterator i = types.find(name);
 120         if (i == types.end())
 121                 return NULL;
 122         return i->second;
 123 }
 124
 125 void Extensible::doUnhookExtensions(const std::vector<ExtensionItem*>& toRemove)
 126 {
 127         for(std::vector<ExtensionItem*>::const_iterator i = toRemove.begin(); i != toRemove.end(); ++i)
 128         {
 129                 ExtensionItem* item = *i;
 130                 ExtensibleStore::iterator e = extensions.find(item);
 131                 if (e != extensions.end())
 132                 {
 133                         item->free(e->second);
 134                         extensions.erase(e);
 135                 }
 136         }
 137 }
 138
 139 static struct DummyExtensionItem : LocalExtItem
 140 {
 141         DummyExtensionItem() : LocalExtItem("", NULL) {}
 142         void free(void*) {}
 143 } dummy;
 144
 145 Extensible::Extensible()
 146 {
 147         extensions[&dummy] = NULL;
 148 }
 149
 150 CullResult Extensible::cull()
 151 {
 152         for(ExtensibleStore::iterator i = extensions.begin(); i != extensions.end(); ++i)
 153         {
 154                 i->first->free(i->second);
 155         }
 156         extensions.clear();
 157         return classbase::cull();
 158 }
 159
 160 Extensible::~Extensible()
 161 {
 162         if (!extensions.empty() && ServerInstance && ServerInstance->Logs)
 163                 ServerInstance->Logs->Log("CULLLIST", DEBUG,
 164                         "Extensible destructor called without cull @%p", (void*)this);
 165 }
 166
 167 LocalExtItem::LocalExtItem(const std::string& Key, Module* mod) : ExtensionItem(Key, mod)
 168 {
 169 }
 170
 171 LocalExtItem::~LocalExtItem()
 172 {
 173 }
 174
 175 std::string LocalExtItem::serialize(SerializeFormat format, const Extensible* container, void* item) const
 176 {
 177         return "";
 178 }
 179
 180 void LocalExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
 181 {
 182 }
 183
 184 LocalStringExt::LocalStringExt(const std::string& Key, Module* Owner)
 185         : SimpleExtItem<std::string>(Key, Owner) { }
 186
 187 LocalStringExt::~LocalStringExt()
 188 {
 189 }
 190
 191 std::string LocalStringExt::serialize(SerializeFormat format, const Extensible* container, void* item) const
 192 {
 193         if (item && format == FORMAT_USER)
 194                 return *static_cast<std::string*>(item);
 195         return "";
 196 }
 197
 198 LocalIntExt::LocalIntExt(const std::string& Key, Module* mod) : LocalExtItem(Key, mod)
 199 {
 200 }
 201
 202 LocalIntExt::~LocalIntExt()
 203 {
 204 }
 205
 206 std::string LocalIntExt::serialize(SerializeFormat format, const Extensible* container, void* item) const
 207 {
 208         if (format != FORMAT_USER)
 209                 return "";
 210         return ConvToStr(reinterpret_cast<intptr_t>(item));
 211 }
 212
 213 intptr_t LocalIntExt::get(const Extensible* container) const
 214 {
 215         return reinterpret_cast<intptr_t>(get_raw(container));
 216 }
 217
 218 intptr_t LocalIntExt::set(Extensible* container, intptr_t value)
 219 {
 220         if (value)
 221                 return reinterpret_cast<intptr_t>(set_raw(container, reinterpret_cast<void*>(value)));
 222         else
 223                 return reinterpret_cast<intptr_t>(unset_raw(container));
 224 }
 225
 226 void LocalIntExt::free(void*)
 227 {
 228 }
 229
 230 StringExtItem::StringExtItem(const std::string& Key, Module* mod) : ExtensionItem(Key, mod)
 231 {
 232 }
 233
 234 StringExtItem::~StringExtItem()
 235 {
 236 }
 237
 238 std::string* StringExtItem::get(const Extensible* container) const
 239 {
 240         return static_cast<std::string*>(get_raw(container));
 241 }
 242
 243 std::string StringExtItem::serialize(SerializeFormat format, const Extensible* container, void* item) const
 244 {
 245         return item ? *static_cast<std::string*>(item) : "";
 246 }
 247
 248 void StringExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
 249 {
 250         if (value.empty())
 251                 unset(container);
 252         else
 253                 set(container, value);
 254 }
 255
 256 void StringExtItem::set(Extensible* container, const std::string& value)
 257 {
 258         void* old = set_raw(container, new std::string(value));
 259         delete static_cast<std::string*>(old);
 260 }
 261
 262 void StringExtItem::unset(Extensible* container)
 263 {
 264         void* old = unset_raw(container);
 265         delete static_cast<std::string*>(old);
 266 }
 267
 268 void StringExtItem::free(void* item)
 269 {
 270         delete static_cast<std::string*>(item);
 271 }