source/collection.h

   1 #ifndef MSP_DATAFILE_COLLECTION_H_
   2 #define MSP_DATAFILE_COLLECTION_H_
   3
   4 #include <type_traits>
   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"
  10 #include "loader.h"
  11 #include "meta.h"
  12
  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. */
  15
  16 namespace Msp {
  17 namespace DataFile {
  18
  19 class CollectionItemTypeBase;
  20
  21 template<typename T>
  22 class CollectionItemType;
  23
  24 template<typename T>
  25 class LoadableCollectionItemType;
  26
  27 template<typename T, bool = HasLoader<T>::value>
  28 struct CollectionItemTypeChooser;
  29
  30 template<typename T>
  31 struct CollectionItemTypeChooser<T, true>
  32 { typedef LoadableCollectionItemType<T> Type; };
  33
  34 template<typename T>
  35 struct CollectionItemTypeChooser<T, false>
  36 { typedef CollectionItemType<T> Type; };
  37
  38 /**
  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.
  41
  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
  44 method for details.
  45
  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.
  48
  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
  52 have been destroyed.
  53 */
  54 class Collection: private NonCopyable
  55 {
  56 public:
  57         /**
  58         Loads objects into a Collection.  Automatically picks up keywords from
  59         defined item types.
  60         */
  61         class Loader: public DataFile::Loader
  62         {
  63                 template<typename T> friend class LoadableCollectionItemType;
  64
  65         private:
  66                 Collection &coll;
  67
  68         public:
  69                 Loader(Collection &);
  70                 Collection &get_object() const { return coll; }
  71         private:
  72                 template<typename T, typename S>
  73                 void item(const std::string &n)
  74                 {
  75                         RefPtr<T> it = new T;
  76                         ItemLoader<T> ldr(*it, coll);
  77                         load_sub_with(ldr);
  78                         coll.add<S>(n, it.get());
  79                         it.release();
  80                 }
  81         };
  82
  83         template<typename T, bool = NeedsCollection<typename T::Loader>::value>
  84         class ItemLoader;
  85
  86 private:
  87         typedef std::map<std::string, Variant> ItemMap;
  88
  89         std::vector<CollectionItemTypeBase *> types;
  90         ItemMap items;
  91         std::vector<const CollectionSource *> sources;
  92         Collection *fallback;
  93
  94 public:
  95         Collection();
  96         virtual ~Collection();
  97
  98         /** Adds an object into the collection.  The name must not pre-exist.  The
  99         collection takes ownership of the object. */
 100         template<typename T>
 101         void add(const std::string &name, T *item)
 102         {
 103                 if(!item)
 104                         throw std::invalid_argument("Collection::add(item)");
 105
 106                 typedef typename std::remove_cv<T>::type NCT;
 107                 RefPtr<NCT> ptr(item);
 108                 try
 109                 {
 110                         add_var(name, get_type<NCT>(name), ptr);
 111                 }
 112                 catch(...)
 113                 {
 114                         // Avoid deleting the object
 115                         ptr.release();
 116                         throw;
 117                 }
 118         }
 119
 120         /// Gets a typed object from the collection.
 121         template<typename T>
 122         T &get(const std::string &name) const
 123         {
 124                 return extract<typename std::remove_cv<T>::type>(get_item(items, name));
 125         }
 126
 127         /** Gets a typed object from the collection.  If the name is not found,
 128         automatic creation with the type's creator function (if defined) or from
 129         sources (if present) is attempted. */
 130         template<typename T>
 131         T &get(const std::string &name)
 132         {
 133                 typedef typename std::remove_cv<T>::type NCT;
 134                 return extract<NCT>(get_var(name, get_type<NCT>(name)));
 135         }
 136
 137         /** Finds a typed object in the collection.  Returns null if the name does
 138         not exist.  Throws if the name exists but the object is of an incorrect
 139         type. */
 140         template<typename T>
 141         T *find(const std::string &name) const
 142         {
 143                 ItemMap::const_iterator i = items.find(name);
 144                 return (i!=items.end() ? extract<typename std::remove_cv<T>::type>(i->second) : 0);
 145         }
 146
 147         template<typename T>
 148         T *find(const std::string &name)
 149         {
 150                 typedef typename std::remove_cv<T>::type NCT;
 151                 const Variant *var = find_var(name, get_type<NCT>(name));
 152                 return (var ? &extract<NCT>(*var) : 0);
 153         }
 154
 155 private:
 156         void add_var(const std::string &, const CollectionItemTypeBase *, const Variant &);
 157         const Variant &get_var(const std::string &, const CollectionItemTypeBase *);
 158         const Variant *find_var(const std::string &, const CollectionItemTypeBase *);
 159
 160         template<typename T>
 161         T &extract(const Variant &var) const;
 162
 163         template<typename T>
 164         std::list<T *> extract_list(const std::vector<const Variant *> &vars) const
 165         {
 166                 std::list<T *> result;
 167                 for(const Variant *v: vars)
 168                         result.push_back(&extract<T>(*v));
 169                 return result;
 170         }
 171
 172         void gather_items(std::vector<const Variant *> *, std::list<std::string> *, const CollectionItemTypeBase &, bool) const;
 173
 174         template<typename T>
 175         void gather_items(std::vector<const Variant *> *vars, std::list<std::string> *names, const CollectionItemTypeBase *type, bool include_sources) const
 176         {
 177                 if(type || (type = get_type<T>()))
 178                         gather_items(vars, names, *type, include_sources);
 179                 else
 180                         gather_items(vars, names, CollectionItemType<T>(), false);
 181         }
 182
 183 public:
 184         /// Returns a list of the names of objects of one type in the collection.
 185         template<typename T>
 186         std::list<std::string> get_names() const
 187         {
 188                 std::list<std::string> names;
 189                 gather_items<typename std::remove_cv<T>::type>(0, &names, 0, false);
 190                 return names;
 191         }
 192
 193         /** Returns a list of the names of objects of one type in the collection or
 194         available from sources. */
 195         template<typename T>
 196         std::list<std::string> get_names()
 197         {
 198                 std::list<std::string> names;
 199                 gather_items<typename std::remove_cv<T>::type>(0, &names, 0, true);
 200                 return names;
 201         }
 202
 203         /// Returns a list of objects of one type in the collection.
 204         template<typename T>
 205         std::list<T *> get_list() const
 206         {
 207                 std::vector<const Variant *> vars;
 208                 gather_items<typename std::remove_cv<T>::type>(&vars, 0, 0, false);
 209                 return extract_list<T>(vars);
 210         }
 211
 212         /** Returns a list of objects of one type, loading them from sources if
 213         necessary. */
 214         template<typename T>
 215         std::list<T *> get_list()
 216         {
 217                 CollectionItemTypeBase *type = get_type<typename std::remove_cv<T>::type>();
 218                 if(type)
 219                         load_items_from_sources(*type);
 220
 221                 std::vector<const Variant *> vars;
 222                 gather_items<typename std::remove_cv<T>::type>(&vars, 0, type, true);
 223                 return extract_list<T>(vars);
 224         }
 225
 226 private:
 227         unsigned get_status(const std::string &, const CollectionItemTypeBase &) const;
 228
 229         template<typename T>
 230         unsigned get_status(const std::string &name) const
 231         {
 232                 // XXX Should go through all applicable types
 233                 if(CollectionItemTypeBase *type = get_type<T>())
 234                         return get_status(name, *type);
 235
 236                 ItemMap::const_iterator i = items.find(name);
 237                 return (i!=items.end() && i->second.check_type<RefPtr<T> >());
 238         }
 239
 240 public:
 241         /// Checks whether a typed object exists in the collection.
 242         template<typename T>
 243         bool contains(const std::string &name) const
 244         { return get_status<typename std::remove_cv<T>::type>(name)==1; }
 245
 246         /** Checks whether a typed object exists in the collection or is loadable
 247         from a source. */
 248         template<typename T>
 249         bool contains(const std::string &name)
 250         { return get_status<typename std::remove_cv<T>::type>(name)>0; }
 251
 252         /// Returns the name of an item in the collection.
 253         template<typename T>
 254         const std::string &get_name(T *d) const
 255         {
 256                 typedef RefPtr<typename std::remove_cv<T>::type> RPNCT;
 257
 258                 for(const auto &kvp: items)
 259                         if(kvp.second.check_type<RPNCT>())
 260                                 if(kvp.second.value<RPNCT>().get()==d)
 261                                         return kvp.first;
 262
 263                 // XXX Need better exception class
 264                 throw std::runtime_error("Item not found in collection");
 265         }
 266
 267 protected:
 268         /** Adds a type to the collection.  The returned descriptor object reference
 269         can be used to define how objects of that type can be loaded. */
 270         template<typename T>
 271         typename CollectionItemTypeChooser<T>::Type &add_type();
 272
 273         /** Returns a mutable reference to an existing type descriptor.  This can be
 274         used to e.g. override the creator function of a type added by a base class. */
 275         template<typename T>
 276         typename CollectionItemTypeChooser<T>::Type &modify_type();
 277
 278 private:
 279         /** Returns the descriptor for a type, or null if one isn't defined.  An
 280         optional name can be given to prioritize matching types. */
 281         template<typename T>
 282         CollectionItemTypeBase *get_type(const std::string & = std::string()) const;
 283
 284         /// Gets a descriptor with the same type as another descriptor.
 285         CollectionItemTypeBase *get_type(const CollectionItemTypeBase &) const;
 286
 287         /// Returns the descriptor for an item, or null if it's of an unknown type.
 288         CollectionItemTypeBase *get_type_for_item(const Variant &) const;
 289
 290 protected:
 291         /** Adds a source for automatically loading items.  Sources are consulted
 292         in the order they are added. */
 293         void add_source(const CollectionSource &);
 294
 295 public:
 296         /** Opens a raw resource, without interpreting it as object data.  Null is
 297         returned if no such file is found.  The caller must dispose of the returned
 298         object when done with it. */
 299         IO::Seekable *open_raw(const std::string &) const;
 300
 301 private:
 302         void gather_names_from_sources(std::list<std::string> &, const CollectionItemTypeBase &) const;
 303
 304         void load_items_from_sources(const CollectionItemTypeBase &);
 305
 306 protected:
 307         /** Sets a fallback collection, which will be consulted if an item is not
 308         found. */
 309         void set_fallback(Collection *);
 310
 311         Collection *get_fallback() const { return fallback; }
 312 };
 313
 314 template<typename T>
 315 class Collection::ItemLoader<T, false>: public T::Loader
 316 {
 317 public:
 318         ItemLoader(T &o, Collection &):
 319                 T::Loader(o)
 320         { }
 321 };
 322
 323 template<typename T>
 324 class Collection::ItemLoader<T, true>: public T::Loader
 325 {
 326 public:
 327         ItemLoader(T &o, Collection &c):
 328                 T::Loader(o, dynamic_cast<typename T::Loader::Collection &>(c))
 329         { }
 330 };
 331
 332
 333 class CollectionItemTypeBase
 334 {
 335 protected:
 336         struct ExtractorBase
 337         {
 338                 virtual ~ExtractorBase() { }
 339         };
 340
 341         template<typename T>
 342         struct Extractor: ExtractorBase
 343         {
 344                 virtual T &extract(const Variant &) const = 0;
 345         };
 346
 347         std::string kwd;
 348         std::vector<std::string> suffixes;
 349         std::vector<ExtractorBase *> extractors;
 350
 351         CollectionItemTypeBase() { }
 352 public:
 353         virtual ~CollectionItemTypeBase();
 354
 355 protected:
 356         void set_keyword(const std::string &);
 357         void add_suffix(const std::string &);
 358 public:
 359         const std::string &get_keyword() const { return kwd; }
 360         bool match_name(const std::string &) const;
 361         virtual bool is_same_type(const CollectionItemTypeBase &) const = 0;
 362         virtual bool check_item_type(const Variant &) const = 0;
 363         virtual void add_to_loader(Collection::Loader &) const = 0;
 364         virtual bool can_create() const = 0;
 365         virtual void create_item(Collection &, const std::string &) const = 0;
 366         virtual void load_item(Collection &, Parser &, const std::string &) const = 0;
 367         virtual void notify_item(const std::string &, const Variant &) const = 0;
 368
 369         template<typename T>
 370         bool can_extract() const
 371         {
 372                 for(ExtractorBase *e: extractors)
 373                         if(dynamic_cast<Extractor<T> *>(e))
 374                                 return true;
 375                 return false;
 376         }
 377
 378         template<typename T>
 379         T *extract(const Variant &var) const
 380         {
 381                 for(ExtractorBase *e: extractors)
 382                         if(Extractor<T> *ex = dynamic_cast<Extractor<T> *>(e))
 383                                 return &ex->extract(var);
 384                 return 0;
 385         }
 386 };
 387
 388
 389 /**
 390 Describes a type of item that can be loaded by a Collection.  These are created
 391 by Collection::add_type.
 392 */
 393 template<typename T>
 394 class CollectionItemType: public CollectionItemTypeBase
 395 {
 396 private:
 397         template<typename B>
 398         struct Extractor: CollectionItemTypeBase::Extractor<B>
 399         {
 400                 virtual B &extract(const Variant &var) const
 401                 { return *var.value<RefPtr<T> >(); }
 402         };
 403
 404         std::function<T *(const std::string &)> create_func;
 405         std::vector<std::function<void(const std::string &, T &)>> notify_funcs;
 406
 407 public:
 408         /** Sets a datafile keyword for this item type.  The Collection's loader
 409         will accept a statement with this keyword and a single string argument - the
 410         item's name. */
 411         CollectionItemType &keyword(const std::string &k)
 412         {
 413                 set_keyword(k);
 414                 return *this;
 415         }
 416
 417         /** Adds a suffix that is used to match names when looking for loadable
 418         objects.  There is no implied separator; a name matches if it ends with the
 419         suffix.  If a keyword is defined before any suffixes, then "."+keyword is
 420         added as a suffix. */
 421         CollectionItemType &suffix(const std::string &s)
 422         {
 423                 add_suffix(s);
 424                 return *this;
 425         }
 426
 427         /** Attaches a creator function to this item type.  If an item is not found
 428         in the Collection, the creator function for its type is called to create it.
 429         The function must be a member of the Collection subclass containing the
 430         type.  It must return the created object, or null if it could not be
 431         created.  It's also permissible to load the item via other means and then
 432         return null. */
 433         template<typename F>
 434         CollectionItemType &creator(F func)
 435         {
 436                 create_func = func;
 437                 return *this;
 438         }
 439
 440         /** Makes items of this type available through a base class. */
 441         template<typename B>
 442         CollectionItemType &base()
 443         {
 444                 extractors.push_back(new Extractor<B>);
 445                 return *this;
 446         }
 447
 448         template<typename F>
 449         CollectionItemType &notify(F func)
 450         {
 451                 notify_funcs.emplace_back(func);
 452                 return *this;
 453         }
 454
 455         virtual bool is_same_type(const CollectionItemTypeBase &other) const
 456         { return dynamic_cast<const CollectionItemType<T> *>(&other); }
 457
 458         virtual bool check_item_type(const Variant &var) const
 459         { return var.check_type<RefPtr<T> >(); }
 460
 461         virtual void add_to_loader(Collection::Loader &) const
 462         { }
 463
 464         virtual bool can_create() const
 465         { return static_cast<bool>(create_func); }
 466
 467         virtual void create_item(Collection &coll, const std::string &name) const
 468         {
 469                 if(!create_func)
 470                         throw std::runtime_error("no creator");
 471                 T *obj = create_func(name);
 472                 if(obj)
 473                         coll.add(name, obj);
 474         }
 475
 476         virtual void load_item(Collection &, Parser &, const std::string &) const
 477         {
 478                 throw std::runtime_error("this type cannot be loaded");
 479         }
 480
 481         virtual void notify_item(const std::string &name, const Variant &var) const
 482         {
 483                 RefPtr<T> obj = var.value<RefPtr<T> >();
 484                 for(const auto &n: notify_funcs)
 485                         n(name, *obj);
 486         }
 487 };
 488
 489
 490 template<typename T>
 491 class LoadableCollectionItemType: public CollectionItemType<T>
 492 {
 493 public:
 494         virtual void add_to_loader(Collection::Loader &loader) const
 495         { loader.add(this->kwd, &Collection::Loader::item<T, T>); }
 496
 497         virtual void load_item(Collection &coll, Parser &parser, const std::string &name) const
 498         {
 499                 RefPtr<T> obj = new T;
 500                 Collection::ItemLoader<T> ldr(*obj, coll);
 501                 ldr.load(parser);
 502                 coll.add(name, obj.get());
 503                 obj.release();
 504         }
 505 };
 506
 507
 508 template<typename T>
 509 T &Collection::extract(const Variant &var) const
 510 {
 511         if(!var.check_type<RefPtr<T> >())
 512                 if(CollectionItemTypeBase *type = get_type_for_item(var))
 513                         if(T *item = type->extract<T>(var))
 514                                 return *item;
 515
 516         return *var.value<RefPtr<T> >();
 517 }
 518
 519 template<typename T>
 520 typename CollectionItemTypeChooser<T>::Type &Collection::add_type()
 521 {
 522         typename CollectionItemTypeChooser<T>::Type *type = new typename CollectionItemTypeChooser<T>::Type;
 523         types.push_back(type);
 524         return *type;
 525 }
 526
 527 template<typename T>
 528 typename CollectionItemTypeChooser<T>::Type &Collection::modify_type()
 529 {
 530         for(CollectionItemTypeBase *t: types)
 531                 if(CollectionItemType<T> *tt = dynamic_cast<CollectionItemType<T> *>(t))
 532                         return *tt;
 533
 534         throw std::logic_error("type not found in collection");
 535 }
 536
 537 template<typename T>
 538 CollectionItemTypeBase *Collection::get_type(const std::string &name) const
 539 {
 540         for(CollectionItemTypeBase *t: types)
 541                 if(dynamic_cast<CollectionItemType<T> *>(t))
 542                         return t;
 543         CollectionItemTypeBase *type = 0;
 544         for(CollectionItemTypeBase *t: types)
 545                 if(t->can_extract<T>())
 546                 {
 547                         if(!name.empty() && t->match_name(name))
 548                                 return t;
 549                         type = t;
 550                 }
 551         return type;
 552 }
 553
 554 } // namespace DataFile
 555 } // namespace Msp
 556
 557 #endif