Variant.h

Go to the documentation of this file.

//
// Copyright 2017 - 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/details/macro_common.h"
#include "comms/details/variant_access.h"
#include "comms/ErrorStatus.h"
#include "comms/field/basic/Variant.h"
#include "comms/field/details/AdaptBasicField.h"
#include "comms/options.h"
#include "comms/util/Tuple.h"
 
namespace comms
{
 
namespace field
{
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
class Variant : public
    details::AdaptBasicFieldT<
        basic::Variant<
            TFieldBase, 
            details::OptionsParser<TOptions...>::ForcedMembersVersionDependency,
            TMembers
        >, 
        TOptions...>
{
    using BaseImpl = 
        details::AdaptBasicFieldT<
        basic::Variant<
            TFieldBase, 
            details::OptionsParser<TOptions...>::ForcedMembersVersionDependency,
            TMembers
        >, 
        TOptions...>;
 
    static_assert(comms::util::IsTuple<TMembers>::Value,
        "TMembers is expected to be a tuple of std::tuple<...>");
 
    static_assert(
        1U <= std::tuple_size<TMembers>::value,
        "Number of members is expected to be at least 1.");
 
public:
    using FieldBase = TFieldBase;
 
    using Endian = typename BaseImpl::Endian;
 
    using VersionType = typename BaseImpl::VersionType;
 
    using ParsedOptions = details::OptionsParser<TOptions...>;
 
    using CommsTag = typename BaseImpl::CommsTag;
 
    using ValueType = typename BaseImpl::ValueType;
 
    using Members = typename BaseImpl::Members;
 
    using FieldType = typename ParsedOptions::FieldType;    
 
    Variant() = default;
 
    explicit Variant(const ValueType& val)
      : BaseImpl(val)
    {
    }
    explicit Variant(const ValueType& val) {…}
 
    explicit Variant(ValueType&& val)
      : BaseImpl(std::move(val))
    {
    }
    explicit Variant(ValueType&& val) {…}
 
    static constexpr bool hasFailOnInvalid()
    {
        return ParsedOptions::HasFailOnInvalid;
    }
    static constexpr bool hasFailOnInvalid() {…}
 
    static constexpr bool hasIgnoreInvalid()
    {
        return ParsedOptions::HasIgnoreInvalid;
    }
    static constexpr bool hasIgnoreInvalid() {…}
 
    static constexpr bool hasEmptySerialization()
    {
        return ParsedOptions::HasEmptySerialization;
    }    
    static constexpr bool hasEmptySerialization() {…}
 
    static constexpr bool hasFieldType()
    {
        return ParsedOptions::HasFieldType;
    }  
    static constexpr bool hasFieldType() {…}
 
    static constexpr bool hasFixedValue()
    {
        return ParsedOptions::HasFixedValue;
    }   
    static constexpr bool hasFixedValue() {…}
 
    static constexpr bool hasName()
    {
        return ParsedOptions::HasName;
    }       
    static constexpr bool hasName() {…}
 
    ValueType& value()
    {
        return BaseImpl::value();
    }
    ValueType& value() {…}
 
    const ValueType& value() const
    {
        return BaseImpl::value();
    }
    const ValueType& value() const {…}
 
    const ValueType& getValue() const
    {
        return BaseImpl::getValue();
    }
    const ValueType& getValue() const {…}
 
    template <typename U>
    void setValue(U&& val)
    {
        BaseImpl::setValue(std::forward<U>(val));
    }          
    void setValue(U&& val) {…}
 
    std::size_t length() const
    {
        return BaseImpl::length();
    }
    std::size_t length() const {…}
 
    static constexpr std::size_t minLength()
    {
        return BaseImpl::minLength();
    }
    static constexpr std::size_t minLength() {…}
 
    static constexpr std::size_t maxLength()
    {
        return BaseImpl::maxLength();
    }
    static constexpr std::size_t maxLength() {…}
 
    template <typename TIter>
    ErrorStatus read(TIter& iter, std::size_t size)
    {
        return BaseImpl::read(iter, size);
    }
    ErrorStatus read(TIter& iter, std::size_t size) {…}
 
    static constexpr bool hasReadNoStatus()
    {
        return false;
    }
    static constexpr bool hasReadNoStatus() {…}
 
    template <typename TIter>
    void readNoStatus(TIter& iter) = delete;
 
    bool canWrite() const
    {
        return BaseImpl::canWrite();
    }
    bool canWrite() const {…}
 
    template <typename TIter>
    ErrorStatus write(TIter& iter, std::size_t size) const
    {
        return BaseImpl::write(iter, size);
    }
    ErrorStatus write(TIter& iter, std::size_t size) const {…}
 
    static constexpr bool hasWriteNoStatus()
    {
        return BaseImpl::hasWriteNoStatus();
    }
    static constexpr bool hasWriteNoStatus() {…}
 
    template <typename TIter>
    void writeNoStatus(TIter& iter) const
    {
        BaseImpl::writeNoStatus(iter);
    }
    void writeNoStatus(TIter& iter) const {…}
 
    bool valid() const
    {
        return BaseImpl::valid();
    }
    bool valid() const {…}
 
    bool refresh()
    {
        return BaseImpl::refresh();
    }
    bool refresh() {…}
 
    std::size_t currentField() const
    {
        return BaseImpl::currentField();
    }
    std::size_t currentField() const {…}
 
    void selectField(std::size_t idx)
    {
        BaseImpl::selectField(idx);
    }
    void selectField(std::size_t idx) {…}
 
    template <typename TFunc>
    void currentFieldExec(TFunc&& func)
    {
        BaseImpl::currentFieldExec(std::forward<TFunc>(func));
    }
    void currentFieldExec(TFunc&& func) {…}
 
    template <typename TFunc>
    void currentFieldExec(TFunc&& func) const
    {
        BaseImpl::currentFieldExec(std::forward<TFunc>(func));
    }
    void currentFieldExec(TFunc&& func) const {…}
 
    template <std::size_t TIdx, typename... TArgs>
    typename std::tuple_element<TIdx, Members>::type& initField(TArgs&&... args)
    {
        return BaseImpl::template initField<TIdx>(std::forward<TArgs>(args)...);
    }
    typename std::tuple_element<TIdx, Members>::type& initField(TArgs&&... args) {…}
 
    template <std::size_t TIdx>
    void deinitField()
    {
        BaseImpl::template deinitField<TIdx>();
    }
    void deinitField() {…}
 
    template <std::size_t TIdx>
    typename std::tuple_element<TIdx, Members>::type& accessField()
    {
        return BaseImpl::template accessField<TIdx>();
    }
    typename std::tuple_element<TIdx, Members>::type& accessField() {…}
 
    template <std::size_t TIdx>
    const typename std::tuple_element<TIdx, Members>::type& accessField() const
    {
        return BaseImpl::template accessField<TIdx>();
    }
    const typename std::tuple_element<TIdx, Members>::type& accessField() const {…}
 
    bool currentFieldValid() const
    {
        return BaseImpl::currentFieldValid();
    }
    bool currentFieldValid() const {…}
 
    void reset()
    {
        BaseImpl::reset();
    }
    void reset() {…}
 
    static constexpr bool isVersionDependent()
    {
        return ParsedOptions::HasCustomVersionUpdate || BaseImpl::isVersionDependent();
    }
    static constexpr bool isVersionDependent() {…}
 
    static constexpr bool hasNonDefaultRefresh()
    {
        return BaseImpl::hasNonDefaultRefresh();
    }
    static constexpr bool hasNonDefaultRefresh() {…}
 
    VersionType getVersion() const
    {
        return BaseImpl::getVersion();
    }
    VersionType getVersion() const {…}
 
    bool setVersion(VersionType version)
    {
        return BaseImpl::setVersion(version);
    }
    bool setVersion(VersionType version) {…}
 
protected:
    using BaseImpl::readData;
    using BaseImpl::writeData;
 
private:
    static_assert(!ParsedOptions::HasSerOffset,
            "comms::option::def::NumValueSerOffset option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasFixedLengthLimit,
            "comms::option::def::FixedLength option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasFixedBitLengthLimit,
            "comms::option::def::FixedBitLength option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasVarLengthLimits,
            "comms::option::def::VarLength option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasAvailableLengthLimit,
            "comms::option::def::AvailableLengthLimit option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasSequenceElemLengthForcing,
            "comms::option::def::SequenceElemLengthForcingEnabled option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasSequenceSizeForcing,
            "comms::option::def::SequenceSizeForcingEnabled option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasSequenceLengthForcing,
            "comms::option::def::SequenceLengthForcingEnabled option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasSequenceFixedSize,
            "comms::option::def::SequenceFixedSize option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasSequenceFixedSizeUseFixedSizeStorage,
            "comms::option::app::SequenceFixedSizeUseFixedSizeStorage option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasSequenceSizeFieldPrefix,
            "comms::option::def::SequenceSizeFieldPrefix option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasSequenceSerLengthFieldPrefix,
            "comms::option::def::SequenceSerLengthFieldPrefix option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasSequenceElemSerLengthFieldPrefix,
            "comms::option::def::SequenceElemSerLengthFieldPrefix option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasSequenceElemFixedSerLengthFieldPrefix,
            "comms::option::def::SequenceElemFixedSerLengthFieldPrefix option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasSequenceTrailingFieldSuffix,
            "comms::option::def::SequenceTrailingFieldSuffix option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasSequenceTerminationFieldSuffix,
            "comms::option::def::SequenceTerminationFieldSuffix option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasFixedSizeStorage,
            "comms::option::app::FixedSizeStorage option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasCustomStorageType,
            "comms::option::app::CustomStorageType option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasScalingRatio,
            "comms::option::def::ScalingRatio option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasUnits,
            "comms::option::def::Units option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasOrigDataView,
            "comms::option::app::OrigDataView option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasMultiRangeValidation,
            "comms::option::def::ValidNumValueRange (or similar) option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasVersionsRange,
            "comms::option::def::ExistsBetweenVersions (or similar) option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasInvalidByDefault,
            "comms::option::def::InvalidByDefault option is not applicable to Variant field");
    static_assert(!ParsedOptions::HasMissingOnReadFail,
            "comms::option::def::MissingOnReadFail option is not applicable to Variant field");   
    static_assert(!ParsedOptions::HasMissingOnInvalid,
            "comms::option::def::MissingOnInvalid option is not applicable to Variant field");              
};
class Variant : public {…};
 
namespace details
{
 
template <typename TVar>
class VariantEqualityCompHelper
{
public:
    VariantEqualityCompHelper(const TVar& other, bool& result)
      : m_other(other),
        m_result(result)
    {}
 
