Ariles
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 
16 namespace 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 
77 namespace 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 
135 namespace 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 
227 namespace 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 
284 namespace 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 
302 namespace 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::count::Parameters
visitor::Parameters Parameters
Definition: count.h:26
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
ariles2
Definition: basic.h:17
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.1