peak_ipl_range.hpp

Go to the documentation of this file.

#pragma once

#include <type_traits>
#include <cmath>
#include <limits>
#include <tuple>

namespace peak
{
namespace ipl
{

template <typename T>
class Range
{
    T m_min{};
    T m_max{};
    T m_inc{};

    template <typename Q = T, typename std::enable_if_t<std::is_integral<Q>::value, int> = 0>
    static constexpr bool almostEqual(Q v1, Q v2)
    {
        return v1 == v2;
    }

    template <typename Q = T, typename std::enable_if_t<std::is_floating_point<Q>::value, int> = 0>
    static constexpr Q almostEqualMaxHelper(Q v1, Q v2)
    {
        return std::max<Q>({ 1.0, std::fabs(v1), std::fabs(v2) });
    }

    template <typename Q = T, typename std::enable_if_t<std::is_floating_point<Q>::value, int> = 0>
    static constexpr bool almostEqual(Q v1, Q v2)
    {
        return std::fabs(v1 - v2) <= std::numeric_limits<Q>::epsilon() * almostEqualMaxHelper(v1, v2);
    }

    template <typename Q = T, typename std::enable_if_t<std::is_integral<Q>::value, int> = 0>
    constexpr bool validateInc(Q v) const
    {
        if (m_inc != 0 && (v % m_inc) != 0)
        {
            return false;
        }
        return true;
    }

    template <typename Q = T, typename std::enable_if_t<std::is_floating_point<Q>::value, int> = 0>
    constexpr bool validateInc(Q v) const
    {
        if (!almostEqual<Q>(m_inc, 0) && !almostEqual<Q>(std::fmod(v, m_inc), 0))
        {
            return false;
        }
        return true;
    }

public:
    constexpr Range(T min, T max, T inc)
        : m_min{ min }
        , m_max{ max }
        , m_inc{ inc }
    {
        if (min > max)
        {
            throw InvalidArgumentException("min > max is not allowed!");
        }
        if (max - min < inc)
        {
            throw InvalidArgumentException("inc > max - min is not allowed!");
        }
        if (inc < 0)
        {
            throw InvalidArgumentException("inc < 0 is not allowed!");
        }
        if (almostEqual(min, max))
        {
            throw InvalidArgumentException("min == max is not allowed!");
        }
    };

    constexpr T Minimum() const
    {
        return m_min;
    }
    constexpr T Maximum() const
    {
        return m_max;
    }
    constexpr T Increment() const
    {
        return m_inc;
    }

    constexpr std::tuple<T, T, T> GetRange() const
    {
        return std::make_tuple(Minimum(), Maximum(), Increment());
    }

    constexpr bool InRange(T value) const
    {
        if (value < m_min || value > m_max)
        {
            return false;
        }

        return validateInc<T>(value);
    }
};

} /* namespace ipl */
} /* namespace peak */