X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcollection.h;h=be9ae88c491595f925db46e30aeff2daa67deb5f;hb=698d4ae13da87b7c53aa96bca99c3deaff397eec;hp=d5e0806afeebad9fbfa2f043ef80d3ef9bc64878;hpb=e249d648f6393fbb4b74e76c2a7b9eee9f1187f1;p=libs%2Fdatafile.git diff --git a/source/collection.h b/source/collection.h index d5e0806..be9ae88 100644 --- a/source/collection.h +++ b/source/collection.h @@ -4,8 +4,12 @@ #include #include #include +#include "collectionsource.h" #include "loader.h" +/* XXX This file is a big mess with too many things in it. However, the +dependencies between those things make it difficult to split up. */ + namespace Msp { namespace DataFile { @@ -38,6 +42,9 @@ identified by a name, which must be unique across the entire collection. While this class can be instantiated by itself and used for storing objects, loading requires that a subclass defines the supported types. See the add_type method for details. + +Collections can have sources for loading objects on demand. Automatic loading +only works on a non-const Collection. See class CollectionSource for details. */ class Collection { @@ -51,40 +58,35 @@ public: template friend class CollectionItemType; private: - template::value> - struct Add; - Collection &coll; public: Loader(Collection &); Collection &get_object() const { return coll; } private: - template - void coll_item(const std::string &n) - { - RefPtr it = new T; - load_sub(*it, dynamic_cast(coll)); - coll.add(n, it.get()); - it.release(); - } - template void item(const std::string &n) { RefPtr it = new T; - load_sub(*it); + ItemLoader ldr(*it, coll); + load_sub_with(ldr); coll.add(n, it.get()); it.release(); } }; +protected: + template::value> + class ItemLoader; + private: typedef std::map ItemMap; typedef std::list TypeList; + typedef std::list SourceList; TypeList types; ItemMap items; + SourceList sources; Collection(const Collection &); Collection &operator=(const Collection &); @@ -100,41 +102,78 @@ public: if(!item) throw std::invalid_argument("Collection::add(item)"); - RefPtr::Type> ptr(item); - try - { - insert_unique(items, name, ptr); - } - catch(...) - { - // Avoid deleting the object - ptr.release(); - throw; - } + insert_unique(items, name, RefPtr::Type>(item)); } /// Gets a typed object from the collection. template T &get(const std::string &name) const { - typedef typename RemoveConst::Type NCT; + return extract(get_item(items, name)); + } - return *get_item(items, name).value >(); + /** Gets a typed object from the collection. If the name is not found, + automatic creation with the type's creator function (if defined) or from + sources (if present) is attempted. */ + template + T &get(const std::string &name) + { + return extract(get_var(name, get_type())); } - /** Gets a typed object from the collection. If the name is not found in - and a creator for the item type is defined, it is invoked. */ +private: + const Variant &get_var(const std::string &, const CollectionItemTypeBase *); + template - T &get(const std::string &); + T &extract(const Variant &var) const + { + return *var.value::Type> >(); + } + template + void collect_items(std::list *objects, std::list *names, std::list *future_names) const + { + typedef RefPtr::Type> RPNCT; + + for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) + if(i->second.check_type()) + { + if(objects) + objects->push_back(i->second.value().get()); + if(names) + names->push_back(i->first); + } + + if(future_names) + if(CollectionItemTypeBase *type = get_type()) + { + for(SourceList::const_iterator i=sources.begin(); i!=sources.end(); ++i) + { + std::list available_names = (*i)->get_names(*type); + for(std::list::iterator j=available_names.begin(); j!=available_names.end(); ++j) + if(!items.count(*j)) + future_names->push_back(*j); + } + } + } + +public: /// Returns a list of the names of objects of one type in the collection. template std::list get_names() const { std::list result; - for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) - if(i->second.check_type::Type> >()) - result.push_back(i->first); + collect_items(0, &result, 0); + return result; + } + + /** Returns a list of the names of objects of one type in the collection or + available from sources. */ + template + std::list get_names() + { + std::list result; + collect_items(0, &result, &result); return result; } @@ -142,26 +181,59 @@ public: template std::list get_list() const { - typedef RefPtr::Type> RPNCT; + std::list result; + collect_items(&result, 0, 0); + return result; + } + /** Returns a list of objects of one type, loading them from sources if + necessary. */ + template + std::list get_list() + { std::list result; - for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) - if(i->second.check_type()) - result.push_back(i->second.value().get()); + std::list future; + collect_items(&result, 0, &future); + for(std::list::iterator i=future.begin(); i!=future.end(); ++i) + result.push_back(&get(*i)); return result; } - /// Checks whether a typed object exists in the collection. +private: template - bool contains(const std::string &name) const + unsigned get_status(const std::string &name) const { ItemMap::const_iterator i = items.find(name); if(i==items.end()) - return false; + { + if(CollectionItemTypeBase *type = get_type()) + { + for(SourceList::const_iterator j=sources.begin(); j!=sources.end(); ++j) + if((*j)->is_loadable(*type, name)) + return 2; + } + return 0; + } - return i->second.check_type::Type>(); + typedef RefPtr::Type> RPNCT; + if(!i->second.check_type()) + return 0; + + return 1; } +public: + /// Checks whether a typed object exists in the collection. + template + bool contains(const std::string &name) const + { return get_status(name)==1; } + + /** Checks whether a typed object exists in the collection or is loadable + from a source. */ + template + bool contains(const std::string &name) + { return get_status(name)>0; } + /// Returns the name of an item in the collection. template const std::string &get_name(T *d) const @@ -182,21 +254,30 @@ protected: can be used to define how objects of that type can be loaded. */ template CollectionItemType &add_type(); -}; + /** Returns the descriptor for a type, or null if one isn't defined. */ + template + CollectionItemTypeBase *get_type() const; -template -struct Collection::Loader::Add + void add_source(CollectionSource &); +}; + +template +class Collection::ItemLoader: public T::Loader { - static void add(Loader &loader, const std::string &kwd) - { loader.add(kwd, &Loader::item); } +public: + ItemLoader(T &o, Collection &): + T::Loader(o) + { } }; -template -struct Collection::Loader::Add +template +class Collection::ItemLoader: public T::Loader { - static void add(Loader &loader, const std::string &kwd) - { loader.add(kwd, &Loader::coll_item); } +public: + ItemLoader(T &o, Collection &c): + T::Loader(o, dynamic_cast(c)) + { } }; @@ -213,22 +294,24 @@ protected: template class Tag: public TagBase - { - public: - virtual ~Tag() { } - }; + { }; std::string kwd; + std::vector suffixes; TagBase *tag; - CollectionItemTypeBase(): tag(0) { } + CollectionItemTypeBase(); public: - virtual ~CollectionItemTypeBase() - { delete tag; } + virtual ~CollectionItemTypeBase(); + void set_keyword(const std::string &); + const std::string &get_keyword() const { return kwd; } + void add_suffix(const std::string &); + bool match_name(const std::string &) const; 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; + virtual void load_item(Collection &, Parser &, const std::string &) const = 0; template bool check_type() const @@ -290,7 +373,7 @@ private: { coll.add(name, static_cast(obj)); } virtual void add_to_loader(Collection::Loader &loader, const std::string &kwd) - { Collection::Loader::Add::add(loader, kwd); } + { loader.add(kwd, &Collection::Loader::item); } }; CreatorBase *creat; @@ -312,7 +395,17 @@ public: item's name. */ CollectionItemType &keyword(const std::string &k) { - kwd = k; + set_keyword(k); + return *this; + } + + /** Adds a suffix that is used to match names when looking for future + objects. There is no implied separator; a name matches if it ends with the + suffix. If a keyword is defined before any suffixes, then "."+keyword is + added as a suffix. */ + CollectionItemType &suffix(const std::string &s) + { + add_suffix(s); return *this; } @@ -356,23 +449,17 @@ public: if(obj) store->store(coll, name, obj); } -}; - -template -T &Collection::get(const std::string &name) -{ - typedef typename RemoveConst::Type NCT; - - if(!items.count(name)) + virtual void load_item(Collection &coll, Parser &parser, const std::string &name) const { - for(TypeList::iterator i=types.begin(); i!=types.end(); ++i) - if((*i)->can_create() && (*i)->check_type()) - (*i)->create_item(*this, name); + RefPtr obj = new T; + Collection::ItemLoader ldr(*obj, coll); + ldr.load(parser); + store->store(coll, name, obj.get()); + obj.release(); } +}; - return *get_item(items, name).value >(); -} template CollectionItemType &Collection::add_type() @@ -382,6 +469,15 @@ CollectionItemType &Collection::add_type() return *type; } +template +CollectionItemTypeBase *Collection::get_type() const +{ + for(TypeList::const_iterator j=types.begin(); j!=types.end(); ++j) + if((*j)->check_type::Type>()) + return *j; + return 0; +} + } // namespace DataFile } // namespace Msp