peak_common_range.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/exceptions/peak_common_exceptions.hpp>
#include <peak_common/types/peak_common_interval.hpp>
#include <peak_common_c/detail/peak_common_defines.h>
 
#include <type_traits>
#include <cmath>
 
namespace peak
{
namespace common
{
 
namespace detail
{

template <typename T>
class RangeT : public detail::IntervalT<T>
{
 
public:
    static_assert(std::is_arithmetic<T>::value, "Template argument of Interval must be arithmetic.");
 
    using type = T;

    constexpr RangeT(T minimum, T maximum, T increment)
        : detail::IntervalT<T>(minimum, maximum)
        , m_increment{ increment }
    {
        if (increment > maximum - minimum)
        {
            throw peak::common::InvalidParameterException("The given increment is larger than the total range!");
        }
    }

    PEAK_COMMON_NO_DISCARD constexpr T GetIncrement() const
    {
        return m_increment;
    }

    PEAK_COMMON_NO_DISCARD constexpr T Constrain(T value) const
    {
        const auto minimum = IntervalT<T>::GetMinimum();
        const auto maximum = IntervalT<T>::GetMaximum();
 
        if (!IsIncrementEqualToZero<T>() && value > minimum)
        {
            value = RoundToIncrement(value);
        }
 
        return detail::Clamp(value, minimum, maximum);
    }

    constexpr bool operator==(const RangeT& rhs) const
    {
        return detail::IntervalT<T>::operator==(rhs) && m_increment == rhs.m_increment;
    }

    constexpr bool operator!=(const RangeT& rhs) const
    {
        return !(rhs == *this);
    }

    friend std::ostream& operator<<(std::ostream& os, RangeT range)
    {
        return os << "{ minimum: " << range.GetMinimum() << ", maximum: " << range.GetMaximum() << ", increment: " << range.GetIncrement()
                  << " }";
    }

    PEAK_COMMON_NO_DISCARD std::string ToString() const
    {
        std::ostringstream ss;
        ss << *this;
        return ss.str();
    }
 
private:
    T m_increment;
 
    friend detail::BackendAccessor<RangeT<T>>;
 
    template <typename U = T, typename std::enable_if<has_c_type_of<RangeT<U>>::value, bool>::type = false>
    explicit RangeT(c_type_of_t<RangeT<U>> range)
        : RangeT<U>(range.minimum, range.maximum, range.increment)
    {}
 
    template <typename U = T, typename std::enable_if<has_c_type_of<RangeT<U>>::value, bool>::type = false>
    constexpr explicit operator detail::c_type_of_t<RangeT<U>>() const
    {
        return { this->GetMinimum(), this->GetMaximum(), this->GetIncrement() };
    }
 
    template <typename V = T, std::enable_if_t<std::is_integral<V>::value, int> = 0>
    PEAK_COMMON_NO_DISCARD constexpr bool IsIncrementEqualToZero() const
    {
        return m_increment == 0;
    }
 
    template <typename V = T, std::enable_if_t<std::is_floating_point<V>::value, int> = 0>
    PEAK_COMMON_NO_DISCARD constexpr bool IsIncrementEqualToZero() const
    {
        // Unit in the last place
        constexpr uint32_t ulp = 4;
        return detail::AreAlmostEqual(m_increment, static_cast<T>(0), ulp);
    }
 
    template<typename V = T, std::enable_if_t<std::is_integral<V>::value, int> = 0>
    PEAK_COMMON_NO_DISCARD constexpr V RoundToIncrement(V value) const
    {
        const auto offset = value - IntervalT<T>::GetMinimum();
        const auto step = (offset + m_increment / 2) / m_increment;
        return IntervalT<T>::GetMinimum() + (step * m_increment);
    }
 
    template<typename V = T, std::enable_if_t<std::is_floating_point<V>::value, int> = 0>
    PEAK_COMMON_NO_DISCARD constexpr V RoundToIncrement(V value) const
    {
        const auto step = std::round((value - IntervalT<T>::GetMinimum()) / m_increment);
        return IntervalT<T>::GetMinimum() + (static_cast<V>(step) * m_increment);
    }
};
 
} // namespace detail

using RangeU = detail::RangeT<uint32_t>;

using Range = detail::RangeT<int32_t>;

using Range64 = detail::RangeT<int64_t>;

using RangeF = detail::RangeT<float>;

using RangeD = detail::RangeT<double>;

using RangeU8 = detail::RangeT<uint8_t>;
 
 
} // namespace common 
} // namespace peak