From: Mikko Rasa Date: Wed, 26 Sep 2012 18:36:28 +0000 (+0300) Subject: Introduce the concept of future objects X-Git-Url: http://git.tdb.fi/?a=commitdiff_plain;h=bbb5a5b00b4008684d5c32b3ea2fd21f7a5fad54;p=libs%2Fdatafile.git Introduce the concept of future objects --- diff --git a/source/collection.h b/source/collection.h index d5e0806..bf44773 100644 --- a/source/collection.h +++ b/source/collection.h @@ -38,6 +38,10 @@ identified by a name, which must be unique across the entire collection. While this class can be instantiated by itself and used for storing objects, loading requires that a subclass defines the supported types. See the add_type method for details. + +Collections also support a notion of "future objects". These are objects which +are known to be possible to load, but loading them is deferred to the first +time they are requested. */ class Collection { @@ -100,26 +104,50 @@ public: if(!item) throw std::invalid_argument("Collection::add(item)"); - RefPtr::Type> ptr(item); - try - { - insert_unique(items, name, ptr); - } - catch(...) + typedef RefPtr::Type> RPNCT; + + ItemMap::iterator i = items.find(name); + if(i!=items.end()) { - // Avoid deleting the object - ptr.release(); - throw; + if(i->second.check_type()) + { + // Replace a future object placeholder + RPNCT &ptr = i->second.value(); + if(!ptr) + { + ptr = item; + return; + } + } + + throw key_error(typeid(ItemMap)); } + + items.insert(ItemMap::value_type(name, RPNCT(item))); } +protected: + /** Adds the name of a future object to the collection. The object itself + will be loaded on first access. The calling subclass should be prepared to + create the object on request. */ + template + void add_future(const std::string &name) + { + RefPtr::Type> ptr(0); + insert_unique(items, name, ptr); + } + +public: /// Gets a typed object from the collection. template T &get(const std::string &name) const { typedef typename RemoveConst::Type NCT; - return *get_item(items, name).value >(); + T *ptr = get_item(items, name).value >(); + if(!ptr) + throw key_error(typeid(ItemMap)); + return *ptr; } /** Gets a typed object from the collection. If the name is not found in @@ -127,41 +155,99 @@ public: template T &get(const std::string &); - /// Returns a list of the names of objects of one type in the collection. +private: + template + void collect_items(std::list *objects, std::list *names, std::list *future_names) + { + typedef RefPtr::Type> RPNCT; + + for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) + if(i->second.check_type()) + { + T *ptr = i->second.value().get(); + if(ptr) + { + if(objects) + objects->push_back(ptr); + if(names) + names->push_back(i->first); + } + else if(future_names) + future_names->push_back(i->first); + } + } + +public: + /** Returns a list of the names of loaded objects of one type in the + collection. */ template std::list get_names() const { std::list result; - for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) - if(i->second.check_type::Type> >()) - result.push_back(i->first); + collect_items(0, &result, 0); + return result; + } + + /** Returns a list of the names of objects of one type in the collection, + including any future objects. */ + template + std::list get_names() + { + std::list result; + collect_items(0, &result, &result); return result; } - /// Returns a list of objects of one type in the collection. + /// Returns a list of loaded objects of one type in the collection. template std::list get_list() const { - typedef RefPtr::Type> RPNCT; + std::list result; + collect_items(&result, 0, 0); + return result; + } + /** Returns a list of objects of one type in the collection. Any future + objects of that type are loaded and returned in the list. */ + template + std::list get_list() + { std::list result; - for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) - if(i->second.check_type()) - result.push_back(i->second.value().get()); + std::list future; + collect_items(&result, 0, &future); + for(std::list::iterator i=future.begin(); i!=future.end(); ++i) + result.push_back(&get(*i)); return result; } - /// Checks whether a typed object exists in the collection. +private: template - bool contains(const std::string &name) const + unsigned get_status(const std::string &name) const { ItemMap::const_iterator i = items.find(name); if(i==items.end()) return false; - return i->second.check_type::Type>(); + typedef RefPtr::Type> RPNCT; + if(!i->second.check_type()) + return false; + + T *ptr = i->second.value().get(); + return ptr ? 1 : 2; } +public: + /// Checks whether a typed object exists and is loaded in the collection. + template + bool contains(const std::string &name) const + { return get_status(name)==1; } + + /** Checks whether a typed object exists in the collection, as either a + loaded or future object. */ + template + bool contains(const std::string &name) + { return get_status(name)>0; } + /// Returns the name of an item in the collection. template const std::string &get_name(T *d) const @@ -364,13 +450,18 @@ T &Collection::get(const std::string &name) { typedef typename RemoveConst::Type NCT; - if(!items.count(name)) + ItemMap::iterator i = items.find(name); + if(i!=items.end()) { - for(TypeList::iterator i=types.begin(); i!=types.end(); ++i) - if((*i)->can_create() && (*i)->check_type()) - (*i)->create_item(*this, name); + NCT *ptr = i->second.value >().get(); + if(ptr) + return *ptr; } + for(TypeList::iterator j=types.begin(); j!=types.end(); ++j) + if((*j)->can_create() && (*j)->check_type()) + (*j)->create_item(*this, name); + return *get_item(items, name).value >(); }