X-Git-Url: http://git.tdb.fi/?p=libs%2Fdatafile.git;a=blobdiff_plain;f=source%2Fcollection.h;h=06b8e348cbe3d2a7e16ce2735971802efa73a863;hp=82339d8859902f725308b347f9f3de3fd39ff244;hb=43b8dee0bf05dee1b4a07cc001fae0c81ec53a2f;hpb=9f2a99f61887a71a31afb4c56558fcc76be532d1 diff --git a/source/collection.h b/source/collection.h index 82339d8..06b8e34 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 { @@ -13,17 +17,14 @@ namespace DataFile { Helper struct to determine whether a Loader has a Collection typedef. */ template -struct NeedsCollection +struct NeedsCollection: public Sfinae { - struct Yes { char c[2]; }; - struct No { char c; }; - template static Yes f(typename U::Collection *); template static No f(...); - enum { value = (sizeof(f(0))==sizeof(Yes)) }; + enum { value = Evaluate(0))>::value }; }; class CollectionItemTypeBase; @@ -34,65 +35,69 @@ 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. + +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. + +As a last resort, a fallback collection can be designated for loading items +that are not present. Items retrieted from the fallback collection are shared +between the collections, and are only deleted when all collections in the chain +have been destroyed. */ class Collection { public: /** - Loads objects into a Collection. + Loads objects into a Collection. Automatically picks up keywords from + defined item types. */ class Loader: public DataFile::Loader { 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); + RefPtr it = new T; + ItemLoader ldr(*it, coll); + load_sub_with(ldr); coll.add(n, it.get()); it.release(); } - - template friend class ItemKeyword; }; + template::value> + class ItemLoader; + private: typedef std::map ItemMap; typedef std::list TypeList; + typedef std::list SourceList; TypeList types; ItemMap items; + SourceList sources; + Collection *fallback; Collection(const Collection &); Collection &operator=(const Collection &); public: - Collection() { } + Collection(); virtual ~Collection(); - /** - Adds an object into the collection. If a name collision occurs, an - exception is thrown. The collection takes ownership of the object. - */ + /** Adds an object into the collection. The name must not pre-exist. The + collection takes ownership of the object. */ template void add(const std::string &name, T *item) { @@ -112,62 +117,119 @@ public: } } - /** - Gets an object of a specific type from the collection. - */ + /// Gets a typed object from the collection. template T &get(const std::string &name) const + { + return extract::Type>(get_item(items, name)); + } + + /** 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) { typedef typename RemoveConst::Type NCT; + return extract(get_var(name, get_type())); + } + +private: + const Variant &get_var(const std::string &, const CollectionItemTypeBase *); + + template + T &extract(const Variant &var) const; - return *get_item(items, name).value >(); + template + std::list extract_list(const std::list &vars) const + { + std::list result; + for(std::list::const_iterator i=vars.begin(); i!=vars.end(); ++i) + result.push_back(&extract(**i)); + return result; } - /** - Gets an object of a specific type from the collection. If the name is not - found in the collection and there is a creator for the item type, it is - invoked. - */ + void gather_items(std::list *, std::list *, const CollectionItemTypeBase &, bool) const; + template - T &get(const std::string &); + void gather_items(std::list *vars, std::list *names, const CollectionItemTypeBase *type, bool include_sources) const + { + if(type || (type = get_type())) + gather_items(vars, names, *type, include_sources); + else + gather_items(vars, names, CollectionItemType(), false); + } - /** - Returns a list of the names of objects of a specific type in the collection. - */ +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); - return result; + std::list names; + gather_items::Type>(0, &names, 0, false); + return names; } - /** - Returns a list of objects of a specific type in the collection. - */ + /** 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 names; + gather_items::Type>(0, &names, 0, true); + return names; + } + + /// Returns a list of objects of one type in the collection. template std::list get_list() const { - typedef RefPtr::Type> RPNCT; + std::list vars; + gather_items::Type>(&vars, 0, 0, false); + return extract_list(vars); + } - 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()); - return result; + /** Returns a list of objects of one type, loading them from sources if + necessary. */ + template + std::list get_list() + { + CollectionItemTypeBase *type = get_type::Type>(); + if(type) + load_items_from_sources(*type); + + std::list vars; + gather_items::Type>(&vars, 0, type, true); + return extract_list(vars); } - /** - Checks whether a name exists in the collection. Does not care about the - type of the object. - */ - bool contains(const std::string &n) const; +private: + unsigned get_status(const std::string &, const CollectionItemTypeBase &) const; - /** - Returns the name of an item in the collection. - */ + template + unsigned get_status(const std::string &name) const + { + // XXX Should go through all applicable types + if(CollectionItemTypeBase *type = get_type()) + return get_status(name, *type); + + ItemMap::const_iterator i = items.find(name); + return (i!=items.end() && i->second.check_type >()); + } + +public: + /// Checks whether a typed object exists in the collection. + template + bool contains(const std::string &name) const + { return get_status::Type>(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::Type>(name)>0; } + + /// Returns the name of an item in the collection. template const std::string &get_name(T *d) const { @@ -183,182 +245,250 @@ public: } protected: + /** Adds a type to the collection. The returned descriptor object reference + can be used to define how objects of that type can be loaded. */ template CollectionItemType &add_type(); -}; +private: + /// Returns the descriptor for a type, or null if one isn't defined. + template + CollectionItemTypeBase *get_type() const; + + /// Gets a descriptor with the same type as another descriptor. + CollectionItemTypeBase *get_type(const CollectionItemTypeBase &) const; + + /// Returns the descriptor for an item, or null if it's of an unknown type. + CollectionItemTypeBase *get_type_for_item(const Variant &) const; + +protected: + /** Adds a source for automatically loading items. Sources are consulted + in the order they are added. */ + void add_source(const CollectionSource &); + +public: + /** Opens a raw resource, without interpreting it as object data. Null is + returned if no such file is found. The caller must dispose of the returned + object when done with it. */ + IO::Seekable *open_raw(const std::string &) const; + +protected: + IO::Seekable *open_from_sources(const std::string &n) { return open_raw(n); } + +private: + void gather_names_from_sources(std::list &, const CollectionItemTypeBase &) const; -template -struct Collection::Loader::Add + void load_items_from_sources(const CollectionItemTypeBase &); + +protected: + /** Sets a fallback collection, which will be consulted if an item is not + found. */ + void set_fallback(Collection *); + + Collection *get_fallback() const { return fallback; } +}; + +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 { - public: - virtual ~Tag() { } + virtual T &extract(const Variant &) const = 0; }; std::string kwd; - TagBase *tag; + std::vector suffixes; + std::vector extractors; - 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 bool is_same_type(const CollectionItemTypeBase &) const = 0; + 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 can_extract() const + { + for(std::vector::const_iterator i=extractors.begin(); i!=extractors.end(); ++i) + if(dynamic_cast *>(*i)) + return true; + return false; + } template - bool check_type() const - { return dynamic_cast *>(tag); } + 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; + } }; +/** +Describes a type of item that can be loaded by a Collection. These are created +by Collection::add_type. +*/ 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); } + { return (dynamic_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 *creator; - StoreBase *store; + CreatorBase *creat; public: CollectionItemType(): - creator(0), store(new Store) - { tag = new Tag; } + creat(0) + { } ~CollectionItemType() { - delete creator; - delete store; + delete creat; } + /** Sets a datafile keyword for this item type. The Collection's loader + will accept a statement with this keyword and a single string argument - the + 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; + } + + /** Attaches a creator function to this item type. If an item is not found + in the Collection, the creator function for its type is called to create it. + The function must be a member of the Collection subclass containing the + type. It must return the created object, or null if it could not be + created. It's also permissible to load the item via other means and then + return null. */ template - CollectionItemType &create(T *(C::*func)(const std::string &)) + CollectionItemType &creator(T *(C::*func)(const std::string &)) { - delete creator; - creator = new Creator(func); + delete creat; + creat = new Creator(func); return *this; } - 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 is_same_type(const CollectionItemTypeBase &other) const + { return dynamic_cast *>(&other); } + + 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 creator!=0; } + { return creat!=0; } virtual void create_item(Collection &coll, const std::string &name) const { - if(!creator) + if(!creat) throw std::runtime_error("no creator"); - T *obj = creator->create(coll, name); - store->store(coll, name, obj); + T *obj = creat->create(coll, name); + if(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; - - 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); - } + 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 @@ -369,6 +499,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 *>(*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