IntValue.h

Go to the documentation of this file.

//
// Copyright 2015 - 2024 (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 <ratio>
#include <limits>
#include <type_traits>
 
#include "comms/CompileControl.h"
#include "comms/ErrorStatus.h"
#include "comms/options.h"
#include "comms/util/type_traits.h"
#include "basic/IntValue.h"
#include "details/AdaptBasicField.h"
#include "comms/details/tag.h"
 
COMMS_MSVC_WARNING_PUSH
COMMS_MSVC_WARNING_DISABLE(4127) // Disable warning about constant conditional expressions
 
namespace comms
{
 
namespace field
{
 
template <typename TFieldBase, typename T, typename... TOptions>
class IntValue : public details::AdaptBasicFieldT<basic::IntValue<TFieldBase, T>, TOptions...>
{
    using BaseImpl = details::AdaptBasicFieldT<basic::IntValue<TFieldBase, T>, TOptions...>;
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 UnitsType = typename ParsedOptions::UnitsType;
 
    using ScalingRatio = typename ParsedOptions::ScalingRatio;
 
    using UnitsRatio = typename ParsedOptions::UnitsRatio;
 
    using FieldType = typename ParsedOptions::FieldType;
 
    IntValue() = default;
 
    explicit IntValue(const ValueType& val)
      : BaseImpl(val)
    {
    }
 
    IntValue(const IntValue&) = default;
 
    ~IntValue() noexcept = default;
 
    IntValue& operator=(const IntValue&) = 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 hasUnits()
    {
        return ParsedOptions::HasUnits;
    }    
 
    static constexpr bool hasScaling()
    {
        return ParsedOptions::HasScalingRatio && !std::is_same<ScalingRatio, std::ratio<1, 1> >::value;
    }
 
    static constexpr bool hasFieldType()
    {
        return ParsedOptions::HasFieldType;
    }    
 
    static constexpr bool hasVarLength()
    {
        return ParsedOptions::HasVarLengthLimits;
    }        
 
    template <typename TRet>
    constexpr TRet getScaled() const
    {
        using TagTmp = 
            typename comms::util::LazyShallowConditional<
                ParsedOptions::HasScalingRatio
            >::template Type<
                HasScalingRatioTag,
                NoScalingRatioTag
            >;
 
        return scaleAsInternal<TRet>(TagTmp());
    }
 
    template <typename TRet>
    constexpr TRet scaleAs() const
    {
        return getScaled<TRet>();
    }
 
    template <typename TScaled>
    void setScaled(TScaled val)
    {
        using TagTmp = 
            typename comms::util::LazyShallowConditional<
                ParsedOptions::HasScalingRatio
            >::template Type<
                HasScalingRatioTag,
                NoScalingRatioTag
            >;
 
        return setScaledInternal(val, TagTmp());
    }
 
    const ValueType& value() const
    {
        return BaseImpl::value();
    }
 
    ValueType& value()
    {
        return BaseImpl::value();
    }
 
    const ValueType& getValue() const
    {
        return BaseImpl::getValue();
    }
 
    template <typename U>
    void setValue(U&& val)
    {
        BaseImpl::setValue(std::forward<U>(val));
    }        
 
    static constexpr ValueType maxValue()
    {
        return std::numeric_limits<ValueType>::max();
    }
 
    static constexpr ValueType minValue()
    {
        return std::numeric_limits<ValueType>::min();
    }    
 
    constexpr std::size_t length() const
    {
        return BaseImpl::length();
    }
 
    static constexpr std::size_t minLength()
    {
        return BaseImpl::minLength();
    }
 
    static constexpr std::size_t maxLength()
    {
        return BaseImpl::maxLength();
    }
 
    bool valid() const
    {
        return BaseImpl::valid();
    }
 
    bool refresh()
    {
        return BaseImpl::refresh();
    }
 
    template <typename TIter>
    ErrorStatus read(TIter& iter, std::size_t size)
    {
        return BaseImpl::read(iter, size);
    }
 
    static constexpr bool hasReadNoStatus()
    {
        return BaseImpl::hasReadNoStatus();
    }
 
    template <typename TIter>
    void readNoStatus(TIter& iter)
    {
        BaseImpl::readNoStatus(iter);
    }
 
    bool canWrite() const
    {
        return BaseImpl::canWrite();
    }
 
    template <typename TIter>
    ErrorStatus write(TIter& iter, std::size_t size) const
    {
        return BaseImpl::write(iter, size);
    }
 
