source/loader.h

   1 /* $Id$
   2
   3 This file is part of libmspdatafile
   4 Copyright © 2006  Mikko Rasa, Mikkosoft Productions
   5 Distributed under the LGPL
   6 */
   7
   8 #ifndef MSP_DATAFILE_LOADER_H_
   9 #define MSP_DATAFILE_LOADER_H_
  10
  11 #include <fstream>
  12 #include <map>
  13 #include "except.h"
  14 #include "parser.h"
  15 #include "statement.h"
  16 #include "value.h"
  17
  18 namespace Msp {
  19 namespace DataFile {
  20
  21 class Loader;
  22 class Statement;
  23
  24 /**
  25 Base class for loader actions.
  26 */
  27 class LoaderAction
  28 {
  29 public:
  30         /**
  31         Called when a statement is to be loaded.
  32         */
  33         virtual void execute(Loader &, const Statement &) const=0;
  34         virtual ~LoaderAction() { }
  35 protected:
  36         LoaderAction() { }
  37 };
  38
  39
  40 /**
  41 Loads a statement by calling a function that takes no arguments.
  42 */
  43 template<typename L>
  44 class LoaderFunc0: public LoaderAction
  45 {
  46 public:
  47         typedef void (L::*FuncType)();
  48
  49         LoaderFunc0(FuncType f): func(f) { }
  50         void execute(Loader &l, const Statement &st) const
  51         {
  52                 if(st.args.size()!=0) throw TypeError(st.get_location()+": Wrong number of arguments");
  53                 (dynamic_cast<L &>(l).*func)();
  54         };
  55 private:
  56         FuncType func;
  57 };
  58
  59
  60 /**
  61 Loads a statement by calling a function that takes one argument.
  62 */
  63 template<typename L, typename A0>
  64 class LoaderFunc1: public LoaderAction
  65 {
  66 public:
  67         typedef void (L::*FuncType)(A0);
  68
  69         LoaderFunc1(FuncType f): func(f) { }
  70         void execute(Loader &l, const Statement &st) const
  71         {
  72                 if(st.args.size()!=1) throw TypeError(st.get_location()+": Wrong number of arguments");
  73                 (dynamic_cast<L &>(l).*func)(st.args[0].get<A0>());
  74         }
  75 private:
  76         FuncType func;
  77 };
  78
  79
  80 /**
  81 Loads a statement by calling a function that takes an array of values.
  82 */
  83 template<typename L, typename A0>
  84 class LoaderFunc1<L, const std::vector<A0> &>: public LoaderAction
  85 {
  86 public:
  87         typedef void (L::*FuncType)(const std::vector<A0> &);
  88
  89         LoaderFunc1(FuncType f): func(f) { }
  90         void execute(Loader &l, const Statement &st) const
  91         {
  92                 std::vector<A0> values;
  93                 values.reserve(st.args.size());
  94                 for(ValueArray::const_iterator i=st.args.begin(); i!=st.args.end(); ++i)
  95                         values.push_back(i->get<A0>());
  96                 (dynamic_cast<L &>(l).*func)(values);
  97         }
  98 private:
  99         FuncType func;
 100 };
 101
 102
 103 template<typename L, typename A0, typename A1>
 104 class LoaderFunc2: public LoaderAction
 105 {
 106 public:
 107         typedef void (L::*FuncType)(A0, A1);
 108
 109         LoaderFunc2(FuncType f): func(f) { }
 110         void execute(Loader &l, const Statement &st) const
 111         {
 112                 if(st.args.size()!=2) throw TypeError(st.get_location()+": Wrong number of arguments");
 113                 (dynamic_cast<L &>(l).*func)(st.args[0].get<A0>(), st.args[1].get<A1>());
 114         }
 115 private:
 116         FuncType func;
 117 };
 118
 119
 120 template<typename L, typename A0, typename A1, typename A2>
 121 class LoaderFunc3: public LoaderAction
 122 {
 123 public:
 124         typedef void (L::*FuncType)(A0, A1, A2);
 125
 126         LoaderFunc3(FuncType f): func(f) { }
 127         void execute(Loader &l, const Statement &st) const
 128         {
 129                 if(st.args.size()!=3) throw TypeError(st.get_location()+": Wrong number of arguments");
 130                 (dynamic_cast<L &>(l).*func)(st.args[0].get<A0>(), st.args[1].get<A1>(), st.args[2].get<A2>());
 131         }
 132 private:
 133         FuncType func;
 134 };
 135
 136
 137 template<typename L, typename A0, typename A1, typename A2, typename A3>
 138 class LoaderFunc4: public LoaderAction
 139 {
 140 public:
 141         typedef void (L::*FuncType)(A0, A1, A2, A3);
 142
 143         LoaderFunc4(FuncType f): func(f) { }
 144         void execute(Loader &l, const Statement &st) const
 145         {
 146                 if(st.args.size()!=4) throw TypeError(st.get_location()+": Wrong number of arguments");
 147                 (dynamic_cast<L &>(l).*func)(st.args[0].get<A0>(), st.args[1].get<A1>(), st.args[2].get<A2>(), st.args[3].get<A3>());
 148         }
 149 private:
 150         FuncType func;
 151 };
 152
 153
 154 template<typename L, typename T0>
 155 class LoadValue1: public LoaderAction
 156 {
 157 public:
 158         typedef T0 L::*Pointer0Type;
 159
 160         LoadValue1(Pointer0Type p0): ptr0(p0) { }
 161         void execute(Loader &l, const Statement &st) const
 162         {
 163                 if(st.args.size()!=1) throw TypeError(st.get_location()+": Wrong number of arguments");
 164                 dynamic_cast<typename L::Loader &>(l).get_object().*ptr0=st.args[0].get<T0>();
 165         }
 166 private:
 167         Pointer0Type ptr0;
 168 };
 169
 170
 171 template<typename L, typename T0>
 172 class LoadValue1<L, T0 *>: public LoaderAction
 173 {
 174 public:
 175         typedef T0 *L::*Pointer0Type;
 176
 177         LoadValue1(Pointer0Type p0): ptr0(p0) { }
 178         void execute(Loader &l, const Statement &st) const
 179         {
 180                 if(st.args.size()!=1) throw TypeError(st.get_location()+": Wrong number of arguments");
 181                 typename L::Loader &ldr=dynamic_cast<typename L::Loader &>(l);
 182                 ldr.get_object().*ptr0=&ldr.get_collection().template get<T0>(st.args[0].get<std::string>());
 183         }
 184 private:
 185         Pointer0Type ptr0;
 186 };
 187
 188
 189 template<typename L, typename T0, typename T1>
 190 class LoadValue2: public LoaderAction
 191 {
 192 public:
 193         typedef T0 L::*Pointer0Type;
 194         typedef T1 L::*Pointer1Type;
 195
 196         LoadValue2(Pointer0Type p0, Pointer1Type p1): ptr0(p0), ptr1(p1) { }
 197         void execute(Loader &l, const Statement &st) const
 198         {
 199                 if(st.args.size()!=2) throw TypeError(st.get_location()+": Wrong number of arguments");
 200                 dynamic_cast<typename L::Loader &>(l).get_object().*ptr0=st.args[0].get<T0>();
 201                 dynamic_cast<typename L::Loader &>(l).get_object().*ptr1=st.args[1].get<T1>();
 202         }
 203 private:
 204         Pointer0Type ptr0;
 205         Pointer1Type ptr1;
 206 };
 207
 208
 209 /**
 210 Base class for data loaders.  To give loading capabilities to a class, create a
 211 public Loader class in it, derived from this class.  Typically a loader object
 212 contains a reference to the loaded object.  To make use of loading directly
 213 into data members, the Loader class must have a get_object() member function,
 214 returning that reference.  If direct loading of pointers is desired, the Loader
 215 class must also have a get_collection() member function, returning a collection
 216 to get pointers from.
 217 */
 218 class Loader
 219 {
 220 public:
 221         /**
 222         Loads data from a statement.  This is normally only used by the Loader class
 223         itself for loading sub-items, but needs to be public so it can be accessed
 224         in derived objects.
 225         */
 226         void load(const Statement &st);
 227
 228         /**
 229         Loads statements from a parser.
 230         */
 231         void load(Parser &p);
 232
 233         virtual ~Loader();
 234 protected:
 235         Loader(): cur_st(0) { }
 236
 237         /**
 238         Adds a keyword that is loaded with a zero-argument function.
 239         */
 240         template<typename L>
 241         void add(const std::string &k, void (L::*func)())
 242         { actions.insert(typename ActionMap::value_type(k, new LoaderFunc0<L>(func))); }
 243
 244         template<typename L, typename A0>
 245         void add(const std::string &k, void (L::*func)(A0))
 246         { actions.insert(typename ActionMap::value_type(k, new LoaderFunc1<L, A0>(func))); }
 247
 248         template<typename L, typename A0, typename A1>
 249         void add(const std::string &k, void (L::*func)(A0, A1))
 250         { actions.insert(typename ActionMap::value_type(k, new LoaderFunc2<L, A0, A1>(func))); }
 251
 252         template<typename L, typename A0, typename A1, typename A2>
 253         void add(const std::string &k, void (L::*func)(A0, A1, A2))
 254         { actions.insert(typename ActionMap::value_type(k, new LoaderFunc3<L, A0, A1, A2>(func))); }
 255
 256         template<typename L, typename A0, typename A1, typename A2, typename A3>
 257         void add(const std::string &k, void (L::*func)(A0, A1, A2, A3))
 258         { actions.insert(typename ActionMap::value_type(k, new LoaderFunc4<L, A0, A1, A2, A3>(func))); }
 259
 260         /**
 261         Adds a keyword that is loaded into a variable of the loaded object.
 262         */
 263         template<typename L, typename T0>
 264         void add(const std::string &k, T0 L::*p0)
 265         { actions.insert(typename ActionMap::value_type(k, new LoadValue1<L, T0>(p0))); }
 266
 267         template<typename L, typename T0, typename T1>
 268         void add(const std::string &k, T0 L::*p0, T1 L::*p1)
 269         { actions.insert(typename ActionMap::value_type(k, new LoadValue2<L, T0, T1>(p0, p1))); }
 270
 271         /**
 272         Adds a keyword that is recognized but ignored.
 273         */
 274         void add(const std::string &k)
 275         { actions.insert(ActionMap::value_type(k, 0)); }
 276
 277         /**
 278         Loads a sub-object from the statement being processed.  The Loader class of
 279         the sub-object is automatically used.
 280         */
 281         template<typename S>
 282         void load_sub(S &s)
 283         { load_sub<typename S::Loader, S>(s); }
 284
 285         /**
 286         Loads a sub-object with a custom Loader class.
 287         */
 288         template<typename L, typename S>
 289         void load_sub(S &s)
 290         {
 291                 if(!cur_st)
 292                         throw InvalidState("load_sub called without current statement");
 293                 L loader(s);
 294                 loader.load(*cur_st);
 295         }
 296
 297         template<typename S, typename T>
 298         void load_sub(S &s, T &p)
 299         { load_sub<typename S::Loader, S, T>(s, p); }
 300
 301         /**
 302         Loads a sub-object with a custom Loader class that takes one argument in
 303         addition to to object to be loaded.
 304         */
 305         template<typename L, typename S, typename T>
 306         void load_sub(S &s, T &p)
 307         {
 308                 if(!cur_st)
 309                         throw InvalidState("load_sub called without current statement");
 310                 L loader(s, p);
 311                 loader.load(*cur_st);
 312         }
 313
 314         /**
 315         Returns the source of the statement being processed.  This can be used to
 316         implement relative paths in include-like statements.  Note that the source
 317         may not necessarily be a file.
 318         */
 319         const std::string &get_source() const
 320         {
 321                 if(!cur_st)
 322                         throw InvalidState("get_source called without current statement");
 323                 return cur_st->source;
 324         }
 325 private:
 326         typedef std::map<std::string, LoaderAction *> ActionMap;
 327
 328         ActionMap       actions;
 329         const Statement *cur_st;
 330
 331         void load_statement(const Statement &st);
 332 };
 333
 334 /**
 335 Loads an object from a file.  The object must have a public Loader class.
 336 */
 337 template<typename T>
 338 void load(T &obj, const std::string &fn)
 339 {
 340         std::ifstream in(fn.c_str());
 341         if(!in)
 342                 throw Exception("Couldn't open "+fn);
 343
 344         Parser parser(in, fn);
 345         typename T::Loader loader(obj);
 346         loader.load(parser);
 347 }
 348
 349 } // namespace DataFile
 350 } // namespace Msp
 351
 352 #endif