-class Extensible;
-class Module;
-
enum SerializeFormat
{
/** Shown to a human (does not need to be unserializable) */
/** Class represnting an extension of some object
*/
-class CoreExport ExtensionItem
+class CoreExport ExtensionItem : public ServiceProvider, public usecountbase
{
public:
- const std::string key;
- Module* const owner;
ExtensionItem(const std::string& key, Module* owner);
virtual ~ExtensionItem();
/** Serialize this item into a string
class CoreExport Extensible : public classbase
{
public:
- typedef std::map<ExtensionItem*,void*> ExtensibleStore;
+ typedef std::map<reference<ExtensionItem>,void*> ExtensibleStore;
// Friend access for the protected getter/setter
friend class ExtensionItem;
*/
inline const ExtensibleStore& GetExtList() const { return extensions; }
+ Extensible();
virtual CullResult cull();
virtual ~Extensible();
- void doUnhookExtensions(const std::vector<ExtensionItem*>& toRemove);
+ void doUnhookExtensions(const std::vector<reference<ExtensionItem> >& toRemove);
};
class CoreExport ExtensionManager
{
- std::map<std::string, ExtensionItem*> types;
+ std::map<std::string, reference<ExtensionItem> > types;
public:
void Register(ExtensionItem* item);
- void BeginUnregister(Module* module, std::vector<ExtensionItem*>& list);
+ void BeginUnregister(Module* module, std::vector<reference<ExtensionItem> >& list);
ExtensionItem* GetItem(const std::string& name);
};
return static_cast<T*>(get_raw(container));
}
- inline T* getNew(Extensible* container) const
- {
- T* ptr = get(container);
- if (!ptr)
- {
- ptr = new T;
- set_raw(container, ptr);
- }
- return ptr;
- }
-
inline void set(Extensible* container, const T& value)
{
T* ptr = new T(value);