Redesign the Collection class

diff --git a/source/collection.cpp b/source/collection.cpp
index c1d72ca8e3b82e2f3b24b2d550d089efc8e2967c..e60b2009a4fc2c2cebf723ba700e5ab59967a00f 100644 (file)
--- a/source/collection.cpp
+++ b/source/collection.cpp
@@ -5,11 +5,7 @@ namespace DataFile {
 
 Collection::~Collection()
 {
 
 Collection::~Collection()
 {

-       for(ItemMap::iterator i = items.begin(); i!=items.end(); ++i)
-               delete i->second;
-       for(ItemKeywordSeq::iterator i = keywords.begin(); i!=keywords.end(); ++i)
-               delete *i;
-       for(ItemCreatorSeq::iterator i = creators.begin(); i!=creators.end(); ++i)
+       for(TypeList::iterator i = types.begin(); i!=types.end(); ++i)

                delete *i;
 }
 
                delete *i;
 }
 


@@ -22,7 +18,7 @@ bool Collection::contains(const std::string &n) const
 Collection::Loader::Loader(Collection &c):
        coll(c)
 {      
 Collection::Loader::Loader(Collection &c):
        coll(c)
 {      

-       for(ItemKeywordSeq::const_iterator i = coll.keywords.begin(); i!=coll.keywords.end(); ++i)
+       for(TypeList::const_iterator i = coll.types.begin(); i!=coll.types.end(); ++i)

                (*i)->add_to_loader(*this);
 }
 
                (*i)->add_to_loader(*this);
 }
 

diff --git a/source/collection.h b/source/collection.h
index 2d346d9a4557a72325a18ae6f89c232e5f629681..82339d8859902f725308b347f9f3de3fd39ff244 100644 (file)
--- a/source/collection.h
+++ b/source/collection.h
@@ -1,8 +1,8 @@
 #ifndef MSP_DATAFILE_COLLECTION_H_
 #define MSP_DATAFILE_COLLECTION_H_
 
 #ifndef MSP_DATAFILE_COLLECTION_H_
 #define MSP_DATAFILE_COLLECTION_H_
 

-#include <msp/core/meta.h>

 #include <msp/core/maputils.h>
 #include <msp/core/maputils.h>

+#include <msp/core/meta.h>

 #include <msp/core/refptr.h>
 #include "loader.h"
 
 #include <msp/core/refptr.h>
 #include "loader.h"
 


@@ -23,113 +23,32 @@ struct NeedsCollection
        template<typename U>
        static No f(...);
 
        template<typename U>
        static No f(...);
 

-       enum { result=(sizeof(f<T>(0))==sizeof(Yes)) };
+       enum { value = (sizeof(f<T>(0))==sizeof(Yes)) };

 };
 
 };
 

