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 "error.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, typename T1>
 172 class LoadValue2: public LoaderAction
 173 {
 174 public:
 175         typedef T0 L::*Pointer0Type;
 176         typedef T1 L::*Pointer1Type;
 177
 178         LoadValue2(Pointer0Type p0, Pointer1Type p1): ptr0(p0), ptr1(p1) { }
 179         void execute(Loader &l, const Statement &st) const
 180         {
 181                 if(st.args.size()!=2) throw TypeError(st.get_location()+": Wrong number of arguments");
 182                 dynamic_cast<typename L::Loader &>(l).get_object().*ptr0=st.args[0].get<T0>();
 183                 dynamic_cast<typename L::Loader &>(l).get_object().*ptr1=st.args[1].get<T1>();
 184         }
 185 private:
 186         Pointer0Type ptr0;
 187         Pointer1Type ptr1;
 188 };
 189
 190
 191 /**
 192 Base class for data loaders.  To give loading capabilities to a class, create a
 193 public Loader class in it, derived from this class.  Typically a loader object
 194 contains a reference to the loaded object.  To make use of loading directly
 195 into data members, the Loader class must have a get_object() member function,
 196 returning that reference.
 197 */
 198 class Loader
 199 {
 200 public:
 201         /**
 202         Loads data from a statement.  This is normally only used by the Loader class
 203         itself for loading sub-items, but needs to be public so it can be accessed
 204         in derived objects.
 205         */
 206         void load(const Statement &st);
 207
 208         /**
 209         Loads statements from a parser.
 210         */
 211         void load(Parser &p);
 212
 213         virtual ~Loader();
 214 protected:
 215         Loader(): cur_st(0) { }
 216
 217         /**
 218         Adds a keyword that is loaded with a zero-argument function.
 219         */
 220         template<typename L>
 221         void add(const std::string &k, void (L::*func)())
 222         { actions.insert(typename ActionMap::value_type(k, new LoaderFunc0<L>(func))); }
 223
 224         template<typename L, typename A0>
 225         void add(const std::string &k, void (L::*func)(A0))
 226         { actions.insert(typename ActionMap::value_type(k, new LoaderFunc1<L, A0>(func))); }
 227
 228         template<typename L, typename A0, typename A1>
 229         void add(const std::string &k, void (L::*func)(A0, A1))
 230         { actions.insert(typename ActionMap::value_type(k, new LoaderFunc2<L, A0, A1>(func))); }
 231
 232         template<typename L, typename A0, typename A1, typename A2>
 233         void add(const std::string &k, void (L::*func)(A0, A1, A2))
 234         { actions.insert(typename ActionMap::value_type(k, new LoaderFunc3<L, A0, A1, A2>(func))); }
 235
 236         template<typename L, typename A0, typename A1, typename A2, typename A3>
 237         void add(const std::string &k, void (L::*func)(A0, A1, A2, A3))
 238         { actions.insert(typename ActionMap::value_type(k, new LoaderFunc4<L, A0, A1, A2, A3>(func))); }
 239
 240         /**
 241         Adds a keyword that is loaded into a variable of the loaded object.
 242         */
 243         template<typename L, typename T0>
 244         void add(const std::string &k, T0 L::*p0)
 245         { actions.insert(typename ActionMap::value_type(k, new LoadValue1<L, T0>(p0))); }
 246
 247         template<typename L, typename T0, typename T1>
 248         void add(const std::string &k, T0 L::*p0, T1 L::*p1)
 249         { actions.insert(typename ActionMap::value_type(k, new LoadValue2<L, T0, T1>(p0, p1))); }
 250
 251         /**
 252         Adds a keyword that is recognized but ignored.
 253         */
 254         void add(const std::string &k)
 255         { actions.insert(ActionMap::value_type(k, 0)); }
 256
 257         /**
 258         Loads a sub-object from the statement being processed.  The Loader class of
 259         the sub-object is automatically used.
 260         */
 261         template<typename S>
 262         void load_sub(S &s)
 263         { load_sub<typename S::Loader, S>(s); }
 264
 265         /**
 266         Loads a sub-object with a custom Loader class.
 267         */
 268         template<typename L, typename S>
 269         void load_sub(S &s)
 270         {
 271                 if(!cur_st)
 272                         throw InvalidState("load_sub called without current statement");
 273                 L loader(s);
 274                 loader.load(*cur_st);
 275         }
 276
 277         template<typename S, typename T>
 278         void load_sub(S &s, T &p)
 279         { load_sub<typename S::Loader, S, T>(s, p); }
 280
 281         /**
 282         Loads a sub-object with a custom Loader class that takes one argument in
 283         addition to to object to be loaded.
 284         */
 285         template<typename L, typename S, typename T>
 286         void load_sub(S &s, T &p)
 287         {
 288                 if(!cur_st)
 289                         throw InvalidState("load_sub called without current statement");
 290                 L loader(s, p);
 291                 loader.load(*cur_st);
 292         }
 293
 294         /**
 295         Returns the source of the statement being processed.  This can be used to
 296         implement relative paths in include-like statements.  Note that the source
 297         may not necessarily be a file.
 298         */
 299         const std::string &get_source() const
 300         {
 301                 if(!cur_st)
 302                         throw InvalidState("get_source called without current statement");
 303                 return cur_st->source;
 304         }
 305 private:
 306         typedef std::map<std::string, LoaderAction *> ActionMap;
 307
 308         ActionMap       actions;
 309         const Statement *cur_st;
 310
 311         void load_statement(const Statement &st);
 312 };
 313
 314 /**
 315 Loads an object from a file.  The object must have a public Loader class.
 316 */
 317 template<typename T>
 318 void load(T &obj, const std::string &fn)
 319 {
 320         std::ifstream in(fn.c_str());
 321         if(!in)
 322                 throw Exception("Couldn't open "+fn);
 323
 324         Parser parser(in, fn);
 325         typename T::Loader loader(obj);
 326         loader.load(parser);
 327 }
 328
 329 } // namespace DataFile
 330 } // namespace Msp
 331
 332 #endif