forked from OSchip/llvm-project
586 lines
19 KiB
C
586 lines
19 KiB
C
|
//===----------------------------------------------------------------------===//
|
||
|
|
//
|
||
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
||
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||
|
|
//
|
||
|
|
//===----------------------------------------------------------------------===//
|
||
|
|
|
||
|
|
#ifndef _LIBCPP___UTILITY_PAIR_H
|
||
|
|
#define _LIBCPP___UTILITY_PAIR_H
|
||
|
|
|
||
|
|
#include <__config>
|
||
|
|
#include <__functional/unwrap_ref.h>
|
||
|
|
#include <__tuple>
|
||
|
|
#include <__utility/forward.h>
|
||
|
|
#include <__utility/move.h>
|
||
|
|
#include <__utility/piecewise_construct.h>
|
||
|
|
#include <cstddef>
|
||
|
|
#include <type_traits>
|
||
|
|
|
||
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||
|
|
#pragma GCC system_header
|
||
|
|
#endif
|
||
|
|
|
||
|
|
_LIBCPP_PUSH_MACROS
|
||
|
|
#include <__undef_macros>
|
||
|
|
|
||
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
|
||
|
|
template <class, class>
|
||
|
|
struct __non_trivially_copyable_base {
|
||
|
|
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
|
||
|
|
__non_trivially_copyable_base() _NOEXCEPT {}
|
||
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
||
|
|
__non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {}
|
||
|
|
};
|
||
|
|
#endif
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
struct _LIBCPP_TEMPLATE_VIS pair
|
||
|
|
#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
|
||
|
|
: private __non_trivially_copyable_base<_T1, _T2>
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
typedef _T1 first_type;
|
||
|
|
typedef _T2 second_type;
|
||
|
|
|
||
|
|
_T1 first;
|
||
|
|
_T2 second;
|
||
|
|
|
||
|
|
#if !defined(_LIBCPP_CXX03_LANG)
|
||
|
|
pair(pair const&) = default;
|
||
|
|
pair(pair&&) = default;
|
||
|
|
#else
|
||
|
|
// Use the implicitly declared copy constructor in C++03
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef _LIBCPP_CXX03_LANG
|
||
|
|
_LIBCPP_INLINE_VISIBILITY
|
||
|
|
pair() : first(), second() {}
|
||
|
|
|
||
|
|
_LIBCPP_INLINE_VISIBILITY
|
||
|
|
pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {}
|
||
|
|
|
||
|
|
template <class _U1, class _U2>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY
|
||
|
|
pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
|
||
|
|
|
||
|
|
_LIBCPP_INLINE_VISIBILITY
|
||
|
|
pair& operator=(pair const& __p) {
|
||
|
|
first = __p.first;
|
||
|
|
second = __p.second;
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
template <bool _Val>
|
||
|
|
using _EnableB _LIBCPP_NODEBUG_TYPE = typename enable_if<_Val, bool>::type;
|
||
|
|
|
||
|
|
struct _CheckArgs {
|
||
|
|
template <int&...>
|
||
|
|
static constexpr bool __enable_explicit_default() {
|
||
|
|
return is_default_constructible<_T1>::value
|
||
|
|
&& is_default_constructible<_T2>::value
|
||
|
|
&& !__enable_implicit_default<>();
|
||
|
|
}
|
||
|
|
|
||
|
|
template <int&...>
|
||
|
|
static constexpr bool __enable_implicit_default() {
|
||
|
|
return __is_implicitly_default_constructible<_T1>::value
|
||
|
|
&& __is_implicitly_default_constructible<_T2>::value;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _U1, class _U2>
|
||
|
|
static constexpr bool __enable_explicit() {
|
||
|
|
return is_constructible<first_type, _U1>::value
|
||
|
|
&& is_constructible<second_type, _U2>::value
|
||
|
|
&& (!is_convertible<_U1, first_type>::value
|
||
|
|
|| !is_convertible<_U2, second_type>::value);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _U1, class _U2>
|
||
|
|
static constexpr bool __enable_implicit() {
|
||
|
|
return is_constructible<first_type, _U1>::value
|
||
|
|
&& is_constructible<second_type, _U2>::value
|
||
|
|
&& is_convertible<_U1, first_type>::value
|
||
|
|
&& is_convertible<_U2, second_type>::value;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <bool _MaybeEnable>
|
||
|
|
using _CheckArgsDep _LIBCPP_NODEBUG_TYPE = typename conditional<
|
||
|
|
_MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;
|
||
|
|
|
||
|
|
struct _CheckTupleLikeConstructor {
|
||
|
|
template <class _Tuple>
|
||
|
|
static constexpr bool __enable_implicit() {
|
||
|
|
return __tuple_convertible<_Tuple, pair>::value;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _Tuple>
|
||
|
|
static constexpr bool __enable_explicit() {
|
||
|
|
return __tuple_constructible<_Tuple, pair>::value
|
||
|
|
&& !__tuple_convertible<_Tuple, pair>::value;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _Tuple>
|
||
|
|
static constexpr bool __enable_assign() {
|
||
|
|
return __tuple_assignable<_Tuple, pair>::value;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template <class _Tuple>
|
||
|
|
using _CheckTLC _LIBCPP_NODEBUG_TYPE = typename conditional<
|
||
|
|
__tuple_like_with_size<_Tuple, 2>::value
|
||
|
|
&& !is_same<typename decay<_Tuple>::type, pair>::value,
|
||
|
|
_CheckTupleLikeConstructor,
|
||
|
|
__check_tuple_constructor_fail
|
||
|
|
>::type;
|
||
|
|
|
||
|
|
template<bool _Dummy = true, _EnableB<
|
||
|
|
_CheckArgsDep<_Dummy>::__enable_explicit_default()
|
||
|
|
> = false>
|
||
|
|
explicit _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||
|
|
pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
|
||
|
|
is_nothrow_default_constructible<second_type>::value)
|
||
|
|
: first(), second() {}
|
||
|
|
|
||
|
|
template<bool _Dummy = true, _EnableB<
|
||
|
|
_CheckArgsDep<_Dummy>::__enable_implicit_default()
|
||
|
|
> = false>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||
|
|
pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
|
||
|
|
is_nothrow_default_constructible<second_type>::value)
|
||
|
|
: first(), second() {}
|
||
|
|
|
||
|
|
template <bool _Dummy = true, _EnableB<
|
||
|
|
_CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>()
|
||
|
|
> = false>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
explicit pair(_T1 const& __t1, _T2 const& __t2)
|
||
|
|
_NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
|
||
|
|
is_nothrow_copy_constructible<second_type>::value)
|
||
|
|
: first(__t1), second(__t2) {}
|
||
|
|
|
||
|
|
template<bool _Dummy = true, _EnableB<
|
||
|
|
_CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>()
|
||
|
|
> = false>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
pair(_T1 const& __t1, _T2 const& __t2)
|
||
|
|
_NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
|
||
|
|
is_nothrow_copy_constructible<second_type>::value)
|
||
|
|
: first(__t1), second(__t2) {}
|
||
|
|
|
||
|
|
template<class _U1, class _U2, _EnableB<
|
||
|
|
_CheckArgs::template __enable_explicit<_U1, _U2>()
|
||
|
|
> = false>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
explicit pair(_U1&& __u1, _U2&& __u2)
|
||
|
|
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
|
||
|
|
is_nothrow_constructible<second_type, _U2>::value))
|
||
|
|
: first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
|
||
|
|
|
||
|
|
template<class _U1, class _U2, _EnableB<
|
||
|
|
_CheckArgs::template __enable_implicit<_U1, _U2>()
|
||
|
|
> = false>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
pair(_U1&& __u1, _U2&& __u2)
|
||
|
|
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
|
||
|
|
is_nothrow_constructible<second_type, _U2>::value))
|
||
|
|
: first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
|
||
|
|
|
||
|
|
template<class _U1, class _U2, _EnableB<
|
||
|
|
_CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>()
|
||
|
|
> = false>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
explicit pair(pair<_U1, _U2> const& __p)
|
||
|
|
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
|
||
|
|
is_nothrow_constructible<second_type, _U2 const&>::value))
|
||
|
|
: first(__p.first), second(__p.second) {}
|
||
|
|
|
||
|
|
template<class _U1, class _U2, _EnableB<
|
||
|
|
_CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>()
|
||
|
|
> = false>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
pair(pair<_U1, _U2> const& __p)
|
||
|
|
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
|
||
|
|
is_nothrow_constructible<second_type, _U2 const&>::value))
|
||
|
|
: first(__p.first), second(__p.second) {}
|
||
|
|
|
||
|
|
template<class _U1, class _U2, _EnableB<
|
||
|
|
_CheckArgs::template __enable_explicit<_U1, _U2>()
|
||
|
|
> = false>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
explicit pair(pair<_U1, _U2>&&__p)
|
||
|
|
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
|
||
|
|
is_nothrow_constructible<second_type, _U2&&>::value))
|
||
|
|
: first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
|
||
|
|
|
||
|
|
template<class _U1, class _U2, _EnableB<
|
||
|
|
_CheckArgs::template __enable_implicit<_U1, _U2>()
|
||
|
|
> = false>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
pair(pair<_U1, _U2>&& __p)
|
||
|
|
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
|
||
|
|
is_nothrow_constructible<second_type, _U2&&>::value))
|
||
|
|
: first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
|
||
|
|
|
||
|
|
template<class _Tuple, _EnableB<
|
||
|
|
_CheckTLC<_Tuple>::template __enable_explicit<_Tuple>()
|
||
|
|
> = false>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
explicit pair(_Tuple&& __p)
|
||
|
|
: first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
|
||
|
|
second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
|
||
|
|
|
||
|
|
template<class _Tuple, _EnableB<
|
||
|
|
_CheckTLC<_Tuple>::template __enable_implicit<_Tuple>()
|
||
|
|
> = false>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
pair(_Tuple&& __p)
|
||
|
|
: first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
|
||
|
|
second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
|
||
|
|
|
||
|
|
template <class... _Args1, class... _Args2>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
||
|
|
pair(piecewise_construct_t __pc,
|
||
|
|
tuple<_Args1...> __first_args, tuple<_Args2...> __second_args)
|
||
|
|
_NOEXCEPT_((is_nothrow_constructible<first_type, _Args1...>::value &&
|
||
|
|
is_nothrow_constructible<second_type, _Args2...>::value))
|
||
|
|
: pair(__pc, __first_args, __second_args,
|
||
|
|
typename __make_tuple_indices<sizeof...(_Args1)>::type(),
|
||
|
|
typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}
|
||
|
|
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
||
|
|
pair& operator=(typename conditional<
|
||
|
|
is_copy_assignable<first_type>::value &&
|
||
|
|
is_copy_assignable<second_type>::value,
|
||
|
|
pair, __nat>::type const& __p)
|
||
|
|
_NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
|
||
|
|
is_nothrow_copy_assignable<second_type>::value)
|
||
|
|
{
|
||
|
|
first = __p.first;
|
||
|
|
second = __p.second;
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
||
|
|
pair& operator=(typename conditional<
|
||
|
|
is_move_assignable<first_type>::value &&
|
||
|
|
is_move_assignable<second_type>::value,
|
||
|
|
pair, __nat>::type&& __p)
|
||
|
|
_NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
|
||
|
|
is_nothrow_move_assignable<second_type>::value)
|
||
|
|
{
|
||
|
|
first = _VSTD::forward<first_type>(__p.first);
|
||
|
|
second = _VSTD::forward<second_type>(__p.second);
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _Tuple, _EnableB<
|
||
|
|
_CheckTLC<_Tuple>::template __enable_assign<_Tuple>()
|
||
|
|
> = false>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
||
|
|
pair& operator=(_Tuple&& __p) {
|
||
|
|
first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p));
|
||
|
|
second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p));
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
||
|
|
void
|
||
|
|
swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
|
||
|
|
__is_nothrow_swappable<second_type>::value)
|
||
|
|
{
|
||
|
|
using _VSTD::swap;
|
||
|
|
swap(first, __p.first);
|
||
|
|
swap(second, __p.second);
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
|
||
|
|
#ifndef _LIBCPP_CXX03_LANG
|
||
|
|
template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
||
|
|
pair(piecewise_construct_t,
|
||
|
|
tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
|
||
|
|
__tuple_indices<_I1...>, __tuple_indices<_I2...>);
|
||
|
|
#endif
|
||
|
|
};
|
||
|
|
|
||
|
|
#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
|
||
|
|
template<class _T1, class _T2>
|
||
|
|
pair(_T1, _T2) -> pair<_T1, _T2>;
|
||
|
|
#endif // _LIBCPP_HAS_NO_DEDUCTION_GUIDES
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
bool
|
||
|
|
operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
|
||
|
|
{
|
||
|
|
return __x.first == __y.first && __x.second == __y.second;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
bool
|
||
|
|
operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
|
||
|
|
{
|
||
|
|
return !(__x == __y);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
bool
|
||
|
|
operator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
|
||
|
|
{
|
||
|
|
return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
bool
|
||
|
|
operator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
|
||
|
|
{
|
||
|
|
return __y < __x;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
bool
|
||
|
|
operator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
|
||
|
|
{
|
||
|
|
return !(__x < __y);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
bool
|
||
|
|
operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
|
||
|
|
{
|
||
|
|
return !(__y < __x);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
||
|
|
typename enable_if
|
||
|
|
<
|
||
|
|
__is_swappable<_T1>::value &&
|
||
|
|
__is_swappable<_T2>::value,
|
||
|
|
void
|
||
|
|
>::type
|
||
|
|
swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
|
||
|
|
_NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
|
||
|
|
__is_nothrow_swappable<_T2>::value))
|
||
|
|
{
|
||
|
|
__x.swap(__y);
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifndef _LIBCPP_CXX03_LANG
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
|
||
|
|
make_pair(_T1&& __t1, _T2&& __t2)
|
||
|
|
{
|
||
|
|
return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
|
||
|
|
(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
|
||
|
|
}
|
||
|
|
|
||
|
|
#else // _LIBCPP_CXX03_LANG
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
||
|
|
pair<_T1,_T2>
|
||
|
|
make_pair(_T1 __x, _T2 __y)
|
||
|
|
{
|
||
|
|
return pair<_T1, _T2>(__x, __y);
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // _LIBCPP_CXX03_LANG
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
struct _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> >
|
||
|
|
: public integral_constant<size_t, 2> {};
|
||
|
|
|
||
|
|
template <size_t _Ip, class _T1, class _T2>
|
||
|
|
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> >
|
||
|
|
{
|
||
|
|
static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");
|
||
|
|
};
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
struct _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> >
|
||
|
|
{
|
||
|
|
typedef _LIBCPP_NODEBUG_TYPE _T1 type;
|
||
|
|
};
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
struct _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >
|
||
|
|
{
|
||
|
|
typedef _LIBCPP_NODEBUG_TYPE _T2 type;
|
||
|
|
};
|
||
|
|
|
||
|
|
template <size_t _Ip> struct __get_pair;
|
||
|
|
|
||
|
|
template <>
|
||
|
|
struct __get_pair<0>
|
||
|
|
{
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
static
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
_T1&
|
||
|
|
get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
static
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
const _T1&
|
||
|
|
get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
|
||
|
|
|
||
|
|
#ifndef _LIBCPP_CXX03_LANG
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
static
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
_T1&&
|
||
|
|
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
static
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
const _T1&&
|
||
|
|
get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T1>(__p.first);}
|
||
|
|
#endif // _LIBCPP_CXX03_LANG
|
||
|
|
};
|
||
|
|
|
||
|
|
template <>
|
||
|
|
struct __get_pair<1>
|
||
|
|
{
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
static
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
_T2&
|
||
|
|
get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
static
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
const _T2&
|
||
|
|
get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
|
||
|
|
|
||
|
|
#ifndef _LIBCPP_CXX03_LANG
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
static
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
_T2&&
|
||
|
|
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
static
|
||
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
const _T2&&
|
||
|
|
get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T2>(__p.second);}
|
||
|
|
#endif // _LIBCPP_CXX03_LANG
|
||
|
|
};
|
||
|
|
|
||
|
|
template <size_t _Ip, class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
typename tuple_element<_Ip, pair<_T1, _T2> >::type&
|
||
|
|
get(pair<_T1, _T2>& __p) _NOEXCEPT
|
||
|
|
{
|
||
|
|
return __get_pair<_Ip>::get(__p);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <size_t _Ip, class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
|
||
|
|
get(const pair<_T1, _T2>& __p) _NOEXCEPT
|
||
|
|
{
|
||
|
|
return __get_pair<_Ip>::get(__p);
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifndef _LIBCPP_CXX03_LANG
|
||
|
|
template <size_t _Ip, class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
|
||
|
|
get(pair<_T1, _T2>&& __p) _NOEXCEPT
|
||
|
|
{
|
||
|
|
return __get_pair<_Ip>::get(_VSTD::move(__p));
|
||
|
|
}
|
||
|
|
|
||
|
|
template <size_t _Ip, class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
|
||
|
|
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
|
||
|
|
get(const pair<_T1, _T2>&& __p) _NOEXCEPT
|
||
|
|
{
|
||
|
|
return __get_pair<_Ip>::get(_VSTD::move(__p));
|
||
|
|
}
|
||
|
|
#endif // _LIBCPP_CXX03_LANG
|
||
|
|
|
||
|
|
#if _LIBCPP_STD_VER > 11
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
||
|
|
constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
|
||
|
|
{
|
||
|
|
return __get_pair<0>::get(__p);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
||
|
|
constexpr _T1 const & get(pair<_T1, _T2> const& __p) _NOEXCEPT
|
||
|
|
{
|
||
|
|
return __get_pair<0>::get(__p);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
||
|
|
constexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT
|
||
|
|
{
|
||
|
|
return __get_pair<0>::get(_VSTD::move(__p));
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
||
|
|
constexpr _T1 const && get(pair<_T1, _T2> const&& __p) _NOEXCEPT
|
||
|
|
{
|
||
|
|
return __get_pair<0>::get(_VSTD::move(__p));
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
||
|
|
constexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT
|
||
|
|
{
|
||
|
|
return __get_pair<1>::get(__p);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
||
|
|
constexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT
|
||
|
|
{
|
||
|
|
return __get_pair<1>::get(__p);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
||
|
|
constexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT
|
||
|
|
{
|
||
|
|
return __get_pair<1>::get(_VSTD::move(__p));
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class _T1, class _T2>
|
||
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
||
|
|
constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT
|
||
|
|
{
|
||
|
|
return __get_pair<1>::get(_VSTD::move(__p));
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
_LIBCPP_END_NAMESPACE_STD
|
||
|
|
|
||
|
|
_LIBCPP_POP_MACROS
|
||
|
|
|
||
|
|
#endif // _LIBCPP___UTILITY_PAIR_H
|