pair.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_UTILITY_PAIR_HPP__
#define NEFORCE_CORE_UTILITY_PAIR_HPP__

 
#include "NeForce/core/interface/icommon.hpp"
#include "NeForce/core/utility/integer_sequence.hpp"
#include "NeForce/core/utility/reference_wrapper.hpp"
NEFORCE_BEGIN_NAMESPACE__

 
template <typename...>
struct tuple;
 
template <typename>
struct tuple_size;
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
constexpr size_t tuple_size_v = tuple_size<remove_cvref_t<T>>::value;
#endif
 
 
template <size_t Index, typename... Tuple>
struct tuple_element;

template <size_t Index, typename... Types>
using tuple_element_t = typename tuple_element<Index, Types...>::type;

template <size_t Index, typename... Types>
using tuple_extract_base_t = typename tuple_element<Index, Types...>::tuple_type;
 
template <size_t Index, typename... Types>
NEFORCE_NODISCARD constexpr tuple_element_t<Index, Types...>& get(tuple<Types...>& t) noexcept;
template <size_t Index, typename... Types>
NEFORCE_NODISCARD constexpr const tuple_element_t<Index, Types...>& get(const tuple<Types...>& t) noexcept;
template <size_t Index, typename... Types>
NEFORCE_NODISCARD constexpr tuple_element_t<Index, Types...>&& get(tuple<Types...>&& t) noexcept;
template <size_t Index, typename... Types>
NEFORCE_NODISCARD constexpr const tuple_element_t<Index, Types...>&& get(const tuple<Types...>&& t) noexcept;

NEFORCE_BEGIN_INNER__
template <size_t Index, typename... Types>
NEFORCE_NODISCARD constexpr tuple_element_t<Index, Types...>&& __pair_get_from_tuple(tuple<Types...>&& t) noexcept;
NEFORCE_END_INNER__
 // Tuple


template <typename T1, typename T2>
struct pair : icommon<pair<T1, T2>> {
    using first_type = T1;  
    using second_type = T2; 
 
    T1 first;  
    T2 second; 
 
#ifdef NEFORCE_STANDARD_20
    template <typename U1 = T1, typename U2 = T2,
              enable_if_t<conjunction_v<is_default_constructible<U1>, is_default_constructible<U2>>, int> = 0>
    constexpr explicit(!conjunction_v<is_implicitly_default_constructible<U1>, is_implicitly_default_constructible<U2>>)
            pair() noexcept(conjunction_v<is_nothrow_default_constructible<U1>, is_nothrow_default_constructible<U2>>) :
    first(),
    second() {}

    template <typename U1 = T1, typename U2 = T2,
              enable_if_t<conjunction_v<is_copy_constructible<U1>, is_copy_constructible<U2>>, int> = 0>
    constexpr explicit(!conjunction_v<is_convertible<const U1&, U1>, is_convertible<const U2&, U2>>)
            pair(const T1& a, const T2& b) noexcept(
                    conjunction_v<is_nothrow_copy_constructible<U1>, is_nothrow_copy_constructible<U2>>) :
    first(a),
    second(b) {}

    template <typename U1, typename U2,
              enable_if_t<conjunction_v<is_constructible<T1, U1>, is_constructible<T2, U2>>, int> = 0>
    constexpr explicit(!conjunction_v<is_convertible<U1, T1>, is_convertible<U2, T2>>)
            pair(U1&& a,
                 U2&& b) noexcept(conjunction_v<is_nothrow_constructible<T1, U1>, is_nothrow_constructible<T2, U2>>) :
    first(_NEFORCE forward<U1>(a)),
    second(_NEFORCE forward<U2>(b)) {}

    template <typename U1, typename U2,
              enable_if_t<conjunction_v<is_constructible<T1, const U1&>, is_constructible<T2, const U2&>>, int> = 0>
    constexpr explicit(!conjunction_v<is_convertible<const U1&, T1>, is_convertible<const U2&, T2>>)
            pair(const pair<U1, U2>& p) noexcept(
                    conjunction_v<is_nothrow_constructible<T1, const U1&>, is_nothrow_constructible<T2, const U2&>>) :
    first(p.first),
    second(p.second) {}

