From 9f2a99f61887a71a31afb4c56558fcc76be532d1 Mon Sep 17 00:00:00 2001 From: Mikko Rasa Date: Mon, 25 Jul 2011 17:54:16 +0300 Subject: [PATCH] Redesign the Collection class --- source/collection.cpp | 8 +- source/collection.h | 386 ++++++++++++++++++++++++------------------ 2 files changed, 223 insertions(+), 171 deletions(-) diff --git a/source/collection.cpp b/source/collection.cpp index c1d72ca..e60b200 100644 --- a/source/collection.cpp +++ b/source/collection.cpp @@ -5,11 +5,7 @@ namespace DataFile { Collection::~Collection() { - for(ItemMap::iterator i = items.begin(); i!=items.end(); ++i) - delete i->second; - for(ItemKeywordSeq::iterator i = keywords.begin(); i!=keywords.end(); ++i) - delete *i; - for(ItemCreatorSeq::iterator i = creators.begin(); i!=creators.end(); ++i) + for(TypeList::iterator i = types.begin(); i!=types.end(); ++i) delete *i; } @@ -22,7 +18,7 @@ bool Collection::contains(const std::string &n) const Collection::Loader::Loader(Collection &c): coll(c) { - for(ItemKeywordSeq::const_iterator i = coll.keywords.begin(); i!=coll.keywords.end(); ++i) + for(TypeList::const_iterator i = coll.types.begin(); i!=coll.types.end(); ++i) (*i)->add_to_loader(*this); } diff --git a/source/collection.h b/source/collection.h index 2d346d9..82339d8 100644 --- a/source/collection.h +++ b/source/collection.h @@ -1,8 +1,8 @@ #ifndef MSP_DATAFILE_COLLECTION_H_ #define MSP_DATAFILE_COLLECTION_H_ -#include #include +#include #include #include "loader.h" @@ -23,113 +23,32 @@ struct NeedsCollection template static No f(...); - enum { result=(sizeof(f(0))==sizeof(Yes)) }; + enum { value = (sizeof(f(0))==sizeof(Yes)) }; }; +class CollectionItemTypeBase; + +template +class CollectionItemType; + /** A collection of objects that can be loaded from a datafile. Each object is identified by a name, which must be unique across the entire collection. */ class Collection { -public: - class Loader; - -private: - /* XXX I don't really like sticking all this stuff in here, but there's some - complex inter-class relationships, especially between ItemKeyword and - Collection::Loader. */ - - struct ItemBase - { - virtual ~ItemBase() { } - }; - - template - struct Item: public ItemBase - { - T *data; - - Item(T *d): data(d) { } - ~Item() { delete data; } - }; - - /** - Used to store keywords for types that can be loaded. - */ - struct ItemKeywordBase - { - virtual ~ItemKeywordBase() { } - virtual void add_to_loader(Loader &) const { }; - }; - - template::result> - struct ItemKeyword: public ItemKeywordBase - { - std::string keyword; - - ItemKeyword(const std::string &kw): keyword(kw) { } - - void add_to_loader(Loader &ldr) const - { ldr.add(keyword, &Loader::item); } - }; - - template - struct ItemKeyword: public ItemKeywordBase - { - std::string keyword; - - ItemKeyword(const std::string &kw): keyword(kw) { } - - virtual void add_to_loader(Loader &ldr) const - { ldr.add(keyword, &Loader::coll_item); } - }; - - /** - Used to store types that can be created automatically. - */ - struct ItemCreatorBase - { - virtual ~ItemCreatorBase() { } - - template - bool create(Collection &coll, const std::string &name, S *&ptr) - { - ItemCreatorBridge *creator=dynamic_cast *>(this); - if(creator) - { - ptr=creator->create(coll, name); - return true; - } - return false; - } - }; - - template - struct ItemCreatorBridge: public ItemCreatorBase - { - virtual S *create(Collection &, const std::string &) const = 0; - }; - - template - struct ItemCreator: public ItemCreatorBridge - { - typedef T *(C::*fCreate)(const std::string &); - - fCreate create_func; - - ItemCreator(fCreate cf): create_func(cf) { } - virtual S *create(Collection &coll, const std::string &name) const - { return (dynamic_cast(coll).*create_func)(name); } - }; - public: /** Loads objects into a Collection. */ class Loader: public DataFile::Loader { + template friend class CollectionItemType; + private: + template::value > + struct Add; + Collection &coll; public: @@ -158,13 +77,11 @@ public: }; private: - typedef std::map ItemMap; - typedef std::list ItemKeywordSeq; - typedef std::list ItemCreatorSeq; + typedef std::map ItemMap; + typedef std::list TypeList; + TypeList types; ItemMap items; - ItemKeywordSeq keywords; - ItemCreatorSeq creators; Collection(const Collection &); Collection &operator=(const Collection &); @@ -177,30 +94,33 @@ public: exception is thrown. The collection takes ownership of the object. */ template - void add(const std::string &name, T *d) + void add(const std::string &name, T *item) { - typedef typename RemoveConst::Type NCT; + if(!item) + throw std::invalid_argument("Collection::add(item)"); - RefPtr > i=new Item(d); - insert_unique(items, i.get()); - i.release(); + RefPtr::Type> ptr(item); + try + { + insert_unique(items, name, ptr); + } + catch(...) + { + // Avoid deleting the object + ptr.release(); + throw; + } } /** Gets an object of a specific type from the collection. */ template - T *get(const std::string &name) const + T &get(const std::string &name) const { typedef typename RemoveConst::Type NCT; - ItemBase *i=get_item(items, name); - - const Item *item=dynamic_cast *>(i); - if(!item) - throw TypeError("Type mismatch on item '"+name+"'"); - - return item->data; + return *get_item(items, name).value >(); } /** @@ -209,32 +129,7 @@ public: invoked. */ template - T *get(const std::string &name) - { - typedef typename RemoveConst::Type NCT; - - if(!items.count(name)) - { - for(ItemCreatorSeq::iterator j=creators.begin(); j!=creators.end(); ++j) - { - NCT *d=0; - if((*j)->create(*this, name, d)) - { - // We already know that the item didn't exist yet - items[name]=new Item(d); - return d; - } - } - } - - ItemBase *i=get_item(items, name); - - const Item *item=dynamic_cast *>(i); - if(!item) - throw TypeError("Type mismatch on item '"+name+"'"); - - return item->data; - } + T &get(const std::string &); /** Returns a list of the names of objects of a specific type in the collection. @@ -244,7 +139,7 @@ public: { std::list result; for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) - if(dynamic_cast::Type> *>(i->second)) + if(i->second.check_type::Type> >()) result.push_back(i->first); return result; } @@ -255,12 +150,12 @@ public: template std::list get_list() const { - typedef typename RemoveConst::Type NCT; + typedef RefPtr::Type> RPNCT; std::list result; for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) - if(Item *item=dynamic_cast *>(i->second)) - result.push_back(item->data); + if(i->second.check_type()) + result.push_back(i->second.value().get()); return result; } @@ -276,43 +171,204 @@ public: template const std::string &get_name(T *d) const { - typedef typename RemoveConst::Type NCT; + typedef RefPtr::Type> RPNCT; for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) - if(Item *item=dynamic_cast *>(i->second)) - if(item->data==d) + if(i->second.check_type()) + if(i->second.value().get()==d) return i->first; - throw KeyError("Item not found in collection"); + // XXX Need better exception class + throw std::runtime_error("Item not found in collection"); } protected: - /** - Adds a type that can be loaded from datafiles. - */ template - void add_keyword(const std::string &keyword) - { add_keyword(keyword); } + CollectionItemType &add_type(); +}; - /** - Adds a type that can be loaded from datafiles, with different storage type. - */ - template - void add_keyword(const std::string &keyword) - { keywords.push_back(new ItemKeyword(keyword)); } - /** - Adds a type that can be created automatically. - */ - template - void add_creator(T *(C::*func)(const std::string &)) - { add_creator(func); } +template +struct Collection::Loader::Add +{ + static void add(Loader &loader, const std::string &kwd) + { loader.add(kwd, &Loader::item); } +}; + +template +struct Collection::Loader::Add +{ + static void add(Loader &loader, const std::string &kwd) + { loader.add(kwd, &Loader::coll_item); } +}; + + +class CollectionItemTypeBase +{ +protected: + class TagBase + { + protected: + TagBase() { } + public: + virtual ~TagBase() { } + }; + + template + class Tag: public TagBase + { + public: + virtual ~Tag() { } + }; + + std::string kwd; + TagBase *tag; + + CollectionItemTypeBase(): tag(0) { } +public: + virtual ~CollectionItemTypeBase() + { delete tag; } + + virtual void add_to_loader(Collection::Loader &) const = 0; + virtual bool can_create() const = 0; + virtual void create_item(Collection &, const std::string &) const = 0; + + template + bool check_type() const + { return dynamic_cast *>(tag); } +}; + + +template +class CollectionItemType: public CollectionItemTypeBase +{ +private: + class CreatorBase + { + protected: + CreatorBase() { } + public: + virtual ~CreatorBase() { } + + virtual T *create(Collection &, const std::string &) const = 0; + }; + + template + class Creator: public CreatorBase + { + public: + typedef T *(C::*FuncPtr)(const std::string &); + + private: + FuncPtr func; + + public: + Creator(FuncPtr f): func(f) { } + + virtual T *create(Collection &coll, const std::string &name) const + { return (static_cast(coll).*func)(name); } + }; + + class StoreBase + { + protected: + StoreBase() { } + public: + virtual ~StoreBase() { } + + virtual void store(Collection &, const std::string &, T *) = 0; + + virtual void add_to_loader(Collection::Loader &, const std::string &) = 0; + }; + + template + class Store: public StoreBase + { + public: + virtual void store(Collection &coll, const std::string &name, T *obj) + { coll.add(name, static_cast(obj)); } + + virtual void add_to_loader(Collection::Loader &loader, const std::string &kwd) + { Collection::Loader::Add::add(loader, kwd); } + }; + + CreatorBase *creator; + StoreBase *store; - template - void add_creator(T *(C::*func)(const std::string &)) - { creators.push_back(new ItemCreator(func)); } +public: + CollectionItemType(): + creator(0), store(new Store) + { tag = new Tag; } + + ~CollectionItemType() + { + delete creator; + delete store; + } + + CollectionItemType &keyword(const std::string &k) + { + kwd = k; + return *this; + } + + template + CollectionItemType &create(T *(C::*func)(const std::string &)) + { + delete creator; + creator = new Creator(func); + return *this; + } + + template + CollectionItemType &store_as() + { + delete tag; + tag = new Tag; + delete store; + store = new Store; + return *this; + } + + virtual void add_to_loader(Collection::Loader &loader) const + { store->add_to_loader(loader, kwd); } + + virtual bool can_create() const + { return creator!=0; } + + virtual void create_item(Collection &coll, const std::string &name) const + { + if(!creator) + throw std::runtime_error("no creator"); + T *obj = creator->create(coll, name); + store->store(coll, name, obj); + } }; + +template +T &Collection::get(const std::string &name) +{ + typedef typename RemoveConst::Type NCT; + + if(!items.count(name)) + { + for(TypeList::iterator i=types.begin(); i!=types.end(); ++i) + if((*i)->can_create() && (*i)->check_type()) + (*i)->create_item(*this, name); + } + + return *get_item(items, name).value >(); +} + +template +CollectionItemType &Collection::add_type() +{ + CollectionItemType *type = new CollectionItemType; + types.push_back(type); + return *type; +} + } // namespace DataFile } // namespace Msp -- 2.43.0