point2d.hpp

Go to the documentation of this file.

/*=============================================================================
  Copyright (C) 2015-2017 DxLibEx project
  https://github.com/Nagarei/DxLibEx/

  Distributed under the Boost Software License, Version 1.0.
  (See http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef DXLE_INC_BASIC_TYPES_POINT2D_HPP_
#define DXLE_INC_BASIC_TYPES_POINT2D_HPP_
#include "dxlibex/config/no_min_max.h"
#include "dxlibex/type_traits/first_enabled.hpp"
#include "dxlibex/type_traits/enable_if.hpp"
#include "dxlibex/type_traits/is_representable.hpp"
#include "dxlibex/type_traits/is_nothrow.hpp"
#include "dxlibex/type_traits/ignore.hpp"
#include "dxlibex/basic_types/use_big_type_when_one_byte_t.hpp"
#include "dxlibex/basic_types/stdint.hpp"
#include "dxlibex/basic_types/distance_result_type_t.hpp"
#include "dxlibex/basic_types/coordinate_operator_bool_helper.hpp"
#include "dxlibex/algorithm.hpp"
#include "dxlibex/math.hpp"
#include "dxlibex/cstdlib.hpp"
#include "dxlibex/char_constant.hpp"
//#include "dxlibex/basic_types.hpp"//DO NOT REMOVE COMMENT-OUT to avoid redefine
#include <iostream>
#include <utility>//std::pair
#include <type_traits>
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <limits>
#include "dxlibex/config/defines.h"

namespace dxle {
    template<typename T, enable_if_t<std::is_nothrow_move_constructible<T>::value && std::is_nothrow_move_assignable<T>::value, nullptr_t>>
    class size_c;
    template<typename T, enable_if_t<std::is_nothrow_move_constructible<T>::value && std::is_nothrow_move_assignable<T>::value, nullptr_t> = nullptr>
    class point_c final
    {
    public:
        typedef typename std::remove_cv<T>::type value_type;
        value_type x, y;
        DXLE_CONSTEXPR point_c() DXLE_NOEXCEPT_IF((std::is_nothrow_constructible<value_type>::value)) : x(), y() {}
        DXLE_CONSTEXPR point_c(const value_type& x_, const value_type& y_) DXLE_NOEXCEPT_IF((std::is_nothrow_copy_constructible<value_type>::value)) : x(x_), y(y_) {}
        DXLE_CONSTEXPR point_c(value_type&& x_, value_type&& y_) DXLE_NOEXCEPT_OR_NOTHROW : x(std::move(x_)), y(std::move(y_)) {}

        template<typename Tp2_> DXLE_CONSTEXPR explicit point_c(const point_c<Tp2_>& other) DXLE_NOEXCEPT_IF((dxle::is_nothrow_convertable<Tp2_, value_type>::value)) : x(static_cast<value_type>(other.x)), y(static_cast<value_type>(other.y)){}
        template<typename Tp2_> DXLE_CONSTEXPR explicit point_c(point_c<Tp2_>&& other) DXLE_NOEXCEPT_IF((dxle::is_nothrow_convertable<Tp2_&&, value_type>::value)) : x(static_cast<value_type>(std::move(other.x))), y(static_cast<value_type>(std::move(other.y))) {}

        //copy constructor
        DXLE_CONSTEXPR point_c(const point_c<value_type>& o) DXLE_NOEXCEPT_IF((std::is_nothrow_copy_constructible<value_type>::value)) : x(o.x), y(o.y) {}
        //move constructor
        DXLE_CONSTEXPR point_c(point_c<value_type>&& o) DXLE_NOEXCEPT_OR_NOTHROW
            : x(std::move(o.x)), y(std::move(o.y)) {}

        template<typename Tp2_> DXLE_CONSTEXPR explicit point_c(const size_c<Tp2_, nullptr>& other) DXLE_NOEXCEPT_IF((dxle::is_nothrow_convertable<Tp2_, value_type>::value))
            : x(static_cast<value_type>(other.width)), y(static_cast<value_type>(other.height)) {}
        template<typename Tp2_> DXLE_CONSTEXPR explicit point_c(size_c<Tp2_, nullptr>&& other) DXLE_NOEXCEPT_IF((dxle::is_nothrow_convertable<Tp2_&&, value_type>::value))
            : x(static_cast<value_type>(std::move(other.width))), y(static_cast<value_type>(std::move(other.height))) {}
        DXLE_CONSTEXPR point_c(const size_c<value_type, nullptr>& other) DXLE_NOEXCEPT_IF((dxle::is_nothrow_convertable<value_type, value_type>::value))
            : x(other.width), y(other.height) {}
        DXLE_CONSTEXPR point_c(size_c<value_type, nullptr>&& other) DXLE_NOEXCEPT_IF((dxle::is_nothrow_convertable<value_type&&, value_type>::value))
            : x(std::move(other.width)), y(std::move(other.height)) {}

        //copy assignment operator
        point_c& operator=(const point_c<value_type>& r) DXLE_NOEXCEPT_IF((std::is_nothrow_copy_assignable<value_type>::value))
        {
            this->x = r.x;
            this->y = r.y;
            return *this;
        }
        //move assignment operator
        point_c& operator=(point_c<value_type>&& r) DXLE_NOEXCEPT_OR_NOTHROW
        {
            this->x = std::move(r.x);
            this->y = std::move(r.y);
            return *this;
        }
        DXLE_CONSTEXPR explicit operator bool() const DXLE_NOEXCEPT_IF_EXPR((dxle::detail::operator_bool_helper(std::declval<value_type>(), std::declval<value_type>()))){
            return dxle::detail::operator_bool_helper(this->x, this->y);
        }
        template<typename Tp2_> explicit operator std::pair<Tp2_, Tp2_>() const DXLE_NOEXCEPT_IF((dxle::is_nothrow_convertable<value_type, Tp2_>::value))
        {
            return std::pair<Tp2_, Tp2_>(static_cast<Tp2_>(this->x), static_cast<Tp2_>(this->y));
        }
    };
    //convert from std::pair

    template<typename T> point_c<T> make_point_c(const std::pair<T, T>& pa) DXLE_NOEXCEPT_IF(std::is_nothrow_copy_constructible<T>::value)
    {
        return point_c<T>(pa.first, pa.second);
    }
    template<typename T> point_c<T> make_point_c(std::pair<T, T>&& pa) DXLE_NOEXCEPT_OR_NOTHROW
    {
        return point_c<T>(std::move(pa.first), std::move(pa.second));
    }

    //ostream operator
    namespace detail {
        template<typename CharType, typename PointType>
        void ostream_operator_helper(std::basic_ostream<CharType>& os, const CharType* str, const point_c<PointType>& p)
        {
            using use_big_type_when_one_byte_p = use_big_type_when_one_byte_t<PointType>;
            os << static_cast<use_big_type_when_one_byte_p>(p.x) << str << static_cast<use_big_type_when_one_byte_p>(p.y);
        }
        template<typename CharType, typename PointType>
        void istream_operator_helper(std::basic_istream<CharType>& is, point_c<PointType>& p)
        {
            use_big_type_when_one_byte_t<PointType> x, y;
            is >> x;
            is.ignore((std::numeric_limits<std::streamsize>::max)(), dxle::char_constant::comma<CharType>());
            is >> y;
            p.x = static_cast<PointType>(x); p.y = static_cast<PointType>(y);
        }
    }
    template<typename T> std::ostream& operator<<(std::ostream& os, const point_c<T>& p)
    {
        dxle::detail::ostream_operator_helper<char, T>(os, ", ", p);
        return os;
    }
    template<typename T> std::wostream& operator<<(std::wostream& os, const point_c<T>& p)
    {
        dxle::detail::ostream_operator_helper<wchar_t, T>(os, L", ", p);
        return os;
    }
    template<typename T> std::istream& operator>>(std::istream& is, point_c<T>& p)
    {
        dxle::detail::istream_operator_helper<char, T>(is, p);
        return is;
    }
    template<typename T> std::wistream& operator>>(std::wistream& is, point_c<T>& p)
    {
        dxle::detail::istream_operator_helper<wchar_t, T>(is, p);
        return is;
    }

    template <typename T>
    DXLE_CONSTEXPR point_c<T> operator -(const point_c<T>& r) DXLE_NOEXCEPT_IF_EXPR(-r.x)
    {
        return { -r.x, -r.y };
    }

    template <typename T>
    DXLE_CONSTEXPR inline point_c<T> operator +(const point_c<T>& r) DXLE_NOEXCEPT_IF(std::is_nothrow_copy_constructible<T>::value) { return r; }

    template <typename T>
    DXLE_CONSTEXPR inline point_c<T>&& operator +(point_c<T>&& r) DXLE_NOEXCEPT_OR_NOTHROW { return std::move(r); }

    template <typename T1, typename T2, enable_if_t<is_representable<T2, T1>::value, nullptr_t> = nullptr>
    point_c<T1>& operator +=(point_c<T1>& l, const point_c<T2>& r) DXLE_NOEXCEPT_IF_EXPR(l.x += r.x)
    {
        l.x += r.x;
        l.y += r.y;
        return l;
    }

    template <typename T1, typename T2, enable_if_t<is_representable<T2, T1>::value, nullptr_t> = nullptr>
    point_c<T1>& operator -=(point_c<T1>& l, const point_c<T2>& r) DXLE_NOEXCEPT_IF_EXPR(l.x -= r.x)
    {
        l.x -= r.x;
        l.y -= r.y;
        return l;
    }

    template <typename T1, typename T2>
    DXLE_CONSTEXPR auto operator +(const point_c<T1>& l, const point_c<T2>& r) DXLE_NOEXCEPT_IF_EXPR(l.x + r.x)
        ->point_c<decltype(std::declval<std::remove_cv_t<T1>>() + std::declval<std::remove_cv_t<T2>>())>
    {
        return {l.x + r.x, l.y + r.y};
    }

    template <typename T1, typename T2>
    DXLE_CONSTEXPR auto operator -(const point_c<T1>& l, const point_c<T2>& r) DXLE_NOEXCEPT_IF_EXPR(l.x - r.x)
        ->point_c<decltype(std::declval<std::remove_cv_t<T1>>() - std::declval<std::remove_cv_t<T2>>())>
    {
        return {l.x - r.x, l.y - r.y};
    }

    template <typename T1, typename T2>
    DXLE_CONSTEXPR auto operator *(const point_c<T1>& l, T2 r) DXLE_NOEXCEPT_IF_EXPR(l.x * r)
        ->point_c<decltype(std::declval<std::remove_cv_t<T1>>() * std::declval<std::remove_cv_t<T2>>())>
    {
        return {l.x * r, l.y * r};
    }

    template <typename T1, typename T2>
    DXLE_CONSTEXPR auto operator *(T1 l, const point_c<T2>& r) DXLE_NOEXCEPT_IF_EXPR(l * r.x)
        ->point_c<decltype(std::declval<std::remove_cv_t<T1>>() * std::declval<std::remove_cv_t<T2>>())>
    {
        return {l * r.x, l * r.y};
    }

    template <typename T1, typename T2, enable_if_t<is_representable<T2, T1>::value, nullptr_t> = nullptr>
    point_c<T1>& operator *=(point_c<T1>& l, T2 r) DXLE_NOEXCEPT_IF_EXPR(l.x *= r)
    {
        l.x *= r;
        l.y *= r;
        return l;
    }

    template <typename T1, typename T2>
    DXLE_CONSTEXPR auto operator /(const point_c<T1>& l, T2 r) DXLE_NOEXCEPT_IF_EXPR(l.x / r)
        ->point_c<decltype(std::declval<std::remove_cv_t<T1>>() / std::declval<std::remove_cv_t<T2>>())>
    {
        return {l.x / r, l.y / r};
    }

    template <typename T1, typename T2, enable_if_t<is_representable<T2, T1>::value, nullptr_t> = nullptr>
    point_c<T1>& operator /=(point_c<T1>& l, T2 r) DXLE_NOEXCEPT_IF_EXPR(l.x /= r)
    {
        l.x /= r;
        l.y /= r;
        return l;
    }

    template <typename T>
    DXLE_CONSTEXPR bool operator !=(const point_c<T>& l, const point_c<T>& r) DXLE_NOEXCEPT_IF_EXPR(l.x != r.x)
    {
        return (l.x != r.x) || (l.y != r.y);
    }

    template <typename T>
    DXLE_CONSTEXPR bool operator ==(const point_c<T>& l, const point_c<T>& r) DXLE_NOEXCEPT_IF_EXPR(l.x != r.x) { return !(l != r); }

    template <typename T>
    DXLE_CONSTEXPR bool operator !=(const point_c<T>& p, std::nullptr_t) DXLE_NOEXCEPT_IF_EXPR(static_cast<bool>(p))
    {
        return static_cast<bool>(p);
    }
    template <typename T>
    DXLE_CONSTEXPR bool operator !=(std::nullptr_t, const point_c<T>& p) DXLE_NOEXCEPT_IF_EXPR(static_cast<bool>(p))
    {
        return static_cast<bool>(p);
    }
    template <typename T>
    DXLE_CONSTEXPR bool operator ==(const point_c<T>& p, nullptr_t) DXLE_NOEXCEPT_IF_EXPR(static_cast<bool>(p))
    {
        return !static_cast<bool>(p);
    }
    template <typename T>
    DXLE_CONSTEXPR bool operator ==(nullptr_t, const point_c<T>& p) DXLE_NOEXCEPT_IF_EXPR(static_cast<bool>(p))
    {
        return !static_cast<bool>(p);
    }

    template<typename T>
    DXLE_CONSTEXPR point_c<T> abs(const point_c<T>& o) DXLE_NOEXCEPT_IF_EXPR(abs(o.x)) { return{ abs(o.x), abs(o.y) }; }


    template<typename T1, typename T2>
    DXLE_CONSTEXPR auto dot(const point_c<T1>& p1, const point_c<T2>& p2) DXLE_NOEXCEPT_IF_EXPR(p1.x * p2.x + p1.y * p2.y)
        ->decltype(std::declval<std::remove_cv_t<T1>>() * std::declval<std::remove_cv_t<T2>>())
    {
        return p1.x * p2.x + p1.y * p2.y;
    }

    template<typename T1, typename T2>
    DXLE_CONSTEXPR double cross(const point_c<T1>& p1, const point_c<T2>& p2) 
        DXLE_NOEXCEPT_IF_EXPR((
            static_cast_if<T1, double, !std::is_floating_point<T1>::value>(std::declval<T1>()) * std::declval<T2>()
            + static_cast_if<T1, double, !std::is_floating_point<T1>::value>(std::declval<T1>()) * std::declval<T2>()
        ))
    {
        return static_cast_if<T1, double, !std::is_floating_point<T1>::value>(p1.x) * p2.y + static_cast_if<T1, double, !std::is_floating_point<T1>::value>(p1.y) * p2.x;
    }
    template<typename T1, typename T2>
    distance_result_type_t<T1, T2> distance(const point_c<T1>& p1, const point_c<T2>& p2) 
        DXLE_NOEXCEPT_IF_EXPR(hypot(safe_dist(std::declval<T1>(), std::declval<T2>()), safe_dist(std::declval<T1>(), std::declval<T2>())))
    {
        return hypot(safe_dist(p1.x, p2.x), safe_dist(p1.y, p2.y));
    }
    typedef point_c<int> pointi;
    typedef point_c<std::uint8_t> pointu8i;
    typedef point_c<std::int8_t> point8i;
    typedef point_c<double> pointd;
    typedef point_c<float> pointf;
};

namespace std
{
    //hash
#define DXLE_TEMP_make_hash(int_t, bit, bit2)\
    template <> struct hash<dxle::point_c<int_t##bit##_t>> {\
        hash() = default;\
        hash(const hash&) = default;\
        hash(hash&& other) :hash_run(std::move(other.hash_run)) {}\
        ~hash() {}\
        hash& operator=(const hash& other) { hash_run = other.hash_run; return *this; }\
        hash& operator=(hash&& other) { hash_run = std::move(other.hash_run); return *this; }\
        size_t operator()(const dxle::point_c<int_t##bit##_t>& key) const { return hash_run((static_cast<int_t##_fast##bit2##_t>(key.x) << bit) | static_cast<int_t##_fast##bit2##_t>(key.y)); }\
        private:\
            std::hash<int_t##_fast##bit2##_t> hash_run;\
    }

    DXLE_TEMP_make_hash(int, 8, 16);
    DXLE_TEMP_make_hash(int, 16, 32);
    DXLE_TEMP_make_hash(int, 32, 64);
    DXLE_TEMP_make_hash(uint, 8, 16);
    DXLE_TEMP_make_hash(uint, 16, 32);
    DXLE_TEMP_make_hash(uint, 32, 64);

#undef DXLE_TEMP_make_hash
}

#endif //DXLE_INC_BASIC_TYPES_POINT2D_HPP_