    template <typename U1, typename U2,
              enable_if_t<conjunction_v<is_constructible<T1, U1>, is_constructible<T2, U2>>, int> = 0>
    constexpr explicit(!conjunction_v<is_convertible<U1, T1>, is_convertible<U2, T2>>) pair(pair<U1, U2>&& p) noexcept(
            conjunction_v<is_nothrow_constructible<T1, U1>, is_nothrow_constructible<T2, U2>>) :
    first(_NEFORCE forward<U1>(p.first)),
    second(_NEFORCE forward<U2>(p.second)) {}
#else
    template <typename U1 = T1, typename U2 = T2,
              enable_if_t<conjunction<is_default_constructible<U1>, is_default_constructible<U2>>::value &&
                                  !conjunction<is_implicitly_default_constructible<U1>,
                                               is_implicitly_default_constructible<U2>>::value,
                          int> = 0>
    explicit pair() noexcept(
            conjunction<is_nothrow_default_constructible<U1>, is_nothrow_default_constructible<U2>>::value) :
    first(),
    second() {}
    template <typename U1 = T1, typename U2 = T2,
              enable_if_t<conjunction<is_default_constructible<U1>, is_default_constructible<U2>>::value &&
                                  conjunction<is_implicitly_default_constructible<U1>,
                                              is_implicitly_default_constructible<U2>>::value,
                          int> = 0>
    pair() noexcept(conjunction<is_nothrow_default_constructible<U1>, is_nothrow_default_constructible<U2>>::value) :
    first(),
    second() {}

    template <typename U1 = T1, typename U2 = T2,
              enable_if_t<conjunction<is_copy_constructible<U1>, is_copy_constructible<U2>>::value &&
                                  !conjunction<is_convertible<const U1&, U1>, is_convertible<const U2&, U2>>::value,
                          int> = 0>
    explicit pair(const T1& a, const T2& b) noexcept(
            conjunction<is_nothrow_copy_constructible<U1>, is_nothrow_copy_constructible<U2>>::value) :
    first(a),
    second(b) {}

    template <typename U1 = T1, typename U2 = T2,
              enable_if_t<conjunction<is_copy_constructible<U1>, is_copy_constructible<U2>>::value &&
                                  conjunction<is_convertible<const U1&, U1>, is_convertible<const U2&, U2>>::value,
                          int> = 0>
    pair(const T1& a, const T2& b) noexcept(
            conjunction<is_nothrow_copy_constructible<U1>, is_nothrow_copy_constructible<U2>>::value) :
    first(a),
    second(b) {}

    template <typename U1, typename U2,
              enable_if_t<conjunction<is_constructible<T1, U1>, is_constructible<T2, U2>>::value &&
                                  !conjunction<is_convertible<U1, T1>, is_convertible<U2, T2>>::value,
                          int> = 0>
    explicit pair(U1&& a, U2&& b) noexcept(
            conjunction<is_nothrow_constructible<T1, U1>, is_nothrow_constructible<T2, U2>>::value) :
    first(_NEFORCE forward<U1>(a)),
    second(_NEFORCE forward<U2>(b)) {}

    template <typename U1, typename U2,
              enable_if_t<conjunction<is_constructible<T1, U1>, is_constructible<T2, U2>>::value &&
                                  conjunction<is_convertible<U1, T1>, is_convertible<U2, T2>>::value,
                          int> = 0>
    pair(U1&& a,
         U2&& b) noexcept(conjunction<is_nothrow_constructible<T1, U1>, is_nothrow_constructible<T2, U2>>::value) :
    first(_NEFORCE forward<U1>(a)),
    second(_NEFORCE forward<U2>(b)) {}

    template <typename U1, typename U2,
              enable_if_t<conjunction<is_constructible<T1, const U1&>, is_constructible<T2, const U2&>>::value &&
                                  !conjunction<is_convertible<const U1&, T1>, is_convertible<const U2&, T2>>::value,
                          int> = 0>
    explicit pair(const pair<U1, U2>& p) noexcept(
            conjunction<is_nothrow_constructible<T1, const U1&>, is_nothrow_constructible<T2, const U2&>>::value) :
    first(p.first),
    second(p.second) {}

    template <typename U1, typename U2,
              enable_if_t<conjunction<is_constructible<T1, const U1&>, is_constructible<T2, const U2&>>::value &&
                                  conjunction<is_convertible<const U1&, T1>, is_convertible<const U2&, T2>>::value,
                          int> = 0>
    pair(const pair<U1, U2>& p) noexcept(
            conjunction<is_nothrow_constructible<T1, const U1&>, is_nothrow_constructible<T2, const U2&>>::value) :
    first(p.first),
    second(p.second) {}

