This is an archive of the discontinued LLVM Phabricator instance.

Differential D112585

Implement the tuple/pair constructor portion of P2255R2
DraftPublic

Authored by tcanens on Oct 26 2021, 5:36 PM.
This is a draft revision that has not yet been submitted for review.

Details

Reviewers
None
Summary

Implement the tuple/pair constructor portion of P2255R2

Also includes LWG3121 and the tuple/pair constructor portion of P2321R2.

Diff Detail

Event Timeline

tcanens created this revision.Oct 26 2021, 5:36 PM
Harbormaster completed remote builds in B130833: Diff 382491.Oct 26 2021, 6:35 PM
ChuanqiXu added a subscriber: ChuanqiXu.Oct 26 2021, 8:00 PM

Revision Contents

PathSize
libcxx/
include/
13 lines
__utility/
146 lines
723 lines
test/
libcxx/
utilities/
tuple/
tuple.tuple/
tuple.cnstr/
22 lines
std/
utilities/
tuple/
tuple.tuple/
tuple.cnstr/
41 lines
utility/
pairs/
pairs.pair/
34 lines

Diff 382491

libcxx/include/__tuple

Show First 20 Lines • Show All 479 Lines • ▼ Show 20 Linesstruct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
static constexpr bool __enable_explicit_default() { return false; } static constexpr bool __enable_explicit_default() { return false; }
static constexpr bool __enable_implicit_default() { return false; } static constexpr bool __enable_implicit_default() { return false; }
template <class ...> template <class ...>
static constexpr bool __enable_explicit() { return false; } static constexpr bool __enable_explicit() { return false; }
template <class ...> template <class ...>
static constexpr bool __enable_implicit() { return false; } static constexpr bool __enable_implicit() { return false; }
template <class ...> template <class ...>
static constexpr bool __delete_explicit() { return false; }
template <class ...>
static constexpr bool __delete_implicit() { return false; }
template <class ...>
static constexpr bool __enable_assign() { return false; } static constexpr bool __enable_assign() { return false; }
}; };
#endif // !defined(_LIBCPP_CXX03_LANG) #endif // !defined(_LIBCPP_CXX03_LANG)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER > 14
template <bool _CanCopy, bool _CanMove> template <bool _CanCopy, bool _CanMove>
struct __sfinae_ctor_base {}; struct __sfinae_ctor_base {};
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesstruct __sfinae_assign_base<false, true> {
__sfinae_assign_base() = default; __sfinae_assign_base() = default;
__sfinae_assign_base(__sfinae_assign_base const&) = default; __sfinae_assign_base(__sfinae_assign_base const&) = default;
__sfinae_assign_base(__sfinae_assign_base &&) = default; __sfinae_assign_base(__sfinae_assign_base &&) = default;
__sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete; __sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete;
__sfinae_assign_base& operator=(__sfinae_assign_base&&) = default; __sfinae_assign_base& operator=(__sfinae_assign_base&&) = default;
}; };
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER > 14
template <class _Dest, class _Src>
struct reference_constructs_from_temporary
#if __has_keyword(__reference_binds_to_temporary)
: integral_constant<bool, __reference_binds_to_temporary(_Dest, _Src)>
#else
: false_type
#endif
{};
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TUPLE #endif // _LIBCPP___TUPLE

