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 Extensible::Extensible()
 140 {
 141         extensions[NULL] = NULL;
 142 }
 143
 144 CullResult Extensible::cull()
 145 {
 146         for(ExtensibleStore::iterator i = extensions.begin(); i != extensions.end(); ++i)
 147         {
 148                 if (i->first)
 149                         i->first->free(i->second);
 150         }
 151         extensions.clear();
 152         return classbase::cull();
 153 }
 154
 155 Extensible::~Extensible()
 156 {
 157         if (!extensions.empty() && ServerInstance && ServerInstance->Logs)
 158                 ServerInstance->Logs->Log("CULLLIST", DEBUG,
 159                         "Extensible destructor called without cull @%p", (void*)this);
 160 }
 161
 162 LocalExtItem::LocalExtItem(const std::string& Key, Module* mod) : ExtensionItem(Key, mod)
 163 {
 164 }
 165
 166 LocalExtItem::~LocalExtItem()
 167 {
 168 }
 169
 170 std::string LocalExtItem::serialize(SerializeFormat format, const Extensible* container, void* item) const
 171 {
 172         return "";
 173 }
 174
 175 void LocalExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
 176 {
 177 }
 178
 179 LocalStringExt::LocalStringExt(const std::string& Key, Module* Owner)
 180         : SimpleExtItem<std::string>(Key, Owner) { }
 181
 182 LocalStringExt::~LocalStringExt()
 183 {
 184 }
 185
 186 std::string LocalStringExt::serialize(SerializeFormat format, const Extensible* container, void* item) const
 187 {
 188         if (item && format == FORMAT_USER)
 189                 return *static_cast<std::string*>(item);
 190         return "";
 191 }
 192
 193 LocalIntExt::LocalIntExt(const std::string& Key, Module* mod) : LocalExtItem(Key, mod)
 194 {
 195 }
 196
 197 LocalIntExt::~LocalIntExt()
 198 {
 199 }
 200
 201 std::string LocalIntExt::serialize(SerializeFormat format, const Extensible* container, void* item) const
 202 {
 203         if (format != FORMAT_USER)
 204                 return "";
 205         return ConvToStr(reinterpret_cast<intptr_t>(item));
 206 }
 207
 208 intptr_t LocalIntExt::get(const Extensible* container) const
 209 {
 210         return reinterpret_cast<intptr_t>(get_raw(container));
 211 }
 212
 213 intptr_t LocalIntExt::set(Extensible* container, intptr_t value)
 214 {
 215         if (value)
 216                 return reinterpret_cast<intptr_t>(set_raw(container, reinterpret_cast<void*>(value)));
 217         else
 218                 return reinterpret_cast<intptr_t>(unset_raw(container));
 219 }
 220
 221 void LocalIntExt::free(void*)
 222 {
 223 }
 224
 225 StringExtItem::StringExtItem(const std::string& Key, Module* mod) : ExtensionItem(Key, mod)
 226 {
 227 }
 228
 229 StringExtItem::~StringExtItem()
 230 {
 231 }
 232
 233 std::string* StringExtItem::get(const Extensible* container) const
 234 {
 235         return static_cast<std::string*>(get_raw(container));
 236 }
 237
 238 std::string StringExtItem::serialize(SerializeFormat format, const Extensible* container, void* item) const
 239 {
 240         return item ? *static_cast<std::string*>(item) : "";
 241 }
 242
 243 void StringExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
 244 {
 245         if (value.empty())
 246                 unset(container);
 247         else
 248                 set(container, value);
 249 }
 250
 251 void StringExtItem::set(Extensible* container, const std::string& value)
 252 {
 253         void* old = set_raw(container, new std::string(value));
 254         delete static_cast<std::string*>(old);
 255 }
 256
 257 void StringExtItem::unset(Extensible* container)
 258 {
 259         void* old = unset_raw(container);
 260         delete static_cast<std::string*>(old);
 261 }
 262
 263 void StringExtItem::free(void* item)
 264 {
 265         delete static_cast<std::string*>(item);
 266 }