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
 
}