BitmaskValue.h

Go to the documentation of this file.

//
// Copyright 2014 - 2026 (C). Alex Robenko. All rights reserved.
//
// SPDX-License-Identifier: MPL-2.0
//
// 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/bits_access.h"
#include "comms/details/gen_enum.h"
#include "comms/Field.h"
#include "comms/field/details/AdaptBasicField.h"
#include "comms/field/details/OptionsParser.h"
#include "comms/field/IntValue.h"
#include "comms/field/tag.h"
#include "comms/util/SizeToType.h"
 
#include <cstddef>
#include <type_traits>
#include <utility>
 
namespace comms
{
 
namespace field
{
 
namespace details
{
 
template <bool THasFixedLength>
struct BitmaskUndertlyingType;
 
template <>
struct BitmaskUndertlyingType<true>
{
    template <typename TOptionsBundle>
    using Type = typename comms::util::SizeToType<TOptionsBundle::FixedLength, false>::Type;
};
 
template <>
struct BitmaskUndertlyingType<false>
{
    template <typename TOptionsBundle>
    using Type = unsigned;
};
 
template <typename TOptionsBundle>
using BitmaskUndertlyingTypeT =
    typename BitmaskUndertlyingType<TOptionsBundle::HasFixedLengthLimit>::template Type<TOptionsBundle>;
 
}  // namespace details
 
template <typename TFieldBase, typename... TOptions>
class BitmaskValue : public TFieldBase
{
    using BaseImpl = TFieldBase;
 
    using OptionsBundle = details::OptionsParser<TOptions...>;
 
    using IntValueType = details::BitmaskUndertlyingTypeT<OptionsBundle>;
 
    using IntValueField =
        IntValue<
            TFieldBase,
            IntValueType,
            TOptions...
        >;
 
public:
    using FieldBase = TFieldBase;
 
    using Endian = typename BaseImpl::Endian;
 
    using VersionType = typename BaseImpl::VersionType;
 
    using ParsedOptions = OptionsBundle;
 
    using CommsTag = tag::Bitmask;
 
    using ValueType = typename IntValueField::ValueType;
 
    using FieldType = typename ParsedOptions::FieldType;
 
    BitmaskValue() = default;
 
    explicit BitmaskValue(const ValueType& val)
       : m_intValue(val)
    {
    }
 
    BitmaskValue(const BitmaskValue&) = default;
 
    ~BitmaskValue() noexcept = default;
 
    BitmaskValue& operator=(const BitmaskValue&) = default;
 
    static constexpr bool hasFailOnInvalid()
    {
        return ParsedOptions::HasFailOnInvalid;
    }
 
    static constexpr bool hasIgnoreInvalid()
    {
        return ParsedOptions::HasIgnoreInvalid;
    }
 
    static constexpr bool hasEmptySerialization()
    {
        return ParsedOptions::HasEmptySerialization;
    }
 
    static constexpr bool hasFieldType()
    {
        return ParsedOptions::HasFieldType;
    }
 
    static constexpr bool hasFixedValue()
    {
        return ParsedOptions::HasFixedValue;
    }
 
    static constexpr bool hasName()
    {
        return ParsedOptions::HasName;
    }
 
    const ValueType& value() const
    {
        return m_intValue.value();
    }
 
    ValueType& value()
    {
        return m_intValue.value();
    }
 
    const ValueType& getValue() const
    {
        return m_intValue.getValue();
    }
 
    template <typename U>
    void setValue(U&& val)
    {
        m_intValue.setValue(std::forward<U>(val));
    }
 
    constexpr std::size_t length() const
    {
        return m_intValue.length();
    }
 
    static constexpr std::size_t maxLength()
    {
        return IntValueField::maxLength();
    }
 
    static constexpr std::size_t minLength()
    {
        return IntValueField::minLength();
    }
 
    template <typename TIter>
    ErrorStatus read(TIter& iter, std::size_t size)
    {
        return m_intValue.read(iter, size);
    }
 
    static constexpr bool hasReadNoStatus()
    {
        return BaseImpl::hasReadNoStatus();
    }
 
    template <typename TIter>
    void readNoStatus(TIter& iter)
    {
        m_intValue.readNoStatus(iter);
    }
 
    bool canWrite() const
    {
        return BaseImpl::canWrite();
    }
 
    template <typename TIter>
    ErrorStatus write(TIter& iter, std::size_t size) const
    {
        return m_intValue.write(iter, size);
    }
 
    static constexpr bool hasWriteNoStatus()
    {
        return BaseImpl::hasWriteNoStatus();
    }
 
    template <typename TIter>
    void writeNoStatus(TIter& iter) const
    {
        m_intValue.writeNoStatus(iter);
    }
 
    constexpr bool valid() const
    {
        return m_intValue.valid();
    }
 
    bool refresh()
    {
        return m_intValue.refresh();
    }
 
    bool hasAllBitsSet(ValueType mask) const
    {
        return (value() & mask) == mask;
    }
 
    bool hasAnyBitsSet(ValueType mask) const
    {
        return (value() & mask) != 0;
    }
 
    void setBits(ValueType mask)
    {
        value() |= mask;
    }
 
    void clearBits(ValueType mask)
    {
        value() &= static_cast<ValueType>(~mask);
    }
 
    bool getBitValue(unsigned bitNum) const
    {
        return hasAllBitsSet(
            static_cast<ValueType>(static_cast<ValueType>(1U) << bitNum));
    }
 
    void setBitValue(unsigned bitNum, bool val)
    {
        auto mask = static_cast<ValueType>(static_cast<ValueType>(1U) << bitNum);
        if (val) {
            setBits(mask);
        }
        else {
            clearBits(mask);
        }
    }
 
