/*
* InspIRCd -- Internet Relay Chat Daemon
*
+ * Copyright (C) 2013, 2018-2019 Sadie Powell <sadie@witchery.services>
+ * Copyright (C) 2012, 2014-2015 Attila Molnar <attilamolnar@hush.com>
+ * Copyright (C) 2012 Robby <robby@chatbelgie.be>
+ * Copyright (C) 2010 Craig Edwards <brain@inspircd.org>
* Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
* Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
- * Copyright (C) 2004-2006 Craig Edwards <craigedwards@brainbox.cc>
- * Copyright (C) 2006 Oliver Lupton <oliverlupton@gmail.com>
+ * Copyright (C) 2006 Oliver Lupton <om@inspircd.org>
*
* This file is part of InspIRCd. InspIRCd is free software: you can
* redistribute it and/or modify it under the terms of the GNU General Public
#include "inspircd.h"
#include "base.h"
-#include <time.h>
+
+#ifdef INSPIRCD_ENABLE_RTTI
#include <typeinfo>
+#endif
classbase::classbase()
{
- if (ServerInstance && ServerInstance->Logs)
- ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::+ @%p", (void*)this);
+#ifdef INSPIRCD_ENABLE_RTTI
+ if (ServerInstance)
+ ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::+%s @%p", typeid(*this).name(), (void*)this);
+#endif
}
CullResult classbase::cull()
{
- if (ServerInstance && ServerInstance->Logs)
- ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::-%s @%p",
- typeid(*this).name(), (void*)this);
+#ifdef INSPIRCD_ENABLE_RTTI
+ if (ServerInstance)
+ ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::-%s @%p", typeid(*this).name(), (void*)this);
+#endif
return CullResult();
}
classbase::~classbase()
{
- if (ServerInstance && ServerInstance->Logs)
- ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::~ @%p", (void*)this);
+#ifdef INSPIRCD_ENABLE_RTTI
+ if (ServerInstance)
+ ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::~%s @%p", typeid(*this).name(), (void*)this);
+#endif
}
CullResult::CullResult()
refcountbase::~refcountbase()
{
- if (refcount && ServerInstance && ServerInstance->Logs)
+ if (refcount && ServerInstance)
ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "refcountbase::~ @%p with refcount %d",
(void*)this, refcount);
}
usecountbase::~usecountbase()
{
- if (usecount && ServerInstance && ServerInstance->Logs)
+ if (usecount && ServerInstance)
ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "usecountbase::~ @%p with refcount %d",
(void*)this, usecount);
}
{
}
-ExtensionItem::ExtensionItem(const std::string& Key, Module* mod) : ServiceProvider(mod, Key, SERVICE_METADATA)
+void ServiceProvider::RegisterService()
+{
+}
+
+ExtensionItem::ExtensionItem(const std::string& Key, ExtensibleType exttype, Module* mod)
+ : ServiceProvider(mod, Key, SERVICE_METADATA)
+ , type(exttype)
{
}
return rv;
}
+void ExtensionItem::RegisterService()
+{
+ if (!ServerInstance->Extensions.Register(this))
+ throw ModuleException("Extension already exists: " + name);
+}
+
bool ExtensionManager::Register(ExtensionItem* item)
{
return types.insert(std::make_pair(item->name, item)).second;
void ExtensionManager::BeginUnregister(Module* module, std::vector<reference<ExtensionItem> >& list)
{
- std::map<std::string, reference<ExtensionItem> >::iterator i = types.begin();
+ ExtMap::iterator i = types.begin();
while (i != types.end())
{
- std::map<std::string, reference<ExtensionItem> >::iterator me = i++;
+ ExtMap::iterator me = i++;
ExtensionItem* item = me->second;
if (item->creator == module)
{
ExtensionItem* ExtensionManager::GetItem(const std::string& name)
{
- std::map<std::string, reference<ExtensionItem> >::iterator i = types.find(name);
+ ExtMap::iterator i = types.find(name);
if (i == types.end())
return NULL;
return i->second;
ExtensibleStore::iterator e = extensions.find(item);
if (e != extensions.end())
{
- item->free(e->second);
+ item->free(this, e->second);
extensions.erase(e);
}
}
}
-static struct DummyExtensionItem : LocalExtItem
-{
- DummyExtensionItem() : LocalExtItem("", NULL) {}
- void free(void*) {}
-} dummy;
-
Extensible::Extensible()
+ : culled(false)
{
- extensions[&dummy] = NULL;
}
CullResult Extensible::cull()
{
FreeAllExtItems();
+ culled = true;
return classbase::cull();
}
{
for(ExtensibleStore::iterator i = extensions.begin(); i != extensions.end(); ++i)
{
- i->first->free(i->second);
+ i->first->free(this, i->second);
}
extensions.clear();
}
Extensible::~Extensible()
{
- if (!extensions.empty() && ServerInstance && ServerInstance->Logs)
+ if ((!extensions.empty() || !culled) && ServerInstance)
ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "Extensible destructor called without cull @%p", (void*)this);
}
-LocalExtItem::LocalExtItem(const std::string& Key, Module* mod) : ExtensionItem(Key, mod)
+void ExtensionItem::FromInternal(Extensible* container, const std::string& value)
+{
+ FromNetwork(container, value);
+}
+
+void ExtensionItem::FromNetwork(Extensible* container, const std::string& value)
+{
+}
+
+std::string ExtensionItem::ToHuman(const Extensible* container, void* item) const
+{
+ // Try to use the network form by default.
+ std::string ret = ToNetwork(container, item);
+
+ // If there's no network form then fall back to the internal form.
+ if (ret.empty())
+ ret = ToInternal(container, item);
+
+ return ret;
+}
+
+std::string ExtensionItem::ToInternal(const Extensible* container, void* item) const
{
+ return ToNetwork(container, item);
}
-LocalExtItem::~LocalExtItem()
+std::string ExtensionItem::ToNetwork(const Extensible* container, void* item) const
{
+ return std::string();
}
-std::string LocalExtItem::serialize(SerializeFormat format, const Extensible* container, void* item) const
+std::string ExtensionItem::serialize(SerializeFormat format, const Extensible* container, void* item) const
{
+ // Wrap the deprecated API with the new API.
+ switch (format)
+ {
+ case FORMAT_USER:
+ return ToHuman(container, item);
+ case FORMAT_INTERNAL:
+ case FORMAT_PERSIST:
+ return ToInternal(container, item);
+ case FORMAT_NETWORK:
+ return ToNetwork(container, item);
+ }
return "";
}
-void LocalExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
+
+void ExtensionItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
{
+ // Wrap the deprecated API with the new API.
+ switch (format)
+ {
+ case FORMAT_USER:
+ break;
+ case FORMAT_INTERNAL:
+ case FORMAT_PERSIST:
+ FromInternal(container, value);
+ break;
+ case FORMAT_NETWORK:
+ FromNetwork(container, value);
+ break;
+ }
}
-LocalStringExt::LocalStringExt(const std::string& Key, Module* Owner)
- : SimpleExtItem<std::string>(Key, Owner) { }
+LocalStringExt::LocalStringExt(const std::string& Key, ExtensibleType exttype, Module* Owner)
+ : SimpleExtItem<std::string>(Key, exttype, Owner)
+{
+}
LocalStringExt::~LocalStringExt()
{
}
-std::string LocalStringExt::serialize(SerializeFormat format, const Extensible* container, void* item) const
+std::string LocalStringExt::ToInternal(const Extensible* container, void* item) const
{
- if (item && format == FORMAT_USER)
- return *static_cast<std::string*>(item);
- return "";
+ return item ? *static_cast<std::string*>(item) : std::string();
+}
+
+void LocalStringExt::FromInternal(Extensible* container, const std::string& value)
+{
+ set(container, value);
}
-LocalIntExt::LocalIntExt(const std::string& Key, Module* mod) : LocalExtItem(Key, mod)
+LocalIntExt::LocalIntExt(const std::string& Key, ExtensibleType exttype, Module* mod)
+ : ExtensionItem(Key, exttype, mod)
{
}
{
}
-std::string LocalIntExt::serialize(SerializeFormat format, const Extensible* container, void* item) const
+std::string LocalIntExt::ToInternal(const Extensible* container, void* item) const
{
- if (format != FORMAT_USER)
- return "";
return ConvToStr(reinterpret_cast<intptr_t>(item));
}
+void LocalIntExt::FromInternal(Extensible* container, const std::string& value)
+{
+ set(container, ConvToNum<intptr_t>(value));
+}
+
intptr_t LocalIntExt::get(const Extensible* container) const
{
return reinterpret_cast<intptr_t>(get_raw(container));
return reinterpret_cast<intptr_t>(unset_raw(container));
}
-void LocalIntExt::free(void*)
+void LocalIntExt::free(Extensible* container, void* item)
{
}
-StringExtItem::StringExtItem(const std::string& Key, Module* mod) : ExtensionItem(Key, mod)
+StringExtItem::StringExtItem(const std::string& Key, ExtensibleType exttype, Module* mod)
+ : ExtensionItem(Key, exttype, mod)
{
}
return static_cast<std::string*>(get_raw(container));
}
-std::string StringExtItem::serialize(SerializeFormat format, const Extensible* container, void* item) const
+std::string StringExtItem::ToNetwork(const Extensible* container, void* item) const
{
- return item ? *static_cast<std::string*>(item) : "";
+ return item ? *static_cast<std::string*>(item) : std::string();
}
-void StringExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
+void StringExtItem::FromNetwork(Extensible* container, const std::string& value)
{
if (value.empty())
unset(container);
void StringExtItem::set(Extensible* container, const std::string& value)
{
void* old = set_raw(container, new std::string(value));
- delete static_cast<std::string*>(old);
+ free(container, old);
}
void StringExtItem::unset(Extensible* container)
{
void* old = unset_raw(container);
- delete static_cast<std::string*>(old);
+ free(container, old);
}
-void StringExtItem::free(void* item)
+void StringExtItem::free(Extensible* container, void* item)
{
delete static_cast<std::string*>(item);
}
projects / user / henk / code / inspircd.git / blobdiff