source/loaderaction.h

   1 #ifndef MSP_DATAFILE_LOADERACTION_H_
   2 #define MSP_DATAFILE_LOADERACTION_H_
   3
   4 #include <msp/core/meta.h>
   5 #include "argumentstore.h"
   6 #include "statement.h"
   7
   8 namespace Msp {
   9 namespace DataFile {
  10
  11 template<typename T>
  12 std::string create_signature(const std::string &prefix = std::string())
  13 { return prefix+std::string(1, TypeInfo<T>::signature); }
  14
  15 template<typename T0, typename T1, typename... Tail>
  16 std::string create_signature(const std::string &prefix = std::string())
  17 { return create_signature<T1, Tail...>(prefix+std::string(1, TypeInfo<T0>::signature)); }
  18
  19 class Loader;
  20
  21 /**
  22 Base class for loader actions.
  23 */
  24 class LoaderAction
  25 {
  26 protected:
  27         LoaderAction() = default;
  28 public:
  29         virtual ~LoaderAction() = default;
  30
  31         /** Called to process a statement. */
  32         virtual void execute(Loader &, const Statement &) const = 0;
  33
  34         virtual void execute(Loader &, const ArgumentStore &) const = 0;
  35
  36         virtual std::string get_signature() const = 0;
  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 private:
  47         typedef void (L::*FuncType)();
  48
  49         FuncType func;
  50
  51 public:
  52         LoaderFunc0(FuncType f): func(f) { }
  53
  54         void execute(Loader &l, const Statement &) const override
  55         {
  56                 (dynamic_cast<L &>(l).*func)();
  57         };
  58
  59         void execute(Loader &l, const ArgumentStore &) const override
  60         {
  61                 (dynamic_cast<L &>(l).*func)();
  62         };
  63
  64         std::string get_signature() const override
  65         { return std::string(); }
  66 };
  67
  68
  69 /**
  70 Loads a statement by calling a function that takes one argument.
  71 */
  72 template<typename L, typename A0>
  73 class LoaderFunc1: public LoaderAction
  74 {
  75 private:
  76         typedef void (L::*FuncType)(A0);
  77
  78         FuncType func;
  79
  80 public:
  81         LoaderFunc1(FuncType f): func(f) { }
  82
  83         void execute(Loader &l, const Statement &st) const override
  84         {
  85                 (dynamic_cast<L &>(l).*func)(st.args[0].get<A0>());
  86         }
  87
  88         void execute(Loader &l, const ArgumentStore &as) const override
  89         {
  90                 (dynamic_cast<L &>(l).*func)(as.get<A0>(0));
  91         }
  92
  93         std::string get_signature() const override
  94         { return std::string(1, TypeInfo<A0>::signature); }
  95 };
  96
  97
  98 /**
  99 Loads a statement by calling a function that takes an array of values.
 100 */
 101 template<typename L, typename A0>
 102 class LoaderFunc1<L, const std::vector<A0> &>: public LoaderAction
 103 {
 104 private:
 105         typedef void (L::*FuncType)(const std::vector<A0> &);
 106
 107         FuncType func;
 108
 109 public:
 110         LoaderFunc1(FuncType f): func(f) { }
 111
 112         void execute(Loader &l, const Statement &st) const override
 113         {
 114                 std::vector<A0> values;
 115                 values.reserve(st.args.size());
 116                 for(const Value &a: st.args)
 117                         values.push_back(a.get<A0>());
 118                 (dynamic_cast<L &>(l).*func)(values);
 119         }
 120
 121         void execute(Loader &l, const ArgumentStore &as) const override
 122         {
 123                 std::vector<A0> values;
 124                 unsigned n_args = as.get_info().key.signature.size();
 125                 values.reserve(n_args);
 126                 for(unsigned i=0; i<n_args; ++i)
 127                         values.push_back(as.get<A0>(i));
 128                 (dynamic_cast<L &>(l).*func)(values);
 129         }
 130
 131         std::string get_signature() const override
 132         {
 133                 std::string result;
 134                 result += TypeInfo<A0>::signature;
 135                 result += '*';
 136                 return result;
 137         }
 138 };
 139
 140
 141 /**
 142 Loads a statement by calling a function with the statement itself as argument.
 143 */
 144 template<typename L>
 145 class LoaderFunc1<L, const Statement &>: public LoaderAction
 146 {
 147 private:
 148         typedef void (L::*FuncType)(const Statement &);
 149
 150         FuncType func;
 151
 152 public:
 153         LoaderFunc1(FuncType f): func(f) { }
 154
 155         void execute(Loader &l, const Statement &st) const override
 156         {
 157                 (dynamic_cast<L &>(l).*func)(st);
 158         }
 159
 160         void execute(Loader &, const ArgumentStore &) const override
 161         {
 162                 throw std::logic_error("incompatible format");
 163         }
 164
 165         std::string get_signature() const override
 166         { return "*"; }
 167 };
 168
 169
 170 template<unsigned I, typename... Args>
 171 struct Apply;
 172
 173 template<unsigned I>
 174 struct Apply<I>
 175 {
 176         template<typename L, typename F, typename... Args>
 177         static void apply(L &l, F func, const Statement &, Args &&... args)
 178         {
 179                 (l.*func)(std::forward<Args>(args)...);
 180         }
 181
 182         template<typename L, typename F, typename... Args>
 183         static void apply(L &l, F func, const ArgumentStore &, Args &&... args)
 184         {
 185                 (l.*func)(std::forward<Args>(args)...);
 186         }
 187 };
 188
 189 template<unsigned I, typename Head, typename... Tail>
 190 struct Apply<I, Head, Tail...>
 191 {
 192         template<typename L, typename F, typename... Args>
 193         static void apply(L &l, F func, const Statement &st, Args &&... args)
 194         {
 195                 Apply<I+1, Tail...>::apply(l, func, st, std::forward<Args>(args)..., std::move(st.args[I].get<Head>()));
 196         }
 197
 198         template<typename L, typename F, typename... Args>
 199         static void apply(L &l, F func, const ArgumentStore &as, Args &&... args)
 200         {
 201                 Apply<I+1, Tail...>::apply(l, func, as, std::forward<Args>(args)..., std::move(as.get<Head>(I)));
 202         }
 203 };
 204
 205
 206 template<typename L, typename... Args>
 207 class LoaderFuncN: public LoaderAction
 208 {
 209 protected:
 210         typedef void (L::*FuncType)(Args...);
 211
 212         FuncType func;
 213
 214 public:
 215         LoaderFuncN(FuncType f): func(f) { }
 216
 217         void execute(Loader &l, const Statement &st) const override
 218         {
 219                 Apply<0, Args...>::apply(dynamic_cast<L &>(l), func, st);
 220         }
 221
 222         void execute(Loader &l, const ArgumentStore &as) const override
 223         {
 224                 Apply<0, Args...>::apply(dynamic_cast<L &>(l), func, as);
 225         }
 226
 227         std::string get_signature() const override
 228         { return create_signature<Args...>(); }
 229 };
 230
 231
 232 template<typename L, typename B0, typename... Args>
 233 class LoaderFuncNBound1: public LoaderAction
 234 {
 235 protected:
 236         typedef void (L::*FuncType)(B0, Args...);
 237         typedef typename std::remove_reference<B0>::type Bound0Type;
 238
 239         FuncType func;
 240         Bound0Type bound0;
 241
 242 public:
 243         LoaderFuncNBound1(FuncType f, const B0 &b0): func(f), bound0(b0) { }
 244         LoaderFuncNBound1(FuncType f, B0 &&b0): func(f), bound0(std::move(b0)) { }
 245
 246         void execute(Loader &l, const Statement &st) const override
 247         {
 248                 Apply<0, Args...>::apply(dynamic_cast<L &>(l), func, st, bound0);
 249         }
 250
 251         void execute(Loader &l, const ArgumentStore &as) const override
 252         {
 253                 Apply<0, Args...>::apply(dynamic_cast<L &>(l), func, as, bound0);
 254         }
 255
 256         std::string get_signature() const override
 257         { return create_signature<Args...>(); }
 258 };
 259
 260
 261 template<typename L, typename T0>
 262 class LoadValue1: public LoaderAction
 263 {
 264 private:
 265         typedef T0 L::*Pointer0Type;
 266
 267         Pointer0Type ptr0;
 268
 269 public:
 270         LoadValue1(Pointer0Type p0): ptr0(p0) { }
 271
 272         void execute(Loader &l, const Statement &st) const override
 273         {
 274                 dynamic_cast<typename L::Loader &>(l).get_object().*ptr0 = st.args[0].get<T0>();
 275         }
 276
 277         void execute(Loader &l, const ArgumentStore &as) const override
 278         {
 279                 dynamic_cast<typename L::Loader &>(l).get_object().*ptr0 = as.get<T0>(0);
 280         }
 281
 282         std::string get_signature() const override
 283         { return std::string(1, TypeInfo<T0>::signature); }
 284 };
 285
 286
 287 template<typename L, typename T0>
 288 class LoadValue1<L, T0 *>: public LoaderAction
 289 {
 290 private:
 291         typedef T0 *L::*Pointer0Type;
 292
 293         Pointer0Type ptr0;
 294
 295 public:
 296         LoadValue1(Pointer0Type p0): ptr0(p0) { }
 297
 298         void execute(Loader &l, const Statement &st) const override
 299         {
 300                 typename L::Loader &ldr = dynamic_cast<typename L::Loader &>(l);
 301                 ldr.get_object().*ptr0 = &ldr.get_collection().template get<T0>(st.args[0].get<std::string>());
 302         }
 303
 304         void execute(Loader &l, const ArgumentStore &as) const override
 305         {
 306                 typename L::Loader &ldr = dynamic_cast<typename L::Loader &>(l);
 307                 ldr.get_object().*ptr0 = &ldr.get_collection().template get<T0>(as.get<std::string>(0));
 308         }
 309
 310         std::string get_signature() const override
 311         { return std::string(1, TypeInfo<std::string>::signature); }
 312 };
 313
 314
 315 template<typename L, typename T0, typename T1>
 316 class LoadValue2: public LoaderAction
 317 {
 318 private:
 319         typedef T0 L::*Pointer0Type;
 320         typedef T1 L::*Pointer1Type;
 321
 322         Pointer0Type ptr0;
 323         Pointer1Type ptr1;
 324
 325 public:
 326         LoadValue2(Pointer0Type p0, Pointer1Type p1): ptr0(p0), ptr1(p1) { }
 327
 328         void execute(Loader &l, const Statement &st) const override
 329         {
 330                 dynamic_cast<typename L::Loader &>(l).get_object().*ptr0 = st.args[0].get<T0>();
 331                 dynamic_cast<typename L::Loader &>(l).get_object().*ptr1 = st.args[1].get<T1>();
 332         }
 333
 334         void execute(Loader &l, const ArgumentStore &as) const override
 335         {
 336                 dynamic_cast<typename L::Loader &>(l).get_object().*ptr0 = as.get<T0>(0);
 337                 dynamic_cast<typename L::Loader &>(l).get_object().*ptr1 = as.get<T1>(1);
 338         }
 339
 340         std::string get_signature() const override
 341         {
 342                 std::string result;
 343                 result += TypeInfo<T0>::signature;
 344                 result += TypeInfo<T1>::signature;
 345                 return result;
 346         }
 347 };
 348
 349 } // namespace DataFile
 350 } // namespace Msp
 351
 352 #endif