X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcollection.h;h=98b359e5eaedd28604a5d1f0a0085f470a657219;hb=256b44a5009467171af53316141277027bcc0ba4;hp=5521975402d0526773a44bf6210c9577b87d0f79;hpb=a887b3f7518605c22e4b70eeb9fe136acb2ea632;p=libs%2Fdatafile.git diff --git a/source/collection.h b/source/collection.h index 5521975..98b359e 100644 --- a/source/collection.h +++ b/source/collection.h @@ -1,8 +1,10 @@ #ifndef MSP_DATAFILE_COLLECTION_H_ #define MSP_DATAFILE_COLLECTION_H_ +#include #include #include +#include #include #include "collectionsource.h" #include "loader.h" @@ -19,6 +21,20 @@ class CollectionItemTypeBase; template class CollectionItemType; +template +class LoadableCollectionItemType; + +template::value> +struct CollectionItemTypeChooser; + +template +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 identified by a name, which must be unique across the entire collection. @@ -35,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: /** @@ -44,7 +60,7 @@ public: */ class Loader: public DataFile::Loader { - template friend class CollectionItemType; + template friend class LoadableCollectionItemType; private: Collection &coll; @@ -69,16 +85,12 @@ public: private: typedef std::map ItemMap; - typedef std::vector TypeList; - typedef std::vector 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(); @@ -91,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(...) { @@ -108,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, @@ -117,12 +130,32 @@ public: template T &get(const std::string &name) { - typedef typename RemoveConst::Type NCT; + 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; @@ -131,8 +164,8 @@ private: std::list extract_list(const std::vector &vars) const { std::list result; - for(std::vector::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; } @@ -153,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; } @@ -163,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; } @@ -172,7 +205,7 @@ public: std::list get_list() const { std::vector vars; - gather_items::Type>(&vars, 0, 0, false); + gather_items::type>(&vars, 0, 0, false); return extract_list(vars); } @@ -181,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::vector vars; - gather_items::Type>(&vars, 0, type, true); + gather_items::type>(&vars, 0, type, true); return extract_list(vars); } @@ -208,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"); @@ -235,12 +268,12 @@ 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 - CollectionItemType &modify_type(); + typename CollectionItemTypeChooser::Type &modify_type(); private: /** Returns the descriptor for a type, or null if one isn't defined. An @@ -265,10 +298,6 @@ public: object when done with it. */ IO::Seekable *open_raw(const std::string &) const; -protected: - // Deprecated. Use open_raw instead. - DEPRECATED IO::Seekable *open_from_sources(const std::string &n) { return open_raw(n); } - private: void gather_names_from_sources(std::list &, const CollectionItemTypeBase &) const; @@ -323,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; @@ -333,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; } @@ -346,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; } @@ -382,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 { @@ -390,6 +442,7 @@ private: }; CreatorBase *creat; + std::vector notif; public: CollectionItemType(): @@ -399,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 @@ -442,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; } @@ -463,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; @@ -486,19 +569,19 @@ 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 -CollectionItemType &Collection::modify_type() +typename CollectionItemTypeChooser::Type &Collection::modify_type() { - for(TypeList::const_iterator j=types.begin(); j!=types.end(); ++j) - if(CollectionItemType *t = dynamic_cast *>(*j)) - return *t; + for(CollectionItemTypeBase *t: types) + if(CollectionItemType *tt = dynamic_cast *>(t)) + return *tt; throw std::logic_error("type not found in collection"); } @@ -506,16 +589,16 @@ CollectionItemType &Collection::modify_type() 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(CollectionItemTypeBase *t: types) + if(dynamic_cast *>(t)) + return t; CollectionItemTypeBase *type = 0; - for(TypeList::const_iterator j=types.begin(); j!=types.end(); ++j) - if((*j)->can_extract()) + for(CollectionItemTypeBase *t: types) + if(t->can_extract()) { - if(!name.empty() && (*j)->match_name(name)) - return *j; - type = *j; + if(!name.empty() && t->match_name(name)) + return t; + type = t; } return type; }