X-Git-Url: http://git.tdb.fi/?p=libs%2Fdatafile.git;a=blobdiff_plain;f=source%2Fcollection.cpp;h=129c0a84f76808c14f0a8164b853e0c56d6ccb97;hp=070991948d33d7315074ec6bb480cc06344d45cc;hb=HEAD;hpb=a5d5fa04bcbe360fc55fdb25b45937b29fb5c9cd diff --git a/source/collection.cpp b/source/collection.cpp index 0709919..e1c25dd 100644 --- a/source/collection.cpp +++ b/source/collection.cpp @@ -1,3 +1,5 @@ +#include +#include #include "collection.h" using namespace std; @@ -5,21 +7,41 @@ using namespace std; namespace Msp { namespace DataFile { -Collection::Collection(): - fallback(0) -{ } - Collection::~Collection() { - for(TypeList::iterator i = types.begin(); i!=types.end(); ++i) - delete *i; + for(CollectionItemTypeBase *t: types) + delete t; +} + +void Collection::add_var(const string &name, const CollectionItemTypeBase *type, const Variant &var) +{ + insert_unique(items, name, var); + try + { + if(type) + type->notify_item(name, var); + } + catch(...) + { + remove_existing(items, name); + throw; + } } const Variant &Collection::get_var(const string &name, const CollectionItemTypeBase *type) +{ + const Variant *var = find_var(name, type); + if(var) + return *var; + + throw key_error(name); +} + +const Variant *Collection::find_var(const string &name, const CollectionItemTypeBase *type) { ItemMap::iterator i = items.find(name); if(i!=items.end()) - return i->second; + return &i->second; if(type) { @@ -29,35 +51,30 @@ const Variant &Collection::get_var(const string &name, const CollectionItemTypeB type->create_item(*this, name); loaded = items.count(name); } - for(SourceList::iterator j=sources.begin(); (!loaded && j!=sources.end()); ++j) + for(auto j=sources.begin(); (!loaded && j!=sources.end()); ++j) { (*j)->load(*this, *type, name); loaded = items.count(name); } if(!loaded && fallback) - { - for(TypeList::const_iterator j=fallback->types.begin(); j!=fallback->types.end(); ++j) - if((*j)->is_same_type(*type)) - { - if(fallback->get_status(name, **j)) - return fallback->get_var(name, *j); - break; - } - } + if(CollectionItemTypeBase *fb_type = fallback->get_type(*type)) + if(fallback->get_status(name, *fb_type)) + return fallback->find_var(name, fb_type); } - return get_item(items, name); + i = items.find(name); + return (i!=items.end() ? &i->second : nullptr); } -void Collection::gather_items(list *vars, list *names, const CollectionItemTypeBase &type, bool include_sources) const +void Collection::gather_items(vector *vars, list *names, const CollectionItemTypeBase &type, bool include_sources) const { - for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) - if(type.check_item_type(i->second)) + for(const auto &kvp: items) + if(type.check_item_type(kvp.second)) { if(vars) - vars->push_back(&i->second); + vars->push_back(&kvp.second); if(names) - names->push_back(i->first); + names->push_back(kvp.first); } if(include_sources && names) @@ -69,48 +86,73 @@ unsigned Collection::get_status(const string &name, const CollectionItemTypeBase ItemMap::const_iterator i = items.find(name); if(i==items.end()) { - for(SourceList::const_iterator j=sources.begin(); j!=sources.end(); ++j) - if((*j)->is_loadable(type, name)) - return 2; + auto j = find_if(sources, [&name, &type](const CollectionSource *s){ return s->is_loadable(type, name); }); + if(j!=sources.end()) + return 2; + if(fallback) + if(CollectionItemTypeBase *fb_type = fallback->get_type(type)) + return fallback->get_status(name, *fb_type); return 0; } return type.check_item_type(i->second); } +CollectionItemTypeBase *Collection::get_type(const CollectionItemTypeBase &type) const +{ + for(CollectionItemTypeBase *t: types) + if(t->is_same_type(type)) + return t; + return nullptr; +} + CollectionItemTypeBase *Collection::get_type_for_item(const Variant &var) const { - for(TypeList::const_iterator i=types.begin(); i!=types.end(); ++i) - if((*i)->check_item_type(var)) - return *i; - return 0; + for(CollectionItemTypeBase *t: types) + if(t->check_item_type(var)) + return t; + return nullptr; } -void Collection::add_source(CollectionSource &s) +void Collection::add_source(const CollectionSource &s) { sources.push_back(&s); } +IO::Seekable *Collection::open_raw(const string &name) const +{ + for(const CollectionSource *s: sources) + if(IO::Seekable *io = s->open(name)) + return io; + + return nullptr; +} + void Collection::gather_names_from_sources(list &names, const CollectionItemTypeBase &type) const { - 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)) - names.push_back(*j); - } + set new_names; + for(const CollectionSource *s: sources) + for(const string &n: s->get_names(type)) + if(!items.count(n)) + new_names.insert(n); + names.insert(names.end(), new_names.begin(), new_names.end()); } void Collection::load_items_from_sources(const CollectionItemTypeBase &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)) - (*i)->load(*this, type, *j); - } + for(const CollectionSource *s: sources) + for(const string &n: s->get_names(type)) + if(!items.count(n)) + { + bool loaded = false; + if(type.can_create()) + { + type.create_item(*this, n); + loaded = items.count(n); + } + if(!loaded) + s->load(*this, type, n); + } } void Collection::set_fallback(Collection *f) @@ -122,15 +164,15 @@ void Collection::set_fallback(Collection *f) Collection::Loader::Loader(Collection &c): coll(c) { - for(TypeList::const_iterator i = coll.types.begin(); i!=coll.types.end(); ++i) - (*i)->add_to_loader(*this); + for(const CollectionItemTypeBase *t: coll.types) + t->add_to_loader(*this); } CollectionItemTypeBase::~CollectionItemTypeBase() { - for(vector::iterator i=extractors.begin(); i!=extractors.end(); ++i) - delete *i; + for(ExtractorBase *e: extractors) + delete e; } void CollectionItemTypeBase::set_keyword(const string &k) @@ -147,8 +189,8 @@ void CollectionItemTypeBase::add_suffix(const string &s) bool CollectionItemTypeBase::match_name(const string &name) const { - for(vector::const_iterator i=suffixes.begin(); i!=suffixes.end(); ++i) - if(name.size()>i->size() && !name.compare(name.size()-i->size(), string::npos, *i)) + for(const string &s: suffixes) + if(name.size()>s.size() && !name.compare(name.size()-s.size(), string::npos, s)) return true; return false; }