Ariles
Loading...
Searching...
No Matches
basic.h
Go to the documentation of this file.
1/**
2 @file
3 @author Alexander Sherikov
4
5 @copyright 2017-2018 Alexander Sherikov, Licensed under the Apache License, Version 2.0.
6 (see @ref LICENSE or http://www.apache.org/licenses/LICENSE-2.0)
7
8 @brief
9*/
10
11#pragma once
12
13#include "../internal/helpers.h"
14#include "../visitors/count.h"
15
16namespace ariles2
17{
18 namespace read
19 {
20 template <class t_Visitor, class t_Entry>
21 void apply_read(
22 t_Visitor &visitor,
23 t_Entry &entry,
24 const typename t_Visitor::Parameters &parameters,
25 ARILES2_IS_BASE_ENABLER(ariles2::read::Base, t_Entry))
26 {
27 CPPUT_TRACE_FUNCTION;
28
29 if (parameters.override_parameters_)
30 {
31 visitor.startMap(entry, parameters);
32 entry.arilesVirtualVisit(visitor, parameters);
33 }
34 else
35 {
36 visitor.startMap(entry, entry.arilesGetParameters(visitor));
37 entry.arilesVirtualVisit(visitor, entry.arilesGetParameters(visitor));
38 }
39 visitor.endMap();
40 }
41
42
43 /**
44 * @brief Read configuration entry (an enum)
45 * This function is necessary since an explicit casting to integer is needed.
46 */
47 template <
48 class t_Visitor,
49 typename t_Enumeration,
50 typename = std::enable_if_t<std::is_enum<t_Enumeration>::value>>
51 void apply_read(t_Visitor &visitor, t_Enumeration &entry, const typename t_Visitor::Parameters & /*param*/)
52 {
53 CPPUT_TRACE_FUNCTION;
54 int tmp_value = 0;
55 visitor.readElement(tmp_value);
56 entry = static_cast<t_Enumeration>(tmp_value);
57 }
58
59
60#define ARILES2_BASIC_TYPE(type) \
61 template <class t_Visitor> \
62 void apply_read(t_Visitor &visitor, type &entry, const typename t_Visitor::Parameters &param) \
63 { \
64 CPPUT_TRACE_FUNCTION; \
65 CPPUT_UNUSED_ARG(param); \
66 visitor.readElement(entry); \
67 }
68
69 ARILES2_BASIC_TYPES_LIST
70 ARILES2_COMPLEX_NUMBER_TYPES_LIST
71
72#undef ARILES2_BASIC_TYPE
73 } // namespace read
74} // namespace ariles2
75
76
77namespace ariles2
78{
79 namespace write
80 {
81 template <class t_Visitor, class t_Entry>
82 void apply_write(
83 t_Visitor &writer,
84 const t_Entry &entry,
85 const typename t_Visitor::Parameters &parameters,
86 ARILES2_IS_BASE_ENABLER(ariles2::write::Base, t_Entry))
87 {
88 CPPUT_TRACE_FUNCTION;
89
90 if (parameters.override_parameters_)
91 {
92 writer.startMap(entry, parameters);
93 entry.arilesVirtualVisit(writer, parameters);
94 }
95 else
96 {
97 writer.startMap(entry, entry.arilesGetParameters(writer));
98 entry.arilesVirtualVisit(writer, entry.arilesGetParameters(writer));
99 }
100 writer.endMap();
101 }
102
103
104
105 template <
106 class t_Visitor,
107 typename t_Enumeration,
108 typename = std::enable_if_t<std::is_enum<t_Enumeration>::value>>
109 void apply_write(t_Visitor &writer, const t_Enumeration entry, const typename t_Visitor::Parameters &param)
110 {
111 CPPUT_TRACE_FUNCTION;
112 writer.writeElement(static_cast<int>(entry), param);
113 }
114
115
116#define ARILES2_BASIC_TYPE(type) \
117 template <class t_Visitor> \
118 void apply_write(t_Visitor &writer, const type &entry, const typename t_Visitor::Parameters &param) \
119 { \
120 CPPUT_TRACE_FUNCTION; \
121 writer.writeElement(entry, param); \
122 }
123
124 /**
125 * @brief Generate apply methods for basic types.
126 */
127 ARILES2_BASIC_TYPES_LIST
128 ARILES2_COMPLEX_NUMBER_TYPES_LIST
129
130#undef ARILES2_BASIC_TYPE
131 } // namespace write
132} // namespace ariles2
133
134
135namespace ariles2
136{
137 namespace compare
138 {
139 template <class t_Visitor, class t_Left, class t_Right, typename = ariles2::traits::is_ariles_t<t_Left>>
140 void apply_compare(
141 t_Visitor &visitor,
142 const t_Left &left,
143 const t_Right &right,
144 const typename t_Visitor::Parameters &param)
145 {
146 CPPUT_TRACE_FUNCTION;
147 if (param.compare_number_of_entries_)
148 {
149 visitor.equal_ &= (ariles2::apply<ariles2::Count>(left) == ariles2::apply<ariles2::Count>(right));
150 }
151 left.arilesVisit(visitor, right, param);
152 }
153
154
155 template <
156 class t_Visitor,
157 typename t_Enumeration,
158 typename = std::enable_if_t<std::is_enum<t_Enumeration>::value>>
159 void apply_compare(
160 t_Visitor &visitor,
161 const t_Enumeration &left,
162 const t_Enumeration &right,
163 const typename t_Visitor::Parameters & /*param*/)
164 {
165 visitor.equal_ &= (left == right);
166 }
167
168
169#define ARILES2_BASIC_TYPE(type) \
170 template <class t_Visitor> \
171 inline void apply_compare( \
172 t_Visitor &visitor, const type &left, const type &right, const typename t_Visitor::Parameters &) \
173 { \
174 visitor.equal_ &= (left == right); \
175 }
176
177/**
178 * @brief Generate compare methods for basic types.
179 */
180#define ARILES2_COMPARE_TYPES_LIST \
181 ARILES2_BASIC_INTEGER_TYPES_LIST \
182 ARILES2_BASIC_TYPE(bool) \
183 ARILES2_BASIC_TYPE(std::string)
184
185 ARILES2_COMPARE_TYPES_LIST
186
187#undef ARILES2_BASIC_TYPE
188
189
190
191 template <class t_Visitor, class t_Scalar>
192 void apply_compare(
193 t_Visitor &visitor,
194 const std::complex<t_Scalar> &left,
195 const std::complex<t_Scalar> &right,
196 const typename t_Visitor::Parameters &param)
197 {
198 apply_compare(visitor, left.real(), right.real(), param);
199 apply_compare(visitor, left.imag(), right.imag(), param);
200 }
201
202
203 template <class t_Visitor>
204 void apply_compare(
205 t_Visitor &visitor,
206 const float &left,
207 const float &right,
208 const typename t_Visitor::Parameters &param)
209 {
210 visitor.equal_ &= (visitor.compareFloats(left, right, param));
211 }
212
213
214 template <class t_Visitor>
215 void apply_compare(
216 t_Visitor &visitor,
217 const double &left,
218 const double &right,
219 const typename t_Visitor::Parameters &param)
220 {
221 visitor.equal_ &= visitor.compareFloats(left, right, param);
222 }
223 } // namespace compare
224} // namespace ariles2
225
226
227namespace ariles2
228{
229 namespace defaults
230 {
231 template <class t_Visitor, class t_Entry>
232 void apply_defaults(
233 const t_Visitor &visitor,
234 t_Entry &entry,
235 const typename t_Visitor::Parameters &param,
236 ARILES2_IS_BASE_ENABLER(ariles2::defaults::Base, t_Entry))
237 {
238 CPPUT_TRACE_FUNCTION;
239 entry.arilesVirtualVisit(visitor, param);
240 }
241
242
243 template <
244 class t_Visitor,
245 typename t_Enumeration,
246 typename = std::enable_if_t<std::is_enum<t_Enumeration>::value>>
247 void apply_defaults(
248 const t_Visitor & /*visitor*/,
249 t_Enumeration & /*entry*/,
250 const typename t_Visitor::Parameters & /*param*/)
251 {
252 CPPUT_TRACE_FUNCTION;
253 }
254
255
256 template <class t_Visitor, typename t_Scalar>
257 void apply_defaults(
258 const t_Visitor & /*visitor*/,
259 std::complex<t_Scalar> &entry,
260 const typename t_Visitor::Parameters &param)
261 {
262 CPPUT_TRACE_FUNCTION;
263 entry.real(param.template getDefault<t_Scalar>());
264 entry.imag(param.template getDefault<t_Scalar>());
265 }
266
267
268#define ARILES2_BASIC_TYPE(type) \
269 template <class t_Visitor> \
270 void apply_defaults(const t_Visitor &, type &entry, const typename t_Visitor::Parameters &param) \
271 { \
272 CPPUT_TRACE_FUNCTION; \
273 entry = param.template getDefault<type>(); \
274 }
275
276 ARILES2_BASIC_TYPES_LIST
277
278#undef ARILES2_BASIC_TYPE
279 } // namespace defaults
280} // namespace ariles2
281
282
283
284namespace ariles2
285{
286 namespace process
287 {
288 template <class t_Visitor, class t_Entry>
289 void apply_process(const t_Visitor &visitor, t_Entry &entry, const typename t_Visitor::Parameters &param)
290 {
291 CPPUT_TRACE_FUNCTION;
292 if constexpr (std::is_base_of_v<ariles2::Ariles, t_Entry>)
293 {
294 entry.arilesVirtualVisit(visitor, param);
295 }
296 }
297 } // namespace process
298} // namespace ariles2
299
300
301
302namespace ariles2
303{
304 namespace copyfrom
305 {
306 template <class t_Visitor, class t_Left, class t_Right, typename = ariles2::traits::is_ariles_t<t_Left>>
307 void apply_copyfrom(
308 t_Visitor &visitor,
309 t_Left &left,
310 const t_Right &right,
311 const typename t_Visitor::Parameters &param)
312 {
313 CPPUT_TRACE_FUNCTION;
314 CPPUT_TRACE_TYPE(left);
315 CPPUT_TRACE_TYPE(right);
316
317 left.arilesVisit(visitor, right, param);
318 }
319
320
321#define ARILES2_BASIC_TYPE(type) \
322 template <class t_Visitor> \
323 void apply_copyfrom(t_Visitor &, type &left, const type &right, const typename t_Visitor::Parameters &) \
324 { \
325 CPPUT_TRACE_FUNCTION; \
326 left = right; \
327 }
328
329 ARILES2_BASIC_TYPES_LIST
330 ARILES2_COMPLEX_NUMBER_TYPES_LIST
331
332#undef ARILES2_BASIC_TYPE
333
334 template <
335 class t_Visitor,
336 typename t_Enumeration,
337 typename = std::enable_if_t<std::is_enum<t_Enumeration>::value>>
338 void apply_copyfrom(
339 t_Visitor &,
340 t_Enumeration &left,
341 const t_Enumeration &right,
342 const typename t_Visitor::Parameters &)
343 {
344 CPPUT_TRACE_FUNCTION;
345 left = right;
346 }
347 } // namespace copyfrom
348
349
350 namespace copyto
351 {
352 template <class t_Visitor, class t_Left, class t_Right, typename = ariles2::traits::is_ariles_t<t_Left>>
353 void apply_copyto(
354 t_Visitor &visitor,
355 const t_Left &left,
356 t_Right &right,
357 const typename t_Visitor::Parameters &param)
358 {
359 CPPUT_TRACE_FUNCTION;
360 CPPUT_TRACE_TYPE(left);
361 CPPUT_TRACE_TYPE(right);
362
363 left.arilesVisit(visitor, right, param);
364 }
365
366
367#define ARILES2_BASIC_TYPE(type) \
368 template <class t_Visitor> \
369 void apply_copyto(t_Visitor &, const type &left, type &right, const typename t_Visitor::Parameters &) \
370 { \
371 CPPUT_TRACE_FUNCTION; \
372 right = left; \
373 }
374
375 ARILES2_BASIC_TYPES_LIST
376 ARILES2_COMPLEX_NUMBER_TYPES_LIST
377
378#undef ARILES2_BASIC_TYPE
379
380 template <
381 class t_Visitor,
382 typename t_Enumeration,
383 typename = std::enable_if_t<std::is_enum<t_Enumeration>::value>>
384 void apply_copyto(
385 t_Visitor &,
386 const t_Enumeration &left,
387 t_Enumeration &right,
388 const typename t_Visitor::Parameters &)
389 {
390 CPPUT_TRACE_FUNCTION;
391 right = left;
392 }
393 } // namespace copyto
394} // namespace ariles2
ARILES2_COMPARE_TYPES_LIST
#define ARILES2_COMPARE_TYPES_LIST
Generate compare methods for basic types.
Definition basic.h:180
ARILES2_COMPLEX_NUMBER_TYPES_LIST
#define ARILES2_COMPLEX_NUMBER_TYPES_LIST
Definition helpers.h:68
ARILES2_IS_BASE_ENABLER
#define ARILES2_IS_BASE_ENABLER(Base, Derived)
Definition helpers.h:25
ARILES2_BASIC_TYPES_LIST
#define ARILES2_BASIC_TYPES_LIST
Definition helpers.h:72
ariles2::compare::apply_compare
void apply_compare(t_Visitor &visitor, const t_Left &left, const t_Right &right, const typename t_Visitor::Parameters &param)
Definition basic.h:140
ariles2::copyfrom::apply_copyfrom
void apply_copyfrom(t_Visitor &visitor, t_Left &left, const t_Right &right, const typename t_Visitor::Parameters &param)
Definition basic.h:307
ariles2::copyto::apply_copyto
void apply_copyto(t_Visitor &visitor, const t_Left &left, t_Right &right, const typename t_Visitor::Parameters &param)
Definition basic.h:353
ariles2::defaults::apply_defaults
void apply_defaults(const t_Visitor &visitor, t_Entry &entry, const typename t_Visitor::Parameters &param, ARILES2_IS_BASE_ENABLER(ariles2::defaults::Base, t_Entry))
Definition basic.h:232
ariles2::process::apply_process
void apply_process(const t_Visitor &visitor, t_Entry &entry, const typename t_Visitor::Parameters &param)
Definition basic.h:289
ariles2::read::apply_read
void apply_read(t_Visitor &visitor, t_Entry &entry, const typename t_Visitor::Parameters &parameters, ARILES2_IS_BASE_ENABLER(ariles2::read::Base, t_Entry))
Definition basic.h:21
ariles2::write::apply_write
void apply_write(t_Visitor &writer, const t_Entry &entry, const typename t_Visitor::Parameters &parameters, ARILES2_IS_BASE_ENABLER(ariles2::write::Base, t_Entry))
Definition basic.h:82
CPPUT_TRACE_FUNCTION
#define CPPUT_TRACE_FUNCTION
Definition trace.h:126
CPPUT_TRACE_TYPE
#define CPPUT_TRACE_TYPE(type)
Definition trace.h:128
Generated by doxygen 1.9.8