3 This file is part of libmspdatafile
4 Copyright © 2006 Mikko Rasa, Mikkosoft Productions
5 Distributed under the LGPL
8 #ifndef MSP_DATAFILE_COLLECTION_H_
9 #define MSP_DATAFILE_COLLECTION_H_
11 #include <msp/core/refptr.h>
18 Helper struct to determine whether a Loader has a Collection typedef.
21 struct NeedsCollection
23 struct Yes { char c[2]; };
24 struct No { char c; };
27 static Yes f(typename U::Collection *);
31 enum { result=(sizeof(f<T>(0))==sizeof(Yes)) };
39 struct RemoveConst<const T>
43 A collection of objects that can be loaded from a datafile. Each object is
44 identified by a name, which must be unique across the entire collection.
52 /* XXX I don't really like sticking all this stuff in here, but there's some
53 complex inter-class relationships, especially between ItemKeyword and
54 Collection::Loader. */
58 virtual ~ItemBase() { }
62 struct Item: public ItemBase
66 Item(T *d): data(d) { }
67 ~Item() { delete data; }
71 Used to store keywords for types that can be loaded.
73 struct ItemKeywordBase
75 virtual ~ItemKeywordBase() { }
76 virtual void add_to_loader(Loader &) const { };
79 template<typename T, typename S, bool need_coll=NeedsCollection<typename T::Loader>::result>
80 struct ItemKeyword: public ItemKeywordBase
84 ItemKeyword(const std::string &kw): keyword(kw) { }
86 void add_to_loader(Loader &ldr) const
87 { ldr.add(keyword, &Loader::item<T, S>); }
90 template<typename T, typename S>
91 struct ItemKeyword<T, S, true>: public ItemKeywordBase
95 ItemKeyword(const std::string &kw): keyword(kw) { }
97 virtual void add_to_loader(Loader &ldr) const
98 { ldr.add(keyword, &Loader::coll_item<T, S, typename T::Loader::Collection>); }
102 Used to store types that can be created automatically.
104 struct ItemCreatorBase
106 virtual ~ItemCreatorBase() { }
109 bool create(Collection &coll, const std::string &name, S *&ptr)
111 ItemCreatorBridge<S> *creator=dynamic_cast<ItemCreatorBridge<S> *>(this);
114 ptr=creator->create(coll, name);
122 struct ItemCreatorBridge: public ItemCreatorBase
124 virtual S *create(Collection &, const std::string &) const =0;
127 template<typename T, typename S, typename C>
128 struct ItemCreator: public ItemCreatorBridge<S>
130 typedef T *(C::*fCreate)(const std::string &);
134 ItemCreator(fCreate cf): create_func(cf) { }
135 virtual S *create(Collection &coll, const std::string &name) const
136 { return (dynamic_cast<C &>(coll).*create_func)(name); }
141 Loads objects into a Collection.
143 class Loader: public DataFile::Loader
149 Loader(Collection &);
150 Collection &get_object() const { return coll; }
152 template<typename T, typename S, typename C>
153 void coll_item(const std::string &n)
156 load_sub(*it, dynamic_cast<C &>(coll));
157 coll.add<S>(n, it.get());
161 template<typename T, typename S>
162 void item(const std::string &n)
166 coll.add<S>(n, it.get());
170 template<typename, typename, bool> friend class ItemKeyword;
174 typedef std::map<std::string, ItemBase *> ItemMap;
175 typedef std::list<ItemKeywordBase *> ItemKeywordSeq;
176 typedef std::list<ItemCreatorBase *> ItemCreatorSeq;
179 ItemKeywordSeq keywords;
180 ItemCreatorSeq creators;
182 Collection(const Collection &);
183 Collection &operator=(const Collection &);
186 virtual ~Collection();
189 Adds an object into the collection. If a name collision occurs, an
190 exception is thrown. The collection takes ownership of the object.
193 void add(const std::string &name, T *d)
195 if(items.count(name))
196 throw KeyError("Duplicate key in collection", name);
198 items[name]=new Item<typename RemoveConst<T>::Type>(d);
202 Gets an object of a specific type from the collection.
205 T *get(const std::string &name) const
207 typedef typename RemoveConst<T>::Type NCT;
209 ItemMap::const_iterator i=items.find(name);
211 throw KeyError("Item not found in collection", name);
213 const Item<NCT> *item=dynamic_cast<const Item<NCT> *>(i->second);
215 throw TypeError("Type mismatch on item '"+name+"'");
221 Gets an object of a specific type from the collection. If the name is not
222 found in the collection and there is a creator for the item type, it is
226 T *get(const std::string &name)
228 typedef typename RemoveConst<T>::Type NCT;
230 ItemMap::const_iterator i=items.find(name);
233 for(ItemCreatorSeq::iterator j=creators.begin(); j!=creators.end(); ++j)
236 if((*j)->create(*this, name, d))
238 // We already know that the item didn't exist yet
239 items[name]=new Item<NCT>(d);
243 throw KeyError("Item not found in collection", name);
246 const Item<NCT> *item=dynamic_cast<const Item<NCT> *>(i->second);
248 throw TypeError("Type mismatch on item '"+name+"'");
254 Returns a list of the names of objects of a specific type in the collection.
257 std::list<std::string> get_names() const
259 std::list<std::string> result;
260 for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i)
261 if(dynamic_cast<const Item<typename RemoveConst<T>::Type> *>(i->second))
262 result.push_back(i->first);
267 Returns a list of objects of a specific type in the collection.
270 std::list<T *> get_list() const
272 typedef typename RemoveConst<T>::Type NCT;
274 std::list<T *> result;
275 for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i)
276 if(Item<NCT> *item=dynamic_cast<Item<NCT> *>(i->second))
277 result.push_back(item->data);
282 Checks whether a name exists in the collection. Does not care about the
285 bool contains(const std::string &n) const;
288 Returns the name of an item in the collection.
291 const std::string &get_name(T *d) const
293 typedef typename RemoveConst<T>::Type NCT;
295 for(ItemMap::const_iterator i=items.begin(); i!=items.end(); ++i)
296 if(Item<NCT> *item=dynamic_cast<Item<NCT> *>(i->second))
300 throw KeyError("Item not found in collection");
305 Adds a type that can be loaded from datafiles.
308 void add_keyword(const std::string &keyword)
309 { add_keyword<T, T>(keyword); }
312 Adds a type that can be loaded from datafiles, with different storage type.
314 template<typename T, typename S>
315 void add_keyword(const std::string &keyword)
316 { keywords.push_back(new ItemKeyword<T, S>(keyword)); }
319 Adds a type that can be created automatically.
321 template<typename T, typename C>
322 void add_creator(T *(C::*func)(const std::string &))
323 { add_creator<T, T, C>(func); }
325 template<typename T, typename S, typename C>
326 void add_creator(T *(C::*func)(const std::string &))
327 { creators.push_back(new ItemCreator<T, S, C>(func)); }
330 } // namespace DataFile