The ItemLoader wrapper from DirectoryCollection can be used in the base
Collection::Loader as well. This removes the need for the kludgy struct
Add and the need for two separate loader functions. As an added bonus,
the ItemLoader can still be used in DirectoryCollection and future derived
classes as well, further reducing duplication.
template<typename T> friend class CollectionItemType;
private:
template<typename T> friend class CollectionItemType;
private:
- template<typename T, typename S, bool = NeedsCollection<typename T::Loader>::value>
- struct Add;
-
Collection &coll;
public:
Loader(Collection &);
Collection &get_object() const { return coll; }
private:
Collection &coll;
public:
Loader(Collection &);
Collection &get_object() const { return coll; }
private:
- template<typename T, typename S, typename C>
- void coll_item(const std::string &n)
- {
- RefPtr<T> it = new T;
- load_sub(*it, dynamic_cast<C &>(coll));
- coll.add<S>(n, it.get());
- it.release();
- }
-
template<typename T, typename S>
void item(const std::string &n)
{
RefPtr<T> it = new T;
template<typename T, typename S>
void item(const std::string &n)
{
RefPtr<T> it = new T;
+ ItemLoader<T> ldr(*it, coll);
+ load_sub_with(ldr);
coll.add<S>(n, it.get());
it.release();
}
};
coll.add<S>(n, it.get());
it.release();
}
};
+protected:
+ template<typename T, bool = NeedsCollection<typename T::Loader>::value>
+ class ItemLoader;
+
private:
typedef std::map<std::string, Variant> ItemMap;
typedef std::list<CollectionItemTypeBase *> TypeList;
private:
typedef std::map<std::string, Variant> ItemMap;
typedef std::list<CollectionItemTypeBase *> TypeList;
CollectionItemType<T> &add_type();
};
CollectionItemType<T> &add_type();
};
-
-template<typename T, typename S>
-struct Collection::Loader::Add<T, S, false>
+template<typename T>
+class Collection::ItemLoader<T, false>: public T::Loader
- static void add(Loader &loader, const std::string &kwd)
- { loader.add(kwd, &Loader::item<T, S>); }
+public:
+ ItemLoader(T &o, Collection &):
+ T::Loader(o)
+ { }
-template<typename T, typename S>
-struct Collection::Loader::Add<T, S, true>
+template<typename T>
+class Collection::ItemLoader<T, true>: public T::Loader
- static void add(Loader &loader, const std::string &kwd)
- { loader.add(kwd, &Loader::coll_item<T, S, typename T::Loader::Collection>); }
+public:
+ ItemLoader(T &o, Collection &c):
+ T::Loader(o, dynamic_cast<typename T::Loader::Collection &>(c))
+ { }
{ return RefPtr<S>(0); }
virtual void add_to_loader(Collection::Loader &loader, const std::string &kwd)
{ return RefPtr<S>(0); }
virtual void add_to_loader(Collection::Loader &loader, const std::string &kwd)
- { Collection::Loader::Add<T, S>::add(loader, kwd); }
+ { loader.add(kwd, &Collection::Loader::item<T, S>); }
class DirectoryCollection: public Collection
{
private:
class DirectoryCollection: public Collection
{
private:
- template<typename T, bool = NeedsCollection<typename T::Loader>::value>
- class ItemLoader;
-
std::list<FS::Path> dirs;
public:
std::list<FS::Path> dirs;
public:
bool lookup_file(const std::string &, FS::Path &) const;
};
bool lookup_file(const std::string &, FS::Path &) const;
};
-template<typename T>
-class DirectoryCollection::ItemLoader<T, false>: public T::Loader
-{
-public:
- ItemLoader(T &o, Collection &):
- T::Loader(o)
- { }
-};
-
-template<typename T>
-class DirectoryCollection::ItemLoader<T, true>: public T::Loader
-{
-public:
- ItemLoader(T &o, Collection &c):
- T::Loader(o, dynamic_cast<typename T::Loader::Collection &>(c))
- { }
-};
-
} // namespace DataFile
} // namespace Msp
} // namespace DataFile
} // namespace Msp