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