X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fextensible.h;h=07756fb599a419fe3525fb326cfac2ff28d1ec22;hb=804d58e2001f04786d2594f046d591b664235642;hp=487b67408e7b5b741db37e5a7afca3cd6141f8e1;hpb=fa2cdd0bb89330cfd9a6c49c4705da2a3cb02834;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/extensible.h b/include/extensible.h index 487b67408..07756fb59 100644 --- a/include/extensible.h +++ b/include/extensible.h @@ -1,3 +1,24 @@ +/* + * InspIRCd -- Internet Relay Chat Daemon + * + * Copyright (C) 2009 Daniel De Graaf + * + * 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 . + */ + + +#pragma once + enum SerializeFormat { /** Shown to a human (does not need to be unserializable) */ @@ -12,12 +33,23 @@ enum SerializeFormat /** Class represnting an extension of some object */ -class CoreExport ExtensionItem : public usecountbase +class CoreExport ExtensionItem : public ServiceProvider, public usecountbase { public: - const std::string key; - ModuleRef owner; - ExtensionItem(const std::string& key, Module* owner); + /** Extensible subclasses + */ + enum ExtensibleType + { + EXT_USER, + EXT_CHANNEL, + EXT_MEMBERSHIP + }; + + /** Type (subclass) of Extensible that this ExtensionItem is valid for + */ + const ExtensibleType type; + + ExtensionItem(const std::string& key, ExtensibleType exttype, Module* owner); virtual ~ExtensionItem(); /** Serialize this item into a string * @@ -35,6 +67,10 @@ class CoreExport ExtensionItem : public usecountbase /** Free the item */ virtual void free(void* item) = 0; + /** Register this object in the ExtensionManager + */ + void RegisterService() CXX11_OVERRIDE; + protected: /** Get the item from the internal map */ void* get_raw(const Extensible* container) const; @@ -54,7 +90,7 @@ class CoreExport ExtensionItem : public usecountbase class CoreExport Extensible : public classbase { public: - typedef std::map,void*> ExtensibleStore; + typedef insp::flat_map, void*> ExtensibleStore; // Friend access for the protected getter/setter friend class ExtensionItem; @@ -63,6 +99,11 @@ class CoreExport Extensible : public classbase * Holds all extensible metadata for the class. */ ExtensibleStore extensions; + + /** True if this Extensible has been culled. + * A warning is generated if false on destruction. + */ + unsigned int culled:1; public: /** * Get the extension items for iteraton (i.e. for metadata sync during netburst) @@ -73,33 +114,48 @@ class CoreExport Extensible : public classbase virtual CullResult cull(); virtual ~Extensible(); void doUnhookExtensions(const std::vector >& toRemove); + + /** + * Free all extension items attached to this Extensible + */ + void FreeAllExtItems(); }; class CoreExport ExtensionManager { - std::map > types; public: - void Register(ExtensionItem* item); + typedef std::map > ExtMap; + + bool Register(ExtensionItem* item); void BeginUnregister(Module* module, std::vector >& list); ExtensionItem* GetItem(const std::string& name); + + /** 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; }; /** Base class for items that are NOT synchronized between servers */ class CoreExport LocalExtItem : public ExtensionItem { public: - LocalExtItem(const std::string& key, Module* owner); + LocalExtItem(const std::string& key, ExtensibleType exttype, 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; }; -template +template > class SimpleExtItem : public LocalExtItem { public: - SimpleExtItem(const std::string& Key, Module* parent) : LocalExtItem(Key, parent) + SimpleExtItem(const std::string& Key, ExtensibleType exttype, Module* parent) + : LocalExtItem(Key, exttype, parent) { } @@ -116,50 +172,57 @@ class SimpleExtItem : public LocalExtItem { T* ptr = new T(value); T* old = static_cast(set_raw(container, ptr)); - delete old; + Del del; + del(old); } inline void set(Extensible* container, T* value) { T* old = static_cast(set_raw(container, value)); - delete old; + Del del; + del(old); } inline void unset(Extensible* container) { T* old = static_cast(unset_raw(container)); - delete old; + Del del; + del(old); } virtual void free(void* item) { - delete static_cast(item); + Del del; + del(static_cast(item)); } }; 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; + void unserialize(SerializeFormat format, Extensible* container, const std::string& value); }; class CoreExport LocalIntExt : public LocalExtItem { 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; + void unserialize(SerializeFormat format, Extensible* container, const std::string& value); 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); }; 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;