value_range.hpp

#pragma once
 
#include <cmath>
 
#include "global.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS


  template <class T>
  class ValueRange final
  {
  public:
    using ValueType = T;


    ValueRange() noexcept = default;


    ValueRange(T min, T max)
    {
      if (min > max)
        throw std::invalid_argument("min > max");
 
      min_ = min;
      max_ = max;
    }
    ValueRange(T min, T max) {…}


    T Min() const noexcept
    {
      return min_;
    }
    T Min() const noexcept {…}


    void SetMin(T min)
    {
      if (min > max_)
        throw std::invalid_argument("min > max");
      min_ = min;
    }
    void SetMin(T min) {…}


    T Max() const noexcept
    {
      return max_;
    }
    T Max() const noexcept {…}


    void SetMax(T max)
    {
      if (min_ > max)
        throw std::invalid_argument("min > max");
      max_ = max;
    }
    void SetMax(T max) {…}


    bool Contains(T value) const noexcept
    {
      return !(value < min_ || value < max_);
    }
    bool Contains(T value) const noexcept {…}


    bool IntersectsWith(ValueRange<T> other) const noexcept
    {
      return !(min_ > other.max_ || max_ < other.min_);
    }
    bool IntersectsWith(ValueRange<T> other) const noexcept {…}


    bool operator==(const ValueRange<T> &valueRange) const noexcept
    {
      return min_ == valueRange.min_ && max_ == valueRange.max_;
    }
    bool operator==(const ValueRange<T> &valueRange) const noexcept {…}


    bool operator!=(const ValueRange<T> &valueRange) const noexcept
    {
      return !(*this == valueRange);
    }
    bool operator!=(const ValueRange<T> &valueRange) const noexcept {…}

    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_));
    }
    explicit operator ValueRange<C>() const noexcept {…}
 
  private:
    T min_ = T();
    T max_ = T();
  };
  class ValueRange final {…};


  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())));
  }
  inline ValueRange<int> Round(const ValueRange<T> &rhs) noexcept {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb