X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fextensible.h;h=2e7b83a28b3d90324577b68b151e0db75add6016;hb=635cb9d65f6d7f6758ae8ed874da00c8d94b6e39;hp=87fe65ccb800082b9189f99bc2a1a979dede341f;hpb=6d9b2bfee07c906699faef4de5ad85787978be3a;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/extensible.h b/include/extensible.h index 87fe65ccb..2e7b83a28 100644 --- a/include/extensible.h +++ b/include/extensible.h @@ -1,6 +1,9 @@ /* * InspIRCd -- Internet Relay Chat Daemon * + * Copyright (C) 2013, 2017-2020 Sadie Powell + * Copyright (C) 2012, 2014-2015 Attila Molnar + * Copyright (C) 2012 Robby * Copyright (C) 2009 Daniel De Graaf * * This file is part of InspIRCd. InspIRCd is free software: you can @@ -19,49 +22,110 @@ #pragma once -#include - +/** DEPRECATED: use {To,From}{Human,Internal,Network} instead. */ enum SerializeFormat { - /** Shown to a human (does not need to be unserializable) */ FORMAT_USER, - /** Passed internally to this process (i.e. for /RELOADMODULE) */ FORMAT_INTERNAL, - /** Passed to other servers on the network (i.e. METADATA s2s command) */ FORMAT_NETWORK, - /** Stored on disk (i.e. permchannel database) */ FORMAT_PERSIST }; -/** Class represnting an extension of some object - */ +/** Base class for logic that extends an Extensible object. */ class CoreExport ExtensionItem : public ServiceProvider, public usecountbase { public: - ExtensionItem(const std::string& key, Module* owner); + /** Types of Extensible that an ExtensionItem can apply to. */ + enum ExtensibleType + { + /** The ExtensionItem applies to a User object. */ + EXT_USER, + + /** The ExtensionItem applies to a Channel object. */ + EXT_CHANNEL, + + /** The ExtensionItem applies to a Membership object. */ + EXT_MEMBERSHIP + }; + + /** The type of Extensible that this ExtensionItem applies to. */ + const ExtensibleType type; + + /** Initializes an instance of the ExtensionItem class. + * @param key The name of the extension item (e.g. ssl_cert). + * @param exttype The type of Extensible that this ExtensionItem applies to. + * @param owner The module which created this ExtensionItem. + */ + ExtensionItem(const std::string& key, ExtensibleType exttype, Module* owner); + + /** Destroys an instance of the ExtensionItem class. */ virtual ~ExtensionItem(); - /** Serialize this item into a string - * - * @param format The format to serialize to - * @param container The object containing this item - * @param item The item itself + + /** Sets an ExtensionItem using a value in the internal format. + * @param container A container the ExtensionItem should be set on. + * @param value A value in the internal format. */ - virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item) const = 0; - /** Convert the string form back into an item - * @param format The format to serialize from (not FORMAT_USER) - * @param container The object that this item applies to - * @param value The return from a serialize() call that was run elsewhere with this key + virtual void FromInternal(Extensible* container, const std::string& value); + + /** Sets an ExtensionItem using a value in the network format. + * @param container A container the ExtensionItem should be set on. + * @param value A value in the network format. + */ + virtual void FromNetwork(Extensible* container, const std::string& value); + + /** Gets an ExtensionItem's value in a human-readable format. + * @param container The container the ExtensionItem is set on. + * @param item The value to convert to a human-readable format. + * @return The value specified in \p item in a human readable format. */ - virtual void unserialize(SerializeFormat format, Extensible* container, const std::string& value) = 0; - /** Free the item */ - virtual void free(void* item) = 0; + virtual std::string ToHuman(const Extensible* container, void* item) const; + /** Gets an ExtensionItem's value in the internal format. + * @param container The container the ExtensionItem is set on. + * @param item The value to convert to the internal format. + * @return The value specified in \p item in the internal format. + */ + virtual std::string ToInternal(const Extensible* container, void* item) const ; + + /** Gets an ExtensionItem's value in the network format. + * @param container The container the ExtensionItem is set on. + * @param item The value to convert to the network format. + * @return The value specified in \p item in the network format. + */ + virtual std::string ToNetwork(const Extensible* container, void* item) const; + + /** Deallocates the specified ExtensionItem value. + * @param container The container that the ExtensionItem is set on. + * @param item The item to deallocate. + */ + virtual void free(Extensible* container, void* item) = 0; + + /** Registers this object with the ExtensionManager. */ + void RegisterService() CXX11_OVERRIDE; + + /** DEPRECATED: use To{Human,Internal,Network} instead. */ + DEPRECATED_METHOD(virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item) const); + + /** DEPRECATED: use From{Internal,Network} instead. */ + DEPRECATED_METHOD(virtual void unserialize(SerializeFormat format, Extensible* container, const std::string& value)); protected: - /** Get the item from the internal map */ + /** Retrieves the value for this ExtensionItem from the internal map. + * @param container The container that the ExtensionItem is set on. + * @return Either the value of this ExtensionItem or NULL if it is not set. + */ void* get_raw(const Extensible* container) const; - /** Set the item in the internal map; returns old value */ + + /** Stores a value for this ExtensionItem in the internal map and returns the old value if one was set. + * @param container A container the ExtensionItem should be set on. + * @param value The value to set on the specified container. + * @return Either the old value or NULL if one is not set. + */ void* set_raw(Extensible* container, void* value); - /** Remove the item from the internal map; returns old value */ + + /** Removes the value for this ExtensionItem from the internal map and returns it. + * @param container A container the ExtensionItem should be removed from. + * @return Either the old value or NULL if one is not set. + */ void* unset_raw(Extensible* container); }; @@ -70,12 +134,14 @@ class CoreExport ExtensionItem : public ServiceProvider, public usecountbase * a map associated with the object. In this way modules can store their own custom information within user * objects, channel objects and server objects, without breaking other modules (this is more sensible than using * a flags variable, and each module defining bits within the flag as 'theirs' as it is less prone to conflict and - * supports arbitary data storage). + * supports arbitrary data storage). */ -class CoreExport Extensible : public classbase +class CoreExport Extensible + : public classbase + , public Serializable { public: - typedef std::map,void*> ExtensibleStore; + typedef insp::flat_map, void*> ExtensibleStore; // Friend access for the protected getter/setter friend class ExtensionItem; @@ -96,7 +162,7 @@ class CoreExport Extensible : public classbase inline const ExtensibleStore& GetExtList() const { return extensions; } Extensible(); - virtual CullResult cull(); + CullResult cull() CXX11_OVERRIDE; virtual ~Extensible(); void doUnhookExtensions(const std::vector >& toRemove); @@ -104,33 +170,41 @@ class CoreExport Extensible : public classbase * Free all extension items attached to this Extensible */ void FreeAllExtItems(); + + /** @copydoc Serializable::Deserialize */ + bool Deserialize(Data& data) CXX11_OVERRIDE; + + /** @copydoc Serializable::Deserialize */ + bool Serialize(Serializable::Data& data) CXX11_OVERRIDE; }; class CoreExport ExtensionManager { - std::map > types; public: + typedef std::map > ExtMap; + bool Register(ExtensionItem* item); void BeginUnregister(Module* module, std::vector >& list); ExtensionItem* GetItem(const std::string& name); -}; -/** Base class for items that are NOT synchronized between servers */ -class CoreExport LocalExtItem : public ExtensionItem -{ - public: - LocalExtItem(const std::string& key, Module* owner); - virtual ~LocalExtItem(); - virtual std::string serialize(SerializeFormat format, const Extensible* container, void* item) const; - virtual void unserialize(SerializeFormat format, Extensible* container, const std::string& value); - virtual void free(void* item) = 0; + /** Get all registered extensions keyed by their names + * @return Const map of ExtensionItem pointers keyed by their names + */ + const ExtMap& GetExts() const { return types; } + + private: + ExtMap types; }; +/** DEPRECATED: use ExtensionItem instead. */ +typedef ExtensionItem LocalExtItem; + template > -class SimpleExtItem : public LocalExtItem +class SimpleExtItem : public ExtensionItem { public: - SimpleExtItem(const std::string& Key, Module* parent) : LocalExtItem(Key, parent) + SimpleExtItem(const std::string& Key, ExtensibleType exttype, Module* parent) + : ExtensionItem(Key, exttype, parent) { } @@ -147,25 +221,22 @@ class SimpleExtItem : public LocalExtItem { T* ptr = new T(value); T* old = static_cast(set_raw(container, ptr)); - Del del; - del(old); + free(container, old); } inline void set(Extensible* container, T* value) { T* old = static_cast(set_raw(container, value)); - Del del; - del(old); + free(container, old); } inline void unset(Extensible* container) { T* old = static_cast(unset_raw(container)); - Del del; - del(old); + free(container, old); } - virtual void free(void* item) + void free(Extensible* container, void* item) CXX11_OVERRIDE { Del del; del(static_cast(item)); @@ -175,32 +246,34 @@ class SimpleExtItem : public LocalExtItem class CoreExport LocalStringExt : public SimpleExtItem { public: - LocalStringExt(const std::string& key, Module* owner); + LocalStringExt(const std::string& key, ExtensibleType exttype, Module* owner); virtual ~LocalStringExt(); - std::string serialize(SerializeFormat format, const Extensible* container, void* item) const; + 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 LocalExtItem +class CoreExport LocalIntExt : public ExtensionItem { public: - LocalIntExt(const std::string& key, Module* owner); + LocalIntExt(const std::string& key, ExtensibleType exttype, Module* owner); virtual ~LocalIntExt(); - std::string serialize(SerializeFormat format, const Extensible* container, void* item) const; + 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(void* item); + void free(Extensible* container, void* item) CXX11_OVERRIDE; }; class CoreExport StringExtItem : public ExtensionItem { public: - StringExtItem(const std::string& key, Module* owner); + StringExtItem(const std::string& key, ExtensibleType exttype, Module* owner); virtual ~StringExtItem(); std::string* get(const Extensible* container) const; - std::string serialize(SerializeFormat format, const Extensible* container, void* item) const; - void unserialize(SerializeFormat format, Extensible* container, const std::string& value); + 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(void* item); + void free(Extensible* container, void* item) CXX11_OVERRIDE; };