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 /* $Core */
  15
  16 #include "inspircd_config.h"
  17 #include "base.h"
  18 #include <time.h>
  19 #include "inspircd.h"
  20
  21 classbase::classbase()
  22 {
  23 }
  24
  25 bool classbase::cull()
  26 {
  27         return true;
  28 }
  29
  30 classbase::~classbase()
  31 {
  32 }
  33
  34 refcountbase::refcountbase() : refcount(0)
  35 {
  36 }
  37
  38 bool refcountbase::cull()
  39 {
  40         return (refcount == 0);
  41 }
  42
  43 refcountbase::~refcountbase()
  44 {
  45 }
  46
  47 ExtensionItem::ExtensionItem(const std::string& Key, Module* mod) : key(Key), owner(mod)
  48 {
  49 }
  50
  51 ExtensionItem::~ExtensionItem()
  52 {
  53 }
  54
  55 void* ExtensionItem::get_raw(const Extensible* container) const
  56 {
  57         Extensible::ExtensibleStore::const_iterator i =
  58                 container->extensions.find(const_cast<ExtensionItem*>(this));
  59         if (i == container->extensions.end())
  60                 return NULL;
  61         return i->second;
  62 }
  63
  64 void* ExtensionItem::set_raw(Extensible* container, void* value)
  65 {
  66         std::pair<Extensible::ExtensibleStore::iterator,bool> rv =
  67                 container->extensions.insert(std::make_pair(this, value));
  68         if (rv.second)
  69         {
  70                 return NULL;
  71         }
  72         else
  73         {
  74                 void* old = rv.first->second;
  75                 rv.first->second = value;
  76                 return old;
  77         }
  78 }
  79
  80 void* ExtensionItem::unset_raw(Extensible* container)
  81 {
  82         Extensible::ExtensibleStore::iterator i = container->extensions.find(this);
  83         if (i == container->extensions.end())
  84                 return NULL;
  85         void* rv = i->second;
  86         container->extensions.erase(i);
  87         return rv;
  88 }
  89
  90 void ExtensionManager::Register(ExtensionItem* item)
  91 {
  92         types.insert(std::make_pair(item->key, item));
  93 }
  94
  95 void ExtensionManager::BeginUnregister(Module* module, std::vector<ExtensionItem*>& list)
  96 {
  97         std::map<std::string, ExtensionItem*>::iterator i = types.begin();
  98         while (i != types.end())
  99         {
 100                 std::map<std::string, ExtensionItem*>::iterator me = i++;
 101                 ExtensionItem* item = me->second;
 102                 if (item->owner == module)
 103                 {
 104                         list.push_back(item);
 105                         types.erase(me);
 106                 }
 107         }
 108 }
 109
 110 ExtensionItem* ExtensionManager::GetItem(const std::string& name)
 111 {
 112         std::map<std::string, ExtensionItem*>::iterator i = types.find(name);
 113         if (i == types.end())
 114                 return NULL;
 115         return i->second;
 116 }
 117
 118 void Extensible::doUnhookExtensions(const std::vector<ExtensionItem*>& toRemove)
 119 {
 120         for(std::vector<ExtensionItem*>::const_iterator i = toRemove.begin(); i != toRemove.end(); ++i)
 121         {
 122                 ExtensionItem* item = *i;
 123                 ExtensibleStore::iterator e = extensions.find(item);
 124                 if (e != extensions.end())
 125                 {
 126                         item->free(e->second);
 127                         extensions.erase(e);
 128                 }
 129         }
 130 }
 131
 132 Extensible::~Extensible()
 133 {
 134         for(ExtensibleStore::iterator i = extensions.begin(); i != extensions.end(); ++i)
 135         {
 136                 i->first->free(i->second);
 137         }
 138 }
 139
 140 LocalExtItem::LocalExtItem(const std::string& Key, Module* mod) : ExtensionItem(Key, mod)
 141 {
 142 }
 143
 144 LocalExtItem::~LocalExtItem()
 145 {
 146 }
 147
 148 std::string LocalExtItem::serialize(SerializeFormat format, const Extensible* container, void* item) const
 149 {
 150         return "";
 151 }
 152
 153 void LocalExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
 154 {
 155 }
 156
 157 LocalStringExt::LocalStringExt(const std::string& Key, Module* Owner)
 158         : SimpleExtItem<std::string>(Key, Owner) { }
 159
 160 LocalStringExt::~LocalStringExt()
 161 {
 162 }
 163
 164 std::string LocalStringExt::serialize(SerializeFormat format, const Extensible* container, void* item) const
 165 {
 166         if (item && format == FORMAT_USER)
 167                 return *static_cast<std::string*>(item);
 168         return "";
 169 }
 170
 171 LocalIntExt::LocalIntExt(const std::string& Key, Module* mod) : LocalExtItem(Key, mod)
 172 {
 173 }
 174
 175 LocalIntExt::~LocalIntExt()
 176 {
 177 }
 178
 179 std::string LocalIntExt::serialize(SerializeFormat format, const Extensible* container, void* item) const
 180 {
 181         if (format != FORMAT_USER)
 182                 return "";
 183         return ConvToStr(reinterpret_cast<intptr_t>(item));
 184 }
 185
 186 intptr_t LocalIntExt::get(const Extensible* container) const
 187 {
 188         return reinterpret_cast<intptr_t>(get_raw(container));
 189 }
 190
 191 intptr_t LocalIntExt::set(Extensible* container, intptr_t value)
 192 {
 193         if (value)
 194                 return reinterpret_cast<intptr_t>(set_raw(container, reinterpret_cast<void*>(value)));
 195         else
 196                 return reinterpret_cast<intptr_t>(unset_raw(container));
 197 }
 198
 199 void LocalIntExt::free(void*)
 200 {
 201 }
 202
 203 StringExtItem::StringExtItem(const std::string& Key, Module* mod) : ExtensionItem(Key, mod)
 204 {
 205 }
 206
 207 StringExtItem::~StringExtItem()
 208 {
 209 }
 210
 211 std::string* StringExtItem::get(const Extensible* container) const
 212 {
 213         return static_cast<std::string*>(get_raw(container));
 214 }
 215
 216 std::string StringExtItem::serialize(SerializeFormat format, const Extensible* container, void* item) const
 217 {
 218         return item ? *static_cast<std::string*>(item) : "";
 219 }
 220
 221 void StringExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
 222 {
 223         if (value.empty())
 224                 unset(container);
 225         else
 226                 set(container, value);
 227 }
 228
 229 void StringExtItem::set(Extensible* container, const std::string& value)
 230 {
 231         void* old = set_raw(container, new std::string(value));
 232         delete static_cast<std::string*>(old);
 233 }
 234
 235 void StringExtItem::unset(Extensible* container)
 236 {
 237         void* old = unset_raw(container);
 238         delete static_cast<std::string*>(old);
 239 }
 240
 241 void StringExtItem::free(void* item)
 242 {
 243         delete static_cast<std::string*>(item);
 244 }