X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcollection.h;h=d0e8a1a8bb9b25c636ab23a8c1e4bbdcfa5c04a7;hb=HEAD;hp=87af3a2c2c606cde35d00abd8a20bf092744e19d;hpb=b26fbba2bf5d53554325762b8022c501b3b8c8fb;p=libs%2Fdatafile.git diff --git a/source/collection.h b/source/collection.h index 87af3a2..c8470dd 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" @@ -49,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: /** @@ -83,18 +85,13 @@ public: private: typedef std::map ItemMap; - typedef std::vector TypeList; - typedef std::vector 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 @@ -105,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(...) { @@ -122,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, @@ -131,7 +129,7 @@ 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))); } @@ -142,18 +140,19 @@ public: T *find(const std::string &name) const { ItemMap::const_iterator i = items.find(name); - return (i!=items.end() ? extract::Type>(i->second) : 0); + return (i!=items.end() ? extract::type>(i->second) : 0); } template T *find(const std::string &name) { - typedef typename RemoveConst::Type NCT; + 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 *); @@ -164,8 +163,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; } @@ -186,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; } @@ -196,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; } @@ -205,7 +204,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); } @@ -214,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::vector vars; - gather_items::Type>(&vars, 0, type, true); + gather_items::type>(&vars, 0, type, true); return extract_list(vars); } @@ -241,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"); @@ -298,10 +297,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; @@ -339,7 +334,7 @@ class CollectionItemTypeBase protected: struct ExtractorBase { - virtual ~ExtractorBase() { } + virtual ~ExtractorBase() = default; }; template @@ -352,7 +347,7 @@ protected: std::vector suffixes; std::vector extractors; - CollectionItemTypeBase() { } + CollectionItemTypeBase() = default; public: virtual ~CollectionItemTypeBase(); @@ -368,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; } @@ -381,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; } @@ -397,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 (dynamic_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. */ @@ -461,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; } @@ -477,31 +444,45 @@ 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 &) const + 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 &, Parser &, const std::string &) 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); + } }; @@ -509,10 +490,10 @@ template class LoadableCollectionItemType: public CollectionItemType { public: - virtual void add_to_loader(Collection::Loader &loader) const + void add_to_loader(Collection::Loader &loader) const override { loader.add(this->kwd, &Collection::Loader::item); } - virtual void load_item(Collection &coll, Parser &parser, const std::string &name) const + void load_item(Collection &coll, Parser &parser, const std::string &name) const override { RefPtr obj = new T; Collection::ItemLoader ldr(*obj, coll); @@ -545,9 +526,9 @@ typename CollectionItemTypeChooser::Type &Collection::add_type() template 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"); } @@ -555,16 +536,16 @@ typename CollectionItemTypeChooser::Type &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; - CollectionItemTypeBase *type = 0; - for(TypeList::const_iterator j=types.begin(); j!=types.end(); ++j) - if((*j)->can_extract()) + for(CollectionItemTypeBase *t: types) + if(dynamic_cast *>(t)) + return t; + CollectionItemTypeBase *type = nullptr; + 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; }