    template <std::size_t TIdx, typename TField>
    void operator()(const TField& field)
    {
        m_result = (field == m_other.template accessField<TIdx>());
    }
 
private:
    const TVar& m_other;
    bool& m_result;
 
};
 
template <typename TVar>
VariantEqualityCompHelper<TVar> makeVariantEqualityCompHelper(TVar& other, bool& result)
{
    return VariantEqualityCompHelper<TVar>(other, result);
}
 
template <typename TVar>
class VariantLessCompHelper
{
public:
    VariantLessCompHelper(const TVar& other, bool& result)
      : m_other(other),
        m_result(result)
    {}
 
    template <std::size_t TIdx, typename TField>
    void operator()(const TField& field)
    {
        m_result = (field < m_other.template accessField<TIdx>());
    }
 
private:
    const TVar& m_other;
    bool& m_result;
};
 
template <typename TVar>
VariantLessCompHelper<TVar> makeVariantLessCompHelper(TVar& other, bool& result)
{
    return VariantLessCompHelper<TVar>(other, result);
}
 
} // namespace details
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
bool operator==(
    const Variant<TFieldBase, TMembers, TOptions...>& field1,
    const Variant<TFieldBase, TMembers, TOptions...>& field2)
{
    if (&field1 == &field2) {
        return true;
    }
 
    if (field1.currentFieldValid() != field2.currentFieldValid()) {
        return false;
    }
 
    if (!field1.currentFieldValid()) {
        return true;
    }
 
    if (field1.currentField() != field2.currentField()) {
        return false;
    }
 
    bool result = false;
    field1.currentFieldExec(details::makeVariantEqualityCompHelper(field2, result));
    return result;
}
bool operator==( {…}
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
bool operator!=(
    const Variant<TFieldBase, TMembers, TOptions...>& field1,
    const Variant<TFieldBase, TMembers, TOptions...>& field2)
{
    return !(field1 == field2);
}
bool operator!=( {…}
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
bool operator<(
    const Variant<TFieldBase, TMembers, TOptions...>& field1,
    const Variant<TFieldBase, TMembers, TOptions...>& field2)
{
    if (!field1.currentFieldValid()) {
        return (!field2.currentFieldValid());
    }
 
    if (!field2.currentFieldValid()) {
        return false;
    }    
 
    if (field1.currentField() < field2.currentField()) {
        return true;
    }
 
    if (field1.currentField() != field2.currentField()) {
        return false;
    }
 
    if (&field1 == &field2) {
        return false;
    }    
 
    bool result = false;
    field1.currentFieldExec(details::makeVariantLessCompHelper(field2, result));
    return result;
}
bool operator<( {…}
 
template <typename T>
constexpr bool isVariant()
{
    return std::is_same<typename T::CommsTag, tag::Variant>::value;
}
constexpr bool isVariant() {…}
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
inline
Variant<TFieldBase, TMembers, TOptions...>&
toFieldBase(Variant<TFieldBase, TMembers, TOptions...>& field)
{
    return field;
}
toFieldBase(Variant<TFieldBase, TMembers, TOptions...>& field) {…}
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
inline
const Variant<TFieldBase, TMembers, TOptions...>&
toFieldBase(const Variant<TFieldBase, TMembers, TOptions...>& field)
{
    return field;
}
toFieldBase(const Variant<TFieldBase, TMembers, TOptions...>& field) {…}
 
#define COMMS_VARIANT_MEMBERS_ACCESS(...) \
    COMMS_EXPAND(COMMS_DEFINE_FIELD_ENUM(__VA_ARGS__)) \
    COMMS_AS_VARIANT_FUNC { \
        auto& var = comms::field::toFieldBase(*this); \
        using Var = typename std::decay<decltype(var)>::type; \
        static_assert(std::tuple_size<typename Var::Members>::value == FieldIdx_numOfValues, \
            "Invalid number of names for variant field"); \
        return var; \
    }\
    COMMS_AS_VARIANT_CONST_FUNC { \
        auto& var = comms::field::toFieldBase(*this); \
        using Var = typename std::decay<decltype(var)>::type; \
        static_assert(std::tuple_size<typename Var::Members>::value == FieldIdx_numOfValues, \
            "Invalid number of names for variant field"); \
        return var; \
    } \
    COMMS_DO_VARIANT_MEM_ACC_FUNC(asVariant(), __VA_ARGS__)
#define COMMS_VARIANT_MEMBERS_ACCESS(...) \ …
 
 
#define COMMS_VARIANT_MEMBERS_ACCESS_NOTEMPLATE(...) \
    COMMS_EXPAND(COMMS_DEFINE_FIELD_ENUM(__VA_ARGS__)) \
    COMMS_DO_VARIANT_MEM_ACC_FUNC_NOTEMPLATE(__VA_ARGS__)
#define COMMS_VARIANT_MEMBERS_ACCESS_NOTEMPLATE(...) \ …
 
#define COMMS_VARIANT_MEMBERS_NAMES(...) \
    COMMS_EXPAND(COMMS_VARIANT_MEMBERS_ACCESS(__VA_ARGS__)) \
    COMMS_EXPAND(COMMS_DO_FIELD_TYPEDEF(typename Base::Members, Field_, FieldIdx_, __VA_ARGS__))
#define COMMS_VARIANT_MEMBERS_NAMES(...) \ …
 
 
}  // namespace field
 
}  // namespace comms