1 #ifndef MSP_DATAFILE_COLLECTION_H_
2 #define MSP_DATAFILE_COLLECTION_H_
5 #include <msp/core/attributes.h>
6 #include <msp/core/maputils.h>
7 #include <msp/core/noncopyable.h>
8 #include <msp/core/refptr.h>
9 #include "collectionsource.h"
13 /* XXX This file is a big mess with too many things in it. However, the
14 dependencies between those things make it difficult to split up. */
19 class CollectionItemTypeBase;
22 class CollectionItemType;
25 class LoadableCollectionItemType;
27 template<typename T, bool = HasLoader<T>::value>
28 struct CollectionItemTypeChooser;
31 struct CollectionItemTypeChooser<T, true>
32 { typedef LoadableCollectionItemType<T> Type; };
35 struct CollectionItemTypeChooser<T, false>
36 { typedef CollectionItemType<T> Type; };
39 A collection of objects that can be loaded from a datafile. Each object is
40 identified by a name, which must be unique across the entire collection.
42 While this class can be instantiated by itself and used for storing objects,
43 loading requires that a subclass defines the supported types. See the add_type
46 Collections can have sources for loading objects on demand. Automatic loading
47 only works on a non-const Collection. See class CollectionSource for details.
49 As a last resort, a fallback collection can be designated for loading items
50 that are not present. Items retrieted from the fallback collection are shared
51 between the collections, and are only deleted when all collections in the chain
54 class Collection: private NonCopyable
58 Loads objects into a Collection. Automatically picks up keywords from
61 class Loader: public DataFile::Loader
63 template<typename T> friend class LoadableCollectionItemType;
70 Collection &get_object() const { return coll; }
72 template<typename T, typename S>
73 void item(const std::string &n)
76 ItemLoader<T> ldr(*it, coll);
78 coll.add<S>(n, it.get());
83 template<typename T, bool = NeedsCollection<typename T::Loader>::value>
87 typedef std::map<std::string, Variant> ItemMap;
89 std::vector<CollectionItemTypeBase *> types;
91 std::vector<const CollectionSource *> sources;
92 Collection *fallback = nullptr;
95 virtual ~Collection();
97 /** Adds an object into the collection. The name must not pre-exist. The
98 collection takes ownership of the object. */
100 void add(const std::string &name, T *item)
103 throw std::invalid_argument("Collection::add(item)");
105 typedef typename std::remove_cv<T>::type NCT;
106 RefPtr<NCT> ptr(item);
109 add_var(name, get_type<NCT>(name), ptr);
113 // Avoid deleting the object
119 /// Gets a typed object from the collection.
121 T &get(const std::string &name) const
123 return extract<typename std::remove_cv<T>::type>(get_item(items, name));
126 /** Gets a typed object from the collection. If the name is not found,
127 automatic creation with the type's creator function (if defined) or from
128 sources (if present) is attempted. */
130 T &get(const std::string &name)
132 typedef typename std::remove_cv<T>::type NCT;
133 return extract<NCT>(get_var(name, get_type<NCT>(name)));
136 /** Finds a typed object in the collection. Returns null if the name does
137 not exist. Throws if the name exists but the object is of an incorrect
140 T *find(const std::string &name) const
142 ItemMap::const_iterator i = items.find(name);
143 return (i!=items.end() ? extract<typename std::remove_cv<T>::type>(i->second) : 0);
147 T *find(const std::string &name)
149 typedef typename std::remove_cv<T>::type NCT;
150 const Variant *var = find_var(name, get_type<NCT>(name));
151 return (var ? &extract<NCT>(*var) : 0);
155 void add_var(const std::string &, const CollectionItemTypeBase *, const Variant &);
156 const Variant &get_var(const std::string &, const CollectionItemTypeBase *);
157 const Variant *find_var(const std::string &, const CollectionItemTypeBase *);
160 T &extract(const Variant &var) const;
163 std::list<T *> extract_list(const std::vector<const Variant *> &vars) const
165 std::list<T *> result;
166 for(const Variant *v: vars)
167 result.push_back(&extract<T>(*v));
171 void gather_items(std::vector<const Variant *> *, std::list<std::string> *, const CollectionItemTypeBase &, bool) const;
174 void gather_items(std::vector<const Variant *> *vars, std::list<std::string> *names, const CollectionItemTypeBase *type, bool include_sources) const
176 if(type || (type = get_type<T>()))
177 gather_items(vars, names, *type, include_sources);
179 gather_items(vars, names, CollectionItemType<T>(), false);
183 /// Returns a list of the names of objects of one type in the collection.
185 std::list<std::string> get_names() const
187 std::list<std::string> names;
188 gather_items<typename std::remove_cv<T>::type>(0, &names, 0, false);
192 /** Returns a list of the names of objects of one type in the collection or
193 available from sources. */
195 std::list<std::string> get_names()
197 std::list<std::string> names;
198 gather_items<typename std::remove_cv<T>::type>(0, &names, 0, true);
202 /// Returns a list of objects of one type in the collection.
204 std::list<T *> get_list() const
206 std::vector<const Variant *> vars;
207 gather_items<typename std::remove_cv<T>::type>(&vars, 0, 0, false);
208 return extract_list<T>(vars);
211 /** Returns a list of objects of one type, loading them from sources if
214 std::list<T *> get_list()
216 CollectionItemTypeBase *type = get_type<typename std::remove_cv<T>::type>();
218 load_items_from_sources(*type);
220 std::vector<const Variant *> vars;
221 gather_items<typename std::remove_cv<T>::type>(&vars, 0, type, true);
222 return extract_list<T>(vars);
226 unsigned get_status(const std::string &, const CollectionItemTypeBase &) const;
229 unsigned get_status(const std::string &name) const
231 // XXX Should go through all applicable types
232 if(CollectionItemTypeBase *type = get_type<T>())
233 return get_status(name, *type);
235 ItemMap::const_iterator i = items.find(name);
236 return (i!=items.end() && i->second.check_type<RefPtr<T> >());
240 /// Checks whether a typed object exists in the collection.
242 bool contains(const std::string &name) const
243 { return get_status<typename std::remove_cv<T>::type>(name)==1; }
245 /** Checks whether a typed object exists in the collection or is loadable
248 bool contains(const std::string &name)
249 { return get_status<typename std::remove_cv<T>::type>(name)>0; }
251 /// Returns the name of an item in the collection.
253 const std::string &get_name(T *d) const
255 typedef RefPtr<typename std::remove_cv<T>::type> RPNCT;
257 for(const auto &kvp: items)
258 if(kvp.second.check_type<RPNCT>())
259 if(kvp.second.value<RPNCT>().get()==d)
262 // XXX Need better exception class
263 throw std::runtime_error("Item not found in collection");
267 /** Adds a type to the collection. The returned descriptor object reference
268 can be used to define how objects of that type can be loaded. */
270 typename CollectionItemTypeChooser<T>::Type &add_type();
272 /** Returns a mutable reference to an existing type descriptor. This can be
273 used to e.g. override the creator function of a type added by a base class. */
275 typename CollectionItemTypeChooser<T>::Type &modify_type();
278 /** Returns the descriptor for a type, or null if one isn't defined. An
279 optional name can be given to prioritize matching types. */
281 CollectionItemTypeBase *get_type(const std::string & = std::string()) const;
283 /// Gets a descriptor with the same type as another descriptor.
284 CollectionItemTypeBase *get_type(const CollectionItemTypeBase &) const;
286 /// Returns the descriptor for an item, or null if it's of an unknown type.
287 CollectionItemTypeBase *get_type_for_item(const Variant &) const;
290 /** Adds a source for automatically loading items. Sources are consulted
291 in the order they are added. */
292 void add_source(const CollectionSource &);
295 /** Opens a raw resource, without interpreting it as object data. Null is
296 returned if no such file is found. The caller must dispose of the returned
297 object when done with it. */
298 IO::Seekable *open_raw(const std::string &) const;
301 void gather_names_from_sources(std::list<std::string> &, const CollectionItemTypeBase &) const;
303 void load_items_from_sources(const CollectionItemTypeBase &);
306 /** Sets a fallback collection, which will be consulted if an item is not
308 void set_fallback(Collection *);
310 Collection *get_fallback() const { return fallback; }
314 class Collection::ItemLoader<T, false>: public T::Loader
317 ItemLoader(T &o, Collection &):
323 class Collection::ItemLoader<T, true>: public T::Loader
326 ItemLoader(T &o, Collection &c):
327 T::Loader(o, dynamic_cast<typename T::Loader::Collection &>(c))
332 class CollectionItemTypeBase
337 virtual ~ExtractorBase() = default;
341 struct Extractor: ExtractorBase
343 virtual T &extract(const Variant &) const = 0;
347 std::vector<std::string> suffixes;
348 std::vector<ExtractorBase *> extractors;
350 CollectionItemTypeBase() = default;
352 virtual ~CollectionItemTypeBase();
355 void set_keyword(const std::string &);
356 void add_suffix(const std::string &);
358 const std::string &get_keyword() const { return kwd; }
359 bool match_name(const std::string &) const;
360 virtual bool is_same_type(const CollectionItemTypeBase &) const = 0;
361 virtual bool check_item_type(const Variant &) const = 0;
362 virtual void add_to_loader(Collection::Loader &) const = 0;
363 virtual bool can_create() const = 0;
364 virtual void create_item(Collection &, const std::string &) const = 0;
365 virtual void load_item(Collection &, Parser &, const std::string &) const = 0;
366 virtual void notify_item(const std::string &, const Variant &) const = 0;
369 bool can_extract() const
371 for(ExtractorBase *e: extractors)
372 if(dynamic_cast<Extractor<T> *>(e))
378 T *extract(const Variant &var) const
380 for(ExtractorBase *e: extractors)
381 if(Extractor<T> *ex = dynamic_cast<Extractor<T> *>(e))
382 return &ex->extract(var);
389 Describes a type of item that can be loaded by a Collection. These are created
390 by Collection::add_type.
393 class CollectionItemType: public CollectionItemTypeBase
397 struct Extractor: CollectionItemTypeBase::Extractor<B>
399 B &extract(const Variant &var) const override
400 { return *var.value<RefPtr<T> >(); }
403 std::function<T *(const std::string &)> create_func;
404 std::vector<std::function<void(const std::string &, T &)>> notify_funcs;
407 /** Sets a datafile keyword for this item type. The Collection's loader
408 will accept a statement with this keyword and a single string argument - the
410 CollectionItemType &keyword(const std::string &k)
416 /** Adds a suffix that is used to match names when looking for loadable
417 objects. There is no implied separator; a name matches if it ends with the
418 suffix. If a keyword is defined before any suffixes, then "."+keyword is
419 added as a suffix. */
420 CollectionItemType &suffix(const std::string &s)
426 /** Attaches a creator function to this item type. If an item is not found
427 in the Collection, the creator function for its type is called to create it.
428 The function must be a member of the Collection subclass containing the
429 type. It must return the created object, or null if it could not be
430 created. It's also permissible to load the item via other means and then
433 CollectionItemType &creator(F func)
439 /** Makes items of this type available through a base class. */
441 CollectionItemType &base()
443 extractors.push_back(new Extractor<B>);
448 CollectionItemType ¬ify(F func)
450 notify_funcs.emplace_back(func);
454 bool is_same_type(const CollectionItemTypeBase &other) const override
455 { return dynamic_cast<const CollectionItemType<T> *>(&other); }
457 bool check_item_type(const Variant &var) const override
458 { return var.check_type<RefPtr<T> >(); }
460 void add_to_loader(Collection::Loader &) const override
463 bool can_create() const override
464 { return static_cast<bool>(create_func); }
466 void create_item(Collection &coll, const std::string &name) const override
469 throw std::runtime_error("no creator");
470 T *obj = create_func(name);
475 void load_item(Collection &, Parser &, const std::string &) const override
477 throw std::runtime_error("this type cannot be loaded");
480 void notify_item(const std::string &name, const Variant &var) const override
482 RefPtr<T> obj = var.value<RefPtr<T> >();
483 for(const auto &n: notify_funcs)
490 class LoadableCollectionItemType: public CollectionItemType<T>
493 void add_to_loader(Collection::Loader &loader) const override
494 { loader.add(this->kwd, &Collection::Loader::item<T, T>); }
496 void load_item(Collection &coll, Parser &parser, const std::string &name) const override
498 RefPtr<T> obj = new T;
499 Collection::ItemLoader<T> ldr(*obj, coll);
501 coll.add(name, obj.get());
508 T &Collection::extract(const Variant &var) const
510 if(!var.check_type<RefPtr<T> >())
511 if(CollectionItemTypeBase *type = get_type_for_item(var))
512 if(T *item = type->extract<T>(var))
515 return *var.value<RefPtr<T> >();
519 typename CollectionItemTypeChooser<T>::Type &Collection::add_type()
521 typename CollectionItemTypeChooser<T>::Type *type = new typename CollectionItemTypeChooser<T>::Type;
522 types.push_back(type);
527 typename CollectionItemTypeChooser<T>::Type &Collection::modify_type()
529 for(CollectionItemTypeBase *t: types)
530 if(CollectionItemType<T> *tt = dynamic_cast<CollectionItemType<T> *>(t))
533 throw std::logic_error("type not found in collection");
537 CollectionItemTypeBase *Collection::get_type(const std::string &name) const
539 for(CollectionItemTypeBase *t: types)
540 if(dynamic_cast<CollectionItemType<T> *>(t))
542 CollectionItemTypeBase *type = nullptr;
543 for(CollectionItemTypeBase *t: types)
544 if(t->can_extract<T>())
546 if(!name.empty() && t->match_name(name))
553 } // namespace DataFile