peak_common_interval.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/detail/peak_common_backend_accessor.hpp>
#include <peak_common/detail/peak_common_math.hpp>
#include <peak_common/detail/peak_common_type_traits.hpp>
#include <peak_common/exceptions/peak_common_exceptions.hpp>
#include <peak_common_c/detail/peak_common_defines.h>
#include <peak_common_c/types/peak_common_simple_types.h>
 
#include <type_traits>
#include <sstream>
 
namespace peak
{
namespace common
{
 
namespace detail
{

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

    constexpr IntervalT(T minimum, T maximum)
        : m_minimum(minimum)
        , m_maximum(maximum)
    {
        if (minimum > maximum)
        {
            throw peak::common::InvalidParameterException("The maximum value has to be greater than or equal to the minimum value!");
        }
    }

    PEAK_COMMON_NO_DISCARD constexpr T GetMinimum() const
    {
        return m_minimum;
    }

    PEAK_COMMON_NO_DISCARD constexpr T GetMaximum() const
    {
        return m_maximum;
    }

    PEAK_COMMON_NO_DISCARD constexpr T Clamp(T value) const
    {
        return detail::Clamp(value, m_minimum, m_maximum);
    }

    template <typename H
        ,
        typename std::enable_if_t<std::is_integral<H>::value, int> = 0
        >
    constexpr bool operator==(const IntervalT<H>& rhs) const
    {
        return GetMinimum() == rhs.GetMinimum() && GetMaximum() == rhs.GetMaximum();
    }

    template <typename H
        ,
        typename std::enable_if_t<std::is_floating_point<H>::value, int> = 0
        >
    constexpr bool operator==(const IntervalT<H>& rhs) const
    {
        // Unit in the last place
        constexpr uint32_t ulp = 4;
 
        using common_type = std::common_type_t<H, T>;
 
        return detail::AreAlmostEqual<common_type>(static_cast<common_type>(GetMinimum()), static_cast<common_type>(rhs.GetMinimum()), ulp)
            && detail::AreAlmostEqual<common_type>(static_cast<common_type>(GetMaximum()), static_cast<common_type>(rhs.GetMaximum()), ulp);
    }

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

    friend std::ostream& operator<<(std::ostream& os, IntervalT interval)
    {
        return os << "{ minimum: " << interval.m_minimum << ", maximum: " << interval.m_maximum << " }";
    }

    PEAK_COMMON_NO_DISCARD std::string ToString() const
    {
        std::ostringstream ss;
        ss << *this;
        return ss.str();
    }
 
private:
    T m_minimum;
    T m_maximum;
 
    friend detail::BackendAccessor<IntervalT<T>>;
 
    template <typename U = T, typename std::enable_if<has_c_type_of<IntervalT<U>>::value, bool>::type = false>
    explicit IntervalT(c_type_of_t<IntervalT<U>> interval)
        : IntervalT<U>(interval.minimum, interval.maximum)
    {}
 
    template <typename U = T, typename std::enable_if<has_c_type_of<IntervalT<U>>::value, bool>::type = false>
    constexpr explicit operator detail::c_type_of_t<IntervalT<U>>() const
    {
        return { this->GetMinimum(), this->GetMaximum() };
    }
};
 
} // namespace detail

using IntervalU = detail::IntervalT<uint32_t>;

using Interval = detail::IntervalT<int32_t>;

using Interval64 = detail::IntervalT<int64_t>;

using IntervalF = detail::IntervalT<float>;
 

using IntervalD = detail::IntervalT<double>;
 
} // namespace common 
} // namespace peak