// -*- C++ -*- //===--------------------------- tuple ------------------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_TUPLE #define _LIBCPP_TUPLE /* tuple synopsis namespace std { template class tuple { public: constexpr tuple(); explicit tuple(const T&...); template explicit tuple(U&&...); tuple(const tuple&) = default; tuple(tuple&&) = default; template tuple(const tuple&); template tuple(tuple&&); template tuple(const pair&); // iff sizeof...(T) == 2 template tuple(pair&&); // iff sizeof...(T) == 2 // allocator-extended constructors template tuple(allocator_arg_t, const Alloc& a); template tuple(allocator_arg_t, const Alloc& a, const T&...); template tuple(allocator_arg_t, const Alloc& a, U&&...); template tuple(allocator_arg_t, const Alloc& a, const tuple&); template tuple(allocator_arg_t, const Alloc& a, tuple&&); template tuple(allocator_arg_t, const Alloc& a, const tuple&); template tuple(allocator_arg_t, const Alloc& a, tuple&&); template tuple(allocator_arg_t, const Alloc& a, const pair&); template tuple(allocator_arg_t, const Alloc& a, pair&&); tuple& operator=(const tuple&); tuple& operator=(tuple&&) noexcept(AND(is_nothrow_move_assignable::value ...)); template tuple& operator=(const tuple&); template tuple& operator=(tuple&&); template tuple& operator=(const pair&); // iff sizeof...(T) == 2 template tuple& operator=(pair&&); //iffsizeof...(T) == 2 void swap(tuple&) noexcept(AND(swap(declval(), declval())...)); }; const unspecified ignore; template tuple make_tuple(T&&...); template tuple forward_as_tuple(T&&...) noexcept; template tuple tie(T&...) noexcept; template tuple tuple_cat(Tuples&&... tpls); // 20.4.1.4, tuple helper classes: template class tuple_size; // undefined template class tuple_size>; template class tuple_element; // undefined template class tuple_element>; // 20.4.1.5, element access: template typename tuple_element>::type& get(tuple&) noexcept; template typename tuple_element>::type const& get(const tuple&) noexcept; template typename tuple_element>::type&& get(tuple&&) noexcept; // 20.4.1.6, relational operators: template bool operator==(const tuple&, const tuple&); template bool operator<(const tuple&, const tuple&); template bool operator!=(const tuple&, const tuple&); template bool operator>(const tuple&, const tuple&); template bool operator<=(const tuple&, const tuple&); template bool operator>=(const tuple&, const tuple&); template struct uses_allocator, Alloc>; template void swap(tuple& x, tuple& y) noexcept(noexcept(x.swap(y))); } // std */ #include <__config> #include <__tuple> #include #include #include <__functional_base> #include #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif _LIBCPP_BEGIN_NAMESPACE_STD // allocator_arg_t struct _LIBCPP_VISIBLE allocator_arg_t { }; extern const allocator_arg_t allocator_arg; // uses_allocator template struct __has_allocator_type { private: struct __two {char _; char __;}; template static __two __test(...); template static char __test(typename _Up::allocator_type* = 0); public: static const bool value = sizeof(__test<_Tp>(0)) == 1; }; template ::value> struct __uses_allocator : public integral_constant::value> { }; template struct __uses_allocator<_Tp, _Alloc, false> : public false_type { }; template struct _LIBCPP_VISIBLE uses_allocator : public __uses_allocator<_Tp, _Alloc> { }; #ifndef _LIBCPP_HAS_NO_VARIADICS // uses-allocator construction template struct __uses_alloc_ctor_imp { static const bool __ua = uses_allocator<_Tp, _Alloc>::value; static const bool __ic = is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value; static const int value = __ua ? 2 - __ic : 0; }; template struct __uses_alloc_ctor : integral_constant::value> {}; #endif // _LIBCPP_HAS_NO_VARIADICS #ifndef _LIBCPP_HAS_NO_VARIADICS // tuple_size template class _LIBCPP_VISIBLE tuple_size > : public integral_constant { }; // tuple_element template class _LIBCPP_VISIBLE tuple_element<_Ip, tuple<_Tp...> > { public: typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type; }; // __tuple_leaf template ::value #if __has_feature(is_final) && !__is_final(_Hp) #endif > class __tuple_leaf; template inline _LIBCPP_INLINE_VISIBILITY void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y) _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value) { swap(__x.get(), __y.get()); } template class __tuple_leaf { _Hp value; __tuple_leaf& operator=(const __tuple_leaf&); public: _LIBCPP_INLINE_VISIBILITY __tuple_leaf() : value() {static_assert(!is_reference<_Hp>::value, "Attempted to default construct a reference element in a tuple");} template _LIBCPP_INLINE_VISIBILITY __tuple_leaf(integral_constant, const _Alloc&) : value() {static_assert(!is_reference<_Hp>::value, "Attempted to default construct a reference element in a tuple");} template _LIBCPP_INLINE_VISIBILITY __tuple_leaf(integral_constant, const _Alloc& __a) : value(allocator_arg_t(), __a) {static_assert(!is_reference<_Hp>::value, "Attempted to default construct a reference element in a tuple");} template _LIBCPP_INLINE_VISIBILITY __tuple_leaf(integral_constant, const _Alloc& __a) : value(__a) {static_assert(!is_reference<_Hp>::value, "Attempted to default construct a reference element in a tuple");} template ::value>::type> _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(_Tp&& __t) : value(_VSTD::forward<_Tp>(__t)) {static_assert(!is_reference<_Hp>::value || (is_lvalue_reference<_Hp>::value && (is_lvalue_reference<_Tp>::value || is_same::type, reference_wrapper< typename remove_reference<_Hp>::type > >::value)) || (is_rvalue_reference<_Hp>::value && !is_lvalue_reference<_Tp>::value), "Attempted to construct a reference element in a tuple with an rvalue");} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(integral_constant, const _Alloc&, _Tp&& __t) : value(_VSTD::forward<_Tp>(__t)) {static_assert(!is_lvalue_reference<_Hp>::value || (is_lvalue_reference<_Hp>::value && (is_lvalue_reference<_Tp>::value || is_same::type, reference_wrapper< typename remove_reference<_Hp>::type > >::value)), "Attempted to construct a reference element in a tuple with an rvalue");} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(integral_constant, const _Alloc& __a, _Tp&& __t) : value(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {static_assert(!is_lvalue_reference<_Hp>::value || (is_lvalue_reference<_Hp>::value && (is_lvalue_reference<_Tp>::value || is_same::type, reference_wrapper< typename remove_reference<_Hp>::type > >::value)), "Attempted to construct a reference element in a tuple with an rvalue");} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(integral_constant, const _Alloc& __a, _Tp&& __t) : value(_VSTD::forward<_Tp>(__t), __a) {static_assert(!is_lvalue_reference<_Hp>::value || (is_lvalue_reference<_Hp>::value && (is_lvalue_reference<_Tp>::value || is_same::type, reference_wrapper< typename remove_reference<_Hp>::type > >::value)), "Attempted to construct a reference element in a tuple with an rvalue");} __tuple_leaf(const __tuple_leaf& __t) : value(__t.get()) {static_assert(!is_rvalue_reference<_Hp>::value, "Can not copy a tuple with rvalue reference member");} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t) : value(__t.get()) {} template _LIBCPP_INLINE_VISIBILITY __tuple_leaf& operator=(_Tp&& __t) { value = _VSTD::forward<_Tp>(__t); return *this; } _LIBCPP_INLINE_VISIBILITY int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value) { _VSTD::swap(*this, __t); return 0; } _LIBCPP_INLINE_VISIBILITY _Hp& get() {return value;} _LIBCPP_INLINE_VISIBILITY const _Hp& get() const {return value;} }; template class __tuple_leaf<_Ip, _Hp, true> : private _Hp { __tuple_leaf& operator=(const __tuple_leaf&); public: _LIBCPP_INLINE_VISIBILITY __tuple_leaf() {} template _LIBCPP_INLINE_VISIBILITY __tuple_leaf(integral_constant, const _Alloc&) {} template _LIBCPP_INLINE_VISIBILITY __tuple_leaf(integral_constant, const _Alloc& __a) : _Hp(allocator_arg_t(), __a) {} template _LIBCPP_INLINE_VISIBILITY __tuple_leaf(integral_constant, const _Alloc& __a) : _Hp(__a) {} template ::value>::type> _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(_Tp&& __t) : _Hp(_VSTD::forward<_Tp>(__t)) {} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(integral_constant, const _Alloc&, _Tp&& __t) : _Hp(_VSTD::forward<_Tp>(__t)) {} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(integral_constant, const _Alloc& __a, _Tp&& __t) : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(integral_constant, const _Alloc& __a, _Tp&& __t) : _Hp(_VSTD::forward<_Tp>(__t), __a) {} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(const __tuple_leaf<_Ip, _Tp>& __t) : _Hp(__t.get()) {} template _LIBCPP_INLINE_VISIBILITY __tuple_leaf& operator=(_Tp&& __t) { _Hp::operator=(_VSTD::forward<_Tp>(__t)); return *this; } _LIBCPP_INLINE_VISIBILITY int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value) { _VSTD::swap(*this, __t); return 0; } _LIBCPP_INLINE_VISIBILITY _Hp& get() {return static_cast<_Hp&>(*this);} _LIBCPP_INLINE_VISIBILITY const _Hp& get() const {return static_cast(*this);} }; template _LIBCPP_INLINE_VISIBILITY void __swallow(_Tp&&...) {} template struct __all; template <> struct __all<> { static const bool value = true; }; template struct __all<_B0, _Bp...> { static const bool value = _B0 && __all<_Bp...>::value; }; // __tuple_impl template struct __tuple_impl; template struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...> : public __tuple_leaf<_Indx, _Tp>... { template _LIBCPP_INLINE_VISIBILITY explicit __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>, __tuple_indices<_Ul...>, __tuple_types<_Tl...>, _Up&&... __u) : __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))..., __tuple_leaf<_Ul, _Tl>()... {} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_impl(allocator_arg_t, const _Alloc& __a, __tuple_indices<_Uf...>, __tuple_types<_Tf...>, __tuple_indices<_Ul...>, __tuple_types<_Tl...>, _Up&&... __u) : __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a, _VSTD::forward<_Up>(__u))..., __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)... {} template >::value >::type > _LIBCPP_INLINE_VISIBILITY __tuple_impl(_Tuple&& __t) : __tuple_leaf<_Indx, _Tp>(_VSTD::forward::type>::type>(_VSTD::get<_Indx>(__t)))... {} template >::value >::type > _LIBCPP_INLINE_VISIBILITY __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t) : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx, typename __make_tuple_types<_Tuple>::type>::type>(), __a, _VSTD::forward::type>::type>(_VSTD::get<_Indx>(__t)))... {} template _LIBCPP_INLINE_VISIBILITY typename enable_if < __tuple_assignable<_Tuple, tuple<_Tp...> >::value, __tuple_impl& >::type operator=(_Tuple&& __t) { __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward::type>::type>(_VSTD::get<_Indx>(__t)))...); return *this; } _LIBCPP_INLINE_VISIBILITY void swap(__tuple_impl& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value) { __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...); } }; template class _LIBCPP_VISIBLE tuple { typedef __tuple_impl::type, _Tp...> base; base base_; template friend typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT; template friend const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT; template friend typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT; public: _LIBCPP_INLINE_VISIBILITY explicit tuple(const _Tp& ... __t) : base_(typename __make_tuple_indices::type(), typename __make_tuple_types::type(), typename __make_tuple_indices<0>::type(), typename __make_tuple_types::type(), __t... ) {} template _LIBCPP_INLINE_VISIBILITY tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t) : base_(allocator_arg_t(), __a, typename __make_tuple_indices::type(), typename __make_tuple_types::type(), typename __make_tuple_indices<0>::type(), typename __make_tuple_types::type(), __t... ) {} template , typename __make_tuple_types::type >::value >::type > _LIBCPP_INLINE_VISIBILITY explicit tuple(_Up&&... __u) : base_(typename __make_tuple_indices::type(), typename __make_tuple_types::type(), typename __make_tuple_indices::type(), typename __make_tuple_types::type(), _VSTD::forward<_Up>(__u)...) {} template , typename __make_tuple_types::type >::value >::type > _LIBCPP_INLINE_VISIBILITY tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u) : base_(allocator_arg_t(), __a, typename __make_tuple_indices::type(), typename __make_tuple_types::type(), typename __make_tuple_indices::type(), typename __make_tuple_types::type(), _VSTD::forward<_Up>(__u)...) {} template ::value >::type > _LIBCPP_INLINE_VISIBILITY tuple(_Tuple&& __t) : base_(_VSTD::forward<_Tuple>(__t)) {} template ::value >::type > _LIBCPP_INLINE_VISIBILITY tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t) : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {} template ::value >::type > _LIBCPP_INLINE_VISIBILITY tuple& operator=(_Tuple&& __t) { base_.operator=(_VSTD::forward<_Tuple>(__t)); return *this; } _LIBCPP_INLINE_VISIBILITY void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value) {base_.swap(__t.base_);} }; template <> class _LIBCPP_VISIBLE tuple<> { public: _LIBCPP_INLINE_VISIBILITY tuple() {} template _LIBCPP_INLINE_VISIBILITY tuple(allocator_arg_t, const _Alloc&) {} template _LIBCPP_INLINE_VISIBILITY tuple(allocator_arg_t, const _Alloc&, const tuple&) {} template _LIBCPP_INLINE_VISIBILITY tuple(array<_Up, 0>) {} template _LIBCPP_INLINE_VISIBILITY tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) {} _LIBCPP_INLINE_VISIBILITY void swap(tuple&) _NOEXCEPT {} }; template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __all<__is_swappable<_Tp>::value...>::value, void >::type swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value) {__t.swap(__u);} // get template inline _LIBCPP_INLINE_VISIBILITY typename tuple_element<_Ip, tuple<_Tp...> >::type& get(tuple<_Tp...>& __t) _NOEXCEPT { typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type; return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get(); } template inline _LIBCPP_INLINE_VISIBILITY const typename tuple_element<_Ip, tuple<_Tp...> >::type& get(const tuple<_Tp...>& __t) _NOEXCEPT { typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type; return static_cast&>(__t.base_).get(); } template inline _LIBCPP_INLINE_VISIBILITY typename tuple_element<_Ip, tuple<_Tp...> >::type&& get(tuple<_Tp...>&& __t) _NOEXCEPT { typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type; return static_cast( static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get()); } // tie template inline _LIBCPP_INLINE_VISIBILITY tuple<_Tp&...> tie(_Tp&... __t) { return tuple<_Tp&...>(__t...); } template struct __ignore_t { template _LIBCPP_INLINE_VISIBILITY const __ignore_t& operator=(_Tp&&) const {return *this;} }; namespace { const __ignore_t ignore = __ignore_t(); } template class reference_wrapper; template struct ___make_tuple_return { typedef _Tp type; }; template struct ___make_tuple_return > { typedef _Tp& type; }; template struct __make_tuple_return { typedef typename ___make_tuple_return::type>::type type; }; template inline _LIBCPP_INLINE_VISIBILITY tuple::type...> make_tuple(_Tp&&... __t) { return tuple::type...>(_VSTD::forward<_Tp>(__t)...); } template inline _LIBCPP_INLINE_VISIBILITY tuple<_Tp&&...> forward_as_tuple(_Tp&&... __t) { return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...); } template struct __tuple_equal { template _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Up& __y) { return __tuple_equal<_Ip - 1>()(__x, __y) && get<_Ip-1>(__x) == get<_Ip-1>(__y); } }; template <> struct __tuple_equal<0> { template _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp&, const _Up&) { return true; } }; template inline _LIBCPP_INLINE_VISIBILITY bool operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) { return __tuple_equal()(__x, __y); } template inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) { return !(__x == __y); } template struct __tuple_less { template _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Up& __y) { return __tuple_less<_Ip-1>()(__x, __y) || (!__tuple_less<_Ip-1>()(__y, __x) && get<_Ip-1>(__x) < get<_Ip-1>(__y)); } }; template <> struct __tuple_less<0> { template _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp&, const _Up&) { return false; } }; template inline _LIBCPP_INLINE_VISIBILITY bool operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) { return __tuple_less()(__x, __y); } template inline _LIBCPP_INLINE_VISIBILITY bool operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) { return __y < __x; } template inline _LIBCPP_INLINE_VISIBILITY bool operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) { return !(__x < __y); } template inline _LIBCPP_INLINE_VISIBILITY bool operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) { return !(__y < __x); } // tuple_cat template struct __tuple_cat_type; template struct __tuple_cat_type, __tuple_types<_Utypes...> > { typedef tuple<_Ttypes..., _Utypes...> type; }; template struct __tuple_cat_return_1 { }; template struct __tuple_cat_return_1, true, _Tuple0> { typedef typename __tuple_cat_type, typename __make_tuple_types::type>::type>::type type; }; template struct __tuple_cat_return_1, true, _Tuple0, _Tuple1, _Tuples...> : public __tuple_cat_return_1< typename __tuple_cat_type< tuple<_Types...>, typename __make_tuple_types::type>::type >::type, __tuple_like::type>::value, _Tuple1, _Tuples...> { }; template struct __tuple_cat_return; template struct __tuple_cat_return<_Tuple0, _Tuples...> : public __tuple_cat_return_1, __tuple_like::type>::value, _Tuple0, _Tuples...> { }; template <> struct __tuple_cat_return<> { typedef tuple<> type; }; inline _LIBCPP_INLINE_VISIBILITY tuple<> tuple_cat() { return tuple<>(); } template struct __tuple_cat_return_ref_imp; template struct __tuple_cat_return_ref_imp, __tuple_indices<_I0...>, _Tuple0> { typedef typename remove_reference<_Tuple0>::type _T0; typedef tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_I0, _T0>::type>::type&&...> type; }; template struct __tuple_cat_return_ref_imp, __tuple_indices<_I0...>, _Tuple0, _Tuple1, _Tuples...> : public __tuple_cat_return_ref_imp< tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_I0, typename remove_reference<_Tuple0>::type>::type>::type&&...>, typename __make_tuple_indices::type>::value>::type, _Tuple1, _Tuples...> { }; template struct __tuple_cat_return_ref : public __tuple_cat_return_ref_imp, typename __make_tuple_indices< tuple_size::type>::value >::type, _Tuple0, _Tuples...> { }; template struct __tuple_cat; template struct __tuple_cat, __tuple_indices<_I0...>, __tuple_indices<_J0...> > { template _LIBCPP_INLINE_VISIBILITY typename __tuple_cat_return_ref&&, _Tuple0&&>::type operator()(tuple<_Types...> __t, _Tuple0&& __t0) { return _VSTD::forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))..., get<_J0>(_VSTD::forward<_Tuple0>(__t0))...); } template _LIBCPP_INLINE_VISIBILITY typename __tuple_cat_return_ref&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls) { typedef typename remove_reference<_Tuple0>::type _T0; typedef typename remove_reference<_Tuple1>::type _T1; return __tuple_cat< tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>, typename __make_tuple_indices::value>::type, typename __make_tuple_indices::value>::type>() (_VSTD::forward_as_tuple( _VSTD::forward<_Types>(get<_I0>(__t))..., get<_J0>(_VSTD::forward<_Tuple0>(__t0))... ), _VSTD::forward<_Tuple1>(__t1), _VSTD::forward<_Tuples>(__tpls)...); } }; template inline _LIBCPP_INLINE_VISIBILITY typename __tuple_cat_return<_Tuple0, _Tuples...>::type tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls) { typedef typename remove_reference<_Tuple0>::type _T0; return __tuple_cat, __tuple_indices<>, typename __make_tuple_indices::value>::type>() (tuple<>(), _VSTD::forward<_Tuple0>(__t0), _VSTD::forward<_Tuples>(__tpls)...); } template struct _LIBCPP_VISIBLE uses_allocator, _Alloc> : true_type {}; template template inline _LIBCPP_INLINE_VISIBILITY pair<_T1, _T2>::pair(piecewise_construct_t, tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args, __tuple_indices<_I1...>, __tuple_indices<_I2...>) : first(_VSTD::forward<_Args1>(get<_I1>( __first_args))...), second(_VSTD::forward<_Args2>(get<_I2>(__second_args))...) { } #endif // _LIBCPP_HAS_NO_VARIADICS _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_TUPLE