libcxx/include/__utility/pair.h

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines struct _CheckArgs {
template <int&...> template <int&...>
static constexpr bool __enable_implicit_default() { static constexpr bool __enable_implicit_default() {
return __is_implicitly_default_constructible<_T1>::value return __is_implicitly_default_constructible<_T1>::value
&& __is_implicitly_default_constructible<_T2>::value; && __is_implicitly_default_constructible<_T2>::value;
} }
template <class _U1, class _U2> template <class _U1, class _U2>
static constexpr bool __enable_explicit() { static constexpr bool __enable_explicit_base() {
return is_constructible<first_type, _U1>::value return is_constructible<first_type, _U1>::value
&& is_constructible<second_type, _U2>::value && is_constructible<second_type, _U2>::value
&& (!is_convertible<_U1, first_type>::value && (!is_convertible<_U1, first_type>::value
|| !is_convertible<_U2, second_type>::value); || !is_convertible<_U2, second_type>::value);
} }
template <class _U1, class _U2> template <class _U1, class _U2>
static constexpr bool __enable_implicit() { static constexpr bool __binds_to_temporary() {
return reference_constructs_from_temporary<first_type, _U1&&>::value
|| reference_constructs_from_temporary<second_type, _U2&&>::value;
}
template <class _U1, class _U2>
static constexpr bool __enable_explicit() {
return __enable_explicit_base<_U1, _U2>() && !__binds_to_temporary<_U1, _U2>();
}
template <class _U1, class _U2>
static constexpr bool __delete_explicit() {
return __enable_explicit_base<_U1, _U2>() && __binds_to_temporary<_U1, _U2>();
}
template <class _U1, class _U2>
static constexpr bool __enable_implicit_base() {
return is_constructible<first_type, _U1>::value return is_constructible<first_type, _U1>::value
&& is_constructible<second_type, _U2>::value && is_constructible<second_type, _U2>::value
&& is_convertible<_U1, first_type>::value && is_convertible<_U1, first_type>::value
&& is_convertible<_U2, second_type>::value; && is_convertible<_U2, second_type>::value;
} }
template <class _U1, class _U2>
static constexpr bool __enable_implicit() {
return __enable_implicit_base<_U1, _U2>() && !__binds_to_temporary<_U1, _U2>();
}
template <class _U1, class _U2>
static constexpr bool __delete_implicit() {
return __enable_implicit_base<_U1, _U2>() && __binds_to_temporary<_U1, _U2>();
}
}; };
template <bool _MaybeEnable> template <bool _MaybeEnable>
using _CheckArgsDep _LIBCPP_NODEBUG = typename conditional< using _CheckArgsDep _LIBCPP_NODEBUG = typename conditional<
_MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type; _MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;
struct _CheckTupleLikeConstructor { struct _CheckTupleLikeConstructor {
template <class _Tuple> template <class _Tuple>
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines explicit pair(_U1&& __u1, _U2&& __u2)
: first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {} : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
template < template <
#if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951 #if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951
class _U1 = _T1, class _U2 = _T2, class _U1 = _T1, class _U2 = _T2,
#else #else
class _U1, class _U2, class _U1, class _U2,
#endif #endif
typename enable_if<_CheckArgs::template __delete_explicit<_U1, _U2>()>::type* = nullptr
>
explicit pair(_U1&&, _U2&&) = delete;
template <
#if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951
class _U1 = _T1, class _U2 = _T2,
#else
class _U1, class _U2,
#endif
typename enable_if<_CheckArgs::template __enable_implicit<_U1, _U2>()>::type* = nullptr typename enable_if<_CheckArgs::template __enable_implicit<_U1, _U2>()>::type* = nullptr
> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(_U1&& __u1, _U2&& __u2) pair(_U1&& __u1, _U2&& __u2)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value && _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
is_nothrow_constructible<second_type, _U2>::value)) is_nothrow_constructible<second_type, _U2>::value))
: first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {} : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
template <
#if _LIBCPP_STD_VER > 20 // http://wg21.link/P1951
class _U1 = _T1, class _U2 = _T2,
#else
class _U1, class _U2,
#endif
typename enable_if<_CheckArgs::template __delete_implicit<_U1, _U2>()>::type* = nullptr
>
pair(_U1&&, _U2&&) = delete;
template<class _U1, class _U2, typename enable_if< template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>() _CheckArgs::template __enable_explicit<_U1&, _U2&>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(pair<_U1, _U2> const& __p) explicit pair(pair<_U1, _U2>& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value && _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&>::value &&
is_nothrow_constructible<second_type, _U2 const&>::value)) is_nothrow_constructible<second_type, _U2&>::value))
: first(__p.first), second(__p.second) {} : first(__p.first), second(__p.second) {}
template<class _U1, class _U2, typename enable_if< template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>() _CheckArgs::template __delete_explicit<_U1&, _U2&>()
>::type* = nullptr>
explicit pair(pair<_U1, _U2>& __p) = delete;
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_implicit<_U1&, _U2&>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(pair<_U1, _U2> const& __p) pair(pair<_U1, _U2>& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value && _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&>::value &&
is_nothrow_constructible<second_type, _U2 const&>::value)) is_nothrow_constructible<second_type, _U2&>::value))
: first(__p.first), second(__p.second) {} : first(__p.first), second(__p.second) {}
template<class _U1, class _U2, typename enable_if< template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_explicit<_U1, _U2>() _CheckArgs::template __delete_implicit<_U1&, _U2&>()
>::type* = nullptr>
pair(pair<_U1, _U2>&) = delete;
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_explicit<const _U1&, const _U2&>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(const pair<_U1, _U2>& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, const _U1&>::value &&
is_nothrow_constructible<second_type, const _U2&>::value))
: first(__p.first), second(__p.second) {}
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __delete_explicit<const _U1&, const _U2&>()
>::type* = nullptr>
explicit pair(const pair<_U1, _U2>& __p) = delete;
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_implicit<const _U1&, const _U2&>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(const pair<_U1, _U2>& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, const _U1&>::value &&
is_nothrow_constructible<second_type, const _U2&>::value))
: first(__p.first), second(__p.second) {}
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __delete_implicit<const _U1&, const _U2&>()
>::type* = nullptr>
pair(const pair<_U1, _U2>&) = delete;
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_explicit<_U1&&, _U2&&>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(pair<_U1, _U2>&&__p) explicit pair(pair<_U1, _U2>&& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value && _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
is_nothrow_constructible<second_type, _U2&&>::value)) is_nothrow_constructible<second_type, _U2&&>::value))
: first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {} : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
template<class _U1, class _U2, typename enable_if< template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_implicit<_U1, _U2>() _CheckArgs::template __delete_explicit<_U1&&, _U2&&>()
>::type* = nullptr>
explicit pair(pair<_U1, _U2>&& __p) = delete;
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_implicit<_U1&&, _U2&&>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(pair<_U1, _U2>&& __p) pair(pair<_U1, _U2>&& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value && _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
is_nothrow_constructible<second_type, _U2&&>::value)) is_nothrow_constructible<second_type, _U2&&>::value))
: first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {} : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __delete_implicit<_U1&&, _U2&&>()
>::type* = nullptr>
pair(pair<_U1, _U2>&&) = delete;
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_explicit<const _U1&&, const _U2&&>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(const pair<_U1, _U2>&& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, const _U1&&>::value &&
is_nothrow_constructible<second_type, const _U2&&>::value))
: first(_VSTD::forward<const _U1>(__p.first)), second(_VSTD::forward<const _U2>(__p.second)) {}
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __delete_explicit<const _U1&&, const _U2&&>()
>::type* = nullptr>
explicit pair(const pair<_U1, _U2>&& __p) = delete;
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __enable_implicit<const _U1&&, const _U2&&>()
>::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
pair(const pair<_U1, _U2>&& __p)
_NOEXCEPT_((is_nothrow_constructible<first_type, const _U1&&>::value &&
is_nothrow_constructible<second_type, const _U2&&>::value))
: first(_VSTD::forward<const _U1>(__p.first)), second(_VSTD::forward<const _U2>(__p.second)) {}
template<class _U1, class _U2, typename enable_if<
_CheckArgs::template __delete_implicit<const _U1&&, const _U2&&>()
>::type* = nullptr>
pair(const pair<_U1, _U2>&&) = delete;
template<class _Tuple, typename enable_if< template<class _Tuple, typename enable_if<
_CheckTLC<_Tuple>::template __enable_explicit<_Tuple>() _CheckTLC<_Tuple>::template __enable_explicit<_Tuple>()
>::type* = nullptr> >::type* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit pair(_Tuple&& __p) explicit pair(_Tuple&& __p)
: first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))), : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {} second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
▲ Show 20 Lines • Show All 367 Lines • Show Last 20 Lines

