X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcollection.h;h=6e6900cece1b0c3428e666e918e2e901b6a4541f;hb=2f73f948cd2f4bb0bdcc0f5f81816fb169819879;hp=0595aaca7caddb801d094d9ed847362c669c8be7;hpb=4f036ceabe12869c86cb6821f698fbb65cd47ea6;p=libs%2Fdatafile.git diff --git a/source/collection.h b/source/collection.h index 0595aac..6e6900c 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 { @@ -39,9 +43,8 @@ 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 also support a notion of "future objects". These are objects which -are known to be possible to load, but loading them is deferred to the first -time they are requested. +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 { @@ -55,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 &); @@ -104,82 +102,70 @@ public: if(!item) throw std::invalid_argument("Collection::add(item)"); - typedef RefPtr::Type> RPNCT; - - ItemMap::iterator i = items.find(name); - if(i!=items.end()) + RefPtr::Type> ptr(item); + try { - if(i->second.check_type()) - { - // Replace a future object placeholder - RPNCT &ptr = i->second.value(); - if(!ptr) - { - ptr = item; - return; - } - } - - throw key_error(typeid(ItemMap)); + insert_unique(items, name, ptr); + } + catch(...) + { + // Avoid deleting the object + ptr.release(); + throw; } - - items.insert(ItemMap::value_type(name, RPNCT(item))); } -protected: - /** Adds the name of a future object to the collection. The object itself - will be loaded on first access. The calling subclass should be prepared to - create the object on request. */ + /// Gets a typed object from the collection. template - void add_future(const std::string &name) + T &get(const std::string &name) const { - RefPtr::Type> ptr(0); - insert_unique(items, name, ptr); + return extract(get_item(items, name)); } -public: - /// Gets a typed object from the collection. + /** 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) const + T &get(const std::string &name) { - typedef typename RemoveConst::Type NCT; - - T *ptr = get_item(items, name).value >(); - if(!ptr) - throw key_error(typeid(ItemMap)); - return *ptr; + 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; -private: template - void collect_items(std::list *objects, std::list *names, std::list *future_names) + 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()) { - T *ptr = i->second.value().get(); - if(ptr) + 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) { - if(objects) - objects->push_back(ptr); - if(names) - names->push_back(i->first); + 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); } - else if(future_names) - future_names->push_back(i->first); } } public: - /** Returns a list of the names of loaded objects of one type in the - collection. */ + /// Returns a list of the names of objects of one type in the collection. template std::list get_names() const { @@ -188,8 +174,8 @@ public: return result; } - /** Returns a list of the names of objects of one type in the collection, - including any future objects. */ + /** Returns a list of the names of objects of one type in the collection or + available from sources. */ template std::list get_names() { @@ -198,7 +184,7 @@ public: return result; } - /// Returns a list of loaded objects of one type in the collection. + /// Returns a list of objects of one type in the collection. template std::list get_list() const { @@ -207,8 +193,8 @@ public: return result; } - /** Returns a list of objects of one type in the collection. Any future - objects of that type are loaded and returned in the list. */ + /** Returns a list of objects of one type, loading them from sources if + necessary. */ template std::list get_list() { @@ -226,24 +212,31 @@ private: { 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; + } typedef RefPtr::Type> RPNCT; if(!i->second.check_type()) - return false; + return 0; - T *ptr = i->second.value().get(); - return ptr ? 1 : 2; + return 1; } public: - /// Checks whether a typed object exists and is loaded in the collection. + /// 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, as either a - loaded or future object. */ + /** 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; } @@ -268,53 +261,85 @@ 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 + /// Returns the descriptor for an item, or null if it's of an unknown type. + CollectionItemTypeBase *get_type_for_item(const Variant &) const; + + 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)) + { } }; class CollectionItemTypeBase { protected: - class TagBase + struct ExtractorBase { - protected: - TagBase() { } - public: - virtual ~TagBase() { } + virtual ~ExtractorBase() { } }; template - class Tag: public TagBase - { }; + struct Extractor: ExtractorBase + { + virtual T &extract(const Variant &) const = 0; + }; std::string kwd; - TagBase *tag; + std::vector suffixes; + std::vector extractors; - CollectionItemTypeBase(); + CollectionItemTypeBase() { } public: 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 bool check_item_type(const Variant &) const = 0; 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 - { return dynamic_cast *>(tag); } + bool can_extract() const + { + for(std::vector::const_iterator i=extractors.begin(); i!=extractors.end(); ++i) + if(dynamic_cast *>(*i)) + return true; + return false; + } + + template + T *extract(const Variant &var) const + { + for(std::vector::const_iterator i=extractors.begin(); i!=extractors.end(); ++i) + if(Extractor *ex = dynamic_cast *>(*i)) + return &ex->extract(var); + return 0; + } }; @@ -326,67 +351,43 @@ template class CollectionItemType: public CollectionItemTypeBase { private: - class CreatorBase + struct CreatorBase { - protected: - CreatorBase() { } - public: virtual ~CreatorBase() { } virtual T *create(Collection &, const std::string &) const = 0; }; template - class Creator: public CreatorBase + struct Creator: 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 + template + struct Extractor: CollectionItemTypeBase::Extractor { - 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); } + virtual B &extract(const Variant &var) const + { return *var.value >(); } }; CreatorBase *creat; - StoreBase *store; public: CollectionItemType(): - creat(0), store(new Store) - { tag = new Tag; } + creat(0) + { } ~CollectionItemType() { delete creat; - delete store; } /** Sets a datafile keyword for this item type. The Collection's loader @@ -394,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; } @@ -412,20 +423,19 @@ public: return *this; } - /** Specifies the storage type for items of this type. It must be a base - class of the actual type. */ - template - CollectionItemType &store_as() + /** Makes items of this type available through a base class. */ + template + CollectionItemType &base() { - delete tag; - tag = new Tag; - delete store; - store = new Store; + extractors.push_back(new Extractor); return *this; } + virtual bool check_item_type(const Variant &var) const + { return var.check_type >(); } + virtual void add_to_loader(Collection::Loader &loader) const - { store->add_to_loader(loader, kwd); } + { loader.add(kwd, &Collection::Loader::item); } virtual bool can_create() const { return creat!=0; } @@ -436,29 +446,31 @@ public: throw std::runtime_error("no creator"); T *obj = creat->create(coll, name); if(obj) - store->store(coll, name, obj); + coll.add(name, obj); + } + + virtual void load_item(Collection &coll, Parser &parser, const std::string &name) const + { + RefPtr obj = new T; + Collection::ItemLoader ldr(*obj, coll); + ldr.load(parser); + coll.add(name, obj.get()); + obj.release(); } }; template -T &Collection::get(const std::string &name) +T &Collection::extract(const Variant &var) const { - typedef typename RemoveConst::Type NCT; - - ItemMap::iterator i = items.find(name); - if(i!=items.end()) - { - NCT *ptr = i->second.value >().get(); - if(ptr) - return *ptr; - } + typedef RefPtr::Type> RPNCT; - for(TypeList::iterator j=types.begin(); j!=types.end(); ++j) - if((*j)->can_create() && (*j)->check_type()) - (*j)->create_item(*this, name); + if(!var.check_type()) + if(CollectionItemTypeBase *type = get_type_for_item(var)) + if(T *item = type->extract(var)) + return *item; - return *get_item(items, name).value >(); + return *var.value(); } template @@ -469,6 +481,18 @@ CollectionItemType &Collection::add_type() return *type; } +template +CollectionItemTypeBase *Collection::get_type() const +{ + for(TypeList::const_iterator j=types.begin(); j!=types.end(); ++j) + if(dynamic_cast::Type> *>(*j)) + return *j; + for(TypeList::const_iterator j=types.begin(); j!=types.end(); ++j) + if((*j)->can_extract()) + return *j; + return 0; +} + } // namespace DataFile } // namespace Msp