options.h

Go to the documentation of this file.

//
// Copyright 2014 - 2025 (C). Alex Robenko. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include "comms/ErrorStatus.h"
#include "comms/field/OptionalMode.h"
#include "comms/traits.h"
#include "comms/util/type_traits.h"
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <ratio>
#include <tuple>
#include <type_traits>
 
namespace comms
{
 
namespace option
{
 
namespace details
{
 
template <typename T>
struct IsRatio
{
    static const bool Value = false;
};
 
template <std::intmax_t TNum, std::intmax_t TDen>
struct IsRatio<std::ratio<TNum, TDen> >
{
    static const bool Value = true;
};
 
template <typename T>
constexpr bool isRatio()
{
    return IsRatio<T>::Value;
}
 
template<typename T, T TVal>
struct DefaultNumValueInitialiser
{
    template <typename TField>
    void operator()(TField&& field)
    {
        using FieldType = typename std::decay<TField>::type;
        using ValueType = typename FieldType::ValueType;
        field.value() = static_cast<ValueType>(TVal);
    }
};
 
template<std::intmax_t TMinValue, std::intmax_t TMaxValue>
struct NumValueRangeValidator
{
    static_assert(
        TMinValue <= TMaxValue,
        "Min value must be not greater than Max value");
 
    template <typename TField>
    constexpr bool operator()(const TField& field) const
    {
        using MinTag =
            typename comms::util::Conditional<
                (std::numeric_limits<decltype(MinValue)>::min() < MinValue)
            >::template Type<
                CompareTag,
                ReturnTrueTag
            >;
 
        using MaxTag =
            typename comms::util::Conditional<
                (MaxValue < std::numeric_limits<decltype(MaxValue)>::max())
            >::template Type<
                CompareTag,
                ReturnTrueTag
            >::type;
 
        return aboveMin(field.value(), MinTag()) && belowMax(field.value(), MaxTag());
    }
 
private:
    struct ReturnTrueTag {};
    struct CompareTag {};
 
    template <typename TValue>
    static constexpr bool aboveMin(const TValue& value, CompareTag)
    {
        using ValueType = typename std::decay<decltype(value)>::type;
        return (static_cast<ValueType>(MinValue) <= static_cast<ValueType>(value));
    }
 
    template <typename TValue>
    static constexpr bool aboveMin(const TValue&, ReturnTrueTag)
    {
        return true;
    }
 
    template <typename TValue>
    static constexpr bool belowMax(const TValue& value, CompareTag)
    {
        using ValueType = typename std::decay<decltype(value)>::type;
        return (value <= static_cast<ValueType>(MaxValue));
    }
 
    template <typename TValue>
    static constexpr bool belowMax(const TValue&, ReturnTrueTag)
    {
        return true;
    }
 
