size.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_SIZE_HPP_
#define DXLE_INC_BASIC_TYPES_SIZE_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/basic_types/use_big_type_when_one_byte_t.hpp"
#include "dxlibex/basic_types/stdint.hpp"
#include "dxlibex/basic_types/coordinate_operator_bool_helper.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 <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 point_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 size_c final
    {
    public:
        typedef T value_type;
        value_type width, height;
        DXLE_CONSTEXPR size_c() DXLE_NOEXCEPT_IF((std::is_nothrow_constructible<value_type>::value)) : width(), height() {}
        DXLE_CONSTEXPR size_c(const value_type& width_, const value_type& height_) DXLE_NOEXCEPT_IF((std::is_nothrow_copy_constructible<value_type>::value)) : width(width_), height(height_) {}
        DXLE_CONSTEXPR size_c(value_type&& width_, value_type&& height_) DXLE_NOEXCEPT_OR_NOTHROW : width(std::move(width_)), height(std::move(height_)) {}

        template<typename Tp2_> DXLE_CONSTEXPR explicit size_c(const size_c<Tp2_>& other) DXLE_NOEXCEPT_IF((dxle::is_nothrow_convertable<Tp2_, value_type>::value))
            : width(static_cast<value_type>(other.width)), height(static_cast<value_type>(other.height)) {}
        template<typename Tp2_> DXLE_CONSTEXPR explicit size_c(size_c<Tp2_>&& other) DXLE_NOEXCEPT_IF((dxle::is_nothrow_convertable<Tp2_&&, value_type>::value))
            : width(static_cast<value_type>(std::move(other.width))), height(static_cast<value_type>(std::move(other.height))) {}
        //copy constructor
        DXLE_CONSTEXPR size_c(const size_c<value_type>& o) DXLE_NOEXCEPT_IF((std::is_nothrow_copy_constructible<value_type>::value)) : width(o.width), height(o.height) {}
        //move constructor
        DXLE_CONSTEXPR size_c(size_c<value_type>&& o) DXLE_NOEXCEPT_OR_NOTHROW : width(std::move(o.width)), height(std::move(o.height)) {}

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

        //copy assignment operator
        size_c& operator=(const size_c<value_type>& r) DXLE_NOEXCEPT_IF((std::is_nothrow_copy_assignable<value_type>::value))
        {
            this->width = r.width;
            this->height = r.height;
            return *this;
        }
        //move assignment operator
        size_c& operator=(size_c<value_type>&& r) DXLE_NOEXCEPT_OR_NOTHROW
        {
            this->width = std::move(r.width);
            this->height = std::move(r.height);
            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->width, this->height);
        }
        template<typename Tp2_> DXLE_CONSTEXPR explicit operator size_c<Tp2_>() const DXLE_NOEXCEPT_IF((dxle::is_nothrow_convertable<value_type, Tp2_>::value))
        {
            return{ static_cast<Tp2_>(this->width), static_cast<Tp2_>(this->height) };
        }
        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->width), static_cast<Tp2_>(this->height));
        }
    };
    //convert from std::pair

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

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

    template <typename T>
    DXLE_CONSTEXPR size_c<T> operator -(const size_c<T>& r) DXLE_NOEXCEPT_IF_EXPR(-r.width)
    {
        return { -r.width, -r.height };
    }

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

    template <typename T>
    DXLE_CONSTEXPR inline size_c<T>&& operator +(size_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>
    size_c<T1>& operator +=(size_c<T1>& l, const size_c<T2>& r) DXLE_NOEXCEPT_IF_EXPR(l.width += r.width)
    {
        l.width += r.width;
        l.height += r.height;
        return l;
    }

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

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

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

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

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

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

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

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

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

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

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

    template<typename T>
    DXLE_CONSTEXPR size_c<T> abs(const size_c<T>& o) DXLE_NOEXCEPT_IF_EXPR(abs(o.width)) { return { abs(o.width), abs(o.height) }; }

    typedef size_c<int> sizei;
    typedef size_c<unsigned int> sizeui;
    typedef size_c<double> sized;
    typedef size_c<float> sizef;
    typedef size_c<std::size_t> size;
};

namespace std
{
    //hash
#define DXLE_TEMP_make_hash(int_t, bit, bit2)\
    template <> struct hash<dxle::size_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::size_c<int_t##bit##_t>& key) const { return hash_run((static_cast<int_t##_fast##bit2##_t>(key.width) << bit) | static_cast<int_t##_fast##bit2##_t>(key.height)); }\
        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_SIZE_HPP_