    static constexpr bool hasWriteNoStatus()
    {
        return BaseImpl::hasWriteNoStatus();
    }
 
    template <typename TIter>
    void writeNoStatus(TIter& iter) const
    {
        BaseImpl::writeNoStatus(iter);
    }
 
    static constexpr bool isVersionDependent()
    {
        return ParsedOptions::HasCustomVersionUpdate || BaseImpl::isVersionDependent();
    }
 
    static constexpr bool hasNonDefaultRefresh()
    {
        return BaseImpl::hasNonDefaultRefresh();
    }
 
    VersionType getVersion() const
    {
        return BaseImpl::getVersion();
    }
 
    bool setVersion(VersionType version)
    {
        return BaseImpl::setVersion(version);
    }
 
    void setForcedLength(int len)
    {
        BaseImpl::setForcedLength(len);
    }
 
    int getForcedLength() const
    {
        return BaseImpl::getForcedLength();
    }    
 
protected:
    using BaseImpl::readData;
    using BaseImpl::writeData;
 
private:
    template <typename... TParams>
    using HasScalingRatioTag = comms::details::tag::Tag1<>;
 
    template <typename... TParams>
    using NoScalingRatioTag = comms::details::tag::Tag2<>;
 
    template <typename... TParams>
    using ScaleAsFpTag = comms::details::tag::Tag3<>;
 
    template <typename... TParams>
    using ScaleAsIntTag = comms::details::tag::Tag4<>;
 
    template <typename TRet, typename... TParams>
    TRet scaleAsInternal(HasScalingRatioTag<TParams...>) const
    {
        using TagTmp = 
            typename comms::util::LazyShallowConditional<
                std::is_floating_point<TRet>::value
            >::template Type<
                ScaleAsFpTag,
                ScaleAsIntTag
            >;
 
        return scaleAsInternal<TRet>(TagTmp());
    }
 
    template <typename TRet, typename... TParams>
    TRet scaleAsInternal(ScaleAsFpTag<TParams...>) const
    {
        static_assert(std::is_floating_point<TRet>::value,
            "TRet is expected to be floating point type");
        return static_cast<TRet>(BaseImpl::value()) * (static_cast<TRet>(ParsedOptions::ScalingRatio::num) / static_cast<TRet>(ParsedOptions::ScalingRatio::den));
    }
 
    template <typename TRet, typename... TParams>
    TRet scaleAsInternal(ScaleAsIntTag<TParams...>) const
    {
        static_assert(std::is_integral<TRet>::value,
            "TRet is expected to be integral type");
 
        using CastType = 
            typename comms::util::Conditional<
                std::is_signed<TRet>::value
            >::template Type<
                std::intmax_t,
                std::uintmax_t
            >;
 
        return
            static_cast<TRet>(
                (static_cast<CastType>(BaseImpl::value()) * ParsedOptions::ScalingRatio::num) / ParsedOptions::ScalingRatio::den);
    }
 
    template <typename TRet, typename... TParams>
    TRet scaleAsInternal(NoScalingRatioTag<TParams...>) const
    {
        return static_cast<TRet>(BaseImpl::value());
    }
 
    template <typename TScaled, typename... TParams>
    void setScaledInternal(TScaled val, HasScalingRatioTag<TParams...>)
    {
        using TagTmp = 
            typename comms::util::LazyShallowConditional<
                std::is_floating_point<typename std::decay<decltype(val)>::type>::value
            >::template Type<
                ScaleAsFpTag,
                ScaleAsIntTag
            >;
 
        setScaledInternal(val, TagTmp());
    }
 
    template <typename TScaled, typename... TParams>
    void setScaledInternal(TScaled val, ScaleAsFpTag<TParams...>)
    {
        using DecayedType = typename std::decay<decltype(val)>::type;
        auto epsilon = DecayedType(0);
        if (ParsedOptions::ScalingRatio::num < ParsedOptions::ScalingRatio::den) {
            epsilon = static_cast<DecayedType>(ParsedOptions::ScalingRatio::num) / static_cast<DecayedType>(ParsedOptions::ScalingRatio::den + 1);
        }
 
        if (epsilon < DecayedType(0)) {
            epsilon = -epsilon;
        }
 
        if (val < DecayedType(0)) {
            epsilon = -epsilon;
        }
 
        BaseImpl::value() =
            static_cast<ValueType>(
                ((val + epsilon) * static_cast<DecayedType>(ParsedOptions::ScalingRatio::den)) / static_cast<DecayedType>(ParsedOptions::ScalingRatio::num));
    }
 
