COMMS
Template library intended to help with implementation of communication protocols.
Loading...
Searching...
No Matches
Variant.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
13#include "comms/details/macro_common.h"
14#include "comms/details/variant_access.h"
15#include "comms/ErrorStatus.h"
16#include "comms/field/basic/Variant.h"
17#include "comms/field/details/AdaptBasicField.h"
18#include "comms/options.h"
19#include "comms/util/Tuple.h"
20
21#include <utility>
22
23namespace comms
24{
25
26namespace field
27{
28
75template <typename TFieldBase, typename TMembers, typename... TOptions>
76class Variant : public
77 details::AdaptBasicFieldT<
78 basic::Variant<
79 TFieldBase,
80 details::OptionsParser<TOptions...>::ForcedMembersVersionDependency,
81 TMembers
82 >,
83 TOptions...>
84{
85 using BaseImpl =
86 details::AdaptBasicFieldT<
87 basic::Variant<
88 TFieldBase,
89 details::OptionsParser<TOptions...>::ForcedMembersVersionDependency,
90 TMembers
91 >,
92 TOptions...>;
93
95 "TMembers is expected to be a tuple of std::tuple<...>");
96
97 static_assert(
98 1U <= std::tuple_size<TMembers>::value,
99 "Number of members is expected to be at least 1.");
100
101public:
103 using FieldBase = TFieldBase;
104
106 using Endian = typename BaseImpl::Endian;
107
109 using VersionType = typename BaseImpl::VersionType;
110
112 using ParsedOptions = details::OptionsParser<TOptions...>;
113
115 using CommsTag = typename BaseImpl::CommsTag;
116
120 using ValueType = typename BaseImpl::ValueType;
121
125 using Members = typename BaseImpl::Members;
126
130 using FieldType = typename ParsedOptions::FieldType;
131
134 Variant() = default;
135
137 explicit Variant(const ValueType& val)
138 : BaseImpl(val)
139 {
140 }
141
143 explicit Variant(ValueType&& val)
144 : BaseImpl(std::move(val))
145 {
146 }
147
150 static constexpr bool hasFailOnInvalid()
151 {
152 return ParsedOptions::HasFailOnInvalid;
153 }
154
157 static constexpr bool hasIgnoreInvalid()
158 {
159 return ParsedOptions::HasIgnoreInvalid;
160 }
161
164 static constexpr bool hasEmptySerialization()
165 {
166 return ParsedOptions::HasEmptySerialization;
167 }
168
171 static constexpr bool hasFieldType()
172 {
173 return ParsedOptions::HasFieldType;
174 }
175
178 static constexpr bool hasFixedValue()
179 {
180 return ParsedOptions::HasFixedValue;
181 }
182
185 static constexpr bool hasName()
186 {
187 return ParsedOptions::HasName;
188 }
189
193 {
194 return BaseImpl::value();
195 }
196
199 const ValueType& value() const
200 {
201 return BaseImpl::value();
202 }
203
206 const ValueType& getValue() const
207 {
208 return BaseImpl::getValue();
209 }
210
213 template <typename U>
214 void setValue(U&& val)
215 {
216 BaseImpl::setValue(std::forward<U>(val));
217 }
218
224 std::size_t length() const
225 {
226 return BaseImpl::length();
227 }
228
231 static constexpr std::size_t minLength()
232 {
233 return BaseImpl::minLength();
234 }
235
238 static constexpr std::size_t maxLength()
239 {
240 return BaseImpl::maxLength();
241 }
242
250 template <typename TIter>
251 ErrorStatus read(TIter& iter, std::size_t size)
252 {
253 return BaseImpl::read(iter, size);
254 }
255
258 static constexpr bool hasReadNoStatus()
259 {
260 return false;
261 }
262
264 template <typename TIter>
265 void readNoStatus(TIter& iter) = delete;
266
268 bool canWrite() const
269 {
270 return BaseImpl::canWrite();
271 }
272
281 template <typename TIter>
282 ErrorStatus write(TIter& iter, std::size_t size) const
283 {
284 return BaseImpl::write(iter, size);
285 }
286
289 static constexpr bool hasWriteNoStatus()
290 {
291 return BaseImpl::hasWriteNoStatus();
292 }
293
299 template <typename TIter>
300 void writeNoStatus(TIter& iter) const
301 {
302 BaseImpl::writeNoStatus(iter);
303 }
304
307 bool valid() const
308 {
309 return BaseImpl::valid();
310 }
311
316 bool refresh()
317 {
318 return BaseImpl::refresh();
319 }
320
324 std::size_t currentField() const
325 {
326 return BaseImpl::currentField();
327 }
328
336 void selectField(std::size_t idx)
337 {
338 BaseImpl::selectField(idx);
339 }
340
376 template <typename TFunc>
377 void currentFieldExec(TFunc&& func)
378 {
379 BaseImpl::currentFieldExec(std::forward<TFunc>(func));
380 }
381
399 template <typename TFunc>
400 void currentFieldExec(TFunc&& func) const
401 {
402 BaseImpl::currentFieldExec(std::forward<TFunc>(func));
403 }
404
418 template <std::size_t TIdx, typename... TArgs>
419 typename std::tuple_element<TIdx, Members>::type& initField(TArgs&&... args)
420 {
421 return BaseImpl::template initField<TIdx>(std::forward<TArgs>(args)...);
422 }
423
431 template <std::size_t TIdx>
433 {
434 BaseImpl::template deinitField<TIdx>();
435 }
436
442 template <std::size_t TIdx>
443 typename std::tuple_element<TIdx, Members>::type& accessField()
444 {
445 return BaseImpl::template accessField<TIdx>();
446 }
447
453 template <std::size_t TIdx>
454 const typename std::tuple_element<TIdx, Members>::type& accessField() const
455 {
456 return BaseImpl::template accessField<TIdx>();
457 }
458
462 bool currentFieldValid() const
463 {
464 return BaseImpl::currentFieldValid();
465 }
466
469 void reset()
470 {
471 BaseImpl::reset();
472 }
473
475 static constexpr bool isVersionDependent()
476 {
477 return ParsedOptions::HasCustomVersionUpdate || BaseImpl::isVersionDependent();
478 }
479
481 static constexpr bool hasNonDefaultRefresh()
482 {
483 return BaseImpl::hasNonDefaultRefresh();
484 }
485
490 {
491 return BaseImpl::getVersion();
492 }
493
497 {
498 return BaseImpl::setVersion(version);
499 }
500
501protected:
502 using BaseImpl::readData;
503 using BaseImpl::writeData;
504
505private:
506 static_assert(!ParsedOptions::HasSerOffset,
507 "comms::option::def::NumValueSerOffset option is not applicable to Variant field");
508 static_assert(!ParsedOptions::HasFixedLengthLimit,
509 "comms::option::def::FixedLength option is not applicable to Variant field");
510 static_assert(!ParsedOptions::HasFixedBitLengthLimit,
511 "comms::option::def::FixedBitLength option is not applicable to Variant field");
512 static_assert(!ParsedOptions::HasVarLengthLimits,
513 "comms::option::def::VarLength option is not applicable to Variant field");
514 static_assert(!ParsedOptions::HasAvailableLengthLimit,
515 "comms::option::def::AvailableLengthLimit option is not applicable to Variant field");
516 static_assert(!ParsedOptions::HasSequenceElemLengthForcing,
517 "comms::option::def::SequenceElemLengthForcingEnabled option is not applicable to Variant field");
518 static_assert(!ParsedOptions::HasSequenceSizeForcing,
519 "comms::option::def::SequenceSizeForcingEnabled option is not applicable to Variant field");
520 static_assert(!ParsedOptions::HasSequenceLengthForcing,
521 "comms::option::def::SequenceLengthForcingEnabled option is not applicable to Variant field");
522 static_assert(!ParsedOptions::HasSequenceFixedSize,
523 "comms::option::def::SequenceFixedSize option is not applicable to Variant field");
524 static_assert(!ParsedOptions::HasSequenceFixedSizeUseFixedSizeStorage,
525 "comms::option::app::SequenceFixedSizeUseFixedSizeStorage option is not applicable to Variant field");
526 static_assert(!ParsedOptions::HasSequenceSizeFieldPrefix,
527 "comms::option::def::SequenceSizeFieldPrefix option is not applicable to Variant field");
528 static_assert(!ParsedOptions::HasSequenceSerLengthFieldPrefix,
529 "comms::option::def::SequenceSerLengthFieldPrefix option is not applicable to Variant field");
530 static_assert(!ParsedOptions::HasSequenceElemSerLengthFieldPrefix,
531 "comms::option::def::SequenceElemSerLengthFieldPrefix option is not applicable to Variant field");
532 static_assert(!ParsedOptions::HasSequenceElemFixedSerLengthFieldPrefix,
533 "comms::option::def::SequenceElemFixedSerLengthFieldPrefix option is not applicable to Variant field");
534 static_assert(!ParsedOptions::HasSequenceTrailingFieldSuffix,
535 "comms::option::def::SequenceTrailingFieldSuffix option is not applicable to Variant field");
536 static_assert(!ParsedOptions::HasSequenceTerminationFieldSuffix,
537 "comms::option::def::SequenceTerminationFieldSuffix option is not applicable to Variant field");
538 static_assert(!ParsedOptions::HasFixedSizeStorage,
539 "comms::option::app::FixedSizeStorage option is not applicable to Variant field");
540 static_assert(!ParsedOptions::HasCustomStorageType,
541 "comms::option::app::CustomStorageType option is not applicable to Variant field");
542 static_assert(!ParsedOptions::HasScalingRatio,
543 "comms::option::def::ScalingRatio option is not applicable to Variant field");
544 static_assert(!ParsedOptions::HasUnits,
545 "comms::option::def::Units option is not applicable to Variant field");
546 static_assert(!ParsedOptions::HasOrigDataView,
547 "comms::option::app::OrigDataView option is not applicable to Variant field");
548 static_assert(!ParsedOptions::HasMultiRangeValidation,
549 "comms::option::def::ValidNumValueRange (or similar) option is not applicable to Variant field");
550 static_assert(!ParsedOptions::HasVersionsRange,
551 "comms::option::def::ExistsBetweenVersions (or similar) option is not applicable to Variant field");
552 static_assert(!ParsedOptions::HasInvalidByDefault,
553 "comms::option::def::InvalidByDefault option is not applicable to Variant field");
554 static_assert(!ParsedOptions::HasMissingOnReadFail,
555 "comms::option::def::MissingOnReadFail option is not applicable to Variant field");
556 static_assert(!ParsedOptions::HasMissingOnInvalid,
557 "comms::option::def::MissingOnInvalid option is not applicable to Variant field");
558};
559
560namespace details
561{
562
563template <typename TVar>
564class VariantEqualityCompHelper
565{
566public:
567 VariantEqualityCompHelper(const TVar& other, bool& result)
568 : m_other(other),
569 m_result(result)
570 {}
571
572 template <std::size_t TIdx, typename TField>
573 void operator()(const TField& field)
574 {
575 m_result = (field == m_other.template accessField<TIdx>());
576 }
577
578private:
579 const TVar& m_other;
580 bool& m_result;
581
582};
583
584template <typename TVar>
585VariantEqualityCompHelper<TVar> makeVariantEqualityCompHelper(TVar& other, bool& result)
586{
587 return VariantEqualityCompHelper<TVar>(other, result);
588}
589
590template <typename TVar>
591class VariantLessCompHelper
592{
593public:
594 VariantLessCompHelper(const TVar& other, bool& result)
595 : m_other(other),
596 m_result(result)
597 {}
598
599 template <std::size_t TIdx, typename TField>
600 void operator()(const TField& field)
601 {
602 m_result = (field < m_other.template accessField<TIdx>());
603 }
604
605private:
606 const TVar& m_other;
607 bool& m_result;
608};
609
610template <typename TVar>
611VariantLessCompHelper<TVar> makeVariantLessCompHelper(TVar& other, bool& result)
612{
613 return VariantLessCompHelper<TVar>(other, result);
614}
615
616} // namespace details
617
623template <typename TFieldBase, typename TMembers, typename... TOptions>
627{
628 if (&field1 == &field2) {
629 return true;
630 }
631
632 if (field1.currentFieldValid() != field2.currentFieldValid()) {
633 return false;
634 }
635
636 if (!field1.currentFieldValid()) {
637 return true;
638 }
639
640 if (field1.currentField() != field2.currentField()) {
641 return false;
642 }
643
644 bool result = false;
645 field1.currentFieldExec(details::makeVariantEqualityCompHelper(field2, result));
646 return result;
647}
648
654template <typename TFieldBase, typename TMembers, typename... TOptions>
658{
659 return !(field1 == field2);
660}
661
666template <typename TFieldBase, typename TMembers, typename... TOptions>
670{
671 if (!field1.currentFieldValid()) {
672 return (!field2.currentFieldValid());
673 }
674
675 if (!field2.currentFieldValid()) {
676 return false;
677 }
678
679 if (field1.currentField() < field2.currentField()) {
680 return true;
681 }
682
683 if (field1.currentField() != field2.currentField()) {
684 return false;
685 }
686
687 if (&field1 == &field2) {
688 return false;
689 }
690
691 bool result = false;
692 field1.currentFieldExec(details::makeVariantLessCompHelper(field2, result));
693 return result;
694}
695
701template <typename T>
702constexpr bool isVariant()
703{
704 return std::is_same<typename T::CommsTag, tag::Variant>::value;
705}
706
710template <typename TFieldBase, typename TMembers, typename... TOptions>
711inline
712Variant<TFieldBase, TMembers, TOptions...>&
714{
715 return field;
716}
717
721template <typename TFieldBase, typename TMembers, typename... TOptions>
722inline
723const Variant<TFieldBase, TMembers, TOptions...>&
725{
726 return field;
727}
728
765#define COMMS_VARIANT_MEMBERS_ACCESS(...) \
766 COMMS_EXPAND(COMMS_DEFINE_FIELD_ENUM(__VA_ARGS__)) \
767 COMMS_AS_VARIANT_FUNC { \
768 auto& var = comms::field::toFieldBase(*this); \
769 using Var = typename std::decay<decltype(var)>::type; \
770 static_assert(std::tuple_size<typename Var::Members>::value == FieldIdx_numOfValues, \
771 "Invalid number of names for variant field"); \
772 return var; \
773 }\
774 COMMS_AS_VARIANT_CONST_FUNC { \
775 auto& var = comms::field::toFieldBase(*this); \
776 using Var = typename std::decay<decltype(var)>::type; \
777 static_assert(std::tuple_size<typename Var::Members>::value == FieldIdx_numOfValues, \
778 "Invalid number of names for variant field"); \
779 return var; \
780 } \
781 COMMS_DO_VARIANT_MEM_ACC_FUNC(asVariant(), __VA_ARGS__)
782
783
794#define COMMS_VARIANT_MEMBERS_ACCESS_NOTEMPLATE(...) \
795 COMMS_EXPAND(COMMS_DEFINE_FIELD_ENUM(__VA_ARGS__)) \
796 COMMS_DO_VARIANT_MEM_ACC_FUNC_NOTEMPLATE(__VA_ARGS__)
797
948#define COMMS_VARIANT_MEMBERS_NAMES(...) \
949 COMMS_EXPAND(COMMS_VARIANT_MEMBERS_ACCESS(__VA_ARGS__)) \
950 COMMS_EXPAND(COMMS_DO_FIELD_TYPEDEF(typename Base::Members, Field_, FieldIdx_, __VA_ARGS__))
951
952
953} // namespace field
954
955} // namespace comms
956
957
This file contain definition of error statuses used by comms module.
Contains various tuple type manipulation classes and functions.
Defines a "variant" field, that can contain any of the provided ones.
Definition Variant.h:84
bool setVersion(VersionType version)
Default implementation of version update.
Definition Variant.h:496
typename ParsedOptions::FieldType FieldType
Type of actual extending field specified via comms::option::def::FieldType.
Definition Variant.h:130
static constexpr bool hasNonDefaultRefresh()
Compile time check if this class has non-default refresh functionality.
Definition Variant.h:481
void deinitField()
Destruct previously initialised (via initField()) contained field.
Definition Variant.h:432
void currentFieldExec(TFunc &&func) const
Execute provided function object with current field as parameter (const variant).
Definition Variant.h:400
void readNoStatus(TIter &iter)=delete
Read operation without error check and status report is not supported.
const std::tuple_element< TIdx, Members >::type & accessField() const
Access already constructed field at specifed index (known at compile time).
Definition Variant.h:454
TFieldBase FieldBase
Base class provided in the first template parameter.
Definition Variant.h:103
const Variant< TFieldBase, TMembers, TOptions... > & toFieldBase(const Variant< TFieldBase, TMembers, TOptions... > &field)
Upcast type of the field definition to its parent comms::field::Variant type in order to have access ...
Definition Variant.h:724
std::tuple_element< TIdx, Members >::type & accessField()
Access already constructed field at specifed index (known at compile time).
Definition Variant.h:443
std::size_t currentField() const
Get index of the current field (within the Members tuple).
Definition Variant.h:324
bool canWrite() const
Check of whether the field has a consistent value for writing.
Definition Variant.h:268
void selectField(std::size_t idx)
Select type of the variant field.
Definition Variant.h:336
ErrorStatus write(TIter &iter, std::size_t size) const
Write current field value to output data sequence.
Definition Variant.h:282
bool refresh()
Refresh the field's value.
Definition Variant.h:316
bool valid() const
Check validity of all the contained field.
Definition Variant.h:307
static constexpr bool hasWriteNoStatus()
Compile time check of whether the field has proper writeNoStatus() member function.
Definition Variant.h:289
static constexpr bool isVersionDependent()
Compile time check if this class is version dependent.
Definition Variant.h:475
static constexpr bool hasFixedValue()
Compile time inquiry of whether comms::option::def::FixedValue option has been used.
Definition Variant.h:178
static constexpr bool hasFailOnInvalid()
Compile time inquiry of whether comms::option::def::FailOnInvalid option has been used.
Definition Variant.h:150
void currentFieldExec(TFunc &&func)
Execute provided function object with current field as parameter.
Definition Variant.h:377
typename BaseImpl::CommsTag CommsTag
Tag indicating type of the field.
Definition Variant.h:115
std::size_t length() const
Get length required to serialise contained fields.
Definition Variant.h:224
Variant(const ValueType &val)
Constructor.
Definition Variant.h:137
static constexpr bool hasEmptySerialization()
Compile time inquiry of whether comms::option::def::EmptySerialization option has been used.
Definition Variant.h:164
void setValue(U &&val)
Set value.
Definition Variant.h:214
typename BaseImpl::Endian Endian
Endian used for serialisation.
Definition Variant.h:106
Variant()=default
Default constructor.
static constexpr std::size_t maxLength()
Get maximal length that is required to serialise all possible contained fields.
Definition Variant.h:238
details::OptionsParser< TOptions... > ParsedOptions
All the options provided to this class bundled into struct.
Definition Variant.h:112
typename BaseImpl::VersionType VersionType
Version type.
Definition Variant.h:109
ValueType & value()
Get access to the internal storage buffer.
Definition Variant.h:192
static constexpr bool hasReadNoStatus()
Compile time check of whether the field has proper readNoStatus() member function.
Definition Variant.h:258
bool operator<(const Variant< TFieldBase, TMembers, TOptions... > &field1, const Variant< TFieldBase, TMembers, TOptions... > &field2)
Order comparison operator.
Definition Variant.h:667
void writeNoStatus(TIter &iter) const
Write current field value to output data sequence without error check and status report.
Definition Variant.h:300
std::tuple_element< TIdx, Members >::type & initField(TArgs &&... args)
Construct and initialise specified contained field in the internal buffer.
Definition Variant.h:419
constexpr bool isVariant()
Compile time check function of whether a provided type is any variant of comms::field::Variant.
Definition Variant.h:702
typename BaseImpl::Members Members
All the supported types.
Definition Variant.h:125
void reset()
Invalidate current state.
Definition Variant.h:469
const ValueType & getValue() const
Get value.
Definition Variant.h:206
Variant(ValueType &&val)
Constructor.
Definition Variant.h:143
const ValueType & value() const
Get access to the internal storage buffer.
Definition Variant.h:199
static constexpr bool hasFieldType()
Compile time inquiry of whether comms::option::def::FieldType option has been used.
Definition Variant.h:171
bool operator!=(const Variant< TFieldBase, TMembers, TOptions... > &field1, const Variant< TFieldBase, TMembers, TOptions... > &field2)
Non-equality comparison operator.
Definition Variant.h:655
static constexpr std::size_t minLength()
Get minimal length that is required to serialise all possible contained fields.
Definition Variant.h:231
bool operator==(const Variant< TFieldBase, TMembers, TOptions... > &field1, const Variant< TFieldBase, TMembers, TOptions... > &field2)
Equality comparison operator.
Definition Variant.h:624
static constexpr bool hasName()
Compile time inquiry of whether comms::option::def::HasName option has been used.
Definition Variant.h:185
typename BaseImpl::ValueType ValueType
Value type.
Definition Variant.h:120
VersionType getVersion() const
Get version of the field.
Definition Variant.h:489
bool currentFieldValid() const
Check whether the field contains a valid instance of other field.
Definition Variant.h:462
static constexpr bool hasIgnoreInvalid()
Compile time inquiry of whether comms::option::def::IgnoreInvalid option has been used.
Definition Variant.h:157
ErrorStatus read(TIter &iter, std::size_t size)
Read field value from input data sequence.
Definition Variant.h:251
Variant< TFieldBase, TMembers, TOptions... > & toFieldBase(Variant< TFieldBase, TMembers, TOptions... > &field)
Upcast type of the field definition to its parent comms::field::Variant type in order to have access ...
Definition Variant.h:713
Main namespace for all classes / functions of COMMS library.
ErrorStatus
Error statuses reported by the Communication module.
Definition ErrorStatus.h:17
constexpr unsigned version()
Version of the COMMS library as single numeric value.
Definition version.h:64
STL namespace.
Contains definition of all the options used by the COMMS library.
Check whether provided type is a variant of std::tuple.
Definition Tuple.h:36