peak_common_size.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/detail/peak_common_backend_accessor.hpp>
#include <peak_common/detail/peak_common_math.hpp>
#include <peak_common/detail/peak_common_type_traits.hpp>
#include <peak_common/exceptions/peak_common_exceptions.hpp>
#include <peak_common_c/detail/peak_common_defines.h>
 
#include <cassert>
#include <cstdint>
#include <sstream>
 
namespace peak
{
namespace common
{
 
namespace detail
{
template <typename T>
class SizeT
{
 
public:
    static_assert(std::is_arithmetic<T>::value, "Template argument of Size must be arithmetic.");
 
    constexpr SizeT() = default;
 
    template <typename H = T
        ,
        typename std::enable_if_t<std::is_integral<H>::value, int> = 0
        >
    constexpr SizeT(T width, T height)
        : m_width{ width }
        , m_height{ height }
    {
        static_assert(std::is_unsigned<T>::value, "Parameter width and/or height has to be greater or equal to zero.");
    }
 
    template <typename H = T
        ,
        typename std::enable_if_t<std::is_floating_point<H>::value, int> = 0
        >
    constexpr SizeT(T width, T height)
        : m_width{ width }
        , m_height{ height }
    {
        if (width < 0)
        {
            throw peak::common::InvalidParameterException("Parameter width has to be greater or equal to zero.");
        }
        if (height < 0)
        {
            throw peak::common::InvalidParameterException("Parameter height has to be greater or equal to zero.");
        }
    }
 
    PEAK_COMMON_NO_DISCARD constexpr T GetWidth() const
    {
        return m_width;
    }
 
    PEAK_COMMON_NO_DISCARD constexpr T GetHeight() const
    {
        return m_height;
    }
 
    PEAK_COMMON_NO_DISCARD constexpr SizeT<T> Transposed() const
    {
        return { m_height, m_width };
    }
 
    template <typename H
        ,
        typename std::enable_if_t<std::is_integral<H>::value, int> = 0
        >
    constexpr bool operator==(const SizeT<H>& rhs) const
    {
        return GetHeight() == rhs.GetHeight() && GetWidth() == rhs.GetWidth();
    }
 
    template <typename H
        ,
        typename std::enable_if_t<std::is_floating_point<H>::value, int> = 0
        >
    constexpr bool operator==(const SizeT<H>& rhs) const
    {
        // Unit in the last place
        constexpr uint32_t ulp = 4;
 
        using common_type = std::common_type_t<H, T>;
 
        return detail::AreAlmostEqual<common_type>(static_cast<common_type>(GetWidth()), static_cast<common_type>(rhs.GetWidth()), ulp)
            && detail::AreAlmostEqual<common_type>(static_cast<common_type>(GetHeight()), static_cast<common_type>(rhs.GetHeight()), ulp);
    }
 
    template <typename H>
    constexpr bool operator!=(const SizeT<H>& rhs) const
    {
        return !(*this == rhs);
    }
 
    friend std::ostream& operator<<(std::ostream& os, SizeT size)
    {
        return os << "{ width: " << size.GetWidth() << ", height: " << size.GetHeight() << " }";
    }
 
    PEAK_COMMON_NO_DISCARD std::string ToString() const
    {
        std::ostringstream ss;
        ss << *this;
        return ss.str();
    }
 
private:
    T m_width{};
    T m_height{};
 
    friend detail::BackendAccessor<SizeT<T>>;
 
    template <typename U = T, typename std::enable_if<has_c_type_of<SizeT<U>>::value, bool>::type = false>
    constexpr explicit operator detail::c_type_of_t<SizeT<T>>() const // NOLINT
    {
        return { this->GetWidth(), this->GetHeight() };
    }
};
 
} // namespace detail
 
using Size = detail::SizeT<uint32_t>;
 
using SizeF = detail::SizeT<float>;
 
} // namespace common 
} // namespace peak