X-Git-Url: http://git.tdb.fi/?p=libs%2Fdatafile.git;a=blobdiff_plain;f=source%2Fcollection.h;h=06b8e348cbe3d2a7e16ce2735971802efa73a863;hp=6e6900cece1b0c3428e666e918e2e901b6a4541f;hb=43b8dee0bf05dee1b4a07cc001fae0c81ec53a2f;hpb=2f73f948cd2f4bb0bdcc0f5f81816fb169819879 diff --git a/source/collection.h b/source/collection.h index 6e6900c..06b8e34 100644 --- a/source/collection.h +++ b/source/collection.h @@ -17,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; @@ -45,6 +42,11 @@ 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 { @@ -75,23 +77,23 @@ public: } }; -protected: template::value> class ItemLoader; private: typedef std::map ItemMap; typedef std::list TypeList; - typedef std::list SourceList; + 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. The name must not pre-exist. The @@ -119,7 +121,7 @@ public: template T &get(const std::string &name) const { - return extract(get_item(items, name)); + return extract::Type>(get_item(items, name)); } /** Gets a typed object from the collection. If the name is not found, @@ -128,7 +130,8 @@ public: template T &get(const std::string &name) { - return extract(get_var(name, get_type())); + typedef typename RemoveConst::Type NCT; + return extract(get_var(name, get_type())); } private: @@ -138,30 +141,23 @@ private: T &extract(const Variant &var) const; template - void collect_items(std::list *objects, std::list *names, std::list *future_names) const + std::list extract_list(const std::list &vars) const { - typedef RefPtr::Type> RPNCT; + std::list result; + for(std::list::const_iterator i=vars.begin(); i!=vars.end(); ++i) + result.push_back(&extract(**i)); + return result; + } - 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); - } - } + void gather_items(std::list *, std::list *, const CollectionItemTypeBase &, bool) const; + + template + 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); } public: @@ -169,9 +165,9 @@ public: template std::list get_names() const { - std::list result; - collect_items(0, &result, 0); - return result; + std::list names; + gather_items::Type>(0, &names, 0, false); + return names; } /** Returns a list of the names of objects of one type in the collection or @@ -179,18 +175,18 @@ public: template std::list get_names() { - std::list result; - collect_items(0, &result, &result); - return result; + 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 { - std::list result; - collect_items(&result, 0, 0); - return result; + std::list vars; + gather_items::Type>(&vars, 0, 0, false); + return extract_list(vars); } /** Returns a list of objects of one type, loading them from sources if @@ -198,48 +194,40 @@ public: template std::list get_list() { - std::list result; - 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; + 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); } private: + unsigned get_status(const std::string &, const CollectionItemTypeBase &) const; + template unsigned get_status(const std::string &name) const { - ItemMap::const_iterator i = items.find(name); - if(i==items.end()) - { - 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; - } + // XXX Should go through all applicable types + if(CollectionItemTypeBase *type = get_type()) + return get_status(name, *type); - typedef RefPtr::Type> RPNCT; - if(!i->second.check_type()) - return 0; - - return 1; + 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(name)==1; } + { 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(name)>0; } + { return get_status::Type>(name)>0; } /// Returns the name of an item in the collection. template @@ -262,14 +250,42 @@ protected: 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; - void add_source(CollectionSource &); +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; + + 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 @@ -317,6 +333,7 @@ public: 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; @@ -368,7 +385,7 @@ private: 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); } }; template @@ -431,6 +448,9 @@ public: 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 >(); } @@ -463,14 +483,12 @@ public: template T &Collection::extract(const Variant &var) const { - typedef RefPtr::Type> RPNCT; - - if(!var.check_type()) + if(!var.check_type >()) if(CollectionItemTypeBase *type = get_type_for_item(var)) if(T *item = type->extract(var)) return *item; - return *var.value(); + return *var.value >(); } template @@ -485,7 +503,7 @@ template CollectionItemTypeBase *Collection::get_type() const { for(TypeList::const_iterator j=types.begin(); j!=types.end(); ++j) - if(dynamic_cast::Type> *>(*j)) + if(dynamic_cast *>(*j)) return *j; for(TypeList::const_iterator j=types.begin(); j!=types.end(); ++j) if((*j)->can_extract())