    static const auto MinValue = TMinValue;
    static const auto MaxValue = TMaxValue;
};
 
template<std::uintmax_t TMask, std::uintmax_t TValue>
struct BitmaskReservedBitsValidator
{
    template <typename TField>
    constexpr bool operator()(TField&& field) const
    {
        using FieldType = typename std::decay<TField>::type;
        using ValueType = typename FieldType::ValueType;
 
        return (field.value() & static_cast<ValueType>(TMask)) == static_cast<ValueType>(TValue);
    }
};
 
template <comms::field::OptionalMode TVal>
struct DefaultOptModeInitialiser
{
    template <typename TField>
    void operator()(TField& field) const
    {
        field.setMode(TVal);
    }
};
 
template<std::size_t TIdx>
struct DefaultVariantIndexInitialiser
{
    template <typename TField>
    void operator()(TField& field)
    {
        field.template initField<TIdx>();
    }
};
 
}  // namespace details
 
namespace def {
 
template <typename TEndian>
struct Endian
{
};
 
using BigEndian = Endian<comms::traits::endian::Big>;
 
using LittleEndian = Endian<comms::traits::endian::Little>;
 
template <typename T>
struct MsgIdType {};
 
template <std::intmax_t TId>
struct StaticNumIdImpl {};
 
struct NoIdImpl {};
 
template <typename TMsg>
struct MsgType {};
 
template <typename TField>
struct FieldType {};
 
template <typename TFields>
struct ExtraTransportFields {};
 
template <std::size_t TIdx>
struct VersionInExtraTransportFields {};
 
template <typename TFields>
struct FieldsImpl;
 
template <typename... TFields>
struct FieldsImpl<std::tuple<TFields...> >
{
};
 
using ZeroFieldsImpl = FieldsImpl<std::tuple<> >;
 
struct HasDoGetId {};
 
struct AssumeFieldsExistence {};
 
template<std::size_t TLen, bool TSignExtend = true>
struct FixedLength {};
 
template<std::size_t TLen, bool TSignExtend = true>
struct FixedBitLength {};
 
template<std::size_t TMin, std::size_t TMax>
struct VarLength
{
    static_assert(TMin <= TMax, "TMin must not be greater that TMax.");
};
 
struct AvailableLengthLimit
{
};
 
template<std::intmax_t TOffset>
struct NumValueSerOffset {};
 
template <std::intmax_t TNum, std::intmax_t TDenom>
struct ScalingRatio
{
    static_assert(TNum != 0, "Wrong scaling ratio");
    static_assert(TDenom != 0, "Wrong scaling ratio");
};
 
template <typename TField>
struct SequenceSizeFieldPrefix {};
 
template <typename TField, comms::ErrorStatus TReadErrorStatus = comms::ErrorStatus::InvalidMsgData>
struct SequenceSerLengthFieldPrefix {};
 
template <typename TField, comms::ErrorStatus TReadErrorStatus = comms::ErrorStatus::InvalidMsgData>
struct SequenceElemSerLengthFieldPrefix {};
 
template <typename TField, comms::ErrorStatus TReadErrorStatus = comms::ErrorStatus::InvalidMsgData>
struct SequenceElemFixedSerLengthFieldPrefix {};
 
template <typename TField>
struct SequenceTerminationFieldSuffix {};
 
template <typename TField>
struct SequenceTrailingFieldSuffix {};
 
struct SequenceSizeForcingEnabled {};
 
struct SequenceLengthForcingEnabled {};
 
struct SequenceElemLengthForcingEnabled {};
 
template <std::size_t TSize>
struct SequenceFixedSize {};
 
template <typename T>
struct DefaultValueInitialiser {};
 
template <typename T>
struct ContentsValidator {};
 
template <comms::ErrorStatus TStatus = comms::ErrorStatus::InvalidMsgData>
struct FailOnInvalid {};
 
struct IgnoreInvalid {};
 
template <typename TType, typename TRatio>
struct Units
{
    static_assert(details::isRatio<TRatio>(),
        "TRatio parameter must be a variant of std::ratio");
 