+class CollectionItemTypeBase;
+
+template<typename T>
+class CollectionItemType;
+

 /**
 A collection of objects that can be loaded from a datafile.  Each object is
 identified by a name, which must be unique across the entire collection.
 */
 class Collection
 {
 /**
 A collection of objects that can be loaded from a datafile.  Each object is
 identified by a name, which must be unique across the entire collection.
 */
 class Collection
 {

-public:
-       class Loader;
-
-private:
-       /* XXX I don't really like sticking all this stuff in here, but there's some
-          complex inter-class relationships, especially between ItemKeyword and
-          Collection::Loader. */
-
-       struct ItemBase
-       {
-               virtual ~ItemBase() { }
-       };
-
-       template<typename T>
-       struct Item: public ItemBase
-       {
-               T *data;
-
-               Item(T *d): data(d) { }
-               ~Item() { delete data; }
-       };
-
-       /**
-       Used to store keywords for types that can be loaded.
-       */
-       struct ItemKeywordBase
-       {
-               virtual ~ItemKeywordBase() { }
-               virtual void add_to_loader(Loader &) const { };
-       };
-
-       template<typename T, typename S, bool need_coll=NeedsCollection<typename T::Loader>::result>
-       struct ItemKeyword: public ItemKeywordBase
-       {
-               std::string keyword;
-
-               ItemKeyword(const std::string &kw): keyword(kw) { }
-
-               void add_to_loader(Loader &ldr) const
-               { ldr.add(keyword, &Loader::item<T, S>); }
-       };
-
-       template<typename T, typename S>
-       struct ItemKeyword<T, S, true>: public ItemKeywordBase
-       {
-               std::string keyword;
-
-               ItemKeyword(const std::string &kw): keyword(kw) { }
-
-               virtual void add_to_loader(Loader &ldr) const
-               { ldr.add(keyword, &Loader::coll_item<T, S, typename T::Loader::Collection>); }
-       };
-
-       /**
-       Used to store types that can be created automatically.
-       */
-       struct ItemCreatorBase
-       {
-               virtual ~ItemCreatorBase() { }
-
-               template<typename S>
-               bool create(Collection &coll, const std::string &name, S *&ptr)
-               {
-                       ItemCreatorBridge<S> *creator=dynamic_cast<ItemCreatorBridge<S> *>(this);
-                       if(creator)
-                       {
-                               ptr=creator->create(coll, name);
-                               return true;
-                       }
-                       return false;
-               }
-       };
-
-       template<typename S>
-       struct ItemCreatorBridge: public ItemCreatorBase
-       {
-               virtual S *create(Collection &, const std::string &) const = 0;
-       };
-
-       template<typename T, typename S, typename C>
-       struct ItemCreator: public ItemCreatorBridge<S>
-       {
-               typedef T *(C::*fCreate)(const std::string &);
-
-               fCreate create_func;
-
-               ItemCreator(fCreate cf): create_func(cf) { }
-               virtual S *create(Collection &coll, const std::string &name) const
-               { return (dynamic_cast<C &>(coll).*create_func)(name); }
-       };
-

 public:
        /**
        Loads objects into a Collection.
        */
        class Loader: public DataFile::Loader
        {
 public:
        /**
        Loads objects into a Collection.
        */
        class Loader: public DataFile::Loader
        {

+               template<typename T> friend class CollectionItemType;
+

        private:
        private:

+               template<typename T, typename S, bool = NeedsCollection<T>::value >
+               struct Add;
+

                Collection &coll;
 
        public:
                Collection &coll;
 
        public:


@@ -158,13 +77,11 @@ public:
        };
 
 private:
        };
 
 private:

-       typedef std::map<std::string, ItemBase *> ItemMap;
-       typedef std::list<ItemKeywordBase *> ItemKeywordSeq;
-       typedef std::list<ItemCreatorBase *> ItemCreatorSeq;
+       typedef std::map<std::string, Variant> ItemMap;
+       typedef std::list<CollectionItemTypeBase *> TypeList;

 
 

+       TypeList types;

        ItemMap items;
        ItemMap items;

-       ItemKeywordSeq keywords;
-       ItemCreatorSeq creators;

 
        Collection(const Collection &);
        Collection &operator=(const Collection &);
 
        Collection(const Collection &);
        Collection &operator=(const Collection &);


@@ -177,30 +94,33 @@ public:
        exception is thrown.  The collection takes ownership of the object.
        */
        template<typename T>
        exception is thrown.  The collection takes ownership of the object.
        */
        template<typename T>

-       void add(const std::string &name, T *d)
+       void add(const std::string &name, T *item)

        {
        {

-               typedef typename RemoveConst<T>::Type NCT;
+               if(!item)
+                       throw std::invalid_argument("Collection::add(item)");

 
 

-               RefPtr<Item<NCT> > i=new Item<NCT>(d);
-               insert_unique(items, i.get());
-               i.release();
+               RefPtr<typename RemoveConst<T>::Type> ptr(item);
+               try
+               {
+                       insert_unique(items, name, ptr);
+               }
+               catch(...)
+               {
+                       // Avoid deleting the object
+                       ptr.release();
+                       throw;
+               }

        }
 
        /**
        Gets an object of a specific type from the collection.
        */
        template<typename T>
        }
 
        /**
        Gets an object of a specific type from the collection.
        */
        template<typename T>

-       T *get(const std::string &name) const
+       T &get(const std::string &name) const

        {
                typedef typename RemoveConst<T>::Type NCT;
 
        {
                typedef typename RemoveConst<T>::Type NCT;
 

-               ItemBase *i=get_item(items, name);
-
-               const Item<NCT> *item=dynamic_cast<const Item<NCT> *>(i);
-               if(!item)
-                       throw TypeError("Type mismatch on item '"+name+"'");
-
-               return item->data;
+               return *get_item(items, name).value<RefPtr<NCT> >();

        }
 
        /**
        }
 
        /**


@@ -209,32 +129,7 @@ public:
        invoked.
        */
        template<typename T>
        invoked.
        */
        template<typename T>

-       T *get(const std::string &name)
-       {
-               typedef typename RemoveConst<T>::Type NCT;
-
-               if(!items.count(name))
-               {
-                       for(ItemCreatorSeq::iterator j=creators.begin(); j!=creators.end(); ++j)
-                       {
-                               NCT *d=0;
-                               if((*j)->create(*this, name, d))
-                               {
-                                       // We already know that the item didn't exist yet
-                                       items[name]=new Item<NCT>(d);
-                                       return d;
-                               }
-                       }
-               }
-
-               ItemBase *i=get_item(items, name);
-
-               const Item<NCT> *item=dynamic_cast<const Item<NCT> *>(i);
-               if(!item)
-                       throw TypeError("Type mismatch on item '"+name+"'");
-
-               return item->data;
-       }
+       T &get(const std::string &);

 
        /**
        Returns a list of the names of objects of a specific type in the collection.
 
        /**
        Returns a list of the names of objects of a specific type in the collection.


@@ -244,7 +139,7 @@ public:
        {
                std::list<std::string> result;
                for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i)
        {
                std::list<std::string> result;
                for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i)

-                       if(dynamic_cast<const Item<typename RemoveConst<T>::Type> *>(i->second))
+                       if(i->second.check_type<RefPtr<typename RemoveConst<T>::Type> >())

                                result.push_back(i->first);
                return result;
        }
                                result.push_back(i->first);
                return result;
        }


@@ -255,12 +150,12 @@ public:
        template<typename T>
        std::list<T *> get_list() const
        {
        template<typename T>
        std::list<T *> get_list() const
        {

-               typedef typename RemoveConst<T>::Type NCT;
+               typedef RefPtr<typename RemoveConst<T>::Type> RPNCT;

 
                std::list<T *> result;
                for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i)
 
                std::list<T *> result;
                for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i)

-                       if(Item<NCT> *item=dynamic_cast<Item<NCT> *>(i->second))
-                               result.push_back(item->data);
+                       if(i->second.check_type<RPNCT>())
+                               result.push_back(i->second.value<RPNCT>().get());

                return result;
        }
 
                return result;
        }
 


@@ -276,43 +171,204 @@ public:
        template<typename T>
        const std::string &get_name(T *d) const
        {
        template<typename T>
        const std::string &get_name(T *d) const
        {

-               typedef typename RemoveConst<T>::Type NCT;
+               typedef RefPtr<typename RemoveConst<T>::Type> RPNCT;

 
                for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i)
 
                for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i)

-                       if(Item<NCT> *item=dynamic_cast<Item<NCT> *>(i->second))
-                               if(item->data==d)
+                       if(i->second.check_type<RPNCT>())
+                               if(i->second.value<RPNCT>().get()==d)

                                        return i->first;
        
                                        return i->first;
        

-               throw KeyError("Item not found in collection");
+               // XXX Need better exception class
+               throw std::runtime_error("Item not found in collection");

        }
 
 protected:
        }
 
 protected:

-       /**
-       Adds a type that can be loaded from datafiles.
-       */

        template<typename T>
        template<typename T>

-       void add_keyword(const std::string &keyword)
-       { add_keyword<T, T>(keyword); }
+       CollectionItemType<T> &add_type();
+};

 
 

-       /**
-       Adds a type that can be loaded from datafiles, with different storage type.
-       */
-       template<typename T, typename S>
-       void add_keyword(const std::string &keyword)
-       { keywords.push_back(new ItemKeyword<T, S>(keyword)); }

 
 

-       /**
-       Adds a type that can be created automatically.
-       */
-       template<typename T, typename C>
-       void add_creator(T *(C::*func)(const std::string &))
-       { add_creator<T, T, C>(func); }
+template<typename T, typename S>
+struct Collection::Loader::Add<T, S, false>
+{
+       static void add(Loader &loader, const std::string &kwd)
+       { loader.add(kwd, &Loader::item<T, S>); }
+};
+
+template<typename T, typename S>
+struct Collection::Loader::Add<T, S, true>
+{
+       static void add(Loader &loader, const std::string &kwd)
+       { loader.add(kwd, &Loader::coll_item<T, S, typename T::Loader::Collection>); }
+};
+
+
+class CollectionItemTypeBase
+{
+protected:
+       class TagBase
+       {
+       protected:
+               TagBase() { }
+       public:
+               virtual ~TagBase() { }
+       };
+
+       template<typename T>
+       class Tag: public TagBase
+       {
+       public:
+               virtual ~Tag() { }
+       };
+
+       std::string kwd;
+       TagBase *tag;
+
+       CollectionItemTypeBase(): tag(0) { }
+public:
+       virtual ~CollectionItemTypeBase()
+       { delete tag; }
+
+       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;
+
+       template<typename T>
+       bool check_type() const
+       { return dynamic_cast<Tag<T> *>(tag); }
+};
+
+
+template<typename T>
+class CollectionItemType: public CollectionItemTypeBase
+{
+private:
+       class CreatorBase
+       {
+       protected:
+               CreatorBase() { }
+       public:
+               virtual ~CreatorBase() { }
+
+               virtual T *create(Collection &, const std::string &) const = 0;
+       };
+
+       template<typename C>
+       class Creator: public CreatorBase
+       {
+       public:
+               typedef T *(C::*FuncPtr)(const std::string &);
+
+       private:
+               FuncPtr func;
+
+       public:
+               Creator(FuncPtr f): func(f) { }
+
+               virtual T *create(Collection &coll, const std::string &name) const
+               { return (static_cast<C &>(coll).*func)(name); }
+       };
+
+       class StoreBase
+       {
+       protected:
+               StoreBase() { }
+       public:
+               virtual ~StoreBase() { }
+
+               virtual void store(Collection &, const std::string &, T *) = 0;
+
+               virtual void add_to_loader(Collection::Loader &, const std::string &) = 0;
+       };
+
+       template<typename S>
+       class Store: public StoreBase
+       {
+       public:
+               virtual void store(Collection &coll, const std::string &name, T *obj)
+               { coll.add(name, static_cast<S *>(obj)); }
+
+               virtual void add_to_loader(Collection::Loader &loader, const std::string &kwd)
+               { Collection::Loader::Add<T, S>::add(loader, kwd); }
+       };
+
+       CreatorBase *creator;
+       StoreBase *store;

 
 

-       template<typename T, typename S, typename C>
-       void add_creator(T *(C::*func)(const std::string &))
-       { creators.push_back(new ItemCreator<T, S, C>(func)); }
+public:
+       CollectionItemType():
+               creator(0), store(new Store<T>)
+       { tag = new Tag<T>; }
+
+       ~CollectionItemType()
+       {
+               delete creator;
+               delete store;
+       }
+
+       CollectionItemType &keyword(const std::string &k)
+       {
+               kwd = k;
+               return *this;
+       }
+
+       template<typename C>
+       CollectionItemType &create(T *(C::*func)(const std::string &))
+       {
+               delete creator;
+               creator = new Creator<C>(func);
+               return *this;
+       }
+
+       template<typename S>
+       CollectionItemType &store_as()
+       {
+               delete tag;
+               tag = new Tag<S>;
+               delete store;
+               store = new Store<S>;
+               return *this;
+       }
+
+       virtual void add_to_loader(Collection::Loader &loader) const
+       { store->add_to_loader(loader, kwd); }
+
+       virtual bool can_create() const
+       { return creator!=0; }
+
+       virtual void create_item(Collection &coll, const std::string &name) const
+       {
+               if(!creator)
+                       throw std::runtime_error("no creator");
+               T *obj = creator->create(coll, name);
+               store->store(coll, name, obj);
+       }

 };
 
 };
 

+
+template<typename T>
+T &Collection::get(const std::string &name)
+{
+       typedef typename RemoveConst<T>::Type NCT;
+
+       if(!items.count(name))
+       {
+               for(TypeList::iterator i=types.begin(); i!=types.end(); ++i)
+                       if((*i)->can_create() && (*i)->check_type<NCT>())
+                               (*i)->create_item(*this, name);
+       }
+
+       return *get_item(items, name).value<RefPtr<NCT> >();
+}
+
+template<typename T>
+CollectionItemType<T> &Collection::add_type()
+{
+       CollectionItemType<T> *type = new CollectionItemType<T>;
+       types.push_back(type);
+       return *type;
+}
+

 } // namespace DataFile
 } // namespace Msp
 
 } // namespace DataFile
 } // namespace Msp