X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcollection.h;h=c83b4376d20b2b6d4854b29dfc0fbda9c0c286b5;hb=348a6d9ca1a9b3838ff8c6da5050f61b2c74d010;hp=021b714a934e05dbb190dd4b2b473f1607b160e6;hpb=4931b4867258d1d2c20bad7ec24dfe4b99646aa1;p=libs%2Fdatafile.git diff --git a/source/collection.h b/source/collection.h index 021b714..c83b437 100644 --- a/source/collection.h +++ b/source/collection.h @@ -34,48 +34,48 @@ 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. + +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 { public: /** - Loads objects into a Collection. + Loads objects into a Collection. Automatically picks up keywords from + defined item types. */ class Loader: public DataFile::Loader { template friend class CollectionItemType; private: - template::value> - struct Add; - Collection &coll; public: Loader(Collection &); Collection &get_object() const { return coll; } private: - template - void coll_item(const std::string &n) - { - RefPtr it=new T; - load_sub(*it, dynamic_cast(coll)); - coll.add(n, it.get()); - it.release(); - } - template void item(const std::string &n) { - RefPtr it=new T; - load_sub(*it); + RefPtr it = new T; + ItemLoader ldr(*it, coll); + load_sub_with(ldr); coll.add(n, it.get()); it.release(); } - - template friend class ItemKeyword; }; +protected: + template::value> + class ItemLoader; + private: typedef std::map ItemMap; typedef std::list TypeList; @@ -89,85 +89,167 @@ public: Collection() { } virtual ~Collection(); - /** - Adds an object into the collection. If a name collision occurs, an - exception is thrown. The collection takes ownership of the object. - */ + /** Adds an object into the collection. The name must not pre-exist. The + collection takes ownership of the object. */ template void add(const std::string &name, T *item) { 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))); } - /** - Gets an object of a specific type from the collection. - */ +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); + } + + /** 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 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 >().get(); + if(!ptr) + throw key_error(typeid(ItemMap)); + return *ptr; } - /** - Gets an object of a specific type from the collection. If the name is not - found in the collection and there is a creator for the item type, it is - invoked. - */ + /** Gets a typed object from the collection. If the name is not found in + and a creator for the item type is defined, it is invoked. */ template T &get(const std::string &); - /** - Returns a list of the names of objects of a specific type in the collection. - */ +private: + template + void collect_items(std::list *objects, std::list *names, std::list *future_names) const + { + 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 objects of a specific type in the collection. - */ + /** 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 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 name exists in the collection. Does not care about the - type of the object. - */ - bool contains(const std::string &n) const; +private: + template + unsigned get_status(const std::string &name) const + { + ItemMap::const_iterator i = items.find(name); + if(i==items.end()) + return false; - /** - Returns the name of an item in the collection. - */ + 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 { @@ -183,23 +265,28 @@ public: } protected: + /** Adds a type to the collection. The returned descriptor object reference + can be used to define how objects of that type can be loaded. */ template CollectionItemType &add_type(); }; - -template -struct Collection::Loader::Add +template +class Collection::ItemLoader: public T::Loader { - static void add(Loader &loader, const std::string &kwd) - { loader.add(kwd, &Loader::item); } +public: + ItemLoader(T &o, Collection &): + T::Loader(o) + { } }; -template -struct Collection::Loader::Add +template +class Collection::ItemLoader: public T::Loader { - static void add(Loader &loader, const std::string &kwd) - { loader.add(kwd, &Loader::coll_item); } +public: + ItemLoader(T &o, Collection &c): + T::Loader(o, dynamic_cast(c)) + { } }; @@ -216,22 +303,24 @@ protected: template class Tag: public TagBase - { - public: - virtual ~Tag() { } - }; + { }; std::string kwd; + std::vector suffixes; TagBase *tag; - CollectionItemTypeBase(): tag(0) { } + CollectionItemTypeBase(); public: - virtual ~CollectionItemTypeBase() - { delete tag; } + 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 bool check_type() const @@ -239,6 +328,10 @@ public: }; +/** +Describes a type of item that can be loaded by a Collection. These are created +by Collection::add_type. +*/ template class CollectionItemType: public CollectionItemTypeBase { @@ -277,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; }; @@ -288,8 +382,11 @@ private: virtual void store(Collection &coll, const std::string &name, T *obj) { coll.add(name, static_cast(obj)); } + virtual Variant create_future() const + { return RefPtr(0); } + virtual void add_to_loader(Collection::Loader &loader, const std::string &kwd) - { Collection::Loader::Add::add(loader, kwd); } + { loader.add(kwd, &Collection::Loader::item); } }; CreatorBase *creat; @@ -306,12 +403,31 @@ public: delete store; } + /** Sets a datafile keyword for this item type. The Collection's loader + will accept a statement with this keyword and a single string argument - the + 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; + } + + /** Attaches a creator function to this item type. If an item is not found + in the Collection, the creator function for its type is called to create it. + The function must be a member of the Collection subclass containing the + type. It must return the created object, or null if it could not be + created. It's also permissible to load the item via other means and then + return null. */ template CollectionItemType &creator(T *(C::*func)(const std::string &)) { @@ -320,6 +436,8 @@ public: return *this; } + /** Specifies the storage type for items of this type. It must be a base + class of the actual type. */ template CollectionItemType &store_as() { @@ -341,8 +459,12 @@ public: if(!creat) throw std::runtime_error("no creator"); T *obj = creat->create(coll, name); - store->store(coll, name, obj); + if(obj) + store->store(coll, name, obj); } + + virtual Variant create_future() const + { return store->create_future(); } }; @@ -351,14 +473,22 @@ 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; } - return *get_item(items, name).value >(); + for(TypeList::iterator j=types.begin(); j!=types.end(); ++j) + if((*j)->can_create() && (*j)->check_type()) + (*j)->create_item(*this, name); + + NCT *ptr = get_item(items, name).value >().get(); + if(!ptr) + throw key_error(typeid(ItemMap)); + return *ptr; } template