X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcollection.h;h=98b359e5eaedd28604a5d1f0a0085f470a657219;hb=256b44a5009467171af53316141277027bcc0ba4;hp=174c7fcabce52812083a7d8184670d2b24eda32e;hpb=acf0e00b9e45615c5f10777d764100c2c086acab;p=libs%2Fdatafile.git diff --git a/source/collection.h b/source/collection.h index 174c7fc..98b359e 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,24 +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: public Sfinae -{ - template - static Yes f(typename U::Collection *); - template - static No f(...); +class CollectionItemType; - enum { value = Evaluate(0))>::value }; -}; +template +class LoadableCollectionItemType; -class CollectionItemTypeBase; +template::value> +struct CollectionItemTypeChooser; template -class CollectionItemType; +struct CollectionItemTypeChooser +{ typedef LoadableCollectionItemType Type; }; + +template +struct CollectionItemTypeChooser +{ typedef CollectionItemType Type; }; /** A collection of objects that can be loaded from a datafile. Each object is @@ -48,7 +51,7 @@ 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: /** @@ -57,7 +60,7 @@ public: */ class Loader: public DataFile::Loader { - template friend class CollectionItemType; + template friend class LoadableCollectionItemType; private: Collection &coll; @@ -82,16 +85,12 @@ public: private: typedef std::map ItemMap; - typedef std::list TypeList; - typedef std::list SourceList; - TypeList types; + std::vector types; ItemMap items; - SourceList sources; + std::vector sources; Collection *fallback; - Collection(const Collection &); - Collection &operator=(const Collection &); public: Collection(); virtual ~Collection(); @@ -104,10 +103,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(...) { @@ -121,7 +121,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, @@ -130,29 +130,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); @@ -166,7 +186,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; } @@ -176,7 +196,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; } @@ -184,8 +204,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); } @@ -194,12 +214,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); } @@ -221,24 +241,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"); @@ -248,12 +268,21 @@ 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; @@ -261,7 +290,7 @@ private: protected: /** Adds a source for automatically loading items. Sources are consulted in the order they are added. */ - void add_source(CollectionSource &); + void add_source(const CollectionSource &); public: /** Opens a raw resource, without interpreting it as object data. Null is @@ -269,9 +298,6 @@ public: 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; @@ -281,6 +307,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 @@ -324,9 +352,11 @@ protected: 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; @@ -334,12 +364,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(Collection &, 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; } @@ -347,8 +378,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; } @@ -383,6 +414,26 @@ private: { return (dynamic_cast(coll).*func)(name); } }; + struct NotifyeeBase + { + virtual ~NotifyeeBase() { } + + virtual void notify(Collection &, const std::string &, T &) const = 0; + }; + + template + struct Notifyee: NotifyeeBase + { + typedef void (C::*FuncPtr)(const std::string &, T &); + + FuncPtr func; + + Notifyee(FuncPtr f): func(f) { } + + virtual void notify(Collection &coll, const std::string &name, T &item) const + { (dynamic_cast(coll).*func)(name, item); } + }; + template struct Extractor: CollectionItemTypeBase::Extractor { @@ -391,6 +442,7 @@ private: }; CreatorBase *creat; + std::vector notif; public: CollectionItemType(): @@ -400,6 +452,8 @@ public: ~CollectionItemType() { delete creat; + for(NotifyeeBase *n: notif) + delete n; } /** Sets a datafile keyword for this item type. The Collection's loader @@ -411,7 +465,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. */ @@ -443,14 +497,21 @@ public: return *this; } + template + CollectionItemType ¬ify(void (C::*func)(const std::string &, T &)) + { + notif.push_back(new Notifyee(func)); + 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 - { loader.add(kwd, &Collection::Loader::item); } + virtual void add_to_loader(Collection::Loader &) const + { } virtual bool can_create() const { return creat!=0; } @@ -464,6 +525,27 @@ public: coll.add(name, obj); } + virtual void load_item(Collection &, Parser &, const std::string &) const + { + throw std::runtime_error("this type cannot be loaded"); + } + + virtual void notify_item(Collection &coll, const std::string &name, const Variant &var) const + { + RefPtr obj = var.value >(); + for(NotifyeeBase *n: notif) + n->notify(coll, name, *obj); + } +}; + + +template +class LoadableCollectionItemType: public CollectionItemType +{ +public: + virtual void add_to_loader(Collection::Loader &loader) const + { loader.add(this->kwd, &Collection::Loader::item); } + virtual void load_item(Collection &coll, Parser &parser, const std::string &name) const { RefPtr obj = new T; @@ -487,23 +569,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 = 0; + for(CollectionItemTypeBase *t: types) + if(t->can_extract()) + { + if(!name.empty() && t->match_name(name)) + return t; + type = t; + } + return type; } } // namespace DataFile