    static constexpr bool isVersionDependent()
    {
        return IntValueField::isVersionDependent();
    }
 
    static constexpr bool hasNonDefaultRefresh()
    {
        return BaseImpl::hasNonDefaultRefresh();
    }
 
    VersionType getVersion() const
    {
        return m_intValue.getVersion();
    }
 
    bool setVersion(VersionType version)
    {
        return m_intValue.setVersion(version);
    }
 
    void setForcedLength(int len)
    {
        m_intValue.setForcedLength(len);
    }
 
    int getForcedLength() const
    {
        return m_intValue.getForcedLength();
    }
 
protected:
    using BaseImpl::readData;
    using BaseImpl::writeData;
 
private:
 
    static_assert(!ParsedOptions::HasSerOffset,
        "comms::option::def::NumValueSerOffset option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasVarLengthLimits,
        "comms::option::def::VarLength option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasSequenceElemLengthForcing,
        "comms::option::def::SequenceElemLengthForcingEnabled option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasSequenceSizeForcing,
        "comms::option::def::SequenceSizeForcingEnabled option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasSequenceLengthForcing,
        "comms::option::def::SequenceLengthForcingEnabled option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasSequenceFixedSize,
        "comms::option::def::SequenceFixedSize option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasSequenceFixedSizeUseFixedSizeStorage,
        "comms::option::app::SequenceFixedSizeUseFixedSizeStorage option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasSequenceSizeFieldPrefix,
        "comms::option::def::SequenceSizeFieldPrefix option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasSequenceSerLengthFieldPrefix,
        "comms::option::def::SequenceSerLengthFieldPrefix option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasSequenceElemSerLengthFieldPrefix,
        "comms::option::def::SequenceElemSerLengthFieldPrefix option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasSequenceElemFixedSerLengthFieldPrefix,
        "comms::option::def::SequenceElemSerLengthFixedFieldPrefix option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasSequenceTrailingFieldSuffix,
        "comms::option::def::SequenceTrailingFieldSuffix option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasSequenceTerminationFieldSuffix,
        "comms::option::def::SequenceTerminationFieldSuffix option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasFixedSizeStorage,
        "comms::option::app::FixedSizeStorage option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasCustomStorageType,
        "comms::option::app::CustomStorageType option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasScalingRatio,
        "comms::option::def::ScalingRatio option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasUnits,
        "comms::option::def::Units option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasOrigDataView,
        "comms::option::app::OrigDataView option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasMultiRangeValidation,
        "comms::option::def::ValidNumValueRange (or similar) option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasVersionsRange,
        "comms::option::def::ExistsBetweenVersions (or similar) option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasInvalidByDefault,
        "comms::option::def::InvalidByDefault option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasMissingOnReadFail,
            "comms::option::def::MissingOnReadFail option is not applicable to BitmaskValue field");
    static_assert(!ParsedOptions::HasMissingOnInvalid,
            "comms::option::def::MissingOnInvalid option is not applicable to BitmaskValue field");
    IntValueField m_intValue;
};
 
// Implementation
 
template <typename TFieldBase, typename... TOptions>
bool operator==(
    const BitmaskValue<TFieldBase, TOptions...>& field1,
    const BitmaskValue<TFieldBase, TOptions...>& field2) noexcept
{
    return field1.value() == field2.value();
}
 
template <typename TFieldBase, typename... TOptions>
bool operator!=(
    const BitmaskValue<TFieldBase, TOptions...>& field1,
    const BitmaskValue<TFieldBase, TOptions...>& field2) noexcept
{
    return field1.value() != field2.value();
}
 
template <typename TFieldBase, typename... TOptions>
bool operator<(
    const BitmaskValue<TFieldBase, TOptions...>& field1,
    const BitmaskValue<TFieldBase, TOptions...>& field2) noexcept
{
    return field1.value() < field2.value();
}
 
template <typename T>
constexpr bool isBitmaskValue()
{
    return std::is_same<typename T::CommsTag, tag::Bitmask>::value;
}
 
template <typename TFieldBase, typename... TOptions>
inline
BitmaskValue<TFieldBase, TOptions...>&
toFieldBase(BitmaskValue<TFieldBase, TOptions...>& field)
{
    return field;
}
 
template <typename TFieldBase, typename... TOptions>
inline
const BitmaskValue<TFieldBase, TOptions...>&
toFieldBase(const BitmaskValue<TFieldBase, TOptions...>& field)
{
    return field;
}
 
#define COMMS_BITMASK_BITS(...) COMMS_DEFINE_ENUM(BitIdx, __VA_ARGS__)
 
#define COMMS_BITMASK_BITS_ACCESS(...) \
    COMMS_AS_BITMASK_FUNC { \
        return comms::field::toFieldBase(*this); \
    }\
    COMMS_AS_BITMASK_CONST_FUNC { \
        return comms::field::toFieldBase(*this); \
    } \
    COMMS_DO_BIT_ACC_FUNC(asBitmask(), __VA_ARGS__)
 
#define COMMS_BITMASK_BITS_ACCESS_NOTEMPLATE(...) \
    COMMS_DO_BIT_ACC_FUNC((*this), __VA_ARGS__)
 
#define COMMS_BITMASK_BITS_SEQ(...) \
    COMMS_BITMASK_BITS(__VA_ARGS__) \
    COMMS_BITMASK_BITS_ACCESS(__VA_ARGS__)
 
#define COMMS_BITMASK_BITS_SEQ_NOTEMPLATE(...) \
    COMMS_BITMASK_BITS(__VA_ARGS__) \
    COMMS_BITMASK_BITS_ACCESS_NOTEMPLATE(__VA_ARGS__)
 
}  // namespace field
 
}  // namespace comms