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

}