    static_assert(TRatio::num != 0, "Wrong ratio value");
    static_assert(TRatio::den != 0, "Wrong ratio value");
};
 
using UnitsNanoseconds =
    Units<comms::traits::units::Time, comms::traits::units::NanosecondsRatio>;
 
using UnitsMicroseconds =
    Units<comms::traits::units::Time, comms::traits::units::MicrosecondsRatio>;
 
using UnitsMilliseconds =
    Units<comms::traits::units::Time, comms::traits::units::MillisecondsRatio>;
 
using UnitsSeconds =
    Units<comms::traits::units::Time, comms::traits::units::SecondsRatio>;
 
using UnitsMinutes =
    Units<comms::traits::units::Time, comms::traits::units::MinutesRatio>;
 
using UnitsHours =
    Units<comms::traits::units::Time, comms::traits::units::HoursRatio>;
 
using UnitsDays =
    Units<comms::traits::units::Time, comms::traits::units::DaysRatio>;
 
using UnitsWeeks =
    Units<comms::traits::units::Time, comms::traits::units::WeeksRatio>;
 
using UnitsNanometers =
    Units<comms::traits::units::Distance, comms::traits::units::NanometersRatio>;
 
using UnitsMicrometers =
    Units<comms::traits::units::Distance, comms::traits::units::MicrometersRatio>;
 
using UnitsMillimeters =
    Units<comms::traits::units::Distance, comms::traits::units::MillimetersRatio>;
 
using UnitsCentimeters =
    Units<comms::traits::units::Distance, comms::traits::units::CentimetersRatio>;
 
using UnitsMeters =
    Units<comms::traits::units::Distance, comms::traits::units::MetersRatio>;
 
using UnitsKilometers =
    Units<comms::traits::units::Distance, comms::traits::units::KilometersRatio>;
 
using UnitsNanometersPerSecond =
    Units<comms::traits::units::Speed, comms::traits::units::NanometersPerSecondRatio>;
 
using UnitsMicrometersPerSecond =
    Units<comms::traits::units::Speed, comms::traits::units::MicrometersPerSecondRatio>;
 
using UnitsMillimetersPerSecond =
    Units<comms::traits::units::Speed, comms::traits::units::MillimetersPerSecondRatio>;
 
using UnitsCentimetersPerSecond =
    Units<comms::traits::units::Speed, comms::traits::units::CentimetersPerSecondRatio>;
 
using UnitsMetersPerSecond =
    Units<comms::traits::units::Speed, comms::traits::units::MetersPerSecondRatio>;
 
using UnitsKilometersPerSecond =
    Units<comms::traits::units::Speed, comms::traits::units::KilometersPerSecondRatio>;
 
using UnitsKilometersPerHour =
    Units<comms::traits::units::Speed, comms::traits::units::KilometersPerHourRatio>;
 
using UnitsHertz =
    Units<comms::traits::units::Frequency, comms::traits::units::HzRatio>;
 
using UnitsKilohertz =
    Units<comms::traits::units::Frequency, comms::traits::units::KiloHzRatio>;
 
using UnitsMegahertz =
    Units<comms::traits::units::Frequency, comms::traits::units::MegaHzRatio>;
 
using UnitsGigahertz =
    Units<comms::traits::units::Frequency, comms::traits::units::GigaHzRatio>;
 
using UnitsDegrees =
    Units<comms::traits::units::Angle, comms::traits::units::DegreesRatio>;
 
using UnitsRadians =
    Units<comms::traits::units::Angle, comms::traits::units::RadiansRatio>;
 
using UnitsNanoamps =
    Units<comms::traits::units::Current, comms::traits::units::NanoampsRatio>;
 
using UnitsMicroamps =
    Units<comms::traits::units::Current, comms::traits::units::MicroampsRatio>;
 
using UnitsMilliamps =
    Units<comms::traits::units::Current, comms::traits::units::MilliampsRatio>;
 
using UnitsAmps =
    Units<comms::traits::units::Current, comms::traits::units::AmpsRatio>;
 
using UnitsKiloamps =
    Units<comms::traits::units::Current, comms::traits::units::KiloampsRatio>;
 
using UnitsNanovolts =
    Units<comms::traits::units::Voltage, comms::traits::units::NanovoltsRatio>;
 
using UnitsMicrovolts =
    Units<comms::traits::units::Voltage, comms::traits::units::MicrovoltsRatio>;
 
using UnitsMillivolts =
    Units<comms::traits::units::Voltage, comms::traits::units::MillivoltsRatio>;
 
using UnitsVolts =
    Units<comms::traits::units::Voltage, comms::traits::units::VoltsRatio>;
 
using UnitsKilovolts =
    Units<comms::traits::units::Voltage, comms::traits::units::KilovoltsRatio>;
 
using UnitsBytes =
    Units<comms::traits::units::Memory, comms::traits::units::BytesRatio>;
 
using UnitsKilobytes =
    Units<comms::traits::units::Memory, comms::traits::units::KilobytesRatio>;
 
using UnitsMegabytes =
    Units<comms::traits::units::Memory, comms::traits::units::MegabytesRatio>;
 
using UnitsGigabytes =
    Units<comms::traits::units::Memory, comms::traits::units::GigabytesRatio>;
 
using UnitsTerabytes =
    Units<comms::traits::units::Memory, comms::traits::units::TerabytesRatio>;
 
template<std::intmax_t TVal>
using DefaultNumValue =
    DefaultValueInitialiser<
        details::DefaultNumValueInitialiser<std::intmax_t, TVal>
    >;
 
template<std::uintmax_t TVal>
using DefaultBigUnsignedNumValue =
    DefaultValueInitialiser<
        details::DefaultNumValueInitialiser<std::uintmax_t, TVal>
    >;
 
template<std::intmax_t TMinValue, std::intmax_t TMaxValue>
struct ValidNumValueRange
{
    static_assert(TMinValue <= TMaxValue, "Invalid range");
};
 
struct ValidRangesClear {};
 
template<std::intmax_t TMinValue, std::intmax_t TMaxValue>
using ValidNumValueRangeOverride =
    std::tuple<
        ValidNumValueRange<TMinValue, TMaxValue>,
        ValidRangesClear
    >;
 
template<std::intmax_t TValue>
using ValidNumValue = ValidNumValueRange<TValue, TValue>;
 
template<std::intmax_t TValue>
using ValidNumValueOverride = ValidNumValueRangeOverride<TValue, TValue>;
 
template<std::uintmax_t TMinValue, std::uintmax_t TMaxValue>
struct ValidBigUnsignedNumValueRange
{
    static_assert(TMinValue <= TMaxValue, "Invalid range");
};
 
template<std::uintmax_t TMinValue, std::uintmax_t TMaxValue>
using ValidBigUnsignedNumValueRangeOverride =
    std::tuple<
        ValidBigUnsignedNumValueRange<TMinValue, TMaxValue>,
        ValidRangesClear
    >;
 
template<std::uintmax_t TValue>
using ValidBigUnsignedNumValue = ValidBigUnsignedNumValueRange<TValue, TValue>;
 
template<std::uintmax_t TValue>
using ValidBigUnsignedNumValueOverride = ValidBigUnsignedNumValueRangeOverride<TValue, TValue>;
 
template<std::uintmax_t TMask, std::uintmax_t TValue = 0U>
using BitmaskReservedBits = ContentsValidator<details::BitmaskReservedBitsValidator<TMask, TValue> >;
 
template<comms::field::OptionalMode TVal>
using DefaultOptionalMode = DefaultValueInitialiser<details::DefaultOptModeInitialiser<TVal> >;
 
using MissingByDefault = DefaultOptionalMode<comms::field::OptionalMode::Missing>;
 
using ExistsByDefault = DefaultOptionalMode<comms::field::OptionalMode::Exists>;
 
using OptionalMissingByDefault = MissingByDefault;
 
using OptionalExistsByDefault = ExistsByDefault;
 
template <std::size_t TIdx>
using DefaultVariantIndex = DefaultValueInitialiser<details::DefaultVariantIndexInitialiser<TIdx> >;
 
struct FrameLayerVerifyBeforeRead {};
 
using ChecksumLayerVerifyBeforeRead = FrameLayerVerifyBeforeRead;
 
template <typename TEscField = void>
struct FrameLayerSeekField {};
 
struct EmptySerialization {};
 
using EmptySerialisation = EmptySerialization;
 
struct FrameLayerForceReadUntilDataSplit {};
 
using ProtocolLayerForceReadUntilDataSplit = FrameLayerForceReadUntilDataSplit;
 
struct FrameLayerSuppressReadUntilDataSplitForcing {};
 
using ProtocolLayerSuppressReadUntilDataSplitForcing = FrameLayerSuppressReadUntilDataSplitForcing;
 
struct FrameLayerDisallowReadUntilDataSplit {};
 
using ProtocolLayerDisallowReadUntilDataSplit = FrameLayerDisallowReadUntilDataSplit;
 
struct HasCustomRead {};
 
struct HasCustomRefresh {};
 
struct HasCustomWrite {};
 
struct HasName {};
 
using HasDoRefresh = HasCustomRefresh;
 
struct PseudoValue {};
 
template <typename T>
struct VersionType
{
    static_assert(std::is_integral<T>::value, "Only unsigned integral types are supported for versions");
    static_assert(std::is_unsigned<T>::value, "Only unsigned integral types are supported for versions");
};
 
struct HasCustomVersionUpdate {};
 
template <std::uintmax_t TFrom, std::uintmax_t TUntil>
struct ExistsBetweenVersions
{
    static_assert(TFrom <= TUntil, "Invalid version parameters");
};
 
template <std::uintmax_t TVer>
using ExistsSinceVersion = ExistsBetweenVersions<TVer, std::numeric_limits<std::uintmax_t>::max()>;
 
template <std::uintmax_t TVer>
using ExistsUntilVersion = ExistsBetweenVersions<0, TVer>;
 
struct InvalidByDefault {};
 
struct VersionStorage {};
 
template <typename T>
struct ExtendingClass {};
 
template <std::size_t TIdx>
struct RemLengthMemberField {};
 
struct MissingOnReadFail {};
 
struct MissingOnInvalid {};
 
struct VariantHasCustomResetOnDestruct {};
 
template <bool TVersionDependent>
struct HasVersionDependentMembers {};
 
struct FixedValue {};
 
template <std::intmax_t TOffset>
struct DisplayOffset {};
 
} // namespace def
 
namespace app
{
 
struct EmptyOption {};
 
template <typename TIter>
struct ReadIterator {};
 
template <typename TIter>
struct WriteIterator {};
 
struct IdInfoInterface {};
 
struct ValidCheckInterface {};
 
struct LengthInfoInterface {};
 
struct RefreshInterface {};
 
struct NameInterface {};
 
template <typename T>
struct Handler {};
 
struct NoDispatchImpl {};
 
struct NoReadImpl {};
 
struct NoWriteImpl {};
 
struct NoValidImpl {};
 
struct NoLengthImpl {};
 
struct NoRefreshImpl {};
 
struct InPlaceAllocation {};
 
template <typename TGenericMessage>
struct SupportGenericMessage {};
 
template <std::size_t TSize>
struct FixedSizeStorage {};
 
template <typename TType>
struct CustomStorageType {};
 
struct SequenceFixedSizeUseFixedSizeStorage {};
 
struct NoVirtualDestructor {};
 
struct OrigDataView {};
 
template <typename T>
struct ForceDispatch {};
 
using ForceDispatchPolymorphic = ForceDispatch<comms::traits::dispatch::Polymorphic>;
 
using ForceDispatchStaticBinSearch = ForceDispatch<comms::traits::dispatch::StaticBinSearch>;
 
using ForceDispatchLinearSwitch = ForceDispatch<comms::traits::dispatch::LinearSwitch>;
 
template <typename TFactory>
struct MsgFactory {};
 
template <template<typename, typename, typename...> class TFactory>
struct MsgFactoryTempl {};
 
} // namespace app
 
// Definition options
 
template <typename TEndian>
using Endian = comms::option::def::Endian<TEndian>;
 
using BigEndian = comms::option::def::BigEndian;
 
using LittleEndian = comms::option::def::LittleEndian;
 
template <typename T>
using MsgIdType = comms::option::def::MsgIdType<T>;
 
template <std::intmax_t TId>
using StaticNumIdImpl = comms::option::def::StaticNumIdImpl<TId>;
 
using NoIdImpl = comms::option::def::NoIdImpl;
 
template <typename TMsg>
using MsgType = comms::option::def::MsgType<TMsg>;
 
template <typename TMsg>
using FieldType = comms::option::def::FieldType<TMsg>;
 
template <typename TFields>
using ExtraTransportFields = comms::option::def::ExtraTransportFields<TFields>;
 
template <std::size_t TIdx>
using VersionInExtraTransportFields = comms::option::def::VersionInExtraTransportFields<TIdx>;
 
template <typename TFields>
using FieldsImpl = comms::option::def::FieldsImpl<TFields>;
 
using ZeroFieldsImpl = comms::option::def::ZeroFieldsImpl;
 
using HasDoGetId = comms::option::def::HasDoGetId;
 
using AssumeFieldsExistence = comms::option::def::AssumeFieldsExistence;
 
template<std::size_t TLen, bool TSignExtend = true>
using FixedLength = comms::option::def::FixedLength<TLen, TSignExtend>;
 
template<std::size_t TLen, bool TSignExtend = true>
using FixedBitLength = comms::option::def::FixedBitLength<TLen, TSignExtend>;
 
template<std::size_t TMin, std::size_t TMax>
using VarLength = comms::option::def::VarLength<TMin, TMax>;
 
template<std::intmax_t TOffset>
using NumValueSerOffset = comms::option::def::NumValueSerOffset<TOffset>;
 
template <std::intmax_t TNum, std::intmax_t TDenom>
using ScalingRatio = comms::option::def::ScalingRatio<TNum, TDenom>;
 
template <typename TField>
using SequenceSizeFieldPrefix = comms::option::def::SequenceSizeFieldPrefix<TField>;
 
template <typename TField, comms::ErrorStatus TReadErrorStatus = comms::ErrorStatus::InvalidMsgData>
using SequenceSerLengthFieldPrefix =
    comms::option::def::SequenceSerLengthFieldPrefix<TField, TReadErrorStatus>;
 
template <typename TField, comms::ErrorStatus TReadErrorStatus = comms::ErrorStatus::InvalidMsgData>
using SequenceElemSerLengthFieldPrefix =
    comms::option::def::SequenceElemSerLengthFieldPrefix<TField, TReadErrorStatus>;
 
template <typename TField, comms::ErrorStatus TReadErrorStatus = comms::ErrorStatus::InvalidMsgData>
using SequenceElemFixedSerLengthFieldPrefix =
    comms::option::def::SequenceElemFixedSerLengthFieldPrefix<TField, TReadErrorStatus>;
 
template <typename TField>
using SequenceTerminationFieldSuffix = comms::option::def::SequenceTerminationFieldSuffix<TField>;
 
template <typename TField>
using SequenceTrailingFieldSuffix = comms::option::def::SequenceTrailingFieldSuffix<TField>;
 
using SequenceSizeForcingEnabled = comms::option::def::SequenceSizeForcingEnabled;
 
using SequenceLengthForcingEnabled = comms::option::def::SequenceLengthForcingEnabled;
 
using SequenceElemLengthForcingEnabled = comms::option::def::SequenceElemLengthForcingEnabled;
 
template <std::size_t TSize>
using SequenceFixedSize = comms::option::def::SequenceFixedSize<TSize>;
 
template <typename T>
using DefaultValueInitialiser = comms::option::def::DefaultValueInitialiser<T>;
 
template <comms::ErrorStatus TStatus = comms::ErrorStatus::InvalidMsgData>
using FailOnInvalid = comms::option::def::FailOnInvalid<TStatus>;
 
using IgnoreInvalid = comms::option::def::IgnoreInvalid;
 
template <typename TType, typename TRatio>
using Units = comms::option::def::Units<TType, TRatio>;
 
using UnitsNanoseconds = comms::option::def::UnitsNanoseconds;
 
using UnitsMicroseconds = comms::option::def::UnitsMicroseconds;
 
using UnitsMilliseconds = comms::option::def::UnitsMilliseconds;
 
using UnitsSeconds = comms::option::def::UnitsSeconds;
 
using UnitsMinutes = comms::option::def::UnitsMinutes;
 
using UnitsHours = comms::option::def::UnitsHours;
 
using UnitsDays = comms::option::def::UnitsDays;
 
using UnitsWeeks = comms::option::def::UnitsWeeks;
 
using UnitsNanometers = comms::option::def::UnitsNanometers;
 
using UnitsMicrometers = comms::option::def::UnitsMicrometers;
 
using UnitsMillimeters = comms::option::def::UnitsMillimeters;
 
using UnitsCentimeters = comms::option::def::UnitsCentimeters;
 
using UnitsMeters = comms::option::def::UnitsMeters;
 
using UnitsKilometers = comms::option::def::UnitsKilometers;
 
using UnitsNanometersPerSecond = comms::option::def::UnitsNanometersPerSecond;
 
using UnitsMicrometersPerSecond = comms::option::def::UnitsMicrometersPerSecond;
 
using UnitsMillimetersPerSecond = comms::option::def::UnitsMillimetersPerSecond;
 
using UnitsCentimetersPerSecond = comms::option::def::UnitsCentimetersPerSecond;
 
using UnitsMetersPerSecond = comms::option::def::UnitsMetersPerSecond;
 
using UnitsKilometersPerSecond = comms::option::def::UnitsKilometersPerSecond;
 
using UnitsKilometersPerHour = comms::option::def::UnitsKilometersPerHour;
 
using UnitsHertz = comms::option::def::UnitsHertz;
 
using UnitsKilohertz = comms::option::def::UnitsKilohertz;
 
using UnitsMegahertz = comms::option::def::UnitsMegahertz;
 
using UnitsGigahertz = comms::option::def::UnitsGigahertz;
 
using UnitsDegrees = comms::option::def::UnitsDegrees;
 
using UnitsRadians = comms::option::def::UnitsRadians;
 
using UnitsNanoamps = comms::option::def::UnitsNanoamps;
 
using UnitsMicroamps = comms::option::def::UnitsMicroamps;
 
using UnitsMilliamps = comms::option::def::UnitsMilliamps;
 
using UnitsAmps = comms::option::def::UnitsAmps;
 
using UnitsKiloamps = comms::option::def::UnitsKiloamps;
 
using UnitsNanovolts = comms::option::def::UnitsNanovolts;
 
using UnitsMicrovolts = comms::option::def::UnitsMicrovolts;
 
using UnitsMillivolts = comms::option::def::UnitsMillivolts;
 
using UnitsVolts = comms::option::def::UnitsVolts;
 
using UnitsKilovolts = comms::option::def::UnitsKilovolts;
 
using UnitsBytes = comms::option::def::UnitsBytes;
 
using UnitsKilobytes = comms::option::def::UnitsKilobytes;
 
using UnitsMegabytes = comms::option::def::UnitsMegabytes;
 
using UnitsGigabytes = comms::option::def::UnitsGigabytes;
 
using UnitsTerabytes = comms::option::def::UnitsTerabytes;
 
template<std::intmax_t TVal>
using DefaultNumValue = comms::option::def::DefaultNumValue<TVal>;
 
template<std::uintmax_t TVal>
using DefaultBigUnsignedNumValue = comms::option::def::DefaultBigUnsignedNumValue<TVal>;
 
template<std::intmax_t TMinValue, std::intmax_t TMaxValue>
using ValidNumValueRange = comms::option::def::ValidNumValueRange<TMinValue, TMaxValue>;
 
using ValidRangesClear = comms::option::def::ValidRangesClear;
 
template<std::intmax_t TMinValue, std::intmax_t TMaxValue>
using ValidNumValueRangeOverride = comms::option::def::ValidNumValueRangeOverride<TMinValue, TMaxValue>;
 
template<std::intmax_t TValue>
using ValidNumValue = comms::option::def::ValidNumValue<TValue>;
 
template<std::intmax_t TValue>
using ValidNumValueOverride = comms::option::def::ValidNumValueOverride<TValue>;
 
template<std::uintmax_t TMinValue, std::uintmax_t TMaxValue>
using ValidBigUnsignedNumValueRange =
    comms::option::def::ValidBigUnsignedNumValueRange<TMinValue, TMaxValue>;
 
template<std::uintmax_t TMinValue, std::uintmax_t TMaxValue>
using ValidBigUnsignedNumValueRangeOverride =
    comms::option::def::ValidBigUnsignedNumValueRangeOverride<TMinValue, TMaxValue>;
 
template<std::uintmax_t TValue>
using ValidBigUnsignedNumValue =
    comms::option::def::ValidBigUnsignedNumValue<TValue>;
 
template<std::uintmax_t TValue>
using ValidBigUnsignedNumValueOverride =
    comms::option::def::ValidBigUnsignedNumValueOverride<TValue>;
 
template<std::uintmax_t TMask, std::uintmax_t TValue = 0U>
using BitmaskReservedBits = comms::option::def::BitmaskReservedBits<TMask, TValue>;
 
template<comms::field::OptionalMode TVal>
using DefaultOptionalMode = comms::option::def::DefaultOptionalMode<TVal>;
 
using MissingByDefault = comms::option::def::MissingByDefault;
 
using ExistsByDefault = comms::option::def::ExistsByDefault;
 
using OptionalMissingByDefault = comms::option::def::OptionalMissingByDefault;
 
using OptionalExistsByDefault = comms::option::def::OptionalExistsByDefault;
 
template <std::size_t TIdx>
using DefaultVariantIndex = comms::option::def::DefaultVariantIndex<TIdx>;
 
using ChecksumLayerVerifyBeforeRead = comms::option::def::FrameLayerVerifyBeforeRead;
 
using EmptySerialization = comms::option::def::EmptySerialization;
 
using EmptySerialisation = comms::option::def::EmptySerialisation;
 
using FrameLayerForceReadUntilDataSplit =
    comms::option::def::FrameLayerForceReadUntilDataSplit;
 
using FrameLayerDisallowReadUntilDataSplit =
    comms::option::def::FrameLayerDisallowReadUntilDataSplit;
 
using HasCustomRead = comms::option::def::HasCustomRead;
 
using HasCustomRefresh = comms::option::def::HasCustomRefresh;
 
using HasName = comms::option::def::HasName;
 
using HasDoRefresh = comms::option::def::HasDoRefresh;
 
using PseudoValue = comms::option::def::PseudoValue;
 
template <typename T>
using VersionType = comms::option::def::VersionType<T>;
 
using HasCustomVersionUpdate = comms::option::def::HasCustomVersionUpdate;
 
template <std::uintmax_t TFrom, std::uintmax_t TUntil>
using ExistsBetweenVersions = comms::option::def::ExistsBetweenVersions<TFrom, TUntil>;
 
template <std::uintmax_t TVer>
using ExistsSinceVersion = comms::option::def::ExistsSinceVersion<TVer>;
 
template <std::uintmax_t TVer>
using ExistsUntilVersion = comms::option::def::ExistsUntilVersion<TVer>;
 
using InvalidByDefault = comms::option::def::InvalidByDefault;
 
using VersionStorage = comms::option::def::VersionStorage;
 
template <typename T>
using ExtendingClass = comms::option::def::ExtendingClass<T>;
 
template <std::size_t TIdx>
using RemLengthMemberField = comms::option::def::RemLengthMemberField<TIdx>;
 
// Application customization options
 
using EmptyOption = comms::option::app::EmptyOption;
 
template <typename TIter>
using ReadIterator = comms::option::app::ReadIterator<TIter>;
 
template <typename TIter>
using WriteIterator = comms::option::app::WriteIterator<TIter>;
 
using IdInfoInterface = comms::option::app::IdInfoInterface;
 
using ValidCheckInterface = comms::option::app::ValidCheckInterface;
 
using LengthInfoInterface = comms::option::app::LengthInfoInterface;
 
using RefreshInterface = comms::option::app::RefreshInterface;
 
using NameInterface = comms::option::app::NameInterface;
 
template <typename T>
using Handler = comms::option::app::Handler<T>;
 
using NoDispatchImpl = comms::option::app::NoDispatchImpl;
 
using NoReadImpl = comms::option::app::NoReadImpl;
 
using NoWriteImpl = comms::option::app::NoWriteImpl;
 
using NoValidImpl = comms::option::app::NoValidImpl;
 
using NoLengthImpl = comms::option::app::NoLengthImpl;
 
using NoRefreshImpl = comms::option::app::NoRefreshImpl;
 
using InPlaceAllocation = comms::option::app::InPlaceAllocation;
 
template <typename TGenericMessage>
using SupportGenericMessage = comms::option::app::SupportGenericMessage<TGenericMessage>;
 
template <std::size_t TSize>
using FixedSizeStorage = comms::option::app::FixedSizeStorage<TSize>;
 
template <typename TType>
using CustomStorageType = comms::option::app::CustomStorageType<TType>;
 
using SequenceFixedSizeUseFixedSizeStorage = comms::option::app::SequenceFixedSizeUseFixedSizeStorage;
 
using NoVirtualDestructor = comms::option::app::NoVirtualDestructor;
 
using OrigDataView = comms::option::app::OrigDataView;
 
template <typename T>
using ForceDispatch = comms::option::app::ForceDispatch<T>;
 
using ForceDispatchPolymorphic = comms::option::app::ForceDispatchPolymorphic;
 
using ForceDispatchStaticBinSearch = comms::option::app::ForceDispatchStaticBinSearch;
 
using ForceDispatchLinearSwitch = comms::option::app::ForceDispatchLinearSwitch;
 
}  // namespace option
 
}  // namespace comms