X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcollection.h;h=d0e8a1a8bb9b25c636ab23a8c1e4bbdcfa5c04a7;hb=HEAD;hp=0d2dc6be2fd7a6c4043ff4db18bfdc32a04bb270;hpb=9b1656018f783eb4aad2fbdc1de1404691e89bb1;p=libs%2Fdatafile.git diff --git a/source/collection.h b/source/collection.h index 0d2dc6b..c8470dd 100644 --- a/source/collection.h +++ b/source/collection.h @@ -1,11 +1,14 @@ #ifndef MSP_DATAFILE_COLLECTION_H_ #define MSP_DATAFILE_COLLECTION_H_ +#include +#include #include -#include +#include #include #include "collectionsource.h" #include "loader.h" +#include "meta.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. */ @@ -13,27 +16,24 @@ dependencies between those things make it difficult to split up. */ namespace Msp { namespace DataFile { -/** -Helper struct to determine whether a Loader has a Collection typedef. -*/ +class CollectionItemTypeBase; + template -struct NeedsCollection -{ - struct Yes { char c[2]; }; - struct No { char c; }; +class CollectionItemType; - template - static Yes f(typename U::Collection *); - template - static No f(...); +template +class LoadableCollectionItemType; - enum { value = (sizeof(f(0))==sizeof(Yes)) }; -}; +template::value> +struct CollectionItemTypeChooser; -class CollectionItemTypeBase; +template +struct CollectionItemTypeChooser +{ typedef LoadableCollectionItemType Type; }; template -class CollectionItemType; +struct CollectionItemTypeChooser +{ typedef CollectionItemType Type; }; /** A collection of objects that can be loaded from a datafile. Each object is @@ -46,12 +46,12 @@ 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. -A fallback collection can be designated as another way of loading items that -are not present. Items retrieted from the fallback collection are shared +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 +class Collection: private NonCopyable { public: /** @@ -60,7 +60,7 @@ public: */ class Loader: public DataFile::Loader { - template friend class CollectionItemType; + template friend class LoadableCollectionItemType; private: Collection &coll; @@ -85,18 +85,13 @@ public: private: typedef std::map ItemMap; - typedef std::list TypeList; - typedef std::list SourceList; - TypeList types; + std::vector types; ItemMap items; - SourceList sources; - Collection *fallback; + std::vector sources; + Collection *fallback = nullptr; - Collection(const Collection &); - Collection &operator=(const Collection &); public: - Collection(); virtual ~Collection(); /** Adds an object into the collection. The name must not pre-exist. The @@ -107,10 +102,11 @@ public: if(!item) throw std::invalid_argument("Collection::add(item)"); - RefPtr::Type> ptr(item); + typedef typename std::remove_cv::type NCT; + RefPtr ptr(item); try { - insert_unique(items, name, ptr); + add_var(name, get_type(name), ptr); } catch(...) { @@ -124,7 +120,7 @@ public: template T &get(const std::string &name) const { - return extract::Type>(get_item(items, name)); + return extract::type>(get_item(items, name)); } /** Gets a typed object from the collection. If the name is not found, @@ -133,29 +129,49 @@ public: template T &get(const std::string &name) { - typedef typename RemoveConst::Type NCT; - return extract(get_var(name, get_type())); + typedef typename std::remove_cv::type NCT; + return extract(get_var(name, get_type(name))); + } + + /** Finds a typed object in the collection. Returns null if the name does + not exist. Throws if the name exists but the object is of an incorrect + type. */ + template + T *find(const std::string &name) const + { + ItemMap::const_iterator i = items.find(name); + return (i!=items.end() ? extract::type>(i->second) : 0); + } + + template + T *find(const std::string &name) + { + typedef typename std::remove_cv::type NCT; + const Variant *var = find_var(name, get_type(name)); + return (var ? &extract(*var) : 0); } private: + void add_var(const std::string &, const CollectionItemTypeBase *, const Variant &); const Variant &get_var(const std::string &, const CollectionItemTypeBase *); + const Variant *find_var(const std::string &, const CollectionItemTypeBase *); template T &extract(const Variant &var) const; template - std::list extract_list(const std::list &vars) const + std::list extract_list(const std::vector &vars) const { std::list result; - for(std::list::const_iterator i=vars.begin(); i!=vars.end(); ++i) - result.push_back(&extract(**i)); + for(const Variant *v: vars) + result.push_back(&extract(*v)); return result; } - void gather_items(std::list *, std::list *, const CollectionItemTypeBase &, bool) const; + void gather_items(std::vector *, std::list *, const CollectionItemTypeBase &, bool) const; template - void gather_items(std::list *vars, std::list *names, const CollectionItemTypeBase *type, bool include_sources) const + void gather_items(std::vector *vars, std::list *names, const CollectionItemTypeBase *type, bool include_sources) const { if(type || (type = get_type())) gather_items(vars, names, *type, include_sources); @@ -169,7 +185,7 @@ public: std::list get_names() const { std::list names; - gather_items::Type>(0, &names, 0, false); + gather_items::type>(0, &names, 0, false); return names; } @@ -179,7 +195,7 @@ public: std::list get_names() { std::list names; - gather_items::Type>(0, &names, 0, true); + gather_items::type>(0, &names, 0, true); return names; } @@ -187,8 +203,8 @@ public: template std::list get_list() const { - std::list vars; - gather_items::Type>(&vars, 0, 0, false); + std::vector vars; + gather_items::type>(&vars, 0, 0, false); return extract_list(vars); } @@ -197,12 +213,12 @@ public: template std::list get_list() { - CollectionItemTypeBase *type = get_type::Type>(); + CollectionItemTypeBase *type = get_type::type>(); if(type) load_items_from_sources(*type); - std::list vars; - gather_items::Type>(&vars, 0, type, true); + std::vector vars; + gather_items::type>(&vars, 0, type, true); return extract_list(vars); } @@ -224,24 +240,24 @@ public: /// Checks whether a typed object exists in the collection. template bool contains(const std::string &name) const - { return get_status::Type>(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::Type>(name)>0; } + { return get_status::type>(name)>0; } /// Returns the name of an item in the collection. template const std::string &get_name(T *d) const { - typedef RefPtr::Type> RPNCT; + typedef RefPtr::type> RPNCT; - for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) - if(i->second.check_type()) - if(i->second.value().get()==d) - return i->first; + for(const auto &kvp: items) + if(kvp.second.check_type()) + if(kvp.second.value().get()==d) + return kvp.first; // XXX Need better exception class throw std::runtime_error("Item not found in collection"); @@ -251,20 +267,35 @@ 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(); + typename CollectionItemTypeChooser::Type &add_type(); + + /** Returns a mutable reference to an existing type descriptor. This can be + used to e.g. override the creator function of a type added by a base class. */ + template + typename CollectionItemTypeChooser::Type &modify_type(); private: - /// Returns the descriptor for a type, or null if one isn't defined. + /** Returns the descriptor for a type, or null if one isn't defined. An + optional name can be given to prioritize matching types. */ template - CollectionItemTypeBase *get_type() const; + CollectionItemTypeBase *get_type(const std::string & = std::string()) 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: - void add_source(CollectionSource &); + /** Adds a source for automatically loading items. Sources are consulted + in the order they are added. */ + void add_source(const CollectionSource &); - IO::Seekable *open_from_sources(const std::string &); +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; private: void gather_names_from_sources(std::list &, const CollectionItemTypeBase &) const; @@ -275,6 +306,8 @@ 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 @@ -301,7 +334,7 @@ class CollectionItemTypeBase protected: struct ExtractorBase { - virtual ~ExtractorBase() { } + virtual ~ExtractorBase() = default; }; template @@ -314,13 +347,15 @@ protected: std::vector suffixes; std::vector extractors; - CollectionItemTypeBase() { } + CollectionItemTypeBase() = default; public: virtual ~CollectionItemTypeBase(); +protected: void set_keyword(const std::string &); - const std::string &get_keyword() const { return kwd; } void add_suffix(const std::string &); +public: + const std::string &get_keyword() const { return kwd; } 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; @@ -328,12 +363,13 @@ public: 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; + virtual void notify_item(const std::string &, const Variant &) const = 0; template bool can_extract() const { - for(std::vector::const_iterator i=extractors.begin(); i!=extractors.end(); ++i) - if(dynamic_cast *>(*i)) + for(ExtractorBase *e: extractors) + if(dynamic_cast *>(e)) return true; return false; } @@ -341,8 +377,8 @@ public: 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)) + for(ExtractorBase *e: extractors) + if(Extractor *ex = dynamic_cast *>(e)) return &ex->extract(var); return 0; } @@ -357,45 +393,17 @@ template class CollectionItemType: public CollectionItemTypeBase { private: - struct CreatorBase - { - virtual ~CreatorBase() { } - - virtual T *create(Collection &, const std::string &) const = 0; - }; - - template - struct Creator: CreatorBase - { - typedef T *(C::*FuncPtr)(const std::string &); - - FuncPtr func; - - Creator(FuncPtr f): func(f) { } - - virtual T *create(Collection &coll, const std::string &name) const - { return (static_cast(coll).*func)(name); } - }; - template struct Extractor: CollectionItemTypeBase::Extractor { - virtual B &extract(const Variant &var) const + B &extract(const Variant &var) const override { return *var.value >(); } }; - CreatorBase *creat; + std::function create_func; + std::vector> notify_funcs; public: - CollectionItemType(): - creat(0) - { } - - ~CollectionItemType() - { - 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. */ @@ -405,7 +413,7 @@ public: return *this; } - /** Adds a suffix that is used to match names when looking for future + /** Adds a suffix that is used to match names when looking for loadable 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. */ @@ -421,11 +429,10 @@ public: 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 &creator(T *(C::*func)(const std::string &)) + template + CollectionItemType &creator(F func) { - delete creat; - creat = new Creator(func); + create_func = func; return *this; } @@ -437,28 +444,56 @@ public: return *this; } - virtual bool is_same_type(const CollectionItemTypeBase &other) const + template + CollectionItemType ¬ify(F func) + { + notify_funcs.emplace_back(func); + return *this; + } + + bool is_same_type(const CollectionItemTypeBase &other) const override { return dynamic_cast *>(&other); } - virtual bool check_item_type(const Variant &var) const + bool check_item_type(const Variant &var) const override { return var.check_type >(); } - virtual void add_to_loader(Collection::Loader &loader) const - { loader.add(kwd, &Collection::Loader::item); } + void add_to_loader(Collection::Loader &) const override + { } - virtual bool can_create() const - { return creat!=0; } + bool can_create() const override + { return static_cast(create_func); } - virtual void create_item(Collection &coll, const std::string &name) const + void create_item(Collection &coll, const std::string &name) const override { - if(!creat) + if(!create_func) throw std::runtime_error("no creator"); - T *obj = creat->create(coll, name); + T *obj = create_func(name); if(obj) coll.add(name, obj); } - virtual void load_item(Collection &coll, Parser &parser, const std::string &name) const + void load_item(Collection &, Parser &, const std::string &) const override + { + throw std::runtime_error("this type cannot be loaded"); + } + + void notify_item(const std::string &name, const Variant &var) const override + { + RefPtr obj = var.value >(); + for(const auto &n: notify_funcs) + n(name, *obj); + } +}; + + +template +class LoadableCollectionItemType: public CollectionItemType +{ +public: + void add_to_loader(Collection::Loader &loader) const override + { loader.add(this->kwd, &Collection::Loader::item); } + + void load_item(Collection &coll, Parser &parser, const std::string &name) const override { RefPtr obj = new T; Collection::ItemLoader ldr(*obj, coll); @@ -481,23 +516,38 @@ T &Collection::extract(const Variant &var) const } template -CollectionItemType &Collection::add_type() +typename CollectionItemTypeChooser::Type &Collection::add_type() { - CollectionItemType *type = new CollectionItemType; + typename CollectionItemTypeChooser::Type *type = new typename CollectionItemTypeChooser::Type; types.push_back(type); return *type; } template -CollectionItemTypeBase *Collection::get_type() const +typename CollectionItemTypeChooser::Type &Collection::modify_type() +{ + for(CollectionItemTypeBase *t: types) + if(CollectionItemType *tt = dynamic_cast *>(t)) + return *tt; + + throw std::logic_error("type not found in collection"); +} + +template +CollectionItemTypeBase *Collection::get_type(const std::string &name) 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; + for(CollectionItemTypeBase *t: types) + if(dynamic_cast *>(t)) + return t; + CollectionItemTypeBase *type = nullptr; + for(CollectionItemTypeBase *t: types) + if(t->can_extract()) + { + if(!name.empty() && t->match_name(name)) + return t; + type = t; + } + return type; } } // namespace DataFile