size_2d.hpp

#pragma once

#include <cmath>

#include "global.hpp"

namespace Cvb
{

CVB_BEGIN_INLINE_NS


template< class T, class ENABLE = void>
class Size2D final
{

#ifndef CVB_DOXYGEN
  static_assert (IsNumeric<T>::value, "CVB: Unsupported data type - must be numeric!");
};


template <class T>
class Size2D<T,
  typename EnableIfNumeric<T>::type> final
{

#endif
  public:



    Size2D() noexcept = default;


    Size2D(T width, T height) noexcept
      : width_(width)
      , height_(height)
    {
    }


    T Width() const noexcept
    {
      return width_;
    }


    void SetWidth(T width) noexcept
    {
      width_ = width;
    }


    T Height() const noexcept
    {
      return height_;
    }


    void SetHeight(T height) noexcept
    {
      height_ = height;
    }



    bool operator==(const Size2D<T>& size) const noexcept
    {
      return (width_ == size.width_ && height_ == size.height_);
    }


    bool operator!=(const Size2D<T>& size) const noexcept
    {
      return !(*this == size);
    }

    template <class C>
    explicit operator Size2D<C>() const noexcept
    {
      static_assert(std::is_floating_point<C>::value, "CVB: Unsupported data type - must be floating point!");
      return Size2D<C>(static_cast<C>(std::round(Width())), static_cast<C>(std::round(Height())));
    }

  private:

    T width_ = static_cast<T>(0);
    T height_ = static_cast<T>(0);
};



template <class T>
inline Size2D<int> Round(const Size2D<T> & rhs) noexcept
{
  static_assert(IsNumeric<T>::value, "CVB: Unsupported data type - must be numeric!");
  return Size2D<int>(static_cast<int>(std::round(rhs.Width())), static_cast<int>(std::round(rhs.Height())));
}

CVB_END_INLINE_NS

}