libcxx/include/tuple

Show First 20 Lines • Show All 588 Lines • ▼ Show 20 Lines explicit tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
typename __make_tuple_types<tuple, 0>::type(), typename __make_tuple_types<tuple, 0>::type(),
__t... __t...
) {} ) {}
// tuple(U&& ...) constructors (including allocator_arg_t variants) // tuple(U&& ...) constructors (including allocator_arg_t variants)
template <class ..._Up> struct _IsThisTuple : false_type { }; template <class ..._Up> struct _IsThisTuple : false_type { };
template <class _Up> struct _IsThisTuple<_Up> : is_same<__uncvref_t<_Up>, tuple> { }; template <class _Up> struct _IsThisTuple<_Up> : is_same<__uncvref_t<_Up>, tuple> { };
template <class _Self, class ..._Up> struct _CheckAllocatorArg : false_type { };
template <class _T0, class... _Stail, class _U0, class ..._Tail>
struct _CheckAllocatorArg<tuple<_T0, _Stail...>, _U0, _Tail...>
: integral_constant<bool,
(sizeof...(_Tail) == 1 || sizeof...(_Tail) == 2) &&
is_same<__uncvref_t<_U0>, allocator_arg_t>::value &&
!is_same<__uncvref_t<_T0>, allocator_arg_t>::value>
{ };
template <class ..._Up> template <class ..._Up>
struct _EnableUTypesCtor : _And< struct _EnableUTypesCtor : _And<
_BoolConstant<sizeof...(_Tp) >= 1>, _BoolConstant<sizeof...(_Tp) >= 1>,
_Not<_IsThisTuple<_Up...> >, // extension to allow mis-behaved user constructors _Not<_IsThisTuple<_Up...> >, // extension to allow mis-behaved user constructors
_Not<_CheckAllocatorArg<tuple, _Up...>>,
is_constructible<_Tp, _Up>... is_constructible<_Tp, _Up>...
> { }; > { };
template <class ..._Up>
struct _BindsReferenceToTemporary :
_Not<_And<_Not<reference_constructs_from_temporary<_Tp, _Up>>...>>
{ };
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>, _EnableUTypesCtor<_Up...>,
_Not<_BindsReferenceToTemporary<_Up...>>,
is_convertible<_Up, _Tp>... // explicit check is_convertible<_Up, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(_Up&&... __u) tuple(_Up&&... __u)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value)) _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
: __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(), : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {} _VSTD::forward<_Up>(__u)...) {}
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>, _EnableUTypesCtor<_Up...>,
_BindsReferenceToTemporary<_Up...>,
is_convertible<_Up, _Tp>... // explicit check
>::value
, int> = 0>
tuple(_Up&&...) = delete;
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>,
_Not<_BindsReferenceToTemporary<_Up...>>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(_Up&&... __u) explicit tuple(_Up&&... __u)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value)) _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
: __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(), : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {} _VSTD::forward<_Up>(__u)...) {}
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>,
_BindsReferenceToTemporary<_Up...>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value
, int> = 0>
explicit tuple(_Up&&...) = delete;
template <class _Alloc, class ..._Up, __enable_if_t< template <class _Alloc, class ..._Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>, _EnableUTypesCtor<_Up...>,
_Not<_BindsReferenceToTemporary<_Up...>>,
is_convertible<_Up, _Tp>... // explicit check is_convertible<_Up, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u) tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
: __base_(allocator_arg_t(), __a, : __base_(allocator_arg_t(), __a,
typename __make_tuple_indices<sizeof...(_Up)>::type(), typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {} _VSTD::forward<_Up>(__u)...) {}
template <class _Alloc, class ..._Up, __enable_if_t< template <class _Alloc, class ..._Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>, _EnableUTypesCtor<_Up...>,
_BindsReferenceToTemporary<_Up...>,
is_convertible<_Up, _Tp>... // explicit check
>::value
, int> = 0>
tuple(allocator_arg_t, const _Alloc&, _Up&&...) = delete;
template <class _Alloc, class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>,
_Not<_BindsReferenceToTemporary<_Up...>>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u) explicit tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
: __base_(allocator_arg_t(), __a, : __base_(allocator_arg_t(), __a,
typename __make_tuple_indices<sizeof...(_Up)>::type(), typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(), typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {} _VSTD::forward<_Up>(__u)...) {}
template <class _Alloc, class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableUTypesCtor<_Up...>,
_BindsReferenceToTemporary<_Up...>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value
, int> = 0>
explicit tuple(allocator_arg_t, const _Alloc&, _Up&&...) = delete;
// Copy and move constructors (including the allocator_arg_t variants) // Copy and move constructors (including the allocator_arg_t variants)
tuple(const tuple&) = default; tuple(const tuple&) = default;
tuple(tuple&&) = default; tuple(tuple&&) = default;
template <class _Alloc, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
_And<is_copy_constructible<_Tp>...>::value _And<is_copy_constructible<_Tp>...>::value
, int> = 0> , int> = 0>
tuple(allocator_arg_t, const _Alloc& __alloc, const tuple& __t) tuple(allocator_arg_t, const _Alloc& __alloc, const tuple& __t)
: __base_(allocator_arg_t(), __alloc, __t) : __base_(allocator_arg_t(), __alloc, __t)
{ } { }
template <class _Alloc, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
_And<is_move_constructible<_Tp>...>::value _And<is_move_constructible<_Tp>...>::value
, int> = 0> , int> = 0>
tuple(allocator_arg_t, const _Alloc& __alloc, tuple&& __t) tuple(allocator_arg_t, const _Alloc& __alloc, tuple&& __t)
: __base_(allocator_arg_t(), __alloc, _VSTD::move(__t)) : __base_(allocator_arg_t(), __alloc, _VSTD::move(__t))
{ } { }
// tuple(const tuple<U...>&) constructors (including allocator_arg_t variants) template<class _Up> using _Lref = _Up&;
template <class ..._Up> template<class _Up> using _Rref = _Up&&;
struct _EnableCopyFromOtherTuple : _And< template<class _Up> using _Clref = _Up const&;
template<class _Up> using _Crref = _Up const&&;
// tuple(tuple<U...>&) constructors (including allocator_arg_t variants)
template <template<class> class _Ref, class ..._Up>
struct _EnableConstructFromOtherTuple : _And<
_Not<is_same<tuple<_Tp...>, tuple<_Up...> > >, _Not<is_same<tuple<_Tp...>, tuple<_Up...> > >,
_Lazy<_Or, _Lazy<_Or,
_BoolConstant<sizeof...(_Tp) != 1>, _BoolConstant<sizeof...(_Tp) != 1>,
// _Tp and _Up are 1-element packs - the pack expansions look // _Tp and _Up are 1-element packs - the pack expansions look
// weird to avoid tripping up the type traits in degenerate cases // weird to avoid tripping up the type traits in degenerate cases
_Lazy<_And, _Lazy<_And,
_Not<is_convertible<const tuple<_Up>&, _Tp> >..., _Not<is_convertible<_Ref<tuple<_Up>>, _Tp> >...,
_Not<is_constructible<_Tp, const tuple<_Up>&> >... _Not<is_constructible<_Tp, _Ref<tuple<_Up>>> >...
> >
>, >,
is_constructible<_Tp, const _Up&>... is_constructible<_Tp, _Ref<_Up>>...
> { }; > { };
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableCopyFromOtherTuple<_Up...>, _EnableConstructFromOtherTuple<_Lref, _Up...>,
_Not<_BindsReferenceToTemporary<_Up&...>>,
is_convertible<_Up&, _Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(tuple<_Up...>& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up&>...>::value))
: __base_(__t)
{ }
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Lref, _Up...>,
_BindsReferenceToTemporary<_Up&...>,
is_convertible<_Up&, _Tp>... // explicit check
>::value
, int> = 0>
tuple(tuple<_Up...>&) = delete;
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Lref, _Up...>,
_Not<_BindsReferenceToTemporary<_Up&...>>,
_Not<_Lazy<_And, is_convertible<_Up&, _Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(tuple<_Up...>& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up&>...>::value))
: __base_(__t)
{ }
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Lref, _Up...>,
_BindsReferenceToTemporary<_Up&...>,
_Not<_Lazy<_And, is_convertible<_Up&, _Tp>...> > // explicit check
>::value
, int> = 0>
explicit tuple(tuple<_Up...>&) = delete;
template <class ..._Up, class _Alloc, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Lref, _Up...>,
_Not<_BindsReferenceToTemporary<_Up&...>>,
is_convertible<_Up&, _Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>& __t)
: __base_(allocator_arg_t(), __a, __t)
{ }
template <class ..._Up, class _Alloc, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Lref, _Up...>,
_BindsReferenceToTemporary< _Up&...>,
is_convertible<_Up&, _Tp>... // explicit check
>::value
, int> = 0>
tuple(allocator_arg_t, const _Alloc&, const tuple<_Up...>&) = delete;
template <class ..._Up, class _Alloc, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Lref, _Up...>,
_Not<_BindsReferenceToTemporary<_Up&...>>,
_Not<_Lazy<_And, is_convertible<_Up&, _Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>& __t)
: __base_(allocator_arg_t(), __a, __t)
{ }
template <class ..._Up, class _Alloc, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Lref, _Up...>,
_BindsReferenceToTemporary<_Up&...>,
_Not<_Lazy<_And, is_convertible<_Up&, _Tp>...> > // explicit check
>::value
, int> = 0>
explicit tuple(allocator_arg_t, const _Alloc&, tuple<_Up...>&) = delete;
// tuple(const tuple<U...>&) constructors (including allocator_arg_t variants)
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Clref, _Up...>,
_Not<_BindsReferenceToTemporary<const _Up&...>>,
is_convertible<const _Up&, _Tp>... // explicit check is_convertible<const _Up&, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(const tuple<_Up...>& __t) tuple(const tuple<_Up...>& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value)) _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
: __base_(__t) : __base_(__t)
{ } { }
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableCopyFromOtherTuple<_Up...>, _EnableConstructFromOtherTuple<_Clref, _Up...>,
_BindsReferenceToTemporary<const _Up&...>,
is_convertible<const _Up&, _Tp>... // explicit check
>::value
, int> = 0>
tuple(const tuple<_Up...>&) = delete;
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Clref, _Up...>,
_Not<_BindsReferenceToTemporary<const _Up&...>>,
_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(const tuple<_Up...>& __t) explicit tuple(const tuple<_Up...>& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value)) _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
: __base_(__t) : __base_(__t)
{ } { }
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Clref, _Up...>,
_BindsReferenceToTemporary<const _Up&...>,
_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
>::value
, int> = 0>
explicit tuple(const tuple<_Up...>&) = delete;
template <class ..._Up, class _Alloc, __enable_if_t< template <class ..._Up, class _Alloc, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableCopyFromOtherTuple<_Up...>, _EnableConstructFromOtherTuple<_Clref, _Up...>,
_Not<_BindsReferenceToTemporary<const _Up&...>>,
is_convertible<const _Up&, _Tp>... // explicit check is_convertible<const _Up&, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t) tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
: __base_(allocator_arg_t(), __a, __t) : __base_(allocator_arg_t(), __a, __t)
{ } { }
template <class ..._Up, class _Alloc, __enable_if_t< template <class ..._Up, class _Alloc, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableCopyFromOtherTuple<_Up...>, _EnableConstructFromOtherTuple<_Clref, _Up...>,
_BindsReferenceToTemporary<const _Up&...>,
is_convertible<const _Up&, _Tp>... // explicit check
>::value
, int> = 0>
tuple(allocator_arg_t, const _Alloc&, const tuple<_Up...>&) = delete;
template <class ..._Up, class _Alloc, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Clref, _Up...>,
_Not<_BindsReferenceToTemporary<const _Up&...>>,
_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t) explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
: __base_(allocator_arg_t(), __a, __t) : __base_(allocator_arg_t(), __a, __t)
{ } { }
// tuple(tuple<U...>&&) constructors (including allocator_arg_t variants) template <class ..._Up, class _Alloc, __enable_if_t<
template <class ..._Up> _And<
struct _EnableMoveFromOtherTuple : _And< _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_Not<is_same<tuple<_Tp...>, tuple<_Up...> > >, _EnableConstructFromOtherTuple<_Clref, _Up...>,
_Lazy<_Or, _BindsReferenceToTemporary<const _Up&...>,
_BoolConstant<sizeof...(_Tp) != 1>, _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
// _Tp and _Up are 1-element packs - the pack expansions look >::value
// weird to avoid tripping up the type traits in degenerate cases , int> = 0>
_Lazy<_And, explicit tuple(allocator_arg_t, const _Alloc&, const tuple<_Up...>&) = delete;
_Not<is_convertible<tuple<_Up>, _Tp> >...,
_Not<is_constructible<_Tp, tuple<_Up> > >...
>
>,
is_constructible<_Tp, _Up>...
> { };
// tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableMoveFromOtherTuple<_Up...>, _EnableConstructFromOtherTuple<_Rref, _Up...>,
_Not<_BindsReferenceToTemporary<_Up&&...>>,
is_convertible<_Up, _Tp>... // explicit check is_convertible<_Up, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(tuple<_Up...>&& __t) tuple(tuple<_Up...>&& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value)) _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
: __base_(_VSTD::move(__t)) : __base_(_VSTD::move(__t))
{ } { }
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableMoveFromOtherTuple<_Up...>, _EnableConstructFromOtherTuple<_Rref, _Up...>,
_BindsReferenceToTemporary<_Up&&...>,
is_convertible<_Up, _Tp>... // explicit check
>::value
, int> = 0>
tuple(tuple<_Up...>&&) = delete;
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Rref, _Up...>,
_Not<_BindsReferenceToTemporary<_Up&&...>>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(tuple<_Up...>&& __t) explicit tuple(tuple<_Up...>&& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value)) _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
: __base_(_VSTD::move(__t)) : __base_(_VSTD::move(__t))
{ } { }
template <class _Alloc, class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Rref, _Up...>,
_BindsReferenceToTemporary<_Up&&...>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value
, int> = 0>
explicit tuple(tuple<_Up...>&&) = delete;
template <class ..._Up, class _Alloc, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableMoveFromOtherTuple<_Up...>, _EnableConstructFromOtherTuple<_Rref, _Up...>,
_Not<_BindsReferenceToTemporary<_Up&&...>>,
is_convertible<_Up, _Tp>... // explicit check is_convertible<_Up, _Tp>... // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t) tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
: __base_(allocator_arg_t(), __a, _VSTD::move(__t)) : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
{ } { }
template <class _Alloc, class ..._Up, __enable_if_t< template <class ..._Up, class _Alloc, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableMoveFromOtherTuple<_Up...>, _EnableConstructFromOtherTuple<_Rref, _Up...>,
_BindsReferenceToTemporary<_Up&&...>,
is_convertible<_Up, _Tp>... // explicit check
>::value
, int> = 0>
tuple(allocator_arg_t, const _Alloc&, const tuple<_Up...>&&) = delete;
template <class ..._Up, class _Alloc, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Rref, _Up...>,
_Not<_BindsReferenceToTemporary<_Up&&...>>,
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t) explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
: __base_(allocator_arg_t(), __a, _VSTD::move(__t)) : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
{ } { }
// tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants) template <class ..._Up, class _Alloc, __enable_if_t<
template <class _Up1, class _Up2, class ..._DependentTp> _And<
struct _EnableImplicitCopyFromPair : _And< _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
is_constructible<_FirstType<_DependentTp...>, const _Up1&>, _EnableConstructFromOtherTuple<_Rref, _Up...>,
is_constructible<_SecondType<_DependentTp...>, const _Up2&>, _BindsReferenceToTemporary<_Up&&...>,
is_convertible<const _Up1&, _FirstType<_DependentTp...> >, // explicit check _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
is_convertible<const _Up2&, _SecondType<_DependentTp...> > >::value
, int> = 0>
explicit tuple(allocator_arg_t, const _Alloc&, tuple<_Up...>&&) = delete;
// tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants)
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Crref, _Up...>,
_Not<_BindsReferenceToTemporary<const _Up&&...> >,
is_convertible<const _Up, _Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(const tuple<_Up...>&& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up>...>::value))
: __base_(_VSTD::move(__t))
{ }
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Crref, _Up...>,
_BindsReferenceToTemporary<const _Up&&...>,
is_convertible<const _Up, _Tp>... // explicit check
>::value
, int> = 0>
tuple(const tuple<_Up...>&&) = delete;
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Crref, _Up...>,
_Not<_BindsReferenceToTemporary<const _Up&&...>>,
_Not<_Lazy<_And, is_convertible<const _Up, _Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(const tuple<_Up...>&& __t)
_NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up>...>::value))
: __base_(_VSTD::move(__t))
{ }
template <class ..._Up, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Crref, _Up...>,
_BindsReferenceToTemporary<const _Up&&...>,
_Not<_Lazy<_And, is_convertible<const _Up, _Tp>...> > // explicit check
>::value
, int> = 0>
explicit tuple(const tuple<_Up...>&&) = delete;
template <class ..._Up, class _Alloc, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Crref, _Up...>,
_Not<_BindsReferenceToTemporary<const _Up&&...>>,
is_convertible<const _Up, _Tp>... // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>&& __t)
: __base_(allocator_arg_t(), __a, _VSTD::move(__t))
{ }
template <class ..._Up, class _Alloc, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Crref, _Up...>,
_BindsReferenceToTemporary<const _Up&&...>,
is_convertible<const _Up, _Tp>... // explicit check
>::value
, int> = 0>
tuple(allocator_arg_t, const _Alloc&, const tuple<_Up...>&&) = delete;
template <class ..._Up, class _Alloc, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Crref, _Up...>,
_Not<_BindsReferenceToTemporary<const _Up&&...>>,
_Not<_Lazy<_And, is_convertible<const _Up, _Tp>...> > // explicit check
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>&& __t)
: __base_(allocator_arg_t(), __a, _VSTD::move(__t))
{ }
template <class ..._Up, class _Alloc, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
_EnableConstructFromOtherTuple<_Crref, _Up...>,
_BindsReferenceToTemporary<const _Up&&...>,
_Not<_Lazy<_And, is_convertible<const _Up, _Tp>...> > // explicit check
>::value
, int> = 0>
explicit tuple(allocator_arg_t, const _Alloc&, const tuple<_Up...>&&) = delete;
// tuple(pair<U1, U2>&) constructors (including allocator_arg_t variants)
template <template<class> class _Ref, class _Up1, class _Up2, class ..._DependentTp>
struct _EnableImplicitConstructFromPair : _And<
is_constructible<_FirstType<_DependentTp...>, _Ref<_Up1> >,
is_constructible<_SecondType<_DependentTp...>, _Ref<_Up2> >,
is_convertible<_Ref<_Up1>, _FirstType<_DependentTp...> >, // explicit check
is_convertible<_Ref<_Up2>, _SecondType<_DependentTp...> >
> { }; > { };
template <class _Up1, class _Up2, class ..._DependentTp> template <template<class> class _Ref, class _Up1, class _Up2, class ..._DependentTp>
struct _EnableExplicitCopyFromPair : _And< struct _EnableExplicitConstructFromPair : _And<
is_constructible<_FirstType<_DependentTp...>, const _Up1&>, is_constructible<_FirstType<_DependentTp...>, _Ref<_Up1> >,
is_constructible<_SecondType<_DependentTp...>, const _Up2&>, is_constructible<_SecondType<_DependentTp...>, _Ref<_Up2> >,
_Not<is_convertible<const _Up1&, _FirstType<_DependentTp...> > >, // explicit check _Not<is_convertible<_Ref<_Up1>, _FirstType<_DependentTp...> > >, // explicit check
_Not<is_convertible<const _Up2&, _SecondType<_DependentTp...> > > _Not<is_convertible<_Ref<_Up2>, _SecondType<_DependentTp...> > >
> { }; > { };
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) == 2>, _BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitCopyFromPair<_Up1, _Up2, _Tp...> _EnableImplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<_Up1&, _Up2&>>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(pair<_Up1, _Up2>& __p)
_NOEXCEPT_((_And<
is_nothrow_constructible<_FirstType<_Tp...>, _Up1&>,
is_nothrow_constructible<_SecondType<_Tp...>, _Up2&>
>::value))
: __base_(__p)
{ }
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<_Up1&, _Up2&>
>::value
, int> = 0>
tuple(pair<_Up1, _Up2>& __p) = delete;
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<_Up1&, _Up2&>>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(pair<_Up1, _Up2>& __p)
_NOEXCEPT_((_And<
is_nothrow_constructible<_FirstType<_Tp...>, _Up1&>,
is_nothrow_constructible<_SecondType<_Tp...>, _Up2&>
>::value))
: __base_(__p)
{ }
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<_Up1&, _Up2&>
>::value
, int> = 0>
explicit tuple(pair<_Up1, _Up2>& __p) = delete;
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<_Up1&, _Up2&>>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>& __p)
: __base_(allocator_arg_t(), __a, __p)
{ }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<_Up1&, _Up2&>
>::value
, int> = 0>
tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>& __p) = delete;
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<_Up1&, _Up2&>>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>& __p)
: __base_(allocator_arg_t(), __a, __p)
{ }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Lref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<_Up1&, _Up2&>
>::value
, int> = 0>
explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>& __p) = delete;
// tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<const _Up1&, const _Up2&>>
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(const pair<_Up1, _Up2>& __p) tuple(const pair<_Up1, _Up2>& __p)
_NOEXCEPT_((_And< _NOEXCEPT_((_And<
is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&>, is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&>,
is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&> is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&>
>::value)) >::value))
: __base_(__p) : __base_(__p)
{ } { }
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) == 2>, _BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitCopyFromPair<_Up1, _Up2, _Tp...> _EnableImplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<const _Up1&, const _Up2&>
>::value
, int> = 0>
tuple(const pair<_Up1, _Up2>& __p) = delete;
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<const _Up1&, const _Up2&>>
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(const pair<_Up1, _Up2>& __p) explicit tuple(const pair<_Up1, _Up2>& __p)
_NOEXCEPT_((_And< _NOEXCEPT_((_And<
is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&>, is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&>,
is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&> is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&>
>::value)) >::value))
: __base_(__p) : __base_(__p)
{ } { }
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<const _Up1&, const _Up2&>
>::value
, int> = 0>
explicit tuple(const pair<_Up1, _Up2>& __p) = delete;
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) == 2>, _BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitCopyFromPair<_Up1, _Up2, _Tp...> _EnableImplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<const _Up1&, const _Up2&>>
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p) tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
: __base_(allocator_arg_t(), __a, __p) : __base_(allocator_arg_t(), __a, __p)
{ } { }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) == 2>, _BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitCopyFromPair<_Up1, _Up2, _Tp...> _EnableImplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<const _Up1&, const _Up2&>
>::value
, int> = 0>
tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p) = delete;
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<const _Up1&, const _Up2&>>
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p) explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
: __base_(allocator_arg_t(), __a, __p) : __base_(allocator_arg_t(), __a, __p)
{ } { }
// tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants) template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
template <class _Up1, class _Up2, class ..._DependentTp> _And<
struct _EnableImplicitMoveFromPair : _And< _BoolConstant<sizeof...(_Tp) == 2>,
is_constructible<_FirstType<_DependentTp...>, _Up1>, _EnableExplicitConstructFromPair<_Clref, _Up1, _Up2, _Tp...>,
is_constructible<_SecondType<_DependentTp...>, _Up2>, _BindsReferenceToTemporary<const _Up1&, const _Up2&>
is_convertible<_Up1, _FirstType<_DependentTp...> >, // explicit check >::value
is_convertible<_Up2, _SecondType<_DependentTp...> > , int> = 0>
> { }; explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p) = delete;
template <class _Up1, class _Up2, class ..._DependentTp>
struct _EnableExplicitMoveFromPair : _And<
is_constructible<_FirstType<_DependentTp...>, _Up1>,
is_constructible<_SecondType<_DependentTp...>, _Up2>,
_Not<is_convertible<_Up1, _FirstType<_DependentTp...> > >, // explicit check
_Not<is_convertible<_Up2, _SecondType<_DependentTp...> > >
> { };
// tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants)
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) == 2>, _BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitMoveFromPair<_Up1, _Up2, _Tp...> _EnableImplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<_Up1&&, _Up2&&>>
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(pair<_Up1, _Up2>&& __p) tuple(pair<_Up1, _Up2>&& __p)
_NOEXCEPT_((_And< _NOEXCEPT_((_And<
is_nothrow_constructible<_FirstType<_Tp...>, _Up1>, is_nothrow_constructible<_FirstType<_Tp...>, _Up1&&>,
is_nothrow_constructible<_SecondType<_Tp...>, _Up2> is_nothrow_constructible<_SecondType<_Tp...>, _Up2&&>
>::value)) >::value))
: __base_(_VSTD::move(__p)) : __base_(_VSTD::move(__p))
{ } { }
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) == 2>, _BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitMoveFromPair<_Up1, _Up2, _Tp...> _EnableImplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<_Up1&&, _Up2&&>
>::value
, int> = 0>
tuple(pair<_Up1, _Up2>&&) = delete;
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<_Up1&&, _Up2&&>>
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(pair<_Up1, _Up2>&& __p) explicit tuple(pair<_Up1, _Up2>&& __p)
_NOEXCEPT_((_And< _NOEXCEPT_((_And<
is_nothrow_constructible<_FirstType<_Tp...>, _Up1>, is_nothrow_constructible<_FirstType<_Tp...>, _Up1&&>,
is_nothrow_constructible<_SecondType<_Tp...>, _Up2> is_nothrow_constructible<_SecondType<_Tp...>, _Up2&&>
>::value)) >::value))
: __base_(_VSTD::move(__p)) : __base_(_VSTD::move(__p))
{ } { }
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<_Up1&&, _Up2&&>
>::value
, int> = 0>
explicit tuple(pair<_Up1, _Up2>&&) = delete;
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) == 2>, _BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitMoveFromPair<_Up1, _Up2, _Tp...> _EnableImplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<_Up1&&, _Up2&&>>
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p) tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
: __base_(allocator_arg_t(), __a, _VSTD::move(__p)) : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
{ } { }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t< template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And< _And<
_BoolConstant<sizeof...(_Tp) == 2>, _BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitMoveFromPair<_Up1, _Up2, _Tp...> _EnableImplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<_Up1&&, _Up2&&>
>::value
, int> = 0>
tuple(allocator_arg_t, const _Alloc&, pair<_Up1, _Up2>&&) = delete;
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<_Up1&&, _Up2&&>>
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p) explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
: __base_(allocator_arg_t(), __a, _VSTD::move(__p)) : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
{ } { }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Rref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<_Up1&&, _Up2&&>
>::value
, int> = 0>
explicit tuple(allocator_arg_t, const _Alloc&, pair<_Up1, _Up2>&&) = delete;
// tuple(const pair<U1, U2>&&) constructors (including allocator_arg_t variants)
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<const _Up1&&, const _Up2&&>>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
tuple(const pair<_Up1, _Up2>&& __p)
_NOEXCEPT_((_And<
is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&&>,
is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&&>
>::value))
: __base_(_VSTD::move(__p))
{ }
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<const _Up1&&, const _Up2&&>
>::value
, int> = 0>
tuple(const pair<_Up1, _Up2>&&) = delete;
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<const _Up1&&, const _Up2&&>>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit tuple(const pair<_Up1, _Up2>&& __p)
_NOEXCEPT_((_And<
is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&&>,
is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&&>
>::value))
: __base_(_VSTD::move(__p))
{ }
template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<const _Up1&&, const _Up2&&>
>::value
, int> = 0>
explicit tuple(const pair<_Up1, _Up2>&&) = delete;
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<const _Up1&&, const _Up2&&>>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>&& __p)
: __base_(allocator_arg_t(), __a, _VSTD::move(__p))
{ }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableImplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<const _Up1&&, const _Up2&&>
>::value
, int> = 0>
tuple(allocator_arg_t, const _Alloc&, const pair<_Up1, _Up2>&&) = delete;
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
_Not<_BindsReferenceToTemporary<const _Up1&&, const _Up2&&>>
>::value
, int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>&& __p)
: __base_(allocator_arg_t(), __a, _VSTD::move(__p))
{ }
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_And<
_BoolConstant<sizeof...(_Tp) == 2>,
_EnableExplicitConstructFromPair<_Crref, _Up1, _Up2, _Tp...>,
_BindsReferenceToTemporary<const _Up1&&, const _Up2&&>
>::value
, int> = 0>
explicit tuple(allocator_arg_t, const _Alloc&, const pair<_Up1, _Up2>&&) = delete;
// [tuple.assign] // [tuple.assign]
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple) tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple)
_NOEXCEPT_((_And<is_nothrow_copy_assignable<_Tp>...>::value)) _NOEXCEPT_((_And<is_nothrow_copy_assignable<_Tp>...>::value))
{ {
_VSTD::__memberwise_copy_assign(*this, __tuple, _VSTD::__memberwise_copy_assign(*this, __tuple,
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
▲ Show 20 Lines • Show All 643 Lines • Show Last 20 Lines

libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp

Show All 38 Lines
}; };
template <class ...Args> template <class ...Args>
void F(typename CannotDeduce<std::tuple<Args...>>::type const&) {} void F(typename CannotDeduce<std::tuple<Args...>>::type const&) {}
int main(int, char**) { int main(int, char**) {
#if TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary) #if TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary)
// Test that we emit our diagnostic from the library.
// expected-error@tuple:* 8 {{"Attempted construction of reference element binds to a temporary whose lifetime has ended"}}
// Good news everybody! Clang now diagnoses this for us!
// expected-error@tuple:* 0+ {{reference member '__value_' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
{ {
F<int, const std::string&>(std::make_tuple(1, "abc")); // expected-note 1 {{requested here}} F<int, const std::string&>(std::make_tuple(1, "abc")); // expected-error-re {{conversion function from {{.*}} invokes a deleted function}}
} }
{ {
std::tuple<int, const std::string&> t(1, "a"); // expected-note 1 {{requested here}} std::tuple<int, const std::string&> t(1, "a"); // expected-error {{call to deleted constructor}}
} }
{ {
F<int, const std::string&>(std::tuple<int, const std::string&>(1, "abc")); // expected-note 1 {{requested here}} F<int, const std::string&>(std::tuple<int, const std::string&>(1, "abc")); // expected-error {{call to deleted constructor}}
} }
{ {
ConvertsTo<int&> ct; ConvertsTo<int&> ct;
std::tuple<const long&, int> t(ct, 42); // expected-note {{requested here}} std::tuple<const long&, int> t(ct, 42); // expected-error {{call to deleted constructor}}
} }
{ {
ConvertsTo<int> ct; ConvertsTo<int> ct;
std::tuple<int const&, void*> t(ct, nullptr); // expected-note {{requested here}} std::tuple<int const&, void*> t(ct, nullptr); // expected-error {{call to deleted constructor}}
} }
{ {
ConvertsTo<Derived> ct; ConvertsTo<Derived> ct;
std::tuple<Base const&, int> t(ct, 42); // expected-note {{requested here}} std::tuple<Base const&, int> t(ct, 42); // expected-error {{call to deleted constructor}}
} }
{ {
std::allocator<int> alloc; std::allocator<int> alloc;
std::tuple<std::string &&> t2("hello"); // expected-note {{requested here}} std::tuple<std::string &&> t2("hello"); // expected-error {{call to deleted constructor}}
std::tuple<std::string &&> t3(std::allocator_arg, alloc, "hello"); // expected-note {{requested here}} std::tuple<std::string &&> t3(std::allocator_arg, alloc, "hello"); // expected-error {{call to deleted constructor}}
} }
#else #else
#error force failure #error force failure
// expected-error@-1 {{force failure}} // expected-error@-1 {{force failure}}
#endif #endif
return 0; return 0;
} }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/binding_to_temporary.compile.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03
// Verify that various attempts to bind a reference to temporary fail in a
// trait-friendly manner
#include <tuple>
#include <type_traits>
#include <utility>
#include "test_macros.h"
constexpr bool expecting_deleted = TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary);
using std::tuple;
using std::pair;
struct ConvertsToInt { operator int() const; };
static_assert(std::is_constructible<tuple<int>, ConvertsToInt>::value, "!");
#define CHECK(X, tquals) \
static_assert(std::is_constructible<tuple<int const&>, X>::value == !expecting_deleted, "!"); \
static_assert(std::is_constructible<tuple<int const&, int>, X, X>::value == !expecting_deleted, "!"); \
static_assert(std::is_constructible<tuple<int const&, int>, X, int>::value == !expecting_deleted, "!"); \
static_assert(std::is_constructible<tuple<int>, tuple<X> tquals>::value, "!"); \
static_assert(std::is_constructible<tuple<int const&>, tuple<X> tquals>::value == !expecting_deleted, "!"); \
static_assert(std::is_constructible<tuple<int const&, int>, tuple<X, X> tquals>::value == !expecting_deleted, "!"); \
static_assert(std::is_constructible<tuple<int const&, int>, tuple<X, int> tquals>::value == !expecting_deleted, "!"); \
static_assert(std::is_constructible<tuple<int const&, int>, pair<X, X> tquals>::value == !expecting_deleted, "!"); \
static_assert(std::is_constructible<tuple<int const&, int>, pair<X, int> tquals>::value == !expecting_deleted, "!");
#define CHECK_ALL_TQUALS(X) CHECK(X, &) CHECK(X, const&) CHECK(X, &&) CHECK(X, const&&)
#define CHECK_ALL(X) CHECK_ALL_TQUALS(X&) CHECK_ALL_TQUALS(X const&) CHECK_ALL_TQUALS(X&&) CHECK_ALL_TQUALS(X const&&)
CHECK_ALL(ConvertsToInt);

libcxx/test/std/utilities/utility/pairs/pairs.pair/binding_to_temporary.compile.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03
// Verify that various attempts to bind a reference to temporary fail in a
// trait-friendly manner
#include <type_traits>
#include <utility>
#include "test_macros.h"
constexpr bool expecting_deleted = TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary);
using std::pair;
struct ConvertsToInt { operator int() const; };
static_assert(std::is_constructible<pair<int, int>, ConvertsToInt, ConvertsToInt>::value, "!");
#define CHECK(X, tquals) \
static_assert(std::is_constructible<pair<int const&, int>, X, X>::value == !expecting_deleted, "!"); \
static_assert(std::is_constructible<pair<int const&, int>, X, int>::value == !expecting_deleted, "!"); \
static_assert(std::is_constructible<pair<int const&, int>, pair<X, X> tquals>::value == !expecting_deleted, "!"); \
static_assert(std::is_constructible<pair<int const&, int>, pair<X, int> tquals>::value == !expecting_deleted, "!");
#define CHECK_ALL_TQUALS(X) CHECK(X, &) CHECK(X, const&) CHECK(X, &&) CHECK(X, const&&)
#define CHECK_ALL(X) CHECK_ALL_TQUALS(X&) CHECK_ALL_TQUALS(X const&) CHECK_ALL_TQUALS(X&&) CHECK_ALL_TQUALS(X const&&)
CHECK_ALL(ConvertsToInt);