peak_common_rectangle.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/types/geometry/peak_common_point.hpp>
#include <peak_common/types/geometry/peak_common_size.hpp>
#include <peak_common_c/detail/peak_common_defines.h>
#include <peak_common_c/types/peak_common_simple_types.h>
 
#include <cstdint>
#include <sstream>
 
namespace peak
{
namespace common
{
 
namespace detail
{
template <typename PointType, typename SizeType>
class RectangleT
{
 
public:
    static_assert(std::is_arithmetic<PointType>::value, "Template argument of Rect must be arithmetic.");

    constexpr RectangleT() = default;

    constexpr RectangleT(const PointT<PointType>& point, const SizeT<SizeType>& size)
        : m_point(point)
        , m_size(size)
    {}

    constexpr RectangleT(PointType x, PointType y, SizeType width, SizeType height)
        : RectangleT({ x, y }, { width, height })
    {}

    PEAK_COMMON_NO_DISCARD constexpr PointType GetX() const
    {
        return m_point.GetX();
    }

    PEAK_COMMON_NO_DISCARD constexpr PointType GetY() const
    {
        return m_point.GetY();
    }

    PEAK_COMMON_NO_DISCARD constexpr SizeType GetWidth() const
    {
        return m_size.GetWidth();
    }

    PEAK_COMMON_NO_DISCARD constexpr SizeType GetHeight() const
    {
        return m_size.GetHeight();
    }

    PEAK_COMMON_NO_DISCARD constexpr SizeT<SizeType> GetSize() const
    {
        return m_size;
    }

    PEAK_COMMON_NO_DISCARD constexpr PointT<PointType> GetPosition() const
    {
        return m_point;
    }

    template <typename RhsPointType, typename RhsSizeType>
    constexpr bool operator==(const RectangleT<RhsPointType, RhsSizeType>& rhs) const
    {
        return GetPosition() == rhs.GetPosition() && GetSize() == rhs.GetSize();
    }

    template <typename RhsPointType, typename RhsSizeType>
    constexpr bool operator!=(const RectangleT<RhsPointType, RhsSizeType>& rhs) const
    {
        return !(*this == rhs);
    }

    friend std::ostream& operator<<(std::ostream& os, RectangleT rectangle)
    {
        return os << "{ point: " << rectangle.m_point << ", size: " << rectangle.m_size << " }";
    }

    PEAK_COMMON_NO_DISCARD std::string ToString() const
    {
        std::ostringstream ss;
        ss << *this;
        return ss.str();
    }
 
private:
    PointT<PointType> m_point;
    SizeT<SizeType> m_size;
 
    friend detail::BackendAccessor<RectangleT<PointType, SizeType>>;

    template <typename T = PointType, typename U = SizeType,
        typename std::enable_if<has_c_type_of<RectangleT<T, U>>::value, bool>::type = false>
    constexpr explicit operator peak::common::detail::c_type_of_t<RectangleT<T, U>>() const // NOLINT
    {
        return { this->GetX(), this->GetY(), this->GetWidth(), this->GetHeight() };
    }
};
 
} // namespace detail

using Rectangle = detail::RectangleT<int32_t, uint32_t>;

using RectangleF = detail::RectangleT<float, float>;

using RectangleU = detail::RectangleT<uint32_t, uint32_t>;
 
} // namespace common 
} // namespace peak