COMMS
Template library intended to help with implementation of communication protocols.
Loading...
Searching...
No Matches
units.h
Go to the documentation of this file.
1//
2// Copyright 2017 - 2025 (C). Alex Robenko. All rights reserved.
3//
4// This Source Code Form is subject to the terms of the Mozilla Public
5// License, v. 2.0. If a copy of the MPL was not distributed with this
6// file, You can obtain one at http://mozilla.org/MPL/2.0/.
7
10
11#pragma once
12
14#include "comms/details/tag.h"
15#include "comms/traits.h"
17
18#include <ratio>
19#include <type_traits>
20#include <utility>
21
22COMMS_MSVC_WARNING_PUSH
23COMMS_MSVC_WARNING_DISABLE(4100) // Disable unreferenced parameter warning
24COMMS_MSVC_WARNING_DISABLE(4127) // Disable warning about constant conditional expressions
25
26namespace comms
27{
28
29namespace units
30{
31
32namespace details
33{
34
35template <typename TField>
36using ScalingRatioOf = typename TField::ScalingRatio;
37
38template <typename TField, typename TConvRatio>
39using FullUnitsRatioOf =
40 typename std::ratio_divide<
41 typename std::ratio_multiply<
42 ScalingRatioOf<TField>,
43 typename TField::UnitsRatio
44 >::type,
45 TConvRatio
46 >::type;
47
48template <typename...>
49struct UnitsValueConverter
50{
51 template <typename TRet, typename TConvRatio, typename TField>
52 static TRet getValue(const TField& field)
53 {
54 using Ratio = FullUnitsRatioOf<TField, TConvRatio>;
55 using Tag = RatioTag<TField, TConvRatio>;
56 return getValueInternal<TRet, Ratio>(field, Tag());
57 }
58
59 template <typename TConvRatio, typename TField, typename TVal>
60 static void setValue(TField& field, TVal&& value)
61 {
62 using Ratio = FullUnitsRatioOf<TField, TConvRatio>;
63 using Tag = RatioTag<TField, TConvRatio>;
64 return setValueInternal<Ratio>(field, std::forward<TVal>(value), Tag());
65 }
66
67private:
68 template <typename...>
69 using HasConversionTag = comms::details::tag::Tag1<>;
70
71 template <typename...>
72 using NoConversionTag = comms::details::tag::Tag2<>;
73
74 template <typename...>
75 using ConvertToFpTag = comms::details::tag::Tag3<>;
76
77 template <typename...>
78 using ConvertToIntTag = comms::details::tag::Tag4<>;
79
80 template <typename TField, typename TConvRatio>
81 using RatioTag =
82 typename comms::util::LazyShallowConditional<
83 std::is_same<FullUnitsRatioOf<TField, TConvRatio>, std::ratio<1, 1> >::value
84 >::template Type<
85 NoConversionTag,
86 HasConversionTag
87 >;
88
89 template <typename TRet>
90 using TypeTag =
91 typename comms::util::LazyShallowConditional<
92 std::is_floating_point<TRet>::value
93 >::template Type<
94 ConvertToFpTag,
95 ConvertToIntTag
96 >;
97
98 template <typename TRet, typename TRatio, typename TField, typename... TParams>
99 static TRet getValueInternal(const TField& field, NoConversionTag<TParams...>)
100 {
101 return static_cast<TRet>(field.value());
102 }
103
104 template <typename TRet, typename TRatio, typename TField, typename... TParams>
105 static TRet getValueInternal(const TField& field, HasConversionTag<TParams...>)
106 {
107 using Tag = TypeTag<TRet>;
108 return getValueInternal<TRet, TRatio>(field, Tag());
109 }
110
111 template <typename TRet, typename TRatio, typename TField, typename... TParams>
112 static TRet getValueInternal(const TField& field, ConvertToFpTag<TParams...>)
113 {
114 static_assert(std::is_floating_point<TRet>::value,
115 "TRet is expected to be floating point type");
116 return static_cast<TRet>(field.value()) * (static_cast<TRet>(TRatio::num) / static_cast<TRet>(TRatio::den));
117 }
118
119 template <typename TRet, typename TRatio, typename TField, typename... TParams>
120 static TRet getValueInternal(const TField& field, ConvertToIntTag<TParams...>)
121 {
122 static_assert(std::is_integral<TRet>::value,
123 "TRet is expected to be integral type");
124
125 using FieldType = typename std::decay<decltype(field)>::type;
126 using ValueType = typename FieldType::ValueType;
127
128 static_assert(
129 std::is_integral<ValueType>::value ||
130 std::is_floating_point<ValueType>::value ||
131 std::is_enum<ValueType>::value,
132 "Unexpected field in units conversion");
133
134 using CastType =
136 std::is_floating_point<ValueType>::value
137 >::template Type<
139 std::is_same<ValueType, float>::value
140 >::template Type<
141 double,
142 ValueType
143 >,
145 std::is_signed<TRet>::value
146 >::template Type<
147 std::intmax_t,
148 std::uintmax_t
149 >
150 >;
151
152 return
153 static_cast<TRet>(
154 (static_cast<CastType>(field.value()) * TRatio::num) / TRatio::den);
155 }
156
157 template <typename TRatio, typename TField, typename TVal, typename... TParams>
158 static void setValueInternal(TField& field, TVal&& value, NoConversionTag<TParams...>)
159 {
160 using FieldType = typename std::decay<decltype(field)>::type;
161 using ValueType = typename FieldType::ValueType;
162 field.value() = static_cast<ValueType>(value);
163 }
164
165 template <typename TRatio, typename TField, typename TVal, typename... TParams>
166 static void setValueInternal(TField& field, TVal&& value, HasConversionTag<TParams...>)
167 {
168 using Tag = TypeTag<typename std::decay<decltype(value)>::type>;
169 setValueInternal<TRatio>(field, std::forward<TVal>(value), Tag());
170 }
171
172 template <typename TRatio, typename TField, typename TVal, typename... TParams>
173 static void setValueInternal(TField& field, TVal&& value, ConvertToIntTag<TParams...>)
174 {
175 using FieldType = typename std::decay<decltype(field)>::type;
176 using ValueType = typename FieldType::ValueType;
177
178 static_assert(
179 std::is_integral<ValueType>::value ||
180 std::is_floating_point<ValueType>::value ||
181 std::is_enum<ValueType>::value,
182 "Unexpected field in units conversion");
183
184 using CastType =
186 std::is_floating_point<ValueType>::value
187 >::template Type<
189 std::is_same<ValueType, float>::value
190 >::template Type<
191 double,
192 ValueType
193 >,
195 std::is_signed<typename std::decay<decltype(value)>::type>::value
196 >::template Type<
197 std::intmax_t,
198 std::uintmax_t
199 >
200 >;
201
202 field.value() =
203 static_cast<ValueType>(
204 (static_cast<CastType>(value) * TRatio::den) / static_cast<CastType>(TRatio::num));
205 }
206
207 template <typename TRatio, typename TField, typename TVal, typename... TParams>
208 static void setValueInternal(TField& field, TVal&& value, ConvertToFpTag<TParams...>)
209 {
210 using DecayedType = typename std::decay<decltype(value)>::type;
211 using FieldType = typename std::decay<decltype(field)>::type;
212 using ValueType = typename FieldType::ValueType;
213
214 auto epsilon = DecayedType(0);
215 if ((TRatio::num < TRatio::den) && std::is_integral<ValueType>::value) {
216 epsilon = static_cast<DecayedType>(TRatio::num) / static_cast<DecayedType>(TRatio::den + 1);
217 }
218
219 if (epsilon < DecayedType(0)) {
220 epsilon = -epsilon;
221 }
222
223 if (value < DecayedType(0)) {
224 epsilon = -epsilon;
225 }
226
227 field.value() =
228 static_cast<ValueType>(
229 ((value + epsilon) * static_cast<DecayedType>(TRatio::den)) / static_cast<DecayedType>(TRatio::num));
230 }
231
232};
233
234template <typename TField, typename TType>
235constexpr bool hasExpectedUnits()
236{
237 return std::is_same<typename TField::UnitsType, TType>::value;
238}
239
240template <typename TRet, typename TConvRatio, typename TField>
241TRet getTime(const TField& field)
242{
243 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Time>(),
244 "The field is expected to contain \"time\" units.");
245 return UnitsValueConverter<>::getValue<TRet, TConvRatio>(field);
246}
247
248template <typename TConvRatio, typename TField, typename TVal>
249void setTime(TField& field, TVal&& val)
250{
251 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Time>(),
252 "The field is expected to contain \"time\" units.");
253 UnitsValueConverter<>::setValue<TConvRatio>(field, std::forward<TVal>(val));
254}
255
256template <typename TRet, typename TConvRatio, typename TField>
257TRet getDistance(const TField& field)
258{
259 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Distance>(),
260 "The field is expected to contain \"distance\" units.");
261 return UnitsValueConverter<>::getValue<TRet, TConvRatio>(field);
262}
263
264template <typename TConvRatio, typename TField, typename TVal>
265void setDistance(TField& field, TVal&& val)
266{
267 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Distance>(),
268 "The field is expected to contain \"distance\" units.");
269 UnitsValueConverter<>::setValue<TConvRatio>(field, std::forward<TVal>(val));
270}
271
272template <typename TRet, typename TConvRatio, typename TField>
273TRet getSpeed(const TField& field)
274{
275 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Speed>(),
276 "The field is expected to contain \"speed\" units.");
277 return UnitsValueConverter<>::getValue<TRet, TConvRatio>(field);
278}
279
280template <typename TConvRatio, typename TField, typename TVal>
281void setSpeed(TField& field, TVal&& val)
282{
283 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Speed>(),
284 "The field is expected to contain \"speed\" units.");
285 UnitsValueConverter<>::setValue<TConvRatio>(field, std::forward<TVal>(val));
286}
287
288template <typename TRet, typename TConvRatio, typename TField>
289TRet getFrequency(const TField& field)
290{
291 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Frequency>(),
292 "The field is expected to contain \"frequency\" units.");
293 return UnitsValueConverter<>::getValue<TRet, TConvRatio>(field);
294}
295
296template <typename TConvRatio, typename TField, typename TVal>
297void setFrequency(TField& field, TVal&& val)
298{
299 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Frequency>(),
300 "The field is expected to contain \"frequency\" units.");
301 UnitsValueConverter<>::setValue<TConvRatio>(field, std::forward<TVal>(val));
302}
303
304template <typename T>
305struct PI
306{
307 static constexpr T Value = static_cast<T>(3.14159265358979323846264338327950288419716939937510582097494459230781640628620899L);
308};
309
310template <typename...>
311struct AngleValueConverter
312{
313 template <typename TRet, typename TConvRatio, typename TField>
314 static TRet getValue(const TField& field)
315 {
316 using FieldType = typename std::decay<decltype(field)>::type;
317 static_assert(details::hasExpectedUnits<FieldType, comms::traits::units::Angle>(),
318 "The field is expected to contain \"angle\" units.");
319
320 using Tag = GetTag<FieldType, TConvRatio>;
321 return getValueInternal<TRet, TConvRatio>(field, Tag());
322 }
323
324 template <typename TConvRatio, typename TField, typename TVal>
325 static void setValue(TField& field, TVal&& val)
326 {
327 using FieldType = typename std::decay<decltype(field)>::type;
328 static_assert(details::hasExpectedUnits<FieldType, comms::traits::units::Angle>(),
329 "The field is expected to contain \"angle\" units.");
330
331 using Tag = SetTag<FieldType, TConvRatio>;
332 setValueInternal<TConvRatio>(field, std::forward<TVal>(val), Tag());
333 }
334
335private:
336 template <typename... TParams>
337 using SameUnitsTag = comms::details::tag::Tag1<>;
338
339 template <typename... TParams>
340 using DegreesToRadiansTag = comms::details::tag::Tag2<>;
341
342 template <typename... TParams>
343 using RadiansToDegreesTag = comms::details::tag::Tag3<>;
344
345 template <typename TConvRatio>
346 using SetUnitsTag =
347 typename comms::util::LazyShallowConditional<
348 std::is_same<TConvRatio, typename comms::traits::units::RadiansRatio>::value
349 >::template Type<
350 RadiansToDegreesTag,
351 DegreesToRadiansTag
352 >;
353
354 template <typename TConvRatio>
355 using GetUnitsTag =
356 typename comms::util::LazyShallowConditional<
357 std::is_same<TConvRatio, typename comms::traits::units::RadiansRatio>::value
358 >::template Type<
359 DegreesToRadiansTag,
360 RadiansToDegreesTag
361 >;
362
363 template <typename TField, typename TConvRatio>
364 using GetTag =
365 typename comms::util::LazyShallowConditional<
366 std::is_same<TConvRatio, typename TField::UnitsRatio>::value
367 >::template Type<
368 SameUnitsTag,
369 GetUnitsTag,
370 TConvRatio
371 >;
372
373 template <typename TField, typename TConvRatio>
374 using SetTag =
375 typename comms::util::LazyShallowConditional<
376 std::is_same<TConvRatio, typename TField::UnitsRatio>::value
377 >::template Type<
378 SameUnitsTag,
379 SetUnitsTag,
380 TConvRatio
381 >;
382
383 template <typename TRet, typename TConvRatio, typename TField, typename... TParams>
384 static TRet getValueInternal(const TField& field, SameUnitsTag<TParams...>)
385 {
386 return field.template getScaled<TRet>();
387 }
388
389 template <typename TRet, typename TConvRatio, typename TField, typename... TParams>
390 static TRet getValueInternal(const TField& field, DegreesToRadiansTag<TParams...>)
391 {
392 using FieldType = typename std::decay<decltype(field)>::type;
393 static_assert(std::is_same<typename FieldType::UnitsRatio, comms::traits::units::DegreesRatio>::value,
394 "The field is expected to contain degrees.");
395
396 return PI<TRet>::Value * UnitsValueConverter<>::getValue<TRet, TConvRatio>(field);
397 }
398
399 template <typename TRet, typename TConvRatio, typename TField, typename... TParams>
400 static TRet getValueInternal(const TField& field, RadiansToDegreesTag<TParams...>)
401 {
402 using FieldType = typename std::decay<decltype(field)>::type;
403 static_assert(std::is_same<typename FieldType::UnitsRatio, comms::traits::units::RadiansRatio>::value,
404 "The field is expected to contain radians.");
405
406 return UnitsValueConverter<>::getValue<TRet, TConvRatio>(field) / PI<TRet>::Value;
407 }
408
409 template <typename TConvRatio, typename TField, typename TVal, typename... TParams>
410 static void setValueInternal(TField& field, TVal&& val, SameUnitsTag<TParams...>)
411 {
412 field.setScaled(std::forward<TVal>(val));
413 }
414
415 template <typename TConvRatio, typename TField, typename TVal, typename... TParams>
416 static void setValueInternal(TField& field, TVal&& val, DegreesToRadiansTag<TParams...>)
417 {
418 using FieldType = typename std::decay<decltype(field)>::type;
419 static_assert(std::is_same<typename FieldType::UnitsRatio, comms::traits::units::RadiansRatio>::value,
420 "The field is expected to contain radians.");
421
422 using ValueType = typename std::decay<decltype(val)>::type;
423 using PiType =
425 std::is_floating_point<ValueType>::value
426 >::template Type<
427 ValueType,
428 double
429 >;
430
431 UnitsValueConverter<>::setValue<TConvRatio>(field, val * PI<PiType>::Value);
432 }
433
434 template <typename TConvRatio, typename TField, typename TVal, typename... TParams>
435 static void setValueInternal(TField& field, TVal&& val, RadiansToDegreesTag<TParams...>)
436 {
437 using FieldType = typename std::decay<decltype(field)>::type;
438 static_assert(std::is_same<typename FieldType::UnitsRatio, comms::traits::units::DegreesRatio>::value,
439 "The field is expected to contain degrees.");
440
441 using ValueType = typename std::decay<decltype(val)>::type;
442 using PiType =
444 std::is_floating_point<ValueType>::value
445 >::template Type<
446 ValueType,
447 double
448 >;
449
450 UnitsValueConverter<>::setValue<TConvRatio>(field, static_cast<PiType>(val) / PI<PiType>::Value);
451 }
452};
453
454template <typename TRet, typename TConvRatio, typename TField>
455TRet getAngle(const TField& field)
456{
457 return AngleValueConverter<>::getValue<TRet, TConvRatio>(field);
458}
459
460template <typename TConvRatio, typename TField, typename TVal>
461void setAngle(TField& field, TVal&& val)
462{
463 AngleValueConverter<>::setValue<TConvRatio>(field, std::forward<TVal>(val));
464}
465
466template <typename TRet, typename TConvRatio, typename TField>
467TRet getCurrent(const TField& field)
468{
469 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Current>(),
470 "The field is expected to contain \"current\" units.");
471 return UnitsValueConverter<>::getValue<TRet, TConvRatio>(field);
472}
473
474template <typename TConvRatio, typename TField, typename TVal>
475void setCurrent(TField& field, TVal&& val)
476{
477 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Current>(),
478 "The field is expected to contain \"current\" units.");
479 UnitsValueConverter<>::setValue<TConvRatio>(field, std::forward<TVal>(val));
480}
481
482template <typename TRet, typename TConvRatio, typename TField>
483TRet getVoltage(const TField& field)
484{
485 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Voltage>(),
486 "The field is expected to contain \"voltage\" units.");
487 return UnitsValueConverter<>::getValue<TRet, TConvRatio>(field);
488}
489
490template <typename TConvRatio, typename TField, typename TVal>
491void setVoltage(TField& field, TVal&& val)
492{
493 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Voltage>(),
494 "The field is expected to contain \"voltage\" units.");
495 UnitsValueConverter<>::setValue<TConvRatio>(field, std::forward<TVal>(val));
496}
497
498template <typename TRet, typename TConvRatio, typename TField>
499TRet getMemory(const TField& field)
500{
501 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Memory>(),
502 "The field is expected to contain \"memory\" units.");
503 return UnitsValueConverter<>::getValue<TRet, TConvRatio>(field);
504}
505
506template <typename TConvRatio, typename TField, typename TVal>
507void setMemory(TField& field, TVal&& val)
508{
509 static_assert(details::hasExpectedUnits<typename std::decay<decltype(field)>::type, comms::traits::units::Memory>(),
510 "The field is expected to contain \"memory\" units.");
511 UnitsValueConverter<>::setValue<TConvRatio>(field, std::forward<TVal>(val));
512}
513
514} // namespace details
515
526template <typename TRet, typename TField>
527TRet getNanoseconds(const TField& field)
528{
529 return details::getTime<TRet, comms::traits::units::NanosecondsRatio>(field);
530}
531
542template <typename TField, typename TVal>
543void setNanoseconds(TField& field, TVal&& val)
544{
545 details::setTime<comms::traits::units::NanosecondsRatio>(field, std::forward<TVal>(val));
546}
547
550template <typename TField>
551constexpr bool isNanoseconds()
552{
553 return
554 TField::hasUnits() &&
555 std::is_same<typename TField::UnitsType, comms::traits::units::Time>::value &&
556 std::is_same<typename TField::UnitsRatio, comms::traits::units::NanosecondsRatio>::value;
557}
558
563template <typename TField>
564constexpr bool isNanoseconds(const TField& field)
565{
566 return isNanoseconds<typename std::decay<decltype(field)>::type>();
567}
568
579template <typename TRet, typename TField>
580TRet getMicroseconds(const TField& field)
581{
582 return details::getTime<TRet, comms::traits::units::MicrosecondsRatio>(field);
583}
584
595template <typename TField, typename TVal>
596void setMicroseconds(TField& field, TVal&& val)
597{
598 details::setTime<comms::traits::units::MicrosecondsRatio>(field, std::forward<TVal>(val));
599}
600
603template <typename TField>
604constexpr bool isMicroseconds()
605{
606 return
607 TField::hasUnits() &&
608 std::is_same<typename TField::UnitsType, comms::traits::units::Time>::value &&
609 std::is_same<typename TField::UnitsRatio, comms::traits::units::MicrosecondsRatio>::value;
610}
611
616template <typename TField>
617constexpr bool isMicroseconds(const TField& field)
618{
619 return isMicroseconds<typename std::decay<decltype(field)>::type>();
620}
621
632template <typename TRet, typename TField>
633TRet getMilliseconds(const TField& field)
634{
635 return details::getTime<TRet, comms::traits::units::MillisecondsRatio>(field);
636}
637
648template <typename TField, typename TVal>
649void setMilliseconds(TField& field, TVal&& val)
650{
651 details::setTime<comms::traits::units::MillisecondsRatio>(field, std::forward<TVal>(val));
652}
653
656template <typename TField>
657constexpr bool isMilliseconds()
658{
659 return
660 TField::hasUnits() &&
661 std::is_same<typename TField::UnitsType, comms::traits::units::Time>::value &&
662 std::is_same<typename TField::UnitsRatio, comms::traits::units::MillisecondsRatio>::value;
663}
664
669template <typename TField>
670constexpr bool isMilliseconds(const TField& field)
671{
672 return isMilliseconds<typename std::decay<decltype(field)>::type>();
673}
674
685template <typename TRet, typename TField>
686TRet getSeconds(const TField& field)
687{
688 return details::getTime<TRet, comms::traits::units::SecondsRatio>(field);
689}
690
701template <typename TField, typename TVal>
702void setSeconds(TField& field, TVal&& val)
703{
704 details::setTime<comms::traits::units::SecondsRatio>(field, std::forward<TVal>(val));
705}
706
709template <typename TField>
710constexpr bool isSeconds()
711{
712 return
713 TField::hasUnits() &&
714 std::is_same<typename TField::UnitsType, comms::traits::units::Time>::value &&
715 std::is_same<typename TField::UnitsRatio, comms::traits::units::SecondsRatio>::value;
716}
717
722template <typename TField>
723constexpr bool isSeconds(const TField& field)
724{
725 return isSeconds<typename std::decay<decltype(field)>::type>();
726}
727
738template <typename TRet, typename TField>
739TRet getMinutes(const TField& field)
740{
741 return details::getTime<TRet, comms::traits::units::MinutesRatio>(field);
742}
743
754template <typename TField, typename TVal>
755void setMinutes(TField& field, TVal&& val)
756{
757 details::setTime<comms::traits::units::MinutesRatio>(field, std::forward<TVal>(val));
758}
759
762template <typename TField>
763constexpr bool isMinutes()
764{
765 return
766 TField::hasUnits() &&
767 std::is_same<typename TField::UnitsType, comms::traits::units::Time>::value &&
768 std::is_same<typename TField::UnitsRatio, comms::traits::units::MinutesRatio>::value;
769}
770
775template <typename TField>
776constexpr bool isMinutes(const TField& field)
777{
778 return isMinutes<typename std::decay<decltype(field)>::type>();
779}
780
791template <typename TRet, typename TField>
792TRet getHours(const TField& field)
793{
794 return details::getTime<TRet, comms::traits::units::HoursRatio>(field);
795}
796
807template <typename TField, typename TVal>
808void setHours(TField& field, TVal&& val)
809{
810 details::setTime<comms::traits::units::HoursRatio>(field, std::forward<TVal>(val));
811}
812
815template <typename TField>
816constexpr bool isHours()
817{
818 return
819 TField::hasUnits() &&
820 std::is_same<typename TField::UnitsType, comms::traits::units::Time>::value &&
821 std::is_same<typename TField::UnitsRatio, comms::traits::units::HoursRatio>::value;
822}
823
828template <typename TField>
829constexpr bool isHours(const TField& field)
830{
831 return isHours<typename std::decay<decltype(field)>::type>();
832}
833
844template <typename TRet, typename TField>
845TRet getDays(const TField& field)
846{
847 return details::getTime<TRet, comms::traits::units::DaysRatio>(field);
848}
849
860template <typename TField, typename TVal>
861void setDays(TField& field, TVal&& val)
862{
863 details::setTime<comms::traits::units::DaysRatio>(field, std::forward<TVal>(val));
864}
865
868template <typename TField>
869constexpr bool isDays()
870{
871 return
872 TField::hasUnits() &&
873 std::is_same<typename TField::UnitsType, comms::traits::units::Time>::value &&
874 std::is_same<typename TField::UnitsRatio, comms::traits::units::DaysRatio>::value;
875}
876
881template <typename TField>
882constexpr bool isDays(const TField& field)
883{
884 return isDays<typename std::decay<decltype(field)>::type>();
885}
886
897template <typename TRet, typename TField>
898TRet getWeeks(const TField& field)
899{
900 return details::getTime<TRet, comms::traits::units::WeeksRatio>(field);
901}
902
913template <typename TField, typename TVal>
914void setWeeks(TField& field, TVal&& val)
915{
916 details::setTime<comms::traits::units::WeeksRatio>(field, std::forward<TVal>(val));
917}
918
921template <typename TField>
922constexpr bool isWeeks()
923{
924 return
925 TField::hasUnits() &&
926 std::is_same<typename TField::UnitsType, comms::traits::units::Time>::value &&
927 std::is_same<typename TField::UnitsRatio, comms::traits::units::WeeksRatio>::value;
928}
929
934template <typename TField>
935constexpr bool isWeeks(const TField& field)
936{
937 return isWeeks<typename std::decay<decltype(field)>::type>();
938}
939
950template <typename TRet, typename TField>
951TRet getNanometers(const TField& field)
952{
953 return details::getDistance<TRet, comms::traits::units::NanometersRatio>(field);
954}
955
966template <typename TField, typename TVal>
967void setNanometers(TField& field, TVal&& val)
968{
969 details::setDistance<comms::traits::units::NanometersRatio>(field, std::forward<TVal>(val));
970}
971
974template <typename TField>
975constexpr bool isNanometers()
976{
977 return
978 TField::hasUnits() &&
979 std::is_same<typename TField::UnitsType, comms::traits::units::Distance>::value &&
980 std::is_same<typename TField::UnitsRatio, comms::traits::units::NanometersRatio>::value;
981}
982
987template <typename TField>
988constexpr bool isNanometers(const TField& field)
989{
990 return isNanometers<typename std::decay<decltype(field)>::type>();
991}
992
1003template <typename TRet, typename TField>
1004TRet getMicrometers(const TField& field)
1005{
1006 return details::getDistance<TRet, comms::traits::units::MicrometersRatio>(field);
1007}
1008
1019template <typename TField, typename TVal>
1020void setMicrometers(TField& field, TVal&& val)
1021{
1022 details::setDistance<comms::traits::units::MicrometersRatio>(field, std::forward<TVal>(val));
1023}
1024
1027template <typename TField>
1028constexpr bool isMicrometers()
1029{
1030 return
1031 TField::hasUnits() &&
1032 std::is_same<typename TField::UnitsType, comms::traits::units::Distance>::value &&
1033 std::is_same<typename TField::UnitsRatio, comms::traits::units::MicrometersRatio>::value;
1034}
1035
1040template <typename TField>
1041constexpr bool isMicrometers(const TField& field)
1042{
1043 return isMicrometers<typename std::decay<decltype(field)>::type>();
1044}
1045
1056template <typename TRet, typename TField>
1057TRet getMillimeters(const TField& field)
1058{
1059 return details::getDistance<TRet, comms::traits::units::MillimetersRatio>(field);
1060}
1061
1072template <typename TField, typename TVal>
1073void setMillimeters(TField& field, TVal&& val)
1074{
1075 details::setDistance<comms::traits::units::MillimetersRatio>(field, std::forward<TVal>(val));
1076}
1077
1080template <typename TField>
1081constexpr bool isMillimeters()
1082{
1083 return
1084 TField::hasUnits() &&
1085 std::is_same<typename TField::UnitsType, comms::traits::units::Distance>::value &&
1086 std::is_same<typename TField::UnitsRatio, comms::traits::units::MillimetersRatio>::value;
1087}
1088
1093template <typename TField>
1094constexpr bool isMillimeters(const TField& field)
1095{
1096 return isMillimeters<typename std::decay<decltype(field)>::type>();
1097}
1098
1109template <typename TRet, typename TField>
1110TRet getCentimeters(const TField& field)
1111{
1112 return details::getDistance<TRet, comms::traits::units::CentimetersRatio>(field);
1113}
1114
1125template <typename TField, typename TVal>
1126void setCentimeters(TField& field, TVal&& val)
1127{
1128 details::setDistance<comms::traits::units::CentimetersRatio>(field, std::forward<TVal>(val));
1129}
1130
1133template <typename TField>
1134constexpr bool isCentimeters()
1135{
1136 return
1137 TField::hasUnits() &&
1138 std::is_same<typename TField::UnitsType, comms::traits::units::Distance>::value &&
1139 std::is_same<typename TField::UnitsRatio, comms::traits::units::CentimetersRatio>::value;
1140}
1141
1146template <typename TField>
1147constexpr bool isCentimeters(const TField& field)
1148{
1149 return isCentimeters<typename std::decay<decltype(field)>::type>();
1150}
1151
1162template <typename TRet, typename TField>
1163TRet getMeters(const TField& field)
1164{
1165 return details::getDistance<TRet, comms::traits::units::MetersRatio>(field);
1166}
1167
1178template <typename TField, typename TVal>
1179void setMeters(TField& field, TVal&& val)
1180{
1181 details::setDistance<comms::traits::units::MetersRatio>(field, std::forward<TVal>(val));
1182}
1183
1186template <typename TField>
1187constexpr bool isMeters()
1188{
1189 return
1190 TField::hasUnits() &&
1191 std::is_same<typename TField::UnitsType, comms::traits::units::Distance>::value &&
1192 std::is_same<typename TField::UnitsRatio, comms::traits::units::MetersRatio>::value;
1193}
1194
1199template <typename TField>
1200constexpr bool isMeters(const TField& field)
1201{
1202 return isMeters<typename std::decay<decltype(field)>::type>();
1203}
1204
1215template <typename TRet, typename TField>
1216TRet getKilometers(const TField& field)
1217{
1218 return details::getDistance<TRet, comms::traits::units::KilometersRatio>(field);
1219}
1220
1231template <typename TField, typename TVal>
1232void setKilometers(TField& field, TVal&& val)
1233{
1234 details::setDistance<comms::traits::units::KilometersRatio>(field, std::forward<TVal>(val));
1235}
1236
1239template <typename TField>
1240constexpr bool isKilometers()
1241{
1242 return
1243 TField::hasUnits() &&
1244 std::is_same<typename TField::UnitsType, comms::traits::units::Distance>::value &&
1245 std::is_same<typename TField::UnitsRatio, comms::traits::units::KilometersRatio>::value;
1246}
1247
1252template <typename TField>
1253constexpr bool isKilometers(const TField& field)
1254{
1255 return isKilometers<typename std::decay<decltype(field)>::type>();
1256}
1257
1268template <typename TRet, typename TField>
1269TRet getNanometersPerSecond(const TField& field)
1270{
1271 return details::getSpeed<TRet, comms::traits::units::NanometersPerSecondRatio>(field);
1272}
1273
1284template <typename TField, typename TVal>
1285void setNanometersPerSecond(TField& field, TVal&& val)
1286{
1287 details::setSpeed<comms::traits::units::NanometersPerSecondRatio>(field, std::forward<TVal>(val));
1288}
1289
1292template <typename TField>
1294{
1295 return
1296 TField::hasUnits() &&
1297 std::is_same<typename TField::UnitsType, comms::traits::units::Speed>::value &&
1298 std::is_same<typename TField::UnitsRatio, comms::traits::units::NanometersPerSecondRatio>::value;
1299}
1300
1305template <typename TField>
1306constexpr bool isNanometersPerSecond(const TField& field)
1307{
1308 return isNanometersPerSecond<typename std::decay<decltype(field)>::type>();
1309}
1310
1321template <typename TRet, typename TField>
1322TRet getMicrometersPerSecond(const TField& field)
1323{
1324 return details::getSpeed<TRet, comms::traits::units::MicrometersPerSecondRatio>(field);
1325}
1326
1337template <typename TField, typename TVal>
1338void setMicrometersPerSecond(TField& field, TVal&& val)
1339{
1340 details::setSpeed<comms::traits::units::MicrometersPerSecondRatio>(field, std::forward<TVal>(val));
1341}
1342
1345template <typename TField>
1347{
1348 return
1349 TField::hasUnits() &&
1350 std::is_same<typename TField::UnitsType, comms::traits::units::Speed>::value &&
1351 std::is_same<typename TField::UnitsRatio, comms::traits::units::MicrometersPerSecondRatio>::value;
1352}
1353
1358template <typename TField>
1359constexpr bool isMicrometersPerSecond(const TField& field)
1360{
1361 return isMicrometersPerSecond<typename std::decay<decltype(field)>::type>();
1362}
1363
1374template <typename TRet, typename TField>
1375TRet getMillimetersPerSecond(const TField& field)
1376{
1377 return details::getSpeed<TRet, comms::traits::units::MillimetersPerSecondRatio>(field);
1378}
1379
1390template <typename TField, typename TVal>
1391void setMillimetersPerSecond(TField& field, TVal&& val)
1392{
1393 details::setSpeed<comms::traits::units::MillimetersPerSecondRatio>(field, std::forward<TVal>(val));
1394}
1395
1398template <typename TField>
1400{
1401 return
1402 TField::hasUnits() &&
1403 std::is_same<typename TField::UnitsType, comms::traits::units::Speed>::value &&
1404 std::is_same<typename TField::UnitsRatio, comms::traits::units::MillimetersPerSecondRatio>::value;
1405}
1406
1411template <typename TField>
1412constexpr bool isMillimetersPerSecond(const TField& field)
1413{
1414 return isMillimetersPerSecond<typename std::decay<decltype(field)>::type>();
1415}
1416
1427template <typename TRet, typename TField>
1428TRet getCentimetersPerSecond(const TField& field)
1429{
1430 return details::getSpeed<TRet, comms::traits::units::CentimetersPerSecondRatio>(field);
1431}
1432
1443template <typename TField, typename TVal>
1444void setCentimetersPerSecond(TField& field, TVal&& val)
1445{
1446 details::setSpeed<comms::traits::units::CentimetersPerSecondRatio>(field, std::forward<TVal>(val));
1447}
1448
1451template <typename TField>
1453{
1454 return
1455 TField::hasUnits() &&
1456 std::is_same<typename TField::UnitsType, comms::traits::units::Speed>::value &&
1457 std::is_same<typename TField::UnitsRatio, comms::traits::units::CentimetersPerSecondRatio>::value;
1458}
1459
1464template <typename TField>
1465constexpr bool isCentimetersPerSecond(const TField& field)
1466{
1467 return isCentimetersPerSecond<typename std::decay<decltype(field)>::type>();
1468}
1469
1480template <typename TRet, typename TField>
1481TRet getMetersPerSecond(const TField& field)
1482{
1483 return details::getSpeed<TRet, comms::traits::units::MetersPerSecondRatio>(field);
1484}
1485
1496template <typename TField, typename TVal>
1497void setMetersPerSecond(TField& field, TVal&& val)
1498{
1499 details::setSpeed<comms::traits::units::MetersPerSecondRatio>(field, std::forward<TVal>(val));
1500}
1501
1504template <typename TField>
1505constexpr bool isMetersPerSecond()
1506{
1507 return
1508 TField::hasUnits() &&
1509 std::is_same<typename TField::UnitsType, comms::traits::units::Speed>::value &&
1510 std::is_same<typename TField::UnitsRatio, comms::traits::units::MetersPerSecondRatio>::value;
1511}
1512
1517template <typename TField>
1518constexpr bool isMetersPerSecond(const TField& field)
1519{
1520 return isMetersPerSecond<typename std::decay<decltype(field)>::type>();
1521}
1522
1533template <typename TRet, typename TField>
1534TRet getKilometersPerSecond(const TField& field)
1535{
1536 return details::getSpeed<TRet, comms::traits::units::KilometersPerSecondRatio>(field);
1537}
1538
1549template <typename TField, typename TVal>
1550void setKilometersPerSecond(TField& field, TVal&& val)
1551{
1552 details::setSpeed<comms::traits::units::KilometersPerSecondRatio>(field, std::forward<TVal>(val));
1553}
1554
1557template <typename TField>
1559{
1560 return
1561 TField::hasUnits() &&
1562 std::is_same<typename TField::UnitsType, comms::traits::units::Speed>::value &&
1563 std::is_same<typename TField::UnitsRatio, comms::traits::units::KilometersPerSecondRatio>::value;
1564}
1565
1570template <typename TField>
1571constexpr bool isKilometersPerSecond(const TField& field)
1572{
1573 return isKilometersPerSecond<typename std::decay<decltype(field)>::type>();
1574}
1575
1586template <typename TRet, typename TField>
1587TRet getKilometersPerHour(const TField& field)
1588{
1589 return details::getSpeed<TRet, comms::traits::units::KilometersPerHourRatio>(field);
1590}
1591
1602template <typename TField, typename TVal>
1603void setKilometersPerHour(TField& field, TVal&& val)
1604{
1605 details::setSpeed<comms::traits::units::KilometersPerHourRatio>(field, std::forward<TVal>(val));
1606}
1607
1610template <typename TField>
1611constexpr bool isKilometersPerHour()
1612{
1613 return
1614 TField::hasUnits() &&
1615 std::is_same<typename TField::UnitsType, comms::traits::units::Speed>::value &&
1616 std::is_same<typename TField::UnitsRatio, comms::traits::units::KilometersPerHourRatio>::value;
1617}
1618
1623template <typename TField>
1624constexpr bool isKilometersPerHour(const TField& field)
1625{
1626 return isKilometersPerHour<typename std::decay<decltype(field)>::type>();
1627}
1628
1639template <typename TRet, typename TField>
1640TRet getHertz(const TField& field)
1641{
1642 return details::getFrequency<TRet, comms::traits::units::HzRatio>(field);
1643}
1644
1655template <typename TField, typename TVal>
1656void setHertz(TField& field, TVal&& val)
1657{
1658 details::setFrequency<comms::traits::units::HzRatio>(field, std::forward<TVal>(val));
1659}
1660
1663template <typename TField>
1664constexpr bool isHertz()
1665{
1666 return
1667 TField::hasUnits() &&
1668 std::is_same<typename TField::UnitsType, comms::traits::units::Frequency>::value &&
1669 std::is_same<typename TField::UnitsRatio, comms::traits::units::HzRatio>::value;
1670}
1671
1676template <typename TField>
1677constexpr bool isHertz(const TField& field)
1678{
1679 return isHertz<typename std::decay<decltype(field)>::type>();
1680}
1681
1692template <typename TRet, typename TField>
1693TRet getKilohertz(const TField& field)
1694{
1695 return details::getFrequency<TRet, comms::traits::units::KiloHzRatio>(field);
1696}
1697
1708template <typename TField, typename TVal>
1709void setKilohertz(TField& field, TVal&& val)
1710{
1711 details::setFrequency<comms::traits::units::KiloHzRatio>(field, std::forward<TVal>(val));
1712}
1713
1716template <typename TField>
1717constexpr bool isKilohertz()
1718{
1719 return
1720 TField::hasUnits() &&
1721 std::is_same<typename TField::UnitsType, comms::traits::units::Frequency>::value &&
1722 std::is_same<typename TField::UnitsRatio, comms::traits::units::KiloHzRatio>::value;
1723}
1724
1729template <typename TField>
1730constexpr bool isKilohertz(const TField& field)
1731{
1732 return isKilohertz<typename std::decay<decltype(field)>::type>();
1733}
1734
1745template <typename TRet, typename TField>
1746TRet getMegahertz(const TField& field)
1747{
1748 return details::getFrequency<TRet, comms::traits::units::MegaHzRatio>(field);
1749}
1750
1761template <typename TField, typename TVal>
1762void setMegahertz(TField& field, TVal&& val)
1763{
1764 details::setFrequency<comms::traits::units::MegaHzRatio>(field, std::forward<TVal>(val));
1765}
1766
1769template <typename TField>
1770constexpr bool isMegahertz()
1771{
1772 return
1773 TField::hasUnits() &&
1774 std::is_same<typename TField::UnitsType, comms::traits::units::Frequency>::value &&
1775 std::is_same<typename TField::UnitsRatio, comms::traits::units::MegaHzRatio>::value;
1776}
1777
1782template <typename TField>
1783constexpr bool isMegahertz(const TField& field)
1784{
1785 return isMegahertz<typename std::decay<decltype(field)>::type>();
1786}
1787
1798template <typename TRet, typename TField>
1799TRet getGigahertz(const TField& field)
1800{
1801 return details::getFrequency<TRet, comms::traits::units::GigaHzRatio>(field);
1802}
1803
1814template <typename TField, typename TVal>
1815void setGigahertz(TField& field, TVal&& val)
1816{
1817 details::setFrequency<comms::traits::units::GigaHzRatio>(field, std::forward<TVal>(val));
1818}
1819
1822template <typename TField>
1823constexpr bool isGigahertz()
1824{
1825 return
1826 TField::hasUnits() &&
1827 std::is_same<typename TField::UnitsType, comms::traits::units::Frequency>::value &&
1828 std::is_same<typename TField::UnitsRatio, comms::traits::units::GigaHzRatio>::value;
1829}
1830
1835template <typename TField>
1836constexpr bool isGigahertz(const TField& field)
1837{
1838 return isGigahertz<typename std::decay<decltype(field)>::type>();
1839}
1840
1851template <typename TRet, typename TField>
1852TRet getDegrees(const TField& field)
1853{
1854 return details::getAngle<TRet, comms::traits::units::DegreesRatio>(field);
1855}
1856
1867template <typename TField, typename TVal>
1868void setDegrees(TField& field, TVal&& val)
1869{
1870 details::setAngle<comms::traits::units::DegreesRatio>(field, std::forward<TVal>(val));
1871}
1872
1875template <typename TField>
1876constexpr bool isDegrees()
1877{
1878 return
1879 TField::hasUnits() &&
1880 std::is_same<typename TField::UnitsType, comms::traits::units::Angle>::value &&
1881 std::is_same<typename TField::UnitsRatio, comms::traits::units::DegreesRatio>::value;
1882}
1883
1888template <typename TField>
1889constexpr bool isDegrees(const TField& field)
1890{
1891 return isDegrees<typename std::decay<decltype(field)>::type>();
1892}
1893
1904template <typename TRet, typename TField>
1905TRet getRadians(const TField& field)
1906{
1907 return details::getAngle<TRet, comms::traits::units::RadiansRatio>(field);
1908}
1909
1920template <typename TField, typename TVal>
1921void setRadians(TField& field, TVal&& val)
1922{
1923 details::setAngle<comms::traits::units::RadiansRatio>(field, std::forward<TVal>(val));
1924}
1925
1928template <typename TField>
1929constexpr bool isRadians()
1930{
1931 return
1932 TField::hasUnits() &&
1933 std::is_same<typename TField::UnitsType, comms::traits::units::Angle>::value &&
1934 std::is_same<typename TField::UnitsRatio, comms::traits::units::RadiansRatio>::value;
1935}
1936
1941template <typename TField>
1942constexpr bool isRadians(const TField& field)
1943{
1944 return isRadians<typename std::decay<decltype(field)>::type>();
1945}
1946
1957template <typename TRet, typename TField>
1958TRet getNanoamps(const TField& field)
1959{
1960 return details::getCurrent<TRet, comms::traits::units::NanoampsRatio>(field);
1961}
1962
1973template <typename TField, typename TVal>
1974void setNanoamps(TField& field, TVal&& val)
1975{
1976 details::setCurrent<comms::traits::units::NanoampsRatio>(field, std::forward<TVal>(val));
1977}
1978
1981template <typename TField>
1982constexpr bool isNanoamps()
1983{
1984 return
1985 TField::hasUnits() &&
1986 std::is_same<typename TField::UnitsType, comms::traits::units::Current>::value &&
1987 std::is_same<typename TField::UnitsRatio, comms::traits::units::NanoampsRatio>::value;
1988}
1989
1994template <typename TField>
1995constexpr bool isNanoamps(const TField& field)
1996{
1997 return isNanoamps<typename std::decay<decltype(field)>::type>();
1998}
1999
2010template <typename TRet, typename TField>
2011TRet getMicroamps(const TField& field)
2012{
2013 return details::getCurrent<TRet, comms::traits::units::MicroampsRatio>(field);
2014}
2015
2026template <typename TField, typename TVal>
2027void setMicroamps(TField& field, TVal&& val)
2028{
2029 details::setCurrent<comms::traits::units::MicroampsRatio>(field, std::forward<TVal>(val));
2030}
2031
2034template <typename TField>
2035constexpr bool isMicroamps()
2036{
2037 return
2038 TField::hasUnits() &&
2039 std::is_same<typename TField::UnitsType, comms::traits::units::Current>::value &&
2040 std::is_same<typename TField::UnitsRatio, comms::traits::units::MicroampsRatio>::value;
2041}
2042
2047template <typename TField>
2048constexpr bool isMicroamps(const TField& field)
2049{
2050 return isMicroamps<typename std::decay<decltype(field)>::type>();
2051}
2052
2053
2064template <typename TRet, typename TField>
2065TRet getMilliamps(const TField& field)
2066{
2067 return details::getCurrent<TRet, comms::traits::units::MilliampsRatio>(field);
2068}
2069
2080template <typename TField, typename TVal>
2081void setMilliamps(TField& field, TVal&& val)
2082{
2083 details::setCurrent<comms::traits::units::MilliampsRatio>(field, std::forward<TVal>(val));
2084}
2085
2088template <typename TField>
2089constexpr bool isMilliamps()
2090{
2091 return
2092 TField::hasUnits() &&
2093 std::is_same<typename TField::UnitsType, comms::traits::units::Current>::value &&
2094 std::is_same<typename TField::UnitsRatio, comms::traits::units::MilliampsRatio>::value;
2095}
2096
2101template <typename TField>
2102constexpr bool isMilliamps(const TField& field)
2103{
2104 return isMilliamps<typename std::decay<decltype(field)>::type>();
2105}
2106
2117template <typename TRet, typename TField>
2118TRet getAmps(const TField& field)
2119{
2120 return details::getCurrent<TRet, comms::traits::units::AmpsRatio>(field);
2121}
2122
2133template <typename TField, typename TVal>
2134void setAmps(TField& field, TVal&& val)
2135{
2136 details::setCurrent<comms::traits::units::AmpsRatio>(field, std::forward<TVal>(val));
2137}
2138
2141template <typename TField>
2142constexpr bool isAmps()
2143{
2144 return
2145 TField::hasUnits() &&
2146 std::is_same<typename TField::UnitsType, comms::traits::units::Current>::value &&
2147 std::is_same<typename TField::UnitsRatio, comms::traits::units::AmpsRatio>::value;
2148}
2149
2154template <typename TField>
2155constexpr bool isAmps(const TField& field)
2156{
2157 return isAmps<typename std::decay<decltype(field)>::type>();
2158}
2159
2170template <typename TRet, typename TField>
2171TRet getKiloamps(const TField& field)
2172{
2173 return details::getCurrent<TRet, comms::traits::units::KiloampsRatio>(field);
2174}
2175
2186template <typename TField, typename TVal>
2187void setKiloamps(TField& field, TVal&& val)
2188{
2189 details::setCurrent<comms::traits::units::KiloampsRatio>(field, std::forward<TVal>(val));
2190}
2191
2194template <typename TField>
2195constexpr bool isKiloamps()
2196{
2197 return
2198 TField::hasUnits() &&
2199 std::is_same<typename TField::UnitsType, comms::traits::units::Current>::value &&
2200 std::is_same<typename TField::UnitsRatio, comms::traits::units::KiloampsRatio>::value;
2201}
2202
2207template <typename TField>
2208constexpr bool isKiloamps(const TField& field)
2209{
2210 return isKiloamps<typename std::decay<decltype(field)>::type>();
2211}
2212
2223template <typename TRet, typename TField>
2224TRet getNanovolts(const TField& field)
2225{
2226 return details::getVoltage<TRet, comms::traits::units::NanovoltsRatio>(field);
2227}
2228
2239template <typename TField, typename TVal>
2240void setNanovolts(TField& field, TVal&& val)
2241{
2242 details::setVoltage<comms::traits::units::NanovoltsRatio>(field, std::forward<TVal>(val));
2243}
2244
2247template <typename TField>
2248constexpr bool isNanovolts()
2249{
2250 return
2251 TField::hasUnits() &&
2252 std::is_same<typename TField::UnitsType, comms::traits::units::Voltage>::value &&
2253 std::is_same<typename TField::UnitsRatio, comms::traits::units::NanovoltsRatio>::value;
2254}
2255
2260template <typename TField>
2261constexpr bool isNanovolts(const TField& field)
2262{
2263 return isNanovolts<typename std::decay<decltype(field)>::type>();
2264}
2265
2276template <typename TRet, typename TField>
2277TRet getMicrovolts(const TField& field)
2278{
2279 return details::getVoltage<TRet, comms::traits::units::MicrovoltsRatio>(field);
2280}
2281
2292template <typename TField, typename TVal>
2293void setMicrovolts(TField& field, TVal&& val)
2294{
2295 details::setVoltage<comms::traits::units::MicrovoltsRatio>(field, std::forward<TVal>(val));
2296}
2297
2300template <typename TField>
2301constexpr bool isMicrovolts()
2302{
2303 return
2304 TField::hasUnits() &&
2305 std::is_same<typename TField::UnitsType, comms::traits::units::Voltage>::value &&
2306 std::is_same<typename TField::UnitsRatio, comms::traits::units::MicrovoltsRatio>::value;
2307}
2308
2313template <typename TField>
2314constexpr bool isMicrovolts(const TField& field)
2315{
2316 return isMicrovolts<typename std::decay<decltype(field)>::type>();
2317}
2318
2329template <typename TRet, typename TField>
2330TRet getMillivolts(const TField& field)
2331{
2332 return details::getVoltage<TRet, comms::traits::units::MillivoltsRatio>(field);
2333}
2334
2345template <typename TField, typename TVal>
2346void setMillivolts(TField& field, TVal&& val)
2347{
2348 details::setVoltage<comms::traits::units::MillivoltsRatio>(field, std::forward<TVal>(val));
2349}
2350
2353template <typename TField>
2354constexpr bool isMillivolts()
2355{
2356 return
2357 TField::hasUnits() &&
2358 std::is_same<typename TField::UnitsType, comms::traits::units::Voltage>::value &&
2359 std::is_same<typename TField::UnitsRatio, comms::traits::units::MillivoltsRatio>::value;
2360}
2361
2366template <typename TField>
2367constexpr bool isMillivolts(const TField& field)
2368{
2369 return isMillivolts<typename std::decay<decltype(field)>::type>();
2370}
2371
2382template <typename TRet, typename TField>
2383TRet getVolts(const TField& field)
2384{
2385 return details::getVoltage<TRet, comms::traits::units::VoltsRatio>(field);
2386}
2387
2398template <typename TField, typename TVal>
2399void setVolts(TField& field, TVal&& val)
2400{
2401 details::setVoltage<comms::traits::units::VoltsRatio>(field, std::forward<TVal>(val));
2402}
2403
2406template <typename TField>
2407constexpr bool isVolts()
2408{
2409 return
2410 TField::hasUnits() &&
2411 std::is_same<typename TField::UnitsType, comms::traits::units::Voltage>::value &&
2412 std::is_same<typename TField::UnitsRatio, comms::traits::units::VoltsRatio>::value;
2413}
2414
2419template <typename TField>
2420constexpr bool isVolts(const TField& field)
2421{
2422 return isVolts<typename std::decay<decltype(field)>::type>();
2423}
2424
2435template <typename TRet, typename TField>
2436TRet getKilovolts(const TField& field)
2437{
2438 return details::getVoltage<TRet, comms::traits::units::KilovoltsRatio>(field);
2439}
2440
2451template <typename TField, typename TVal>
2452void setKilovolts(TField& field, TVal&& val)
2453{
2454 details::setVoltage<comms::traits::units::KilovoltsRatio>(field, std::forward<TVal>(val));
2455}
2456
2459template <typename TField>
2460constexpr bool isKilovolts()
2461{
2462 return
2463 TField::hasUnits() &&
2464 std::is_same<typename TField::UnitsType, comms::traits::units::Voltage>::value &&
2465 std::is_same<typename TField::UnitsRatio, comms::traits::units::KilovoltsRatio>::value;
2466}
2467
2472template <typename TField>
2473constexpr bool isKilovolts(const TField& field)
2474{
2475 return isKilovolts<typename std::decay<decltype(field)>::type>();
2476}
2477
2488template <typename TRet, typename TField>
2489TRet getBytes(const TField& field)
2490{
2491 return details::getMemory<TRet, comms::traits::units::BytesRatio>(field);
2492}
2493
2504template <typename TField, typename TVal>
2505void setBytes(TField& field, TVal&& val)
2506{
2507 details::setMemory<comms::traits::units::BytesRatio>(field, std::forward<TVal>(val));
2508}
2509
2512template <typename TField>
2513constexpr bool isBytes()
2514{
2515 return
2516 TField::hasUnits() &&
2517 std::is_same<typename TField::UnitsType, comms::traits::units::Memory>::value &&
2518 std::is_same<typename TField::UnitsRatio, comms::traits::units::BytesRatio>::value;
2519}
2520
2525template <typename TField>
2526constexpr bool isBytes(const TField& field)
2527{
2528 return isBytes<typename std::decay<decltype(field)>::type>();
2529}
2530
2541template <typename TRet, typename TField>
2542TRet getKilobytes(const TField& field)
2543{
2544 return details::getMemory<TRet, comms::traits::units::KilobytesRatio>(field);
2545}
2546
2557template <typename TField, typename TVal>
2558void setKilobytes(TField& field, TVal&& val)
2559{
2560 details::setMemory<comms::traits::units::KilobytesRatio>(field, std::forward<TVal>(val));
2561}
2562
2565template <typename TField>
2566constexpr bool isKilobytes()
2567{
2568 return
2569 TField::hasUnits() &&
2570 std::is_same<typename TField::UnitsType, comms::traits::units::Memory>::value &&
2571 std::is_same<typename TField::UnitsRatio, comms::traits::units::KilobytesRatio>::value;
2572}
2573
2578template <typename TField>
2579constexpr bool isKilobytes(const TField& field)
2580{
2581 return isKilobytes<typename std::decay<decltype(field)>::type>();
2582}
2583
2594template <typename TRet, typename TField>
2595TRet getMegabytes(const TField& field)
2596{
2597 return details::getMemory<TRet, comms::traits::units::MegabytesRatio>(field);
2598}
2599
2610template <typename TField, typename TVal>
2611void setMegabytes(TField& field, TVal&& val)
2612{
2613 details::setMemory<comms::traits::units::MegabytesRatio>(field, std::forward<TVal>(val));
2614}
2615
2618template <typename TField>
2619constexpr bool isMegabytes()
2620{
2621 return
2622 TField::hasUnits() &&
2623 std::is_same<typename TField::UnitsType, comms::traits::units::Memory>::value &&
2624 std::is_same<typename TField::UnitsRatio, comms::traits::units::MegabytesRatio>::value;
2625}
2626
2631template <typename TField>
2632constexpr bool isMegabytes(const TField& field)
2633{
2634 return isMegabytes<typename std::decay<decltype(field)>::type>();
2635}
2636
2637
2648template <typename TRet, typename TField>
2649TRet getGigabytes(const TField& field)
2650{
2651 return details::getMemory<TRet, comms::traits::units::GigabytesRatio>(field);
2652}
2653
2664template <typename TField, typename TVal>
2665void setGigabytes(TField& field, TVal&& val)
2666{
2667 details::setMemory<comms::traits::units::GigabytesRatio>(field, std::forward<TVal>(val));
2668}
2669
2672template <typename TField>
2673constexpr bool isGigabytes()
2674{
2675 return
2676 TField::hasUnits() &&
2677 std::is_same<typename TField::UnitsType, comms::traits::units::Memory>::value &&
2678 std::is_same<typename TField::UnitsRatio, comms::traits::units::GigabytesRatio>::value;
2679}
2680
2685template <typename TField>
2686constexpr bool isGigabytes(const TField& field)
2687{
2688 return isGigabytes<typename std::decay<decltype(field)>::type>();
2689}
2690
2701template <typename TRet, typename TField>
2702TRet getTerabytes(const TField& field)
2703{
2704 return details::getMemory<TRet, comms::traits::units::TerabytesRatio>(field);
2705}
2706
2717template <typename TField, typename TVal>
2718void setTerabytes(TField& field, TVal&& val)
2719{
2720 details::setMemory<comms::traits::units::TerabytesRatio>(field, std::forward<TVal>(val));
2721}
2722
2725template <typename TField>
2726constexpr bool isTerabytes()
2727{
2728 return
2729 TField::hasUnits() &&
2730 std::is_same<typename TField::UnitsType, comms::traits::units::Memory>::value &&
2731 std::is_same<typename TField::UnitsRatio, comms::traits::units::TerabytesRatio>::value;
2732}
2733
2738template <typename TField>
2739constexpr bool isTerabytes(const TField& field)
2740{
2741 return isTerabytes<typename std::decay<decltype(field)>::type>();
2742}
2743
2744} // namespace units
2745
2746} // namespace comms
2747
2748COMMS_MSVC_WARNING_POP
Contains various compiler related definitions.
comms::option::def::FieldType< TMsg > FieldType
Same as comms::option::def::FieldType.
Definition options.h:1492
constexpr bool isMinutes()
Compile time check whether the field type holds minutes.
Definition units.h:763
TRet getNanovolts(const TField &field)
Retrieve field's value as nanovolts.
Definition units.h:2224
constexpr bool isMillimetersPerSecond()
Compile time check whether the field type holds millimeters per second.
Definition units.h:1399
TRet getMicrovolts(const TField &field)
Retrieve field's value as microvolts.
Definition units.h:2277
void setMicroamps(TField &field, TVal &&val)
Update field's value accordingly, while providing microamps value.
Definition units.h:2027
TRet getMilliseconds(const TField &field)
Retrieve field's value as milliseconds.
Definition units.h:633
constexpr bool isMegahertz()
Compile time check whether the field type holds megahertz.
Definition units.h:1770
void setBytes(TField &field, TVal &&val)
Update field's value accordingly, while providing bytes value.
Definition units.h:2505
void setMillimetersPerSecond(TField &field, TVal &&val)
Update field's value accordingly, while providing millimeters per second value.
Definition units.h:1391
TRet getGigabytes(const TField &field)
Retrieve field's value as gigabytes.
Definition units.h:2649
TRet getVolts(const TField &field)
Retrieve field's value as volts.
Definition units.h:2383
void setHours(TField &field, TVal &&val)
Update field's value accordingly, while providing hours value.
Definition units.h:808
void setMillivolts(TField &field, TVal &&val)
Update field's value accordingly, while providing millivolts value.
Definition units.h:2346
constexpr bool isMegabytes()
Compile time check whether the field type holds megabytes.
Definition units.h:2619
void setNanometersPerSecond(TField &field, TVal &&val)
Update field's value accordingly, while providing nanometers per second value.
Definition units.h:1285
TRet getCentimeters(const TField &field)
Retrieve field's value as centimeters.
Definition units.h:1110
constexpr bool isMeters()
Compile time check whether the field type holds meters.
Definition units.h:1187
constexpr bool isMillimeters()
Compile time check whether the field type holds millimeters.
Definition units.h:1081
TRet getMillivolts(const TField &field)
Retrieve field's value as millivolts.
Definition units.h:2330
TRet getHertz(const TField &field)
Retrieve field's value as hertz.
Definition units.h:1640
void setKilobytes(TField &field, TVal &&val)
Update field's value accordingly, while providing kilobytes value.
Definition units.h:2558
TRet getNanoamps(const TField &field)
Retrieve field's value as nanoamps.
Definition units.h:1958
constexpr bool isKilovolts()
Compile time check whether the field type holds kilovolts.
Definition units.h:2460
constexpr bool isCentimetersPerSecond()
Compile time check whether the field type holds centimeters per second.
Definition units.h:1452
constexpr bool isBytes()
Compile time check whether the field type holds bytes.
Definition units.h:2513
TRet getDays(const TField &field)
Retrieve field's value as days.
Definition units.h:845
constexpr bool isNanometers()
Compile time check whether the field type holds nanometers.
Definition units.h:975
void setWeeks(TField &field, TVal &&val)
Update field's value accordingly, while providing weeks value.
Definition units.h:914
TRet getMinutes(const TField &field)
Retrieve field's value as minutes.
Definition units.h:739
void setGigahertz(TField &field, TVal &&val)
Update field's value accordingly, while providing gigahertz value.
Definition units.h:1815
void setGigabytes(TField &field, TVal &&val)
Update field's value accordingly, while providing gigabytes value.
Definition units.h:2665
void setMicrometersPerSecond(TField &field, TVal &&val)
Update field's value accordingly, while providing micrometers per second value.
Definition units.h:1338
TRet getNanometersPerSecond(const TField &field)
Retrieve field's value as nanometers per second.
Definition units.h:1269
TRet getNanometers(const TField &field)
Retrieve field's value as nanometers.
Definition units.h:951
void setTerabytes(TField &field, TVal &&val)
Update field's value accordingly, while providing terabytes value.
Definition units.h:2718
TRet getMilliamps(const TField &field)
Retrieve field's value as milliamps.
Definition units.h:2065
TRet getMicroseconds(const TField &field)
Retrieve field's value as microseconds.
Definition units.h:580
TRet getMicrometers(const TField &field)
Retrieve field's value as micrometers.
Definition units.h:1004
constexpr bool isMicrometersPerSecond()
Compile time check whether the field type holds micrometers per second.
Definition units.h:1346
constexpr bool isKilometers()
Compile time check whether the field type holds kilometers.
Definition units.h:1240
constexpr bool isKilometersPerHour()
Compile time check whether the field type holds kilometers per hour.
Definition units.h:1611
TRet getMicroamps(const TField &field)
Retrieve field's value as microamps.
Definition units.h:2011
TRet getKiloamps(const TField &field)
Retrieve field's value as kiloamps.
Definition units.h:2171
constexpr bool isTerabytes()
Compile time check whether the field type holds terabytes.
Definition units.h:2726
void setMilliamps(TField &field, TVal &&val)
Update field's value accordingly, while providing milliamps value.
Definition units.h:2081
void setAmps(TField &field, TVal &&val)
Update field's value accordingly, while providing amps value.
Definition units.h:2134
TRet getKilohertz(const TField &field)
Retrieve field's value as kilohertz.
Definition units.h:1693
constexpr bool isMetersPerSecond()
Compile time check whether the field type holds meters per second.
Definition units.h:1505
constexpr bool isMicrometers()
Compile time check whether the field type holds micrometers.
Definition units.h:1028
void setDays(TField &field, TVal &&val)
Update field's value accordingly, while providing days value.
Definition units.h:861
constexpr bool isGigabytes()
Compile time check whether the field type holds gigabytes.
Definition units.h:2673
constexpr bool isVolts()
Compile time check whether the field type holds volts.
Definition units.h:2407
TRet getKilometersPerSecond(const TField &field)
Retrieve field's value as kilometers per second.
Definition units.h:1534
constexpr bool isHours()
Compile time check whether the field type holds hours.
Definition units.h:816
TRet getHours(const TField &field)
Retrieve field's value as hours.
Definition units.h:792
void setMetersPerSecond(TField &field, TVal &&val)
Update field's value accordingly, while providing meters per second value.
Definition units.h:1497
TRet getWeeks(const TField &field)
Retrieve field's value as weeks.
Definition units.h:898
TRet getNanoseconds(const TField &field)
Retrieve field's value as nanoseconds.
Definition units.h:527
constexpr bool isMicroamps()
Compile time check whether the field type holds microamps.
Definition units.h:2035
TRet getMeters(const TField &field)
Retrieve field's value as meters.
Definition units.h:1163
void setCentimeters(TField &field, TVal &&val)
Update field's value accordingly, while providing centimeters value.
Definition units.h:1126
void setKilovolts(TField &field, TVal &&val)
Update field's value accordingly, while providing kilovolts value.
Definition units.h:2452
void setMilliseconds(TField &field, TVal &&val)
Update field's value accordingly, while providing milliseconds value.
Definition units.h:649
constexpr bool isNanometersPerSecond()
Compile time check whether the field type holds nanometers per second.
Definition units.h:1293
TRet getKilometersPerHour(const TField &field)
Retrieve field's value as kilometers per hour.
Definition units.h:1587
void setSeconds(TField &field, TVal &&val)
Update field's value accordingly, while providing seconds value.
Definition units.h:702
void setMillimeters(TField &field, TVal &&val)
Update field's value accordingly, while providing millimeters value.
Definition units.h:1073
constexpr bool isMicrovolts()
Compile time check whether the field type holds microvolts.
Definition units.h:2301
constexpr bool isMicroseconds()
Compile time check whether the field type holds microseconds.
Definition units.h:604
TRet getTerabytes(const TField &field)
Retrieve field's value as terabytes.
Definition units.h:2702
constexpr bool isNanoamps()
Compile time check whether the field type holds nanoamps.
Definition units.h:1982
void setKilometers(TField &field, TVal &&val)
Update field's value accordingly, while providing kilometers value.
Definition units.h:1232
void setKiloamps(TField &field, TVal &&val)
Update field's value accordingly, while providing kiloamps value.
Definition units.h:2187
TRet getAmps(const TField &field)
Retrieve field's value as amps.
Definition units.h:2118
constexpr bool isMilliseconds()
Compile time check whether the field type holds milliseconds.
Definition units.h:657
constexpr bool isWeeks()
Compile time check whether the field type holds weeks.
Definition units.h:922
void setCentimetersPerSecond(TField &field, TVal &&val)
Update field's value accordingly, while providing centimeters per second value.
Definition units.h:1444
void setNanoamps(TField &field, TVal &&val)
Update field's value accordingly, while providing nanoamps value.
Definition units.h:1974
constexpr bool isKilohertz()
Compile time check whether the field type holds kilohertz.
Definition units.h:1717
constexpr bool isGigahertz()
Compile time check whether the field type holds gigahertz.
Definition units.h:1823
TRet getKilovolts(const TField &field)
Retrieve field's value as kilovolts.
Definition units.h:2436
TRet getBytes(const TField &field)
Retrieve field's value as bytes.
Definition units.h:2489
TRet getMetersPerSecond(const TField &field)
Retrieve field's value as meters per second.
Definition units.h:1481
void setMegahertz(TField &field, TVal &&val)
Update field's value accordingly, while providing megahertz value.
Definition units.h:1762
constexpr bool isNanoseconds()
Compile time check whether the field type holds nanoseconds.
Definition units.h:551
constexpr bool isKilobytes()
Compile time check whether the field type holds kilobytes.
Definition units.h:2566
void setHertz(TField &field, TVal &&val)
Update field's value accordingly, while providing hertz value.
Definition units.h:1656
TRet getMillimetersPerSecond(const TField &field)
Retrieve field's value as millimeters per second.
Definition units.h:1375
constexpr bool isMilliamps()
Compile time check whether the field type holds milliamps.
Definition units.h:2089
constexpr bool isKiloamps()
Compile time check whether the field type holds kiloamps.
Definition units.h:2195
TRet getKilobytes(const TField &field)
Retrieve field's value as kilobytes.
Definition units.h:2542
TRet getGigahertz(const TField &field)
Retrieve field's value as gigahertz.
Definition units.h:1799
void setMinutes(TField &field, TVal &&val)
Update field's value accordingly, while providing minutes value.
Definition units.h:755
void setDegrees(TField &field, TVal &&val)
Update field's value accordingly, while providing degrees value.
Definition units.h:1868
void setNanometers(TField &field, TVal &&val)
Update field's value accordingly, while providing nanometers value.
Definition units.h:967
void setMicroseconds(TField &field, TVal &&val)
Update field's value accordingly, while providing microseconds value.
Definition units.h:596
TRet getSeconds(const TField &field)
Retrieve field's value as seconds.
Definition units.h:686
void setMicrometers(TField &field, TVal &&val)
Update field's value accordingly, while providing micrometers value.
Definition units.h:1020
TRet getMicrometersPerSecond(const TField &field)
Retrieve field's value as micrometers per second.
Definition units.h:1322
void setMeters(TField &field, TVal &&val)
Update field's value accordingly, while providing meters value.
Definition units.h:1179
void setNanoseconds(TField &field, TVal &&val)
Update field's value accordingly, while providing nanoseconds value.
Definition units.h:543
void setRadians(TField &field, TVal &&val)
Update field's value accordingly, while providing radians value.
Definition units.h:1921
constexpr bool isDegrees()
Compile time check whether the field type holds degrees.
Definition units.h:1876
TRet getKilometers(const TField &field)
Retrieve field's value as kilometers.
Definition units.h:1216
TRet getCentimetersPerSecond(const TField &field)
Retrieve field's value as centimeters per second.
Definition units.h:1428
TRet getMegahertz(const TField &field)
Retrieve field's value as megahertz.
Definition units.h:1746
void setMegabytes(TField &field, TVal &&val)
Update field's value accordingly, while providing megabytes value.
Definition units.h:2611
void setKilometersPerSecond(TField &field, TVal &&val)
Update field's value accordingly, while providing kilometers per second value.
Definition units.h:1550
void setNanovolts(TField &field, TVal &&val)
Update field's value accordingly, while providing nanovolts value.
Definition units.h:2240
void setVolts(TField &field, TVal &&val)
Update field's value accordingly, while providing volts value.
Definition units.h:2399
constexpr bool isRadians()
Compile time check whether the field type holds radians.
Definition units.h:1929
constexpr bool isCentimeters()
Compile time check whether the field type holds centimeters.
Definition units.h:1134
void setKilometersPerHour(TField &field, TVal &&val)
Update field's value accordingly, while providing kilometers per hour value.
Definition units.h:1603
void setMicrovolts(TField &field, TVal &&val)
Update field's value accordingly, while providing microvolts value.
Definition units.h:2293
TRet getMegabytes(const TField &field)
Retrieve field's value as megabytes.
Definition units.h:2595
constexpr bool isDays()
Compile time check whether the field type holds days.
Definition units.h:869
constexpr bool isHertz()
Compile time check whether the field type holds hertz.
Definition units.h:1664
constexpr bool isSeconds()
Compile time check whether the field type holds seconds.
Definition units.h:710
void setKilohertz(TField &field, TVal &&val)
Update field's value accordingly, while providing kilohertz value.
Definition units.h:1709
constexpr bool isNanovolts()
Compile time check whether the field type holds nanovolts.
Definition units.h:2248
TRet getDegrees(const TField &field)
Retrieve field's value as degrees.
Definition units.h:1852
TRet getRadians(const TField &field)
Retrieve field's value as radians.
Definition units.h:1905
constexpr bool isMillivolts()
Compile time check whether the field type holds millivolts.
Definition units.h:2354
TRet getMillimeters(const TField &field)
Retrieve field's value as millimeters.
Definition units.h:1057
constexpr bool isAmps()
Compile time check whether the field type holds amps.
Definition units.h:2142
constexpr bool isKilometersPerSecond()
Compile time check whether the field type holds kilometers per second.
Definition units.h:1558
Main namespace for all classes / functions of COMMS library.
Tag class used to indicate electrical current value.
Definition traits.h:55
Tag class used to indicate distance value.
Definition traits.h:43
Tag class used to indicate frequency value.
Definition traits.h:49
Tag class used to indicate memory size value.
Definition traits.h:61
Tag class used to indicate speed value.
Definition traits.h:46
Tag class used to indicate time value.
Definition traits.h:40
Tag class used to indicate electrical voltage value.
Definition traits.h:58
Replacement to std::conditional.
Definition type_traits.h:29
This file contains all the classes necessary to properly define message traits.
Replacement to some types from standard type_traits.