1 #ifndef MSP_DATAFILE_LOADERACTION_H_
2 #define MSP_DATAFILE_LOADERACTION_H_
4 #include <msp/core/meta.h>
5 #include "argumentstore.h"
12 std::string create_signature(const std::string &prefix = std::string())
13 { return prefix+std::string(1, TypeInfo<T>::signature); }
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)); }
22 Base class for loader actions.
27 LoaderAction() = default;
29 virtual ~LoaderAction() = default;
31 /** Called to process a statement. */
32 virtual void execute(Loader &, const Statement &) const = 0;
34 virtual void execute(Loader &, const ArgumentStore &) const = 0;
36 virtual std::string get_signature() const = 0;
41 Loads a statement by calling a function that takes no arguments.
44 class LoaderFunc0: public LoaderAction
47 typedef void (L::*FuncType)();
52 LoaderFunc0(FuncType f): func(f) { }
54 void execute(Loader &l, const Statement &) const override
56 (dynamic_cast<L &>(l).*func)();
59 void execute(Loader &l, const ArgumentStore &) const override
61 (dynamic_cast<L &>(l).*func)();
64 std::string get_signature() const override
65 { return std::string(); }
70 Loads a statement by calling a function that takes one argument.
72 template<typename L, typename A0>
73 class LoaderFunc1: public LoaderAction
76 typedef void (L::*FuncType)(A0);
81 LoaderFunc1(FuncType f): func(f) { }
83 void execute(Loader &l, const Statement &st) const override
85 (dynamic_cast<L &>(l).*func)(st.args[0].get<A0>());
88 void execute(Loader &l, const ArgumentStore &as) const override
90 (dynamic_cast<L &>(l).*func)(as.get<A0>(0));
93 std::string get_signature() const override
94 { return std::string(1, TypeInfo<A0>::signature); }
99 Loads a statement by calling a function that takes an array of values.
101 template<typename L, typename A0>
102 class LoaderFunc1<L, const std::vector<A0> &>: public LoaderAction
105 typedef void (L::*FuncType)(const std::vector<A0> &);
110 LoaderFunc1(FuncType f): func(f) { }
112 void execute(Loader &l, const Statement &st) const override
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);
121 void execute(Loader &l, const ArgumentStore &as) const override
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);
131 std::string get_signature() const override
134 result += TypeInfo<A0>::signature;
142 Loads a statement by calling a function with the statement itself as argument.
145 class LoaderFunc1<L, const Statement &>: public LoaderAction
148 typedef void (L::*FuncType)(const Statement &);
153 LoaderFunc1(FuncType f): func(f) { }
155 void execute(Loader &l, const Statement &st) const override
157 (dynamic_cast<L &>(l).*func)(st);
160 void execute(Loader &, const ArgumentStore &) const override
162 throw std::logic_error("incompatible format");
165 std::string get_signature() const override
170 template<unsigned I, typename... Args>
176 template<typename L, typename F, typename... Args>
177 static void apply(L &l, F func, const Statement &, Args &&... args)
179 (l.*func)(std::forward<Args>(args)...);
182 template<typename L, typename F, typename... Args>
183 static void apply(L &l, F func, const ArgumentStore &, Args &&... args)
185 (l.*func)(std::forward<Args>(args)...);
189 template<unsigned I, typename Head, typename... Tail>
190 struct Apply<I, Head, Tail...>
192 template<typename L, typename F, typename... Args>
193 static void apply(L &l, F func, const Statement &st, Args &&... args)
195 Apply<I+1, Tail...>::apply(l, func, st, std::forward<Args>(args)..., std::move(st.args[I].get<Head>()));
198 template<typename L, typename F, typename... Args>
199 static void apply(L &l, F func, const ArgumentStore &as, Args &&... args)
201 Apply<I+1, Tail...>::apply(l, func, as, std::forward<Args>(args)..., std::move(as.get<Head>(I)));
206 template<typename L, typename... Args>
207 class LoaderFuncN: public LoaderAction
210 typedef void (L::*FuncType)(Args...);
215 LoaderFuncN(FuncType f): func(f) { }
217 void execute(Loader &l, const Statement &st) const override
219 Apply<0, Args...>::apply(dynamic_cast<L &>(l), func, st);
222 void execute(Loader &l, const ArgumentStore &as) const override
224 Apply<0, Args...>::apply(dynamic_cast<L &>(l), func, as);
227 std::string get_signature() const override
228 { return create_signature<Args...>(); }
232 template<typename L, typename B0, typename... Args>
233 class LoaderFuncNBound1: public LoaderAction
236 typedef void (L::*FuncType)(B0, Args...);
237 typedef typename std::remove_reference<B0>::type Bound0Type;
243 LoaderFuncNBound1(FuncType f, const B0 &b0): func(f), bound0(b0) { }
244 LoaderFuncNBound1(FuncType f, B0 &&b0): func(f), bound0(std::move(b0)) { }
246 void execute(Loader &l, const Statement &st) const override
248 Apply<0, Args...>::apply(dynamic_cast<L &>(l), func, st, bound0);
251 void execute(Loader &l, const ArgumentStore &as) const override
253 Apply<0, Args...>::apply(dynamic_cast<L &>(l), func, as, bound0);
256 std::string get_signature() const override
257 { return create_signature<Args...>(); }
261 template<typename L, typename T0>
262 class LoadValue1: public LoaderAction
265 typedef T0 L::*Pointer0Type;
270 LoadValue1(Pointer0Type p0): ptr0(p0) { }
272 void execute(Loader &l, const Statement &st) const override
274 dynamic_cast<typename L::Loader &>(l).get_object().*ptr0 = st.args[0].get<T0>();
277 void execute(Loader &l, const ArgumentStore &as) const override
279 dynamic_cast<typename L::Loader &>(l).get_object().*ptr0 = as.get<T0>(0);
282 std::string get_signature() const override
283 { return std::string(1, TypeInfo<T0>::signature); }
287 template<typename L, typename T0>
288 class LoadValue1<L, T0 *>: public LoaderAction
291 typedef T0 *L::*Pointer0Type;
296 LoadValue1(Pointer0Type p0): ptr0(p0) { }
298 void execute(Loader &l, const Statement &st) const override
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>());
304 void execute(Loader &l, const ArgumentStore &as) const override
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));
310 std::string get_signature() const override
311 { return std::string(1, TypeInfo<std::string>::signature); }
315 template<typename L, typename T0, typename T1>
316 class LoadValue2: public LoaderAction
319 typedef T0 L::*Pointer0Type;
320 typedef T1 L::*Pointer1Type;
326 LoadValue2(Pointer0Type p0, Pointer1Type p1): ptr0(p0), ptr1(p1) { }
328 void execute(Loader &l, const Statement &st) const override
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>();
334 void execute(Loader &l, const ArgumentStore &as) const override
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);
340 std::string get_signature() const override
343 result += TypeInfo<T0>::signature;
344 result += TypeInfo<T1>::signature;
349 } // namespace DataFile