    template <typename U1, typename U2,
              enable_if_t<conjunction<is_constructible<T1, U1>, is_constructible<T2, U2>>::value &&
                                  !conjunction<is_convertible<U1, T1>, is_convertible<U2, T2>>::value,
                          int> = 0>
    explicit pair(pair<U1, U2>&& p) noexcept(
            conjunction<is_nothrow_constructible<T1, U1>, is_nothrow_constructible<T2, U2>>::value) :
    first(_NEFORCE forward<U1>(p.first)),
    second(_NEFORCE forward<U2>(p.second)) {}

    template <typename U1, typename U2,
              enable_if_t<conjunction<is_constructible<T1, U1>, is_constructible<T2, U2>>::value &&
                                  conjunction<is_convertible<U1, T1>, is_convertible<U2, T2>>::value,
                          int> = 0>
    pair(pair<U1, U2>&& p) noexcept(
            conjunction<is_nothrow_constructible<T1, U1>, is_nothrow_constructible<T2, U2>>::value) :
    first(_NEFORCE forward<U1>(p.first)),
    second(_NEFORCE forward<U2>(p.second)) {}
#endif
 
    pair(const pair& p) = default; 
    pair(pair&& p) = default;      

    template <typename Tuple1, typename Tuple2, size_t... Index1, size_t... Index2>
    constexpr pair(Tuple1& t1, Tuple2& t2, index_sequence<Index1...> idx1, index_sequence<Index2...> idx2) :
    first(inner::__pair_get_from_tuple<Index1>(_NEFORCE move(t1))...),
    second(inner::__pair_get_from_tuple<Index2>(_NEFORCE move(t2))...) {}

    template <typename... Types1, typename... Types2>
    constexpr pair(unpack_utility_construct_tag, tuple<Types1...> t1, tuple<Types2...> t2) :
    pair(t1, t2, index_sequence_for<Types1...>{}, index_sequence_for<Types2...>{}) {}

    template <typename T = pair, enable_if_t<conjunction<is_copy_assignable<typename T::first_type>,
                                                         is_copy_assignable<typename T::second_type>>::value,
                                             int> = 0>
    NEFORCE_CONSTEXPR14 pair& operator=(type_identity_t<const T&> p) noexcept(
            conjunction<is_nothrow_copy_assignable<T1>, is_nothrow_copy_assignable<T2>>::value) {
        first = p.first;
        second = p.second;
        return *this;
    }

    template <typename T = pair, enable_if_t<conjunction<is_move_assignable<typename T::first_type>,
                                                         is_move_assignable<typename T::second_type>>::value,
                                             int> = 0>
    NEFORCE_CONSTEXPR14 pair& operator=(type_identity_t<T&&> p) noexcept(
            conjunction<is_nothrow_move_assignable<T1>, is_nothrow_move_assignable<T2>>::value) {
        first = _NEFORCE forward<T1>(p.first);
        second = _NEFORCE forward<T2>(p.second);
        return *this;
    }

    template <typename U1, typename U2,
              enable_if_t<conjunction<negation<is_same<pair, pair<U1, U2>>>, is_assignable<T1&, const U1&>,
                                      is_assignable<T2&, const U2&>>::value,
                          int> = 0>
    NEFORCE_CONSTEXPR14 pair& operator=(const pair<U1, U2>& p) noexcept(
            conjunction<is_nothrow_assignable<T1&, const U1&>, is_nothrow_assignable<T2&, const U2&>>::value) {
        first = p.first;
        second = p.second;
        return *this;
    }

    template <typename U1, typename U2,
              enable_if_t<conjunction<negation<is_same<pair, pair<U1, U2>>>, is_assignable<T1&, U1>,
                                      is_assignable<T2&, U2>>::value,
                          int> = 0>
    NEFORCE_CONSTEXPR14 pair& operator=(pair<U1, U2>&& p) noexcept(
            conjunction<is_nothrow_assignable<T1&, U1>, is_nothrow_assignable<T2&, U2>>::value) {
        first = _NEFORCE forward<U1>(p.first);
        second = _NEFORCE forward<U2>(p.second);
        return *this;
    }
 
    pair& operator=(const volatile pair&) = delete; 
 
    NEFORCE_CONSTEXPR20 ~pair() = default; 

    constexpr bool operator==(const pair& y) const
            noexcept(noexcept(this->first == y.first && this->second == y.second)) {
        return this->first == y.first && this->second == y.second;
    }

