X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcollection.h;h=be9ae88c491595f925db46e30aeff2daa67deb5f;hb=698d4ae13da87b7c53aa96bca99c3deaff397eec;hp=e7d173d061ed7947750702d8fe1681cd2e44bcb5;hpb=1d9c21a8a301007fb242e05b69cc6390ec566273;p=libs%2Fdatafile.git diff --git a/source/collection.h b/source/collection.h index e7d173d..be9ae88 100644 --- a/source/collection.h +++ b/source/collection.h @@ -1,17 +1,15 @@ -/* $Id$ - -This file is part of libmspdatafile -Copyright © 2006 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - #ifndef MSP_DATAFILE_COLLECTION_H_ #define MSP_DATAFILE_COLLECTION_H_ +#include +#include #include -#include "item.h" +#include "collectionsource.h" #include "loader.h" +/* XXX This file is a big mess with too many things in it. However, the +dependencies between those things make it difficult to split up. */ + namespace Msp { namespace DataFile { @@ -29,252 +27,457 @@ struct NeedsCollection template static No f(...); - enum { result=(sizeof(f(0))==sizeof(Yes)) }; + enum { value = (sizeof(f(0))==sizeof(Yes)) }; }; +class CollectionItemTypeBase; + +template +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 can have sources for loading objects on demand. Automatic loading +only works on a non-const Collection. See class CollectionSource for details. */ class Collection { public: - class Loader; + /** + Loads objects into a Collection. Automatically picks up keywords from + defined item types. + */ + class Loader: public DataFile::Loader + { + template friend class CollectionItemType; -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. */ + private: + Collection &coll; - struct ItemBase - { - virtual ~ItemBase() { } + public: + Loader(Collection &); + Collection &get_object() const { return coll; } + private: + template + void item(const std::string &n) + { + RefPtr it = new T; + ItemLoader ldr(*it, coll); + load_sub_with(ldr); + coll.add(n, it.get()); + it.release(); + } }; +protected: + template::value> + class ItemLoader; + +private: + typedef std::map ItemMap; + typedef std::list TypeList; + typedef std::list SourceList; + + TypeList types; + ItemMap items; + SourceList sources; + + Collection(const Collection &); + Collection &operator=(const Collection &); +public: + Collection() { } + virtual ~Collection(); + + /** Adds an object into the collection. The name must not pre-exist. The + collection takes ownership of the object. */ template - struct Item: public ItemBase + void add(const std::string &name, T *item) { - T *data; + if(!item) + throw std::invalid_argument("Collection::add(item)"); - Item(T *d): data(d) { } - ~Item() { delete data; } - }; + insert_unique(items, name, RefPtr::Type>(item)); + } - /** - Used to store keywords for types that can be loaded. - */ - struct ItemKeywordBase + /// Gets a typed object from the collection. + template + T &get(const std::string &name) const { - virtual void add_to_loader(Loader &) const { }; - }; + return extract(get_item(items, name)); + } - template::result> - struct ItemKeyword: public ItemKeywordBase + /** Gets a typed object from the collection. If the name is not found, + automatic creation with the type's creator function (if defined) or from + sources (if present) is attempted. */ + template + T &get(const std::string &name) { - std::string keyword; + return extract(get_var(name, get_type())); + } - ItemKeyword(const std::string &kw): keyword(kw) { } +private: + const Variant &get_var(const std::string &, const CollectionItemTypeBase *); - void add_to_loader(Loader &ldr) const - { ldr.add(keyword, &Loader::item); } - }; + template + T &extract(const Variant &var) const + { + return *var.value::Type> >(); + } + + 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()) + { + if(objects) + objects->push_back(i->second.value().get()); + if(names) + names->push_back(i->first); + } + + if(future_names) + if(CollectionItemTypeBase *type = get_type()) + { + for(SourceList::const_iterator i=sources.begin(); i!=sources.end(); ++i) + { + std::list available_names = (*i)->get_names(*type); + for(std::list::iterator j=available_names.begin(); j!=available_names.end(); ++j) + if(!items.count(*j)) + future_names->push_back(*j); + } + } + } - template - struct ItemKeyword: public ItemKeywordBase +public: + /// Returns a list of the names of objects of one type in the collection. + template + std::list get_names() const { - std::string keyword; + std::list result; + collect_items(0, &result, 0); + return result; + } - ItemKeyword(const std::string &kw): keyword(kw) { } + /** Returns a list of the names of objects of one type in the collection or + available from sources. */ + template + std::list get_names() + { + std::list result; + collect_items(0, &result, &result); + return result; + } - virtual void add_to_loader(Loader &ldr) const - { ldr.add(keyword, &Loader::coll_item); } - }; + /// Returns a list of objects of one type in the collection. + template + std::list get_list() const + { + std::list result; + collect_items(&result, 0, 0); + return result; + } - /** - Used to store types that can be created automatically. - */ - struct ItemCreatorBase + /** Returns a list of objects of one type, loading them from sources if + necessary. */ + template + std::list get_list() { - virtual ~ItemCreatorBase() { } + std::list result; + 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; + } - template - S *create(Collection &coll, const std::string &name) +private: + template + unsigned get_status(const std::string &name) const + { + ItemMap::const_iterator i = items.find(name); + if(i==items.end()) { - ItemCreatorBridge *creator=dynamic_cast *>(this); - if(creator) - return creator->create(coll, name); + if(CollectionItemTypeBase *type = get_type()) + { + for(SourceList::const_iterator j=sources.begin(); j!=sources.end(); ++j) + if((*j)->is_loadable(*type, name)) + return 2; + } return 0; } - }; - template - struct ItemCreatorBridge: public ItemCreatorBase - { - virtual S *create(Collection &, const std::string &) const =0; - }; + typedef RefPtr::Type> RPNCT; + if(!i->second.check_type()) + return 0; + + return 1; + } - template - struct ItemCreator: public ItemCreatorBridge +public: + /// Checks whether a typed object exists 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 or is loadable + from a source. */ + 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 { - typedef T *(C::*fCreate)(const std::string &); + typedef RefPtr::Type> RPNCT; + + for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) + if(i->second.check_type()) + if(i->second.value().get()==d) + return i->first; + + // XXX Need better exception class + throw std::runtime_error("Item not found in collection"); + } + +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(); + + /** Returns the descriptor for a type, or null if one isn't defined. */ + template + CollectionItemTypeBase *get_type() const; - fCreate create_func; + void add_source(CollectionSource &); +}; - ItemCreator(fCreate cf): create_func(cf) { } - virtual S *create(Collection &coll, const std::string &name) const - { return (dynamic_cast(coll).*create_func)(name); } +template +class Collection::ItemLoader: public T::Loader +{ +public: + ItemLoader(T &o, Collection &): + T::Loader(o) + { } +}; + +template +class Collection::ItemLoader: public T::Loader +{ +public: + ItemLoader(T &o, Collection &c): + T::Loader(o, dynamic_cast(c)) + { } +}; + + +class CollectionItemTypeBase +{ +protected: + class TagBase + { + protected: + TagBase() { } + public: + virtual ~TagBase() { } }; + template + class Tag: public TagBase + { }; + + std::string kwd; + std::vector suffixes; + TagBase *tag; + + CollectionItemTypeBase(); public: - /** - Loads objects into a Collection. - */ - class Loader: public DataFile::Loader + 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 void load_item(Collection &, Parser &, const std::string &) const = 0; + + template + bool check_type() const + { return dynamic_cast *>(tag); } +}; + + +/** +Describes a type of item that can be loaded by a Collection. These are created +by Collection::add_type. +*/ +template +class CollectionItemType: public CollectionItemTypeBase +{ +private: + class CreatorBase { - private: - Collection &coll; + protected: + CreatorBase() { } + public: + virtual ~CreatorBase() { } + virtual T *create(Collection &, const std::string &) const = 0; + }; + + template + class Creator: public CreatorBase + { public: - Loader(Collection &); - Collection &get_object() const { return coll; } + typedef T *(C::*FuncPtr)(const std::string &); + 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(); - } + FuncPtr func; - template - void item(const std::string &n) - { - RefPtr it=new T; - load_sub(*it); - coll.add(n, it.get()); - it.release(); - } + public: + Creator(FuncPtr f): func(f) { } - template friend class ItemKeyword; + virtual T *create(Collection &coll, const std::string &name) const + { return (static_cast(coll).*func)(name); } }; -private: - typedef std::map ItemMap; - typedef std::list ItemKeywordSeq; - typedef std::list ItemCreatorSeq; + class StoreBase + { + protected: + StoreBase() { } + public: + virtual ~StoreBase() { } - ItemMap items; - ItemKeywordSeq keywords; - ItemCreatorSeq creators; + virtual void store(Collection &, const std::string &, T *) = 0; -public: - virtual ~Collection(); + virtual void add_to_loader(Collection::Loader &, const std::string &) = 0; + }; - /** - Adds an object into the collection. If a name collision occurs, an - exception is thrown. The collection takes ownership of the object. - */ - template - void add(const std::string &name, T *d) + template + class Store: public StoreBase { - if(items.count(name)) - throw KeyError("Duplicate key '"+name+"' in collection"); + public: + virtual void store(Collection &coll, const std::string &name, T *obj) + { coll.add(name, static_cast(obj)); } - items[name]=new Item(d); - } + virtual void add_to_loader(Collection::Loader &loader, const std::string &kwd) + { loader.add(kwd, &Collection::Loader::item); } + }; - /** - Gets an object of a specific type from the collection. - */ - template - T &get(const std::string &name) const - { - ItemMap::const_iterator i=items.find(name); - if(i==items.end()) - throw KeyError("Item '"+name+"' not found in collection"); + CreatorBase *creat; + StoreBase *store; - const Item *item=dynamic_cast *>(i->second); - if(!item) - throw TypeError("Item '"+name+"' is not of correct type"); +public: + CollectionItemType(): + creat(0), store(new Store) + { tag = new Tag; } - return *item->data; + ~CollectionItemType() + { + delete creat; + delete store; } - /** - 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. - */ - template - T &get(const std::string &name) + /** 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) { - ItemMap::const_iterator i=items.find(name); - if(i==items.end()) - { - for(ItemCreatorSeq::iterator j=creators.begin(); j!=creators.end(); ++j) - if(T *d=(*j)->create(*this, name)) - { - // We already know that the item didn't exist yet - items[name]=new Item(d); - return *d; - } - throw KeyError("Item '"+name+"' not found in collection"); - } - - const Item *item=dynamic_cast *>(i->second); - if(!item) - throw TypeError("Item '"+name+"' is not of correct type"); + set_keyword(k); + return *this; + } - return *item->data; + /** 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; } - /** - Returns a list of the names of objects of a specific type in the collection. - */ - template - std::list get_names() const + /** 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 &)) { - std::list result; - for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i) - if(dynamic_cast *>(i->second)) - result.push_back(i->first); - return result; + delete creat; + creat = new Creator(func); + return *this; } - /** - Checks whether a name exists in the collection. Does not care about the - type of the object. - */ - bool contains(const std::string &n) const; + /** Specifies the storage type for items of this type. It must be a base + class of the actual type. */ + template + CollectionItemType &store_as() + { + delete tag; + tag = new Tag; + delete store; + store = new Store; + return *this; + } -protected: - /** - Adds a type that can be loaded from datafiles. - */ - template - void add_keyword(const std::string &keyword) - { add_keyword(keyword); } + virtual void add_to_loader(Collection::Loader &loader) const + { store->add_to_loader(loader, kwd); } - /** - Adds a type that can be loaded from datafiles, with different storage type. - */ - template - void add_keyword(const std::string &keyword) - { keywords.push_back(new ItemKeyword(keyword)); } + virtual bool can_create() const + { return creat!=0; } - /** - Adds a type that can be created automatically. - */ - template - void add_creator(T *(C::*func)(const std::string &)) - { add_creator(func); } + virtual void create_item(Collection &coll, const std::string &name) const + { + if(!creat) + throw std::runtime_error("no creator"); + T *obj = creat->create(coll, name); + if(obj) + store->store(coll, name, obj); + } - template - void add_creator(T *(C::*func)(const std::string &)) - { creators.push_back(new ItemCreator(func)); } + virtual void load_item(Collection &coll, Parser &parser, const std::string &name) const + { + RefPtr obj = new T; + Collection::ItemLoader ldr(*obj, coll); + ldr.load(parser); + store->store(coll, name, obj.get()); + obj.release(); + } }; + +template +CollectionItemType &Collection::add_type() +{ + CollectionItemType *type = new CollectionItemType; + types.push_back(type); + return *type; +} + +template +CollectionItemTypeBase *Collection::get_type() const +{ + for(TypeList::const_iterator j=types.begin(); j!=types.end(); ++j) + if((*j)->check_type::Type>()) + return *j; + return 0; +} + } // namespace DataFile } // namespace Msp