Convert the ISO 8859-2 nationalchars files to codepage configs.

[user/henk/code/inspircd.git] / src / base.cpp

diff --git a/src/base.cpp b/src/base.cpp
index c268c7493e5526a4a874af3ca630b277a9a5165b..17c619fbe28e99a2ae0d6b4b15360cc0f6256d14 100644 (file)
--- a/src/base.cpp
+++ b/src/base.cpp
@@ -1,10 +1,13 @@
 /*
  * 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
@@ -22,33 +25,34 @@
 
 #include "inspircd.h"
 #include "base.h"
-#include <time.h>
+
 #ifdef INSPIRCD_ENABLE_RTTI
 #include <typeinfo>
 #endif
 
 classbase::classbase()
 {
+#ifdef INSPIRCD_ENABLE_RTTI
        if (ServerInstance)
-               ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::+ @%p", (void*)this);
+               ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::+%s @%p", typeid(*this).name(), (void*)this);
+#endif
 }
 
 CullResult classbase::cull()
 {
-       if (ServerInstance)
 #ifdef INSPIRCD_ENABLE_RTTI
-               ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::-%s @%p",
-                       typeid(*this).name(), (void*)this);
-#else
-               ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::- @%p", (void*)this);
+       if (ServerInstance)
+               ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::-%s @%p", typeid(*this).name(), (void*)this);
 #endif
        return CullResult();
 }
 
 classbase::~classbase()
 {
+#ifdef INSPIRCD_ENABLE_RTTI
        if (ServerInstance)
-               ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::~ @%p", (void*)this);
+               ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::~%s @%p", typeid(*this).name(), (void*)this);
+#endif
 }
 
 CullResult::CullResult()
@@ -95,6 +99,10 @@ ServiceProvider::~ServiceProvider()
 {
 }
 
+void ServiceProvider::RegisterService()
+{
+}
+
 ExtensionItem::ExtensionItem(const std::string& Key, ExtensibleType exttype, Module* mod)
        : ServiceProvider(mod, Key, SERVICE_METADATA)
        , type(exttype)
@@ -140,6 +148,12 @@ void* ExtensionItem::unset_raw(Extensible* container)
        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;
@@ -176,7 +190,7 @@ void Extensible::doUnhookExtensions(const std::vector<reference<ExtensionItem> >
                ExtensibleStore::iterator e = extensions.find(item);
                if (e != extensions.end())
                {
-                       item->free(e->second);
+                       item->free(this, e->second);
                        extensions.erase(e);
                }
        }
@@ -198,7 +212,7 @@ void Extensible::FreeAllExtItems()
 {
        for(ExtensibleStore::iterator i = extensions.begin(); i != extensions.end(); ++i)
        {
-               i->first->free(i->second);
+               i->first->free(this, i->second);
        }
        extensions.clear();
 }
@@ -209,22 +223,69 @@ Extensible::~Extensible()
                ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "Extensible destructor called without cull @%p", (void*)this);
 }
 
-LocalExtItem::LocalExtItem(const std::string& Key, ExtensibleType exttype, Module* mod)
-       : ExtensionItem(Key, exttype, 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, ExtensibleType exttype, Module* Owner)
@@ -236,15 +297,18 @@ 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, ExtensibleType exttype, Module* mod)
-       : LocalExtItem(Key, exttype, mod)
+       : ExtensionItem(Key, exttype, mod)
 {
 }
 
@@ -252,13 +316,16 @@ LocalIntExt::~LocalIntExt()
 {
 }
 
-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));
@@ -272,7 +339,7 @@ intptr_t LocalIntExt::set(Extensible* container, intptr_t value)
                return reinterpret_cast<intptr_t>(unset_raw(container));
 }
 
-void LocalIntExt::free(void*)
+void LocalIntExt::free(Extensible* container, void* item)
 {
 }
 
@@ -290,12 +357,12 @@ std::string* StringExtItem::get(const Extensible* container) const
        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);
@@ -306,16 +373,16 @@ void StringExtItem::unserialize(SerializeFormat format, Extensible* container, c
 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);
 }