    constexpr bool operator<(const pair& y) const
            noexcept(noexcept(this->first < y.first || (!(y.first < this->first) && this->second < y.second))) {
        return this->first < y.first || (!(y.first < this->first) && this->second < y.second);
    }

    NEFORCE_NODISCARD constexpr size_t to_hash() const
            noexcept(noexcept(hash<remove_cvref_t<T1>>()(first) ^ hash<remove_cvref_t<T2>>()(second))) {
        return hash<remove_cvref_t<T1>>()(first) ^ hash<remove_cvref_t<T2>>()(second);
    }

    NEFORCE_CONSTEXPR14 void
    swap(pair& p) noexcept(conjunction<is_nothrow_swappable<T1>, is_nothrow_swappable<T2>>::value) {
        _NEFORCE swap(first, p.first);
        _NEFORCE swap(second, p.second);
    }
};
 
#ifdef NEFORCE_STANDARD_17
template <typename T1, typename T2>
pair(T1, T2) -> pair<T1, T2>;
#endif
 

template <typename T1, typename T2>
constexpr pair<unwrap_ref_decay_t<T1>, unwrap_ref_decay_t<T2>>
make_pair(T1&& x, T2&& y) noexcept(conjunction<is_nothrow_constructible<unwrap_ref_decay_t<T1>, T1>,
                                               is_nothrow_constructible<unwrap_ref_decay_t<T2>, T2>>::value) {
    using unwrap_pair = pair<unwrap_ref_decay_t<T1>, unwrap_ref_decay_t<T2>>;
    return unwrap_pair(_NEFORCE forward<T1>(x), _NEFORCE forward<T2>(y));
}
 // Pair


template <typename... Types>
struct tuple_size<tuple<Types...>> : integral_constant<size_t, sizeof...(Types)> {};

template <size_t Index>
struct tuple_element<Index, tuple<>> {};

template <typename This, typename... Rest>
struct tuple_element<0, tuple<This, Rest...>> {
    using type = This;
    using tuple_type = tuple<This, Rest...>;
};

template <size_t Index, typename This, typename... Rest>
struct tuple_element<Index, tuple<This, Rest...>> : tuple_element<Index - 1, tuple<Rest...>> {};

template <size_t Index, typename... Types>
struct tuple_element : tuple_element<Index, tuple<Types...>> {};
 

template <typename T1, typename T2>
struct tuple_size<pair<T1, T2>> : integral_constant<size_t, 2> {};

template <size_t Index, typename T1, typename T2>
struct tuple_element<Index, pair<T1, T2>> {
    static_assert(Index < 2, "pair element index out of range.");
 
    using type = conditional_t<Index == 0, T1, T2>; 
    using tuple_type = tuple<T1, T2>;               
};
 // Tuple

 
#ifndef NEFORCE_STANDARD_17
NEFORCE_BEGIN_INNER__
 
template <size_t Index, typename T1, typename T2>
struct __pair_get_helper;
template <typename T1, typename T2>
struct __pair_get_helper<0, T1, T2> {
    NEFORCE_NODISCARD constexpr static tuple_element_t<0, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept {
        return pir.first;
    }
    NEFORCE_NODISCARD constexpr static const tuple_element_t<0, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept {
        return pir.first;
    }
    NEFORCE_NODISCARD constexpr static tuple_element_t<0, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept {
        return _NEFORCE forward<T1>(pir.first);
    }
    NEFORCE_NODISCARD constexpr static const tuple_element_t<0, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept {
        return _NEFORCE forward<const T1>(pir.first);
    }
};
 
template <typename T1, typename T2>
struct __pair_get_helper<1, T1, T2> {
    NEFORCE_NODISCARD constexpr static tuple_element_t<1, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept {
        return pir.second;
    }
    NEFORCE_NODISCARD constexpr static const tuple_element_t<1, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept {
        return pir.second;
    }
    NEFORCE_NODISCARD constexpr static tuple_element_t<1, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept {
        return _NEFORCE forward<T2>(pir.second);
    }
    NEFORCE_NODISCARD constexpr static const tuple_element_t<1, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept {
        return _NEFORCE forward<const T2>(pir.second);
    }
};
 
NEFORCE_END_INNER__
#endif // !NEFORCE_STANDARD_17

template <size_t Index, typename T1, typename T2>
NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept;
 