    template <typename TScaled, typename... TParams>
    void setScaledInternal(TScaled val, ScaleAsIntTag<TParams...>)
    {
        using CastType = 
            typename comms::util::Conditional<
                std::is_signed<typename std::decay<decltype(val)>::type>::value
            >::template Type<
                std::intmax_t,
                std::uintmax_t
            >;
 
        BaseImpl::value() =
            static_cast<ValueType>(
                (static_cast<CastType>(val) * ParsedOptions::ScalingRatio::den) / static_cast<CastType>(ParsedOptions::ScalingRatio::num));
    }
 
    template <typename TScaled, typename... TParams>
    void setScaledInternal(TScaled val, NoScalingRatioTag<TParams...>)
    {
        BaseImpl::value() = static_cast<ValueType>(val);
    }
 
    static_assert(!ParsedOptions::HasSequenceElemLengthForcing,
        "comms::option::def::SequenceElemLengthForcingEnabled option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasSequenceSizeForcing,
        "comms::option::def::SequenceSizeForcingEnabled option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasSequenceLengthForcing,
        "comms::option::def::SequenceLengthForcingEnabled option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasSequenceFixedSize,
        "comms::option::def::SequenceFixedSize option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasSequenceFixedSizeUseFixedSizeStorage,
        "comms::option::app::SequenceFixedSizeUseFixedSizeStorage option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasSequenceSizeFieldPrefix,
        "comms::option::def::SequenceSizeFieldPrefix option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasSequenceSerLengthFieldPrefix,
        "comms::option::def::SequenceSerLengthFieldPrefix option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasSequenceElemSerLengthFieldPrefix,
        "comms::option::def::SequenceElemSerLengthFieldPrefix option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasSequenceElemFixedSerLengthFieldPrefix,
        "comms::option::def::SequenceElemSerLengthFixedFieldPrefix option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasSequenceTrailingFieldSuffix,
        "comms::option::def::SequenceTrailingFieldSuffix option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasSequenceTerminationFieldSuffix,
        "comms::option::def::SequenceTerminationFieldSuffix option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasFixedSizeStorage,
        "comms::option::app::FixedSizeStorage option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasCustomStorageType,
        "comms::option::app::CustomStorageType option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasOrigDataView,
        "comms::option::app::OrigDataView option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasVersionsRange,
        "comms::option::def::ExistsBetweenVersions (or similar) option is not applicable to IntValue field");
    static_assert(!ParsedOptions::HasMissingOnReadFail,
            "comms::option::def::MissingOnReadFail option is not applicable to IntValue field");           
    static_assert(!ParsedOptions::HasMissingOnInvalid,
            "comms::option::def::MissingOnInvalid option is not applicable to IntValue field");                
};
 
 
template <typename TFieldBase, typename T, typename... TOptions>
bool operator==(
    const IntValue<TFieldBase, T, TOptions...>& field1,
    const IntValue<TFieldBase, T, TOptions...>& field2) noexcept
{
    return field1.value() == field2.value();
}
 
template <typename TFieldBase, typename T, typename... TOptions>
bool operator!=(
    const IntValue<TFieldBase, T, TOptions...>& field1,
    const IntValue<TFieldBase, T, TOptions...>& field2) noexcept
{
    return field1.value() != field2.value();
}
 
template <typename TFieldBase, typename T, typename... TOptions>
bool operator<(
    const IntValue<TFieldBase, T, TOptions...>& field1,
    const IntValue<TFieldBase, T, TOptions...>& field2) noexcept
{
    return field1.value() < field2.value();
}
 
template <typename T>
constexpr bool isIntValue()
{
    return std::is_same<typename T::CommsTag, tag::Int>::value;
}
 
template <typename TFieldBase, typename T, typename... TOptions>
inline
IntValue<TFieldBase, T, TOptions...>&
toFieldBase(IntValue<TFieldBase, T, TOptions...>& field)
{
    return field;
}
 
template <typename TFieldBase, typename T, typename... TOptions>
inline
const IntValue<TFieldBase, T, TOptions...>&
toFieldBase(const IntValue<TFieldBase, T, TOptions...>& field)
{
    return field;
}
 
}  // namespace field
 
}  // namespace comms
 
COMMS_MSVC_WARNING_POP