29 #ifndef _GLIBCXX_TUPLE
30 #define _GLIBCXX_TUPLE 1
32 #pragma GCC system_header
34 #if __cplusplus < 201103L
40 #include <bits/uses_allocator.h>
42 namespace std _GLIBCXX_VISIBILITY(default)
44 _GLIBCXX_BEGIN_NAMESPACE_VERSION
51 template<std::
size_t _Idx,
typename _Head,
bool _IsEmptyNotFinal>
54 template<std::
size_t _Idx,
typename _Head>
55 struct _Head_base<_Idx, _Head, true>
58 constexpr _Head_base()
61 constexpr _Head_base(
const _Head& __h)
64 constexpr _Head_base(
const _Head_base&) =
default;
65 constexpr _Head_base(_Head_base&&) =
default;
67 template<
typename _UHead>
68 constexpr _Head_base(_UHead&& __h)
71 _Head_base(allocator_arg_t, __uses_alloc0)
74 template<
typename _Alloc>
75 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
76 : _Head(allocator_arg, *__a._M_a) { }
78 template<
typename _Alloc>
79 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
80 : _Head(*__a._M_a) { }
82 template<
typename _UHead>
83 _Head_base(__uses_alloc0, _UHead&& __uhead)
86 template<
typename _Alloc,
typename _UHead>
87 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
88 : _Head(allocator_arg, *__a._M_a,
std::
forward<_UHead>(__uhead)) { }
90 template<
typename _Alloc,
typename _UHead>
91 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
92 : _Head(
std::
forward<_UHead>(__uhead), *__a._M_a) { }
94 static constexpr _Head&
95 _M_head(_Head_base& __b) noexcept {
return __b; }
97 static constexpr
const _Head&
98 _M_head(
const _Head_base& __b) noexcept {
return __b; }
101 template<std::
size_t _Idx,
typename _Head>
102 struct _Head_base<_Idx, _Head, false>
104 constexpr _Head_base()
107 constexpr _Head_base(
const _Head& __h)
108 : _M_head_impl(__h) { }
110 constexpr _Head_base(
const _Head_base&) =
default;
111 constexpr _Head_base(_Head_base&&) =
default;
113 template<
typename _UHead>
114 constexpr _Head_base(_UHead&& __h)
117 _Head_base(allocator_arg_t, __uses_alloc0)
120 template<
typename _Alloc>
121 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
122 : _M_head_impl(allocator_arg, *__a._M_a) { }
124 template<
typename _Alloc>
125 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
126 : _M_head_impl(*__a._M_a) { }
128 template<
typename _UHead>
129 _Head_base(__uses_alloc0, _UHead&& __uhead)
130 : _M_head_impl(
std::
forward<_UHead>(__uhead)) { }
132 template<
typename _Alloc,
typename _UHead>
133 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
134 : _M_head_impl(allocator_arg, *__a._M_a,
std::
forward<_UHead>(__uhead))
137 template<
typename _Alloc,
typename _UHead>
138 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
139 : _M_head_impl(
std::
forward<_UHead>(__uhead), *__a._M_a) { }
141 static constexpr _Head&
142 _M_head(_Head_base& __b) noexcept {
return __b._M_head_impl; }
144 static constexpr
const _Head&
145 _M_head(
const _Head_base& __b) noexcept {
return __b._M_head_impl; }
158 template<std::size_t _Idx,
typename... _Elements>
161 template<
typename _Tp>
162 struct __is_empty_non_tuple :
is_empty<_Tp> { };
165 template<
typename _El0,
typename... _El>
169 template<
typename _Tp>
170 using __empty_not_final
171 =
typename conditional<__is_final(_Tp),
false_type,
172 __is_empty_non_tuple<_Tp>>::type;
179 template<std::size_t _Idx,
typename _Head,
typename... _Tail>
182 private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
184 template<std::size_t,
typename...>
friend class _Tuple_impl;
187 typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
189 static constexpr _Head&
190 _M_head(
_Tuple_impl& __t) noexcept {
return _Base::_M_head(__t); }
192 static constexpr
const _Head&
193 _M_head(
const _Tuple_impl& __t) noexcept {
return _Base::_M_head(__t); }
199 _M_tail(
const _Tuple_impl& __t) noexcept {
return __t; }
205 constexpr _Tuple_impl(
const _Head& __head,
const _Tail&... __tail)
208 template<
typename _UHead,
typename... _UTail,
typename =
typename
209 enable_if<
sizeof...(_Tail) ==
sizeof...(_UTail)>::type>
211 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
212 :
_Inherited(std::forward<_UTail>(__tail)...),
213 _Base(std::forward<_UHead>(__head)) { }
215 constexpr _Tuple_impl(
const _Tuple_impl&) =
default;
218 _Tuple_impl(_Tuple_impl&& __in)
219 noexcept(__and_<is_nothrow_move_constructible<_Head>,
220 is_nothrow_move_constructible<_Inherited>>::value)
222 _Base(std::forward<_Head>(_M_head(__in))) { }
224 template<
typename... _UElements>
229 template<
typename _UHead,
typename... _UTails>
233 _Base(std::forward<_UHead>
236 template<
typename _Alloc>
239 _Base(__tag, __use_alloc<_Head>(__a)) { }
241 template<
typename _Alloc>
243 const _Head& __head,
const _Tail&... __tail)
245 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
247 template<
typename _Alloc,
typename _UHead,
typename... _UTail,
248 typename =
typename enable_if<
sizeof...(_Tail)
249 ==
sizeof...(_UTail)>::type>
251 _UHead&& __head, _UTail&&... __tail)
252 :
_Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
253 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
254 std::forward<_UHead>(__head)) { }
256 template<
typename _Alloc>
258 const _Tuple_impl& __in)
260 _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
262 template<
typename _Alloc>
265 :
_Inherited(__tag, __a, std::move(_M_tail(__in))),
266 _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
267 std::forward<_Head>(_M_head(__in))) { }
269 template<
typename _Alloc,
typename... _UElements>
274 _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
277 template<
typename _Alloc,
typename _UHead,
typename... _UTails>
282 _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
287 operator=(
const _Tuple_impl& __in)
289 _M_head(*
this) = _M_head(__in);
290 _M_tail(*
this) = _M_tail(__in);
295 operator=(_Tuple_impl&& __in)
296 noexcept(__and_<is_nothrow_move_assignable<_Head>,
297 is_nothrow_move_assignable<_Inherited>>::value)
299 _M_head(*
this) = std::forward<_Head>(_M_head(__in));
300 _M_tail(*
this) = std::move(_M_tail(__in));
304 template<
typename... _UElements>
313 template<
typename _UHead,
typename... _UTails>
317 _M_head(*
this) = std::forward<_UHead>
319 _M_tail(*
this) = std::move
326 _M_swap(_Tuple_impl& __in)
327 noexcept(noexcept(swap(std::declval<_Head&>(),
328 std::declval<_Head&>()))
329 && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
332 swap(_M_head(*
this), _M_head(__in));
333 _Inherited::_M_swap(_M_tail(__in));
338 template<std::
size_t _Idx,
typename _Head>
340 :
private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
342 template<std::size_t,
typename...>
friend class _Tuple_impl;
344 typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
346 static constexpr _Head&
347 _M_head(
_Tuple_impl& __t) noexcept {
return _Base::_M_head(__t); }
349 static constexpr
const _Head&
350 _M_head(
const _Tuple_impl& __t) noexcept {
return _Base::_M_head(__t); }
352 constexpr _Tuple_impl()
356 constexpr _Tuple_impl(
const _Head& __head)
359 template<
typename _UHead>
361 constexpr _Tuple_impl(_UHead&& __head)
364 constexpr _Tuple_impl(
const _Tuple_impl&) =
default;
367 _Tuple_impl(_Tuple_impl&& __in)
368 noexcept(is_nothrow_move_constructible<_Head>::value)
369 : _Base(
std::
forward<_Head>(_M_head(__in))) { }
371 template<
typename _UHead>
372 constexpr _Tuple_impl(
const _Tuple_impl<_Idx, _UHead>& __in)
373 : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
375 template<
typename _UHead>
376 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
377 : _Base(
std::
forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
380 template<
typename _Alloc>
381 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a)
382 : _Base(__tag, __use_alloc<_Head>(__a)) { }
384 template<
typename _Alloc>
385 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
387 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
389 template<
typename _Alloc,
typename _UHead>
390 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
392 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
395 template<
typename _Alloc>
396 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
397 const _Tuple_impl& __in)
398 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
400 template<
typename _Alloc>
401 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
403 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
406 template<
typename _Alloc,
typename _UHead>
407 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
408 const _Tuple_impl<_Idx, _UHead>& __in)
409 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
410 _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
412 template<
typename _Alloc,
typename _UHead>
413 _Tuple_impl(allocator_arg_t __tag,
const _Alloc& __a,
414 _Tuple_impl<_Idx, _UHead>&& __in)
415 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
416 std::
forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
420 operator=(
const _Tuple_impl& __in)
422 _M_head(*
this) = _M_head(__in);
427 operator=(_Tuple_impl&& __in)
428 noexcept(is_nothrow_move_assignable<_Head>::value)
430 _M_head(*
this) = std::forward<_Head>(_M_head(__in));
434 template<
typename _UHead>
436 operator=(
const _Tuple_impl<_Idx, _UHead>& __in)
438 _M_head(*
this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
442 template<
typename _UHead>
444 operator=(_Tuple_impl<_Idx, _UHead>&& __in)
447 = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
453 _M_swap(_Tuple_impl& __in)
454 noexcept(noexcept(swap(std::declval<_Head&>(), std::declval<_Head&>())))
457 swap(_M_head(*
this), _M_head(__in));
462 template<
typename... _Elements>
472 constexpr tuple(
const _Elements&... __elements)
475 template<
typename... _UElements,
typename =
typename
476 enable_if<__and_<is_convertible<_UElements,
477 _Elements>...>::value>::type>
479 constexpr tuple(_UElements&&... __elements)
480 :
_Inherited(std::forward<_UElements>(__elements)...) { }
482 constexpr tuple(
const tuple&) =
default;
484 constexpr tuple(tuple&&) =
default;
486 template<
typename... _UElements,
typename =
typename
487 enable_if<__and_<is_convertible<
const _UElements&,
488 _Elements>...>::value>::type>
490 :
_Inherited(
static_cast<const _Tuple_impl<0, _UElements...
>&>(__in))
493 template<
typename... _UElements,
typename =
typename
494 enable_if<__and_<is_convertible<_UElements,
495 _Elements>...>::value>::type>
497 :
_Inherited(
static_cast<_Tuple_impl<0, _UElements...
>&&>(__in)) { }
501 template<
typename _Alloc>
505 template<
typename _Alloc>
507 const _Elements&... __elements)
510 template<
typename _Alloc,
typename... _UElements,
typename =
typename
511 enable_if<
sizeof...(_UElements)
512 ==
sizeof...(_Elements)>::type>
514 _UElements&&... __elements)
515 :
_Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
518 template<
typename _Alloc>
520 :
_Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
522 template<
typename _Alloc>
524 :
_Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
526 template<
typename _Alloc,
typename... _UElements,
typename =
typename
527 enable_if<
sizeof...(_UElements)
528 ==
sizeof...(_Elements)>::type>
532 static_cast<const _Tuple_impl<0, _UElements...
>&>(__in))
535 template<
typename _Alloc,
typename... _UElements,
typename =
typename
536 enable_if<
sizeof...(_UElements)
537 ==
sizeof...(_Elements)>::type>
541 static_cast<_Tuple_impl<0, _UElements...
>&&>(__in))
545 operator=(
const tuple& __in)
552 operator=(tuple&& __in)
553 noexcept(is_nothrow_move_assignable<_Inherited>::value)
555 static_cast<_Inherited&
>(*this) = std::move(__in);
559 template<
typename... _UElements,
typename =
typename
560 enable_if<
sizeof...(_UElements)
561 ==
sizeof...(_Elements)>::type>
569 template<
typename... _UElements,
typename =
typename
570 enable_if<
sizeof...(_UElements)
571 ==
sizeof...(_Elements)>::type>
575 static_cast<_Inherited&
>(*this) = std::move(__in);
581 noexcept(noexcept(__in._M_swap(__in)))
582 { _Inherited::_M_swap(__in); }
590 void swap(
tuple&) noexcept { }
595 template<
typename _T1,
typename _T2>
605 constexpr tuple(
const _T1& __a1,
const _T2& __a2)
606 : _Inherited(__a1, __a2) { }
608 template<
typename _U1,
typename _U2,
typename =
typename
609 enable_if<__and_<is_convertible<_U1, _T1>,
610 is_convertible<_U2, _T2>>::value>::type>
612 constexpr tuple(_U1&& __a1, _U2&& __a2)
613 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
615 constexpr tuple(
const tuple&) =
default;
617 constexpr tuple(tuple&&) =
default;
619 template<
typename _U1,
typename _U2,
typename =
typename
620 enable_if<__and_<is_convertible<const _U1&, _T1>,
621 is_convertible<const _U2&, _T2>>::value>::type>
625 template<
typename _U1,
typename _U2,
typename =
typename
626 enable_if<__and_<is_convertible<_U1, _T1>,
627 is_convertible<_U2, _T2>>::value>::type>
631 template<
typename _U1,
typename _U2,
typename =
typename
632 enable_if<__and_<is_convertible<const _U1&, _T1>,
633 is_convertible<const _U2&, _T2>>::value>::type>
637 template<
typename _U1,
typename _U2,
typename =
typename
638 enable_if<__and_<is_convertible<_U1, _T1>,
639 is_convertible<_U2, _T2>>::value>::type>
641 : _Inherited(std::forward<_U1>(__in.
first),
642 std::forward<_U2>(__in.
second)) { }
646 template<
typename _Alloc>
648 : _Inherited(__tag, __a) { }
650 template<
typename _Alloc>
652 const _T1& __a1,
const _T2& __a2)
653 : _Inherited(__tag, __a, __a1, __a2) { }
655 template<
typename _Alloc,
typename _U1,
typename _U2>
656 tuple(
allocator_arg_t __tag,
const _Alloc& __a, _U1&& __a1, _U2&& __a2)
657 : _Inherited(__tag, __a, std::forward<_U1>(__a1),
658 std::forward<_U2>(__a2)) { }
660 template<
typename _Alloc>
662 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
664 template<
typename _Alloc>
666 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
668 template<
typename _Alloc,
typename _U1,
typename _U2>
671 : _Inherited(__tag, __a,
675 template<
typename _Alloc,
typename _U1,
typename _U2>
680 template<
typename _Alloc,
typename _U1,
typename _U2>
683 : _Inherited(__tag, __a, __in.
first, __in.
second) { }
685 template<
typename _Alloc,
typename _U1,
typename _U2>
687 : _Inherited(__tag, __a, std::forward<_U1>(__in.
first),
688 std::forward<_U2>(__in.
second)) { }
691 operator=(
const tuple& __in)
693 static_cast<_Inherited&
>(*this) = __in;
698 operator=(tuple&& __in)
699 noexcept(is_nothrow_move_assignable<_Inherited>::value)
701 static_cast<_Inherited&
>(*this) = std::move(__in);
705 template<
typename _U1,
typename _U2>
709 static_cast<_Inherited&
>(*this) = __in;
713 template<
typename _U1,
typename _U2>
717 static_cast<_Inherited&
>(*this) = std::move(__in);
721 template<
typename _U1,
typename _U2>
725 this->_M_head(*
this) = __in.
first;
726 this->_M_tail(*this)._M_head(*
this) = __in.
second;
730 template<
typename _U1,
typename _U2>
734 this->_M_head(*
this) = std::forward<_U1>(__in.
first);
735 this->_M_tail(*this)._M_head(*
this) = std::forward<_U2>(__in.
second);
741 noexcept(noexcept(__in._M_swap(__in)))
742 { _Inherited::_M_swap(__in); }
747 template<std::
size_t __i,
typename _Tp>
754 template<std::size_t __i,
typename _Head,
typename... _Tail>
761 template<
typename _Head,
typename... _Tail>
768 template<std::
size_t __i,
typename _Tp>
771 template<std::
size_t __i,
typename _Tp>
774 typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
777 template<std::
size_t __i,
typename _Tp>
778 struct tuple_element<__i, volatile _Tp>
780 typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
783 template<std::
size_t __i,
typename _Tp>
784 struct tuple_element<__i, const volatile _Tp>
786 typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
789 #if __cplusplus > 201103L
790 #define __cpp_lib_tuple_element_t 201402
792 template<std::
size_t __i,
typename _Tp>
793 using tuple_element_t =
typename tuple_element<__i, _Tp>::type;
797 template<
typename _Tp>
802 template<
typename _Tp>
803 struct tuple_size<const _Tp>
804 : integral_constant<size_t, tuple_size<_Tp>::value> { };
806 template<
typename _Tp>
807 struct tuple_size<volatile _Tp>
808 : integral_constant<size_t, tuple_size<_Tp>::value> { };
810 template<
typename _Tp>
811 struct tuple_size<const volatile _Tp>
812 : integral_constant<size_t, tuple_size<_Tp>::value> { };
815 template<
typename... _Elements>
819 template<std::size_t __i,
typename _Head,
typename... _Tail>
824 template<std::size_t __i,
typename _Head,
typename... _Tail>
825 constexpr
const _Head&
826 __get_helper(
const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
827 {
return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
830 template<std::size_t __i,
typename... _Elements>
831 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
832 get(
tuple<_Elements...>& __t) noexcept
833 {
return std::__get_helper<__i>(__t); }
836 template<std::size_t __i,
typename... _Elements>
837 constexpr
const __tuple_element_t<__i, tuple<_Elements...>>&
838 get(
const tuple<_Elements...>& __t) noexcept
839 {
return std::__get_helper<__i>(__t); }
842 template<std::size_t __i,
typename... _Elements>
843 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
844 get(
tuple<_Elements...>&& __t) noexcept
846 typedef __tuple_element_t<__i,
tuple<_Elements...>> __element_type;
847 return std::forward<__element_type&&>(std::get<__i>(__t));
850 #if __cplusplus > 201103L
852 #define __cpp_lib_tuples_by_type 201304
854 template<
typename _Head,
size_t __i,
typename... _Tail>
856 __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
857 {
return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
859 template<
typename _Head,
size_t __i,
typename... _Tail>
860 constexpr
const _Head&
861 __get_helper2(
const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
862 {
return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
865 template <
typename _Tp,
typename... _Types>
868 {
return std::__get_helper2<_Tp>(__t); }
871 template <
typename _Tp,
typename... _Types>
873 get(
tuple<_Types...>&& __t) noexcept
874 {
return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
877 template <
typename _Tp,
typename... _Types>
879 get(
const tuple<_Types...>& __t) noexcept
880 {
return std::__get_helper2<_Tp>(__t); }
884 template<
typename _Tp,
typename _Up,
size_t __i,
size_t __size>
885 struct __tuple_compare
887 static constexpr
bool
888 __eq(
const _Tp& __t,
const _Up& __u)
890 return bool(std::get<__i>(__t) == std::get<__i>(__u))
891 && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
894 static constexpr
bool
895 __less(
const _Tp& __t,
const _Up& __u)
897 return bool(std::get<__i>(__t) < std::get<__i>(__u))
898 || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
899 && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
903 template<
typename _Tp,
typename _Up,
size_t __size>
904 struct __tuple_compare<_Tp, _Up, __size, __size>
906 static constexpr
bool
907 __eq(
const _Tp&,
const _Up&) {
return true; }
909 static constexpr
bool
910 __less(
const _Tp&,
const _Up&) {
return false; }
913 template<
typename... _TElements,
typename... _UElements>
915 operator==(
const tuple<_TElements...>& __t,
916 const tuple<_UElements...>& __u)
918 static_assert(
sizeof...(_TElements) ==
sizeof...(_UElements),
919 "tuple objects can only be compared if they have equal sizes.");
920 using __compare = __tuple_compare<tuple<_TElements...>,
921 tuple<_UElements...>,
922 0,
sizeof...(_TElements)>;
923 return __compare::__eq(__t, __u);
926 template<
typename... _TElements,
typename... _UElements>
928 operator<(
const tuple<_TElements...>& __t,
929 const tuple<_UElements...>& __u)
931 static_assert(
sizeof...(_TElements) ==
sizeof...(_UElements),
932 "tuple objects can only be compared if they have equal sizes.");
933 using __compare = __tuple_compare<tuple<_TElements...>,
934 tuple<_UElements...>,
935 0,
sizeof...(_TElements)>;
936 return __compare::__less(__t, __u);
939 template<
typename... _TElements,
typename... _UElements>
941 operator!=(
const tuple<_TElements...>& __t,
942 const tuple<_UElements...>& __u)
943 {
return !(__t == __u); }
945 template<
typename... _TElements,
typename... _UElements>
947 operator>(
const tuple<_TElements...>& __t,
948 const tuple<_UElements...>& __u)
949 {
return __u < __t; }
951 template<
typename... _TElements,
typename... _UElements>
953 operator<=(
const tuple<_TElements...>& __t,
954 const tuple<_UElements...>& __u)
955 {
return !(__u < __t); }
957 template<
typename... _TElements,
typename... _UElements>
959 operator>=(
const tuple<_TElements...>& __t,
960 const tuple<_UElements...>& __u)
961 {
return !(__t < __u); }
964 template<
typename... _Elements>
965 constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
966 make_tuple(_Elements&&... __args)
968 typedef tuple<typename __decay_and_strip<_Elements>::__type...>
970 return __result_type(std::forward<_Elements>(__args)...);
973 template<
typename... _Elements>
974 tuple<_Elements&&...>
975 forward_as_tuple(_Elements&&... __args) noexcept
976 {
return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
979 struct __is_tuple_like_impl : false_type
982 template<
typename... _Tps>
983 struct __is_tuple_like_impl<tuple<_Tps...>> :
true_type
986 template<
typename _T1,
typename _T2>
987 struct __is_tuple_like_impl<pair<_T1, _T2>> :
true_type
990 template<
typename _Tp, std::
size_t _Nm>
991 struct __is_tuple_like_impl<array<_Tp, _Nm>> :
true_type
995 template<
typename _Tp>
996 struct __is_tuple_like
997 :
public __is_tuple_like_impl<typename std::remove_cv
998 <typename std::remove_reference<_Tp>::type>::type>::type
1001 template<
size_t,
typename,
typename,
size_t>
1002 struct __make_tuple_impl;
1004 template<
size_t _Idx,
typename _Tuple,
typename... _Tp,
size_t _Nm>
1005 struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
1006 : __make_tuple_impl<_Idx + 1,
1007 tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
1011 template<std::size_t _Nm,
typename _Tuple,
typename... _Tp>
1012 struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
1014 typedef tuple<_Tp...> __type;
1017 template<
typename _Tuple>
1018 struct __do_make_tuple
1019 : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
1023 template<
typename _Tuple>
1025 :
public __do_make_tuple<typename std::remove_cv
1026 <typename std::remove_reference<_Tuple>::type>::type>
1030 template<
typename...>
1031 struct __combine_tuples;
1034 struct __combine_tuples<>
1036 typedef tuple<> __type;
1039 template<
typename... _Ts>
1040 struct __combine_tuples<tuple<_Ts...>>
1042 typedef tuple<_Ts...> __type;
1045 template<
typename... _T1s,
typename... _T2s,
typename... _Rem>
1046 struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
1048 typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
1049 _Rem...>::__type __type;
1053 template<
typename... _Tpls>
1054 struct __tuple_cat_result
1056 typedef typename __combine_tuples
1057 <
typename __make_tuple<_Tpls>::__type...>::__type __type;
1062 template<
typename...>
1063 struct __make_1st_indices;
1066 struct __make_1st_indices<>
1068 typedef std::_Index_tuple<> __type;
1071 template<
typename _Tp,
typename... _Tpls>
1072 struct __make_1st_indices<_Tp, _Tpls...>
1075 typename std::remove_reference<_Tp>::type>::value>::__type __type;
1081 template<
typename _Ret,
typename _Indices,
typename... _Tpls>
1082 struct __tuple_concater;
1084 template<
typename _Ret, std::size_t... _Is,
typename _Tp,
typename... _Tpls>
1085 struct __tuple_concater<_Ret,
std::_Index_tuple<_Is...>, _Tp, _Tpls...>
1087 template<
typename... _Us>
1088 static constexpr _Ret
1089 _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
1091 typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1092 typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
1093 return __next::_S_do(std::forward<_Tpls>(__tps)...,
1094 std::forward<_Us>(__us)...,
1095 std::get<_Is>(std::forward<_Tp>(__tp))...);
1099 template<
typename _Ret>
1100 struct __tuple_concater<_Ret,
std::_Index_tuple<>>
1102 template<
typename... _Us>
1103 static constexpr _Ret
1104 _S_do(_Us&&... __us)
1106 return _Ret(std::forward<_Us>(__us)...);
1111 template<
typename... _Tpls,
typename =
typename
1112 enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
1115 ->
typename __tuple_cat_result<_Tpls...>::__type
1117 typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
1118 typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1119 typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
1120 return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
1124 template<
typename... _Elements>
1125 inline tuple<_Elements&...>
1126 tie(_Elements&... __args) noexcept
1127 {
return tuple<_Elements&...>(__args...); }
1130 template<
typename... _Elements>
1133 noexcept(noexcept(__x.swap(__y)))
1138 struct _Swallow_assign
1141 const _Swallow_assign&
1142 operator=(
const _Tp&)
const
1146 const _Swallow_assign ignore{};
1149 template<
typename... _Types,
typename _Alloc>
1153 template<
class _T1,
class _T2>
1154 template<
typename... _Args1,
typename... _Args2>
1159 :
pair(__first, __second,
1160 typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
1161 typename _Build_index_tuple<sizeof...(_Args2)>::__type())
1164 template<
class _T1,
class _T2>
1165 template<
typename... _Args1, std::size_t... _Indexes1,
1166 typename... _Args2, std::size_t... _Indexes2>
1169 pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
1170 _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
1171 : first(
std::
forward<_Args1>(
std::get<_Indexes1>(__tuple1))...),
1172 second(
std::
forward<_Args2>(
std::get<_Indexes2>(__tuple2))...)
1177 _GLIBCXX_END_NAMESPACE_VERSION
1182 #endif // _GLIBCXX_TUPLE
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
_T1 first
second_type is the second bound type
Declare uses_allocator so it can be specialized in etc.
integral_constant< bool, false > false_type
The type used as a compile-time boolean with false value.
Primary class template, tuple.
ISO C++ entities toplevel namespace is std.
constexpr auto tuple_cat(_Tpls &&...__tpls) -> typename __tuple_cat_result< _Tpls...>::__type
tuple_cat
tuple< _Elements &...> tie(_Elements &...__args) noexcept
tie
Struct holding two objects of arbitrary type.
constexpr pair()
second is a copy of the second object
integral_constant< bool, true > true_type
The type used as a compile-time boolean with true value.
_T2 second
first is a copy of the first object