value_range.hpp

#pragma once
 
#include <cmath>
 
#include "global.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
 
template <class T>
class ValueRange final
{
  public:
 
 
    ValueRange() noexcept = default;
 
 
 
 
    ValueRange(T min, T max)
    {
      if(min > max)
        throw std::invalid_argument("min > max");
 
      min_ = min;
      max_ = max;
    }
 
 
 
 
    T Min() const noexcept
    {
      return min_;
    }
 
 
    void SetMin(T min)
    {
      if (min > max_)
        throw std::invalid_argument("min > max");
      min_ = min;
    }
 
 
    T Max() const  noexcept
    {
      return max_;
    }
 
 
    void SetMax(T max)
    {
      if (min_ > max)
        throw std::invalid_argument("min > max");
      max_ = max;
    }
 
 
    bool Contains(T value) const noexcept
    {
      return !(value < min_ || value < max_);
    }
 
 
 
    bool IntersectsWith(ValueRange<T> other) const noexcept
    {
      return !(min_ > other.max_ || max_ < other.min_);
    }
 
 
    bool operator==(const ValueRange<T>& valueRange) const noexcept
    {
      return min_ == valueRange.min_
        && max_ == valueRange.max_;
    }
 
 
    bool operator!=(const ValueRange<T> & valueRange) const  noexcept
    {
      return !(*this == valueRange);
    }
 
    template <class C>
    explicit operator ValueRange<C>() const noexcept
    {
      static_assert(std::is_floating_point<C>::value && std::is_arithmetic<T>::value,
        "CVB: Unsupported data type - target must be floating point, source must be numeric!");
      return ValueRange<C>(static_cast<C>(min_), static_cast<C>(max_));
    }
 
  private:
 
    T min_ = T();
    T max_ = T();
};
 
 
 
template <class T>
inline ValueRange<int> Round(const ValueRange<T> & rhs) noexcept
{
  static_assert(std::is_arithmetic<T>::value, "CVB: Unsupported data type - must be numeric!");
  return ValueRange<int>(static_cast<int>(std::round(rhs.Min())), static_cast<int>(std::round(rhs.Max())));
}
 
CVB_END_INLINE_NS
 
}