Throw an exception if a future object couldn't be created

[libs/datafile.git] / source / collection.h

diff --git a/source/collection.h b/source/collection.h
index 0595aaca7caddb801d094d9ed847362c669c8be7..c83b4376d20b2b6d4854b29dfc0fbda9c0c286b5 100644 (file)
--- a/source/collection.h
+++ b/source/collection.h
@@ -55,34 +55,27 @@ public:
                template<typename T> friend class CollectionItemType;
 
        private:
-               template<typename T, typename S, bool = NeedsCollection<typename T::Loader>::value>
-               struct Add;
-
                Collection &coll;
 
        public:
                Loader(Collection &);
                Collection &get_object() const { return coll; }
        private:
-               template<typename T, typename S, typename C>
-               void coll_item(const std::string &n)
-               {
-                       RefPtr<T> it = new T;
-                       load_sub(*it, dynamic_cast<C &>(coll));
-                       coll.add<S>(n, it.get());
-                       it.release();
-               }
-
                template<typename T, typename S>
                void item(const std::string &n)
                {
                        RefPtr<T> it = new T;
-                       load_sub(*it);
+                       ItemLoader<T> ldr(*it, coll);
+                       load_sub_with(ldr);
                        coll.add<S>(n, it.get());
                        it.release();
                }
        };
 
+protected:
+       template<typename T, bool = NeedsCollection<typename T::Loader>::value>
+       class ItemLoader;
+
 private:
        typedef std::map<std::string, Variant> ItemMap;
        typedef std::list<CollectionItemTypeBase *> TypeList;
@@ -137,6 +130,14 @@ protected:
                insert_unique(items, name, ptr);
        }
 
+       /** Adds the name of a future object, guessing its type.  If a type matching
+       the name can't be found, nothing is done. */
+       void add_future(const std::string &name);
+
+       /** Adds the name of a future object, using a keyword to determine its type.
+       The keyword must be known to the collection. */
+       void add_future_with_keyword(const std::string &name, const std::string &);
+
 public:
        /// Gets a typed object from the collection.
        template<typename T>
@@ -144,7 +145,7 @@ public:
        {
                typedef typename RemoveConst<T>::Type NCT;
 
-               T *ptr = get_item(items, name).value<RefPtr<NCT> >();
+               T *ptr = get_item(items, name).value<RefPtr<NCT> >().get();
                if(!ptr)
                        throw key_error(typeid(ItemMap));
                return *ptr;
@@ -157,7 +158,7 @@ public:
 
 private:
        template<typename T>
-       void collect_items(std::list<T *> *objects, std::list<std::string> *names, std::list<std::string> *future_names)
+       void collect_items(std::list<T *> *objects, std::list<std::string> *names, std::list<std::string> *future_names) const
        {
                typedef RefPtr<typename RemoveConst<T>::Type> RPNCT;
 
@@ -270,19 +271,22 @@ protected:
        CollectionItemType<T> &add_type();
 };
 
-
-template<typename T, typename S>
-struct Collection::Loader::Add<T, S, false>
+template<typename T>
+class Collection::ItemLoader<T, false>: public T::Loader
 {
-       static void add(Loader &loader, const std::string &kwd)
-       { loader.add(kwd, &Loader::item<T, S>); }
+public:
+       ItemLoader(T &o, Collection &):
+               T::Loader(o)
+       { }
 };
 
-template<typename T, typename S>
-struct Collection::Loader::Add<T, S, true>
+template<typename T>
+class Collection::ItemLoader<T, true>: public T::Loader
 {
-       static void add(Loader &loader, const std::string &kwd)
-       { loader.add(kwd, &Loader::coll_item<T, S, typename T::Loader::Collection>); }
+public:
+       ItemLoader(T &o, Collection &c):
+               T::Loader(o, dynamic_cast<typename T::Loader::Collection &>(c))
+       { }
 };
 
 
@@ -302,15 +306,21 @@ protected:
        { };
 
        std::string kwd;
+       std::vector<std::string> suffixes;
        TagBase *tag;
 
        CollectionItemTypeBase();
 public:
        virtual ~CollectionItemTypeBase();
 
+       void set_keyword(const std::string &);
+       const std::string &get_keyword() const { return kwd; }
+       void add_suffix(const std::string &);
+       bool match_name(const std::string &) const;
        virtual void add_to_loader(Collection::Loader &) const = 0;
        virtual bool can_create() const = 0;
        virtual void create_item(Collection &, const std::string &) const = 0;
+       virtual Variant create_future() const = 0;
 
        template<typename T>
        bool check_type() const
@@ -360,6 +370,7 @@ private:
                virtual ~StoreBase() { }
 
                virtual void store(Collection &, const std::string &, T *) = 0;
+               virtual Variant create_future() const = 0;
 
                virtual void add_to_loader(Collection::Loader &, const std::string &) = 0;
        };
@@ -371,8 +382,11 @@ private:
                virtual void store(Collection &coll, const std::string &name, T *obj)
                { coll.add(name, static_cast<S *>(obj)); }
 
+               virtual Variant create_future() const
+               { return RefPtr<S>(0); }
+
                virtual void add_to_loader(Collection::Loader &loader, const std::string &kwd)
-               { Collection::Loader::Add<T, S>::add(loader, kwd); }
+               { loader.add(kwd, &Collection::Loader::item<T, S>); }
        };
 
        CreatorBase *creat;
@@ -394,7 +408,17 @@ public:
        item's name. */
        CollectionItemType &keyword(const std::string &k)
        {
-               kwd = k;
+               set_keyword(k);
+               return *this;
+       }
+
+       /** Adds a suffix that is used to match names when looking for future
+       objects.  There is no implied separator; a name matches if it ends with the
+       suffix.  If a keyword is defined before any suffixes, then "."+keyword is
+       added as a suffix. */
+       CollectionItemType &suffix(const std::string &s)
+       {
+               add_suffix(s);
                return *this;
        }
 
@@ -438,6 +462,9 @@ public:
                if(obj)
                        store->store(coll, name, obj);
        }
+
+       virtual Variant create_future() const
+       { return store->create_future(); }
 };
 
 
@@ -458,7 +485,10 @@ T &Collection::get(const std::string &name)
                if((*j)->can_create() && (*j)->check_type<NCT>())
                        (*j)->create_item(*this, name);
 
-       return *get_item(items, name).value<RefPtr<NCT> >();
+       NCT *ptr = get_item(items, name).value<RefPtr<NCT> >().get();
+       if(!ptr)
+               throw key_error(typeid(ItemMap));
+       return *ptr;
 }
 
 template<typename T>