Introduce the concept of future objects

diff --git a/source/collection.h b/source/collection.h
index d5e0806afeebad9fbfa2f043ef80d3ef9bc64878..bf44773e54f1b0914cd5b46a80130b8022b881ee 100644 (file)
--- 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<typename RemoveConst<T>::Type> ptr(item);
-               try
-               {
-                       insert_unique(items, name, ptr);
-               }
-               catch(...)
+               typedef RefPtr<typename RemoveConst<T>::Type> RPNCT;
+
+               ItemMap::iterator i = items.find(name);
+               if(i!=items.end())
                {
-                       // Avoid deleting the object
-                       ptr.release();
-                       throw;
+                       if(i->second.check_type<RPNCT>())
+                       {
+                               // Replace a future object placeholder
+                               RPNCT &ptr = i->second.value<RPNCT>();
+                               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<typename T>
+       void add_future(const std::string &name)
+       {
+               RefPtr<typename RemoveConst<T>::Type> ptr(0);
+               insert_unique(items, name, ptr);
+       }
+
+public:
        /// Gets a typed object from the collection.
        template<typename T>
        T &get(const std::string &name) const
        {
                typedef typename RemoveConst<T>::Type NCT;
 
-               return *get_item(items, name).value<RefPtr<NCT> >();
+               T *ptr = get_item(items, name).value<RefPtr<NCT> >();
+               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<typename T>
        T &get(const std::string &);
 
-       /// Returns a list of the names of objects of one type in the collection.
+private:
+       template<typename T>
+       void collect_items(std::list<T *> *objects, std::list<std::string> *names, std::list<std::string> *future_names)
+       {
+               typedef RefPtr<typename RemoveConst<T>::Type> RPNCT;
+
+               for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i)
+                       if(i->second.check_type<RPNCT>())
+                       {
+                               T *ptr = i->second.value<RPNCT>().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<typename T>
        std::list<std::string> get_names() const
        {
                std::list<std::string> result;
-               for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i)
-                       if(i->second.check_type<RefPtr<typename RemoveConst<T>::Type> >())
-                               result.push_back(i->first);
+               collect_items<T>(0, &result, 0);
+               return result;
+       }
+
+       /** Returns a list of the names of objects of one type in the collection,
+       including any future objects. */
+       template<typename T>
+       std::list<std::string> get_names()
+       {
+               std::list<std::string> result;
+               collect_items<T>(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<typename T>
        std::list<T *> get_list() const
        {
-               typedef RefPtr<typename RemoveConst<T>::Type> RPNCT;
+               std::list<T *> result;
+               collect_items<T>(&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<typename T>
+       std::list<T *> get_list()
+       {
                std::list<T *> result;
-               for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i)
-                       if(i->second.check_type<RPNCT>())
-                               result.push_back(i->second.value<RPNCT>().get());
+               std::list<std::string> future;
+               collect_items<T>(&result, 0, &future);
+               for(std::list<std::string>::iterator i=future.begin(); i!=future.end(); ++i)
+                       result.push_back(&get<T>(*i));
                return result;
        }
 
-       /// Checks whether a typed object exists in the collection.
+private:
        template<typename T>
-       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<typename RemoveConst<T>::Type>();
+               typedef RefPtr<typename RemoveConst<T>::Type> RPNCT;
+               if(!i->second.check_type<RPNCT>())
+                       return false;
+
+               T *ptr = i->second.value<RPNCT>().get();
+               return ptr ? 1 : 2;
        }
 
+public:
+       /// Checks whether a typed object exists and is loaded in the collection.
+       template<typename T>
+       bool contains(const std::string &name) const
+       { return get_status<T>(name)==1; }
+
+       /** Checks whether a typed object exists in the collection, as either a
+       loaded or future object. */
+       template<typename T>
+       bool contains(const std::string &name)
+       { return get_status<T>(name)>0; }
+
        /// Returns the name of an item in the collection.
        template<typename T>
        const std::string &get_name(T *d) const
@@ -364,13 +450,18 @@ T &Collection::get(const std::string &name)
 {
        typedef typename RemoveConst<T>::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<NCT>())
-                               (*i)->create_item(*this, name);
+               NCT *ptr = i->second.value<RefPtr<NCT> >().get();
+               if(ptr)
+                       return *ptr;
        }
 
+       for(TypeList::iterator j=types.begin(); j!=types.end(); ++j)
+               if((*j)->can_create() && (*j)->check_type<NCT>())
+                       (*j)->create_item(*this, name);
+
        return *get_item(items, name).value<RefPtr<NCT> >();
 }