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>
 
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;
    }

    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() };
    }
};
 
} // namespace detail

using RangeU = detail::RangeT<uint32_t>;

using Range = detail::RangeT<int32_t>;

using RangeF = detail::RangeT<float>;

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