extensible.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2013, 2017-2020 Sadie Powell <[email protected]>
 *   Copyright (C) 2012, 2014-2015 Attila Molnar <[email protected]>
 *   Copyright (C) 2012 Robby <[email protected]>
 *   Copyright (C) 2009 Daniel De Graaf <[email protected]>
 *
 * 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
 * License as published by the Free Software Foundation, version 2.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
#pragma once
 
enum SerializeFormat
{
        FORMAT_USER,
        FORMAT_INTERNAL,
        FORMAT_NETWORK,
        FORMAT_PERSIST
};
 
class CoreExport ExtensionItem : public ServiceProvider, public usecountbase
{
 public:
        enum ExtensibleType
        {
                EXT_USER,
 
                EXT_CHANNEL,
 
                EXT_MEMBERSHIP
        };
 
        const ExtensibleType type;
 
        ExtensionItem(const std::string& key, ExtensibleType exttype, Module* owner);
 
        virtual ~ExtensionItem();
 
        virtual void FromInternal(Extensible* container, const std::string& value);
 
        virtual void FromNetwork(Extensible* container, const std::string& value);
 
        virtual std::string ToHuman(const Extensible* container, void* item) const;
        virtual std::string ToInternal(const Extensible* container, void* item) const ;
 
        virtual std::string ToNetwork(const Extensible* container, void* item) const;
 
        virtual void free(Extensible* container, void* item) = 0;
 
        void RegisterService() CXX11_OVERRIDE;
 
        DEPRECATED_METHOD(virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item) const);
 
        DEPRECATED_METHOD(virtual void unserialize(SerializeFormat format, Extensible* container, const std::string& value));
 
 protected:
        void* get_raw(const Extensible* container) const;
 
        void* set_raw(Extensible* container, void* value);
 
        void* unset_raw(Extensible* container);
};
 
class CoreExport Extensible
        : public classbase
        , public Serializable
{
 public:
        typedef insp::flat_map<reference<ExtensionItem>, void*> ExtensibleStore;
 
        // Friend access for the protected getter/setter
        friend class ExtensionItem;
 private:
        ExtensibleStore extensions;
 
        unsigned int culled:1;
 public:
        inline const ExtensibleStore& GetExtList() const { return extensions; }
 
        Extensible();
        CullResult cull() CXX11_OVERRIDE;
        virtual ~Extensible();
        void doUnhookExtensions(const std::vector<reference<ExtensionItem> >& toRemove);
 
        void FreeAllExtItems();
 
        bool Deserialize(Data& data) CXX11_OVERRIDE;
 
        bool Serialize(Serializable::Data& data) CXX11_OVERRIDE;
};
 
class CoreExport ExtensionManager
{
 public:
        typedef std::map<std::string, reference<ExtensionItem> > ExtMap;
 
        bool Register(ExtensionItem* item);
        void BeginUnregister(Module* module, std::vector<reference<ExtensionItem> >& list);
        ExtensionItem* GetItem(const std::string& name);
 
        const ExtMap& GetExts() const { return types; }
 
 private:
        ExtMap types;
};
 
typedef ExtensionItem LocalExtItem;
 
template <typename T, typename Del = stdalgo::defaultdeleter<T> >
class SimpleExtItem : public ExtensionItem
{
 public:
        SimpleExtItem(const std::string& Key, ExtensibleType exttype, Module* parent)
                : ExtensionItem(Key, exttype, parent)
        {
        }
 
        virtual ~SimpleExtItem()
        {
        }
 
        inline T* get(const Extensible* container) const
        {
                return static_cast<T*>(get_raw(container));
        }
 
        inline void set(Extensible* container, const T& value)
        {
                T* ptr = new T(value);
                T* old = static_cast<T*>(set_raw(container, ptr));
                free(container, old);
        }
 
        inline void set(Extensible* container, T* value)
        {
                T* old = static_cast<T*>(set_raw(container, value));
                free(container, old);
        }
 
        inline void unset(Extensible* container)
        {
                T* old = static_cast<T*>(unset_raw(container));
                free(container, old);
        }
 
        void free(Extensible* container, void* item) CXX11_OVERRIDE
        {
                Del del;
                del(static_cast<T*>(item));
        }
};
 
class CoreExport LocalStringExt : public SimpleExtItem<std::string>
{
 public:
        LocalStringExt(const std::string& key, ExtensibleType exttype, Module* owner);
        virtual ~LocalStringExt();
        std::string ToInternal(const Extensible* container, void* item) const CXX11_OVERRIDE;
        void FromInternal(Extensible* container, const std::string& value) CXX11_OVERRIDE;
};
 
class CoreExport LocalIntExt : public ExtensionItem
{
 public:
        LocalIntExt(const std::string& key, ExtensibleType exttype, Module* owner);
        virtual ~LocalIntExt();
        std::string ToInternal(const Extensible* container, void* item) const CXX11_OVERRIDE;
        void FromInternal(Extensible* container, const std::string& value) CXX11_OVERRIDE;
        intptr_t get(const Extensible* container) const;
        intptr_t set(Extensible* container, intptr_t value);
        void unset(Extensible* container) { set(container, 0); }
        void free(Extensible* container, void* item) CXX11_OVERRIDE;
};
 
class CoreExport StringExtItem : public ExtensionItem
{
 public:
        StringExtItem(const std::string& key, ExtensibleType exttype, Module* owner);
        virtual ~StringExtItem();
        std::string* get(const Extensible* container) const;
        std::string ToNetwork(const Extensible* container, void* item) const CXX11_OVERRIDE;
        void FromNetwork(Extensible* container, const std::string& value) CXX11_OVERRIDE;
        void set(Extensible* container, const std::string& value);
        void unset(Extensible* container);
        void free(Extensible* container, void* item) CXX11_OVERRIDE;
};