ClampedBaseValue.h

Go to the documentation of this file.

 
#pragma once
#include "BaseValue.h"
 
namespace catapult { namespace utils {
 
    template<typename TValue, typename TRange>
    struct ClampedBaseValue;
 
    namespace detail {
        template<typename TRange>
        struct TaggedRange {};
 
        template<typename TValue, typename TRange>
        struct ClampedBaseValueTraits {
            using TaggedRangeType = TaggedRange<TRange>;
 
            using UnclampedType = BaseValue<TValue, TaggedRangeType>;
 
            using ClampedType = ClampedBaseValue<TValue, TRange>;
 
            using ClampedBaseType = BasicBaseValue<TValue, TaggedRangeType, ClampedType>;
        };
    }
 
    template<typename TValue, typename TRange>
    struct ClampedBaseValue : public detail::ClampedBaseValueTraits<TValue, TRange>::ClampedBaseType {
    private:
        using Traits = detail::ClampedBaseValueTraits<TValue, TRange>;
 
    public:
        using Unclamped = typename Traits::UnclampedType;
 
    public:
        constexpr explicit ClampedBaseValue(TValue value = TRange::Default_Value)
                : Traits::ClampedBaseType(Clamp(value))
        {}
 
    private:
        static constexpr TValue Clamp(TValue value) {
            return value < TRange::Min_Value
                    ? TRange::Min_Value
                    : value > TRange::Max_Value ? TRange::Max_Value : value;
        }
 
    public:
        static constexpr ClampedBaseValue Min() {
            return ClampedBaseValue(TRange::Min_Value);
        }
 
        static constexpr ClampedBaseValue Max() {
            return ClampedBaseValue(TRange::Max_Value);
        }
 
    public:
        constexpr ClampedBaseValue operator+(Unclamped rhs) const {
            return ClampedBaseValue(this->unwrap() + rhs.unwrap());
        }
 
        constexpr Unclamped operator-(ClampedBaseValue rhs) const {
            return Unclamped(this->unwrap() - rhs.unwrap());
        }
    };
}}