#ifdef NEFORCE_STANDARD_17
template <size_t Index, typename T1, typename T2>
NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept {
    if constexpr (Index == 0) {
        return pir.first;
    } else {
        return pir.second;
    }
}
#else
template <size_t Index, typename T1, typename T2>
NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept {
    return inner::__pair_get_helper<Index, T1, T2>::get(pir);
}
#endif // NEFORCE_STANDARD_17

template <typename T1, typename T2>
NEFORCE_NODISCARD constexpr T1& get(pair<T1, T2>& pir) noexcept {
    return pir.first;
}

template <typename T2, typename T1>
NEFORCE_NODISCARD constexpr T2& get(pair<T1, T2>& pir) noexcept {
    return pir.second;
}
 

template <size_t Index, typename T1, typename T2>
NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept;
 
#ifdef NEFORCE_STANDARD_17
template <size_t Index, typename T1, typename T2>
NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept {
    if constexpr (Index == 0) {
        return pir.first;
    } else {
        return pir.second;
    }
}
#else
template <size_t Index, typename T1, typename T2>
NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept {
    return inner::__pair_get_helper<Index, T1, T2>::get(pir);
}
#endif // NEFORCE_STANDARD_17

template <typename T1, typename T2>
NEFORCE_NODISCARD constexpr const T1& get(const pair<T1, T2>& pir) noexcept {
    return pir.first;
}

template <typename T2, typename T1>
NEFORCE_NODISCARD constexpr const T2& get(const pair<T1, T2>& pir) noexcept {
    return pir.second;
}
 

template <size_t Index, typename T1, typename T2>
NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept;
 
#ifdef NEFORCE_STANDARD_17
template <size_t Index, typename T1, typename T2>
NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept {
    if constexpr (Index == 0) {
        return _NEFORCE forward<T1>(pir.first);
    } else {
        return _NEFORCE forward<T2>(pir.second);
    }
}
#else
template <size_t Index, typename T1, typename T2>
NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept {
    return _NEFORCE forward<tuple_element_t<Index, pair<T1, T2>>>(
            inner::__pair_get_helper<Index, T1, T2>::get(_NEFORCE forward<pair<T1, T2>>(pir)));
}
#endif // NEFORCE_STANDARD_17

template <typename T1, typename T2>
NEFORCE_NODISCARD constexpr T1&& get(pair<T1, T2>&& pir) noexcept {
    return _NEFORCE forward<T1>(pir.first);
}

template <typename T2, typename T1>
NEFORCE_NODISCARD constexpr T2&& get(pair<T1, T2>&& pir) noexcept {
    return _NEFORCE forward<T2>(pir.second);
}
 

template <size_t Index, typename T1, typename T2>
NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept;
 
#ifdef NEFORCE_STANDARD_17
template <size_t Index, typename T1, typename T2>
NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept {
    if constexpr (Index == 0) {
        return _NEFORCE forward<const T1>(pir.first);
    } else {
        return _NEFORCE forward<const T2>(pir.second);
    }
}
#else
template <size_t Index, typename T1, typename T2>
NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept {
    return _NEFORCE forward<const tuple_element_t<Index, pair<T1, T2>>>(
            inner::__pair_get_helper<Index, T1, T2>::get(_NEFORCE forward<const pair<T1, T2>>(pir)));
}
#endif // NEFORCE_STANDARD_17

template <typename T1, typename T2>
NEFORCE_NODISCARD constexpr const T1&& get(const pair<T1, T2>&& pir) noexcept {
    return _NEFORCE forward<const T1>(pir.first);
}

template <typename T2, typename T1>
NEFORCE_NODISCARD constexpr const T2&& get(const pair<T1, T2>&& pir) noexcept {
    return _NEFORCE forward<const T2>(pir.second);
}
 // Pair
 
NEFORCE_END_NAMESPACE__
 
#ifdef NEFORCE_STANDARD_17
#    include <utility>
namespace std {
    template <typename T1, typename T2>
    struct tuple_size<_NEFORCE pair<T1, T2>> : _NEFORCE integral_constant<_NEFORCE size_t, 2> {};
 
    template <_NEFORCE size_t I, typename T1, typename T2>
    struct tuple_element<I, _NEFORCE pair<T1, T2>> {
        using type = _NEFORCE tuple_element_t<I, _NEFORCE pair<T1, T2>>;
    };
} // namespace std
#endif
 
#endif // NEFORCE_CORE_UTILITY_PAIR_HPP__