Line data Source code
1 : // <tuple> -*- C++ -*-
2 :
3 : // Copyright (C) 2007-2017 Free Software Foundation, Inc.
4 : //
5 : // This file is part of the GNU ISO C++ Library. This library is free
6 : // software; you can redistribute it and/or modify it under the
7 : // terms of the GNU General Public License as published by the
8 : // Free Software Foundation; either version 3, or (at your option)
9 : // any later version.
10 :
11 : // This library is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 :
16 : // Under Section 7 of GPL version 3, you are granted additional
17 : // permissions described in the GCC Runtime Library Exception, version
18 : // 3.1, as published by the Free Software Foundation.
19 :
20 : // You should have received a copy of the GNU General Public License and
21 : // a copy of the GCC Runtime Library Exception along with this program;
22 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 : // <http://www.gnu.org/licenses/>.
24 :
25 : /** @file include/tuple
26 : * This is a Standard C++ Library header.
27 : */
28 :
29 : #ifndef _GLIBCXX_TUPLE
30 : #define _GLIBCXX_TUPLE 1
31 :
32 : #pragma GCC system_header
33 :
34 : #if __cplusplus < 201103L
35 : # include <bits/c++0x_warning.h>
36 : #else
37 :
38 : #include <utility>
39 : #include <array>
40 : #include <bits/uses_allocator.h>
41 : #include <bits/invoke.h>
42 :
43 : namespace std _GLIBCXX_VISIBILITY(default)
44 : {
45 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
46 :
47 : /**
48 : * @addtogroup utilities
49 : * @{
50 : */
51 :
52 : template<typename... _Elements>
53 : class tuple;
54 :
55 : template<typename _Tp>
56 : struct __is_empty_non_tuple : is_empty<_Tp> { };
57 :
58 : // Using EBO for elements that are tuples causes ambiguous base errors.
59 : template<typename _El0, typename... _El>
60 : struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
61 :
62 : // Use the Empty Base-class Optimization for empty, non-final types.
63 : template<typename _Tp>
64 : using __empty_not_final
65 : = typename conditional<__is_final(_Tp), false_type,
66 : __is_empty_non_tuple<_Tp>>::type;
67 :
68 : template<std::size_t _Idx, typename _Head,
69 : bool = __empty_not_final<_Head>::value>
70 : struct _Head_base;
71 :
72 : template<std::size_t _Idx, typename _Head>
73 : struct _Head_base<_Idx, _Head, true>
74 : : public _Head
75 : {
76 10 : constexpr _Head_base()
77 10 : : _Head() { }
78 :
79 : constexpr _Head_base(const _Head& __h)
80 : : _Head(__h) { }
81 :
82 : constexpr _Head_base(const _Head_base&) = default;
83 : constexpr _Head_base(_Head_base&&) = default;
84 :
85 : template<typename _UHead>
86 : constexpr _Head_base(_UHead&& __h)
87 : : _Head(std::forward<_UHead>(__h)) { }
88 :
89 : _Head_base(allocator_arg_t, __uses_alloc0)
90 : : _Head() { }
91 :
92 : template<typename _Alloc>
93 : _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
94 : : _Head(allocator_arg, *__a._M_a) { }
95 :
96 : template<typename _Alloc>
97 : _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
98 : : _Head(*__a._M_a) { }
99 :
100 : template<typename _UHead>
101 : _Head_base(__uses_alloc0, _UHead&& __uhead)
102 : : _Head(std::forward<_UHead>(__uhead)) { }
103 :
104 : template<typename _Alloc, typename _UHead>
105 : _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
106 : : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
107 :
108 : template<typename _Alloc, typename _UHead>
109 : _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
110 : : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
111 :
112 : static constexpr _Head&
113 10 : _M_head(_Head_base& __b) noexcept { return __b; }
114 :
115 : static constexpr const _Head&
116 : _M_head(const _Head_base& __b) noexcept { return __b; }
117 : };
118 :
119 : template<std::size_t _Idx, typename _Head>
120 : struct _Head_base<_Idx, _Head, false>
121 : {
122 10 : constexpr _Head_base()
123 10 : : _M_head_impl() { }
124 :
125 2388 : constexpr _Head_base(const _Head& __h)
126 2388 : : _M_head_impl(__h) { }
127 :
128 : constexpr _Head_base(const _Head_base&) = default;
129 : constexpr _Head_base(_Head_base&&) = default;
130 :
131 : template<typename _UHead>
132 : constexpr _Head_base(_UHead&& __h)
133 : : _M_head_impl(std::forward<_UHead>(__h)) { }
134 :
135 : _Head_base(allocator_arg_t, __uses_alloc0)
136 : : _M_head_impl() { }
137 :
138 : template<typename _Alloc>
139 : _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
140 : : _M_head_impl(allocator_arg, *__a._M_a) { }
141 :
142 : template<typename _Alloc>
143 : _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
144 : : _M_head_impl(*__a._M_a) { }
145 :
146 : template<typename _UHead>
147 : _Head_base(__uses_alloc0, _UHead&& __uhead)
148 : : _M_head_impl(std::forward<_UHead>(__uhead)) { }
149 :
150 : template<typename _Alloc, typename _UHead>
151 : _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
152 : : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
153 : { }
154 :
155 : template<typename _Alloc, typename _UHead>
156 : _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
157 : : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
158 :
159 : static constexpr _Head&
160 2408 : _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
161 :
162 : static constexpr const _Head&
163 34 : _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
164 :
165 : _Head _M_head_impl;
166 : };
167 :
168 : /**
169 : * Contains the actual implementation of the @c tuple template, stored
170 : * as a recursive inheritance hierarchy from the first element (most
171 : * derived class) to the last (least derived class). The @c Idx
172 : * parameter gives the 0-based index of the element stored at this
173 : * point in the hierarchy; we use it to implement a constant-time
174 : * get() operation.
175 : */
176 : template<std::size_t _Idx, typename... _Elements>
177 : struct _Tuple_impl;
178 :
179 : /**
180 : * Recursive tuple implementation. Here we store the @c Head element
181 : * and derive from a @c Tuple_impl containing the remaining elements
182 : * (which contains the @c Tail).
183 : */
184 : template<std::size_t _Idx, typename _Head, typename... _Tail>
185 : struct _Tuple_impl<_Idx, _Head, _Tail...>
186 : : public _Tuple_impl<_Idx + 1, _Tail...>,
187 : private _Head_base<_Idx, _Head>
188 : {
189 : template<std::size_t, typename...> friend class _Tuple_impl;
190 :
191 : typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
192 : typedef _Head_base<_Idx, _Head> _Base;
193 :
194 : static constexpr _Head&
195 20 : _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
196 :
197 : static constexpr const _Head&
198 34 : _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
199 :
200 : static constexpr _Inherited&
201 : _M_tail(_Tuple_impl& __t) noexcept { return __t; }
202 :
203 : static constexpr const _Inherited&
204 : _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
205 :
206 10 : constexpr _Tuple_impl()
207 10 : : _Inherited(), _Base() { }
208 :
209 : explicit
210 : constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
211 : : _Inherited(__tail...), _Base(__head) { }
212 :
213 : template<typename _UHead, typename... _UTail, typename = typename
214 : enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
215 : explicit
216 : constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
217 : : _Inherited(std::forward<_UTail>(__tail)...),
218 : _Base(std::forward<_UHead>(__head)) { }
219 :
220 : constexpr _Tuple_impl(const _Tuple_impl&) = default;
221 :
222 : constexpr
223 : _Tuple_impl(_Tuple_impl&& __in)
224 : noexcept(__and_<is_nothrow_move_constructible<_Head>,
225 : is_nothrow_move_constructible<_Inherited>>::value)
226 : : _Inherited(std::move(_M_tail(__in))),
227 : _Base(std::forward<_Head>(_M_head(__in))) { }
228 :
229 : template<typename... _UElements>
230 : constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
231 : : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
232 : _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
233 :
234 : template<typename _UHead, typename... _UTails>
235 : constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
236 : : _Inherited(std::move
237 : (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
238 : _Base(std::forward<_UHead>
239 : (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
240 :
241 : template<typename _Alloc>
242 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
243 : : _Inherited(__tag, __a),
244 : _Base(__tag, __use_alloc<_Head>(__a)) { }
245 :
246 : template<typename _Alloc>
247 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
248 : const _Head& __head, const _Tail&... __tail)
249 : : _Inherited(__tag, __a, __tail...),
250 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
251 :
252 : template<typename _Alloc, typename _UHead, typename... _UTail,
253 : typename = typename enable_if<sizeof...(_Tail)
254 : == sizeof...(_UTail)>::type>
255 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
256 : _UHead&& __head, _UTail&&... __tail)
257 : : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
258 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
259 : std::forward<_UHead>(__head)) { }
260 :
261 : template<typename _Alloc>
262 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
263 : const _Tuple_impl& __in)
264 : : _Inherited(__tag, __a, _M_tail(__in)),
265 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
266 :
267 : template<typename _Alloc>
268 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
269 : _Tuple_impl&& __in)
270 : : _Inherited(__tag, __a, std::move(_M_tail(__in))),
271 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
272 : std::forward<_Head>(_M_head(__in))) { }
273 :
274 : template<typename _Alloc, typename... _UElements>
275 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
276 : const _Tuple_impl<_Idx, _UElements...>& __in)
277 : : _Inherited(__tag, __a,
278 : _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
279 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
280 : _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
281 :
282 : template<typename _Alloc, typename _UHead, typename... _UTails>
283 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
284 : _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
285 : : _Inherited(__tag, __a, std::move
286 : (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
287 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
288 : std::forward<_UHead>
289 : (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
290 :
291 : _Tuple_impl&
292 : operator=(const _Tuple_impl& __in)
293 : {
294 : _M_head(*this) = _M_head(__in);
295 : _M_tail(*this) = _M_tail(__in);
296 : return *this;
297 : }
298 :
299 : _Tuple_impl&
300 : operator=(_Tuple_impl&& __in)
301 : noexcept(__and_<is_nothrow_move_assignable<_Head>,
302 : is_nothrow_move_assignable<_Inherited>>::value)
303 : {
304 : _M_head(*this) = std::forward<_Head>(_M_head(__in));
305 : _M_tail(*this) = std::move(_M_tail(__in));
306 : return *this;
307 : }
308 :
309 : template<typename... _UElements>
310 : _Tuple_impl&
311 : operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
312 : {
313 : _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
314 : _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
315 : return *this;
316 : }
317 :
318 : template<typename _UHead, typename... _UTails>
319 : _Tuple_impl&
320 : operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
321 : {
322 : _M_head(*this) = std::forward<_UHead>
323 : (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
324 : _M_tail(*this) = std::move
325 : (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
326 : return *this;
327 : }
328 :
329 : protected:
330 : void
331 : _M_swap(_Tuple_impl& __in)
332 : noexcept(__is_nothrow_swappable<_Head>::value
333 : && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
334 : {
335 : using std::swap;
336 : swap(_M_head(*this), _M_head(__in));
337 : _Inherited::_M_swap(_M_tail(__in));
338 : }
339 : };
340 :
341 : // Basis case of inheritance recursion.
342 : template<std::size_t _Idx, typename _Head>
343 : struct _Tuple_impl<_Idx, _Head>
344 : : private _Head_base<_Idx, _Head>
345 : {
346 : template<std::size_t, typename...> friend class _Tuple_impl;
347 :
348 : typedef _Head_base<_Idx, _Head> _Base;
349 :
350 : static constexpr _Head&
351 2398 : _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
352 :
353 : static constexpr const _Head&
354 : _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
355 :
356 10 : constexpr _Tuple_impl()
357 10 : : _Base() { }
358 :
359 : explicit
360 1194 : constexpr _Tuple_impl(const _Head& __head)
361 1194 : : _Base(__head) { }
362 :
363 : template<typename _UHead>
364 : explicit
365 : constexpr _Tuple_impl(_UHead&& __head)
366 : : _Base(std::forward<_UHead>(__head)) { }
367 :
368 : constexpr _Tuple_impl(const _Tuple_impl&) = default;
369 :
370 : constexpr
371 1194 : _Tuple_impl(_Tuple_impl&& __in)
372 : noexcept(is_nothrow_move_constructible<_Head>::value)
373 1194 : : _Base(std::forward<_Head>(_M_head(__in))) { }
374 :
375 : template<typename _UHead>
376 : constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
377 : : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
378 :
379 : template<typename _UHead>
380 : constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
381 : : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
382 : { }
383 :
384 : template<typename _Alloc>
385 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
386 : : _Base(__tag, __use_alloc<_Head>(__a)) { }
387 :
388 : template<typename _Alloc>
389 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
390 : const _Head& __head)
391 : : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
392 :
393 : template<typename _Alloc, typename _UHead>
394 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
395 : _UHead&& __head)
396 : : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
397 : std::forward<_UHead>(__head)) { }
398 :
399 : template<typename _Alloc>
400 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
401 : const _Tuple_impl& __in)
402 : : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
403 :
404 : template<typename _Alloc>
405 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
406 : _Tuple_impl&& __in)
407 : : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
408 : std::forward<_Head>(_M_head(__in))) { }
409 :
410 : template<typename _Alloc, typename _UHead>
411 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
412 : const _Tuple_impl<_Idx, _UHead>& __in)
413 : : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
414 : _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
415 :
416 : template<typename _Alloc, typename _UHead>
417 : _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
418 : _Tuple_impl<_Idx, _UHead>&& __in)
419 : : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
420 : std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
421 : { }
422 :
423 : _Tuple_impl&
424 : operator=(const _Tuple_impl& __in)
425 : {
426 : _M_head(*this) = _M_head(__in);
427 : return *this;
428 : }
429 :
430 : _Tuple_impl&
431 : operator=(_Tuple_impl&& __in)
432 : noexcept(is_nothrow_move_assignable<_Head>::value)
433 : {
434 : _M_head(*this) = std::forward<_Head>(_M_head(__in));
435 : return *this;
436 : }
437 :
438 : template<typename _UHead>
439 : _Tuple_impl&
440 : operator=(const _Tuple_impl<_Idx, _UHead>& __in)
441 : {
442 : _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
443 : return *this;
444 : }
445 :
446 : template<typename _UHead>
447 : _Tuple_impl&
448 : operator=(_Tuple_impl<_Idx, _UHead>&& __in)
449 : {
450 : _M_head(*this)
451 : = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
452 : return *this;
453 : }
454 :
455 : protected:
456 : void
457 : _M_swap(_Tuple_impl& __in)
458 : noexcept(__is_nothrow_swappable<_Head>::value)
459 : {
460 : using std::swap;
461 : swap(_M_head(*this), _M_head(__in));
462 : }
463 : };
464 :
465 : // Concept utility functions, reused in conditionally-explicit
466 : // constructors.
467 : template<bool, typename... _Elements>
468 : struct _TC
469 : {
470 : template<typename... _UElements>
471 : static constexpr bool _ConstructibleTuple()
472 : {
473 : return __and_<is_constructible<_Elements, const _UElements&>...>::value;
474 : }
475 :
476 : template<typename... _UElements>
477 : static constexpr bool _ImplicitlyConvertibleTuple()
478 : {
479 : return __and_<is_convertible<const _UElements&, _Elements>...>::value;
480 : }
481 :
482 : template<typename... _UElements>
483 : static constexpr bool _MoveConstructibleTuple()
484 : {
485 : return __and_<is_constructible<_Elements, _UElements&&>...>::value;
486 : }
487 :
488 : template<typename... _UElements>
489 : static constexpr bool _ImplicitlyMoveConvertibleTuple()
490 : {
491 : return __and_<is_convertible<_UElements&&, _Elements>...>::value;
492 : }
493 :
494 : template<typename _SrcTuple>
495 : static constexpr bool _NonNestedTuple()
496 : {
497 : return __and_<__not_<is_same<tuple<_Elements...>,
498 : typename remove_cv<
499 : typename remove_reference<_SrcTuple>::type
500 : >::type>>,
501 : __not_<is_convertible<_SrcTuple, _Elements...>>,
502 : __not_<is_constructible<_Elements..., _SrcTuple>>
503 : >::value;
504 : }
505 : template<typename... _UElements>
506 : static constexpr bool _NotSameTuple()
507 : {
508 : return __not_<is_same<tuple<_Elements...>,
509 : typename remove_const<
510 : typename remove_reference<_UElements...>::type
511 : >::type>>::value;
512 : }
513 : };
514 :
515 : template<typename... _Elements>
516 : struct _TC<false, _Elements...>
517 : {
518 : template<typename... _UElements>
519 : static constexpr bool _ConstructibleTuple()
520 : {
521 : return false;
522 : }
523 :
524 : template<typename... _UElements>
525 : static constexpr bool _ImplicitlyConvertibleTuple()
526 : {
527 : return false;
528 : }
529 :
530 : template<typename... _UElements>
531 : static constexpr bool _MoveConstructibleTuple()
532 : {
533 : return false;
534 : }
535 :
536 : template<typename... _UElements>
537 : static constexpr bool _ImplicitlyMoveConvertibleTuple()
538 : {
539 : return false;
540 : }
541 :
542 : template<typename... _UElements>
543 : static constexpr bool _NonNestedTuple()
544 : {
545 : return true;
546 : }
547 : template<typename... _UElements>
548 : static constexpr bool _NotSameTuple()
549 : {
550 : return true;
551 : }
552 : };
553 :
554 : /// Primary class template, tuple
555 : template<typename... _Elements>
556 : class tuple : public _Tuple_impl<0, _Elements...>
557 : {
558 : typedef _Tuple_impl<0, _Elements...> _Inherited;
559 :
560 : // Used for constraining the default constructor so
561 : // that it becomes dependent on the constraints.
562 : template<typename _Dummy>
563 : struct _TC2
564 : {
565 : static constexpr bool _DefaultConstructibleTuple()
566 : {
567 : return __and_<is_default_constructible<_Elements>...>::value;
568 : }
569 : static constexpr bool _ImplicitlyDefaultConstructibleTuple()
570 : {
571 : return __and_<__is_implicitly_default_constructible<_Elements>...>
572 : ::value;
573 : }
574 : };
575 :
576 : public:
577 : template<typename _Dummy = void,
578 : typename enable_if<_TC2<_Dummy>::
579 : _ImplicitlyDefaultConstructibleTuple(),
580 : bool>::type = true>
581 : constexpr tuple()
582 : : _Inherited() { }
583 :
584 : template<typename _Dummy = void,
585 : typename enable_if<_TC2<_Dummy>::
586 : _DefaultConstructibleTuple()
587 : &&
588 : !_TC2<_Dummy>::
589 : _ImplicitlyDefaultConstructibleTuple(),
590 : bool>::type = false>
591 : explicit constexpr tuple()
592 : : _Inherited() { }
593 :
594 : // Shortcut for the cases where constructors taking _Elements...
595 : // need to be constrained.
596 : template<typename _Dummy> using _TCC =
597 : _TC<is_same<_Dummy, void>::value,
598 : _Elements...>;
599 :
600 : template<typename _Dummy = void,
601 : typename enable_if<
602 : _TCC<_Dummy>::template
603 : _ConstructibleTuple<_Elements...>()
604 : && _TCC<_Dummy>::template
605 : _ImplicitlyConvertibleTuple<_Elements...>()
606 : && (sizeof...(_Elements) >= 1),
607 : bool>::type=true>
608 1194 : constexpr tuple(const _Elements&... __elements)
609 1194 : : _Inherited(__elements...) { }
610 :
611 : template<typename _Dummy = void,
612 : typename enable_if<
613 : _TCC<_Dummy>::template
614 : _ConstructibleTuple<_Elements...>()
615 : && !_TCC<_Dummy>::template
616 : _ImplicitlyConvertibleTuple<_Elements...>()
617 : && (sizeof...(_Elements) >= 1),
618 : bool>::type=false>
619 : explicit constexpr tuple(const _Elements&... __elements)
620 : : _Inherited(__elements...) { }
621 :
622 : // Shortcut for the cases where constructors taking _UElements...
623 : // need to be constrained.
624 : template<typename... _UElements> using _TMC =
625 : _TC<(sizeof...(_Elements) == sizeof...(_UElements))
626 : && (_TC<(sizeof...(_UElements)==1), _Elements...>::
627 : template _NotSameTuple<_UElements...>()),
628 : _Elements...>;
629 :
630 : // Shortcut for the cases where constructors taking tuple<_UElements...>
631 : // need to be constrained.
632 : template<typename... _UElements> using _TMCT =
633 : _TC<(sizeof...(_Elements) == sizeof...(_UElements))
634 : && !is_same<tuple<_Elements...>,
635 : tuple<_UElements...>>::value,
636 : _Elements...>;
637 :
638 : template<typename... _UElements, typename
639 : enable_if<
640 : _TMC<_UElements...>::template
641 : _MoveConstructibleTuple<_UElements...>()
642 : && _TMC<_UElements...>::template
643 : _ImplicitlyMoveConvertibleTuple<_UElements...>()
644 : && (sizeof...(_Elements) >= 1),
645 : bool>::type=true>
646 : constexpr tuple(_UElements&&... __elements)
647 : : _Inherited(std::forward<_UElements>(__elements)...) { }
648 :
649 : template<typename... _UElements, typename
650 : enable_if<
651 : _TMC<_UElements...>::template
652 : _MoveConstructibleTuple<_UElements...>()
653 : && !_TMC<_UElements...>::template
654 : _ImplicitlyMoveConvertibleTuple<_UElements...>()
655 : && (sizeof...(_Elements) >= 1),
656 : bool>::type=false>
657 : explicit constexpr tuple(_UElements&&... __elements)
658 : : _Inherited(std::forward<_UElements>(__elements)...) { }
659 :
660 : constexpr tuple(const tuple&) = default;
661 :
662 1194 : constexpr tuple(tuple&&) = default;
663 :
664 : // Shortcut for the cases where constructors taking tuples
665 : // must avoid creating temporaries.
666 : template<typename _Dummy> using _TNTC =
667 : _TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1,
668 : _Elements...>;
669 :
670 : template<typename... _UElements, typename _Dummy = void, typename
671 : enable_if<_TMCT<_UElements...>::template
672 : _ConstructibleTuple<_UElements...>()
673 : && _TMCT<_UElements...>::template
674 : _ImplicitlyConvertibleTuple<_UElements...>()
675 : && _TNTC<_Dummy>::template
676 : _NonNestedTuple<const tuple<_UElements...>&>(),
677 : bool>::type=true>
678 : constexpr tuple(const tuple<_UElements...>& __in)
679 : : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
680 : { }
681 :
682 : template<typename... _UElements, typename _Dummy = void, typename
683 : enable_if<_TMCT<_UElements...>::template
684 : _ConstructibleTuple<_UElements...>()
685 : && !_TMCT<_UElements...>::template
686 : _ImplicitlyConvertibleTuple<_UElements...>()
687 : && _TNTC<_Dummy>::template
688 : _NonNestedTuple<const tuple<_UElements...>&>(),
689 : bool>::type=false>
690 : explicit constexpr tuple(const tuple<_UElements...>& __in)
691 : : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
692 : { }
693 :
694 : template<typename... _UElements, typename _Dummy = void, typename
695 : enable_if<_TMCT<_UElements...>::template
696 : _MoveConstructibleTuple<_UElements...>()
697 : && _TMCT<_UElements...>::template
698 : _ImplicitlyMoveConvertibleTuple<_UElements...>()
699 : && _TNTC<_Dummy>::template
700 : _NonNestedTuple<tuple<_UElements...>&&>(),
701 : bool>::type=true>
702 : constexpr tuple(tuple<_UElements...>&& __in)
703 : : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
704 :
705 : template<typename... _UElements, typename _Dummy = void, typename
706 : enable_if<_TMCT<_UElements...>::template
707 : _MoveConstructibleTuple<_UElements...>()
708 : && !_TMCT<_UElements...>::template
709 : _ImplicitlyMoveConvertibleTuple<_UElements...>()
710 : && _TNTC<_Dummy>::template
711 : _NonNestedTuple<tuple<_UElements...>&&>(),
712 : bool>::type=false>
713 : explicit constexpr tuple(tuple<_UElements...>&& __in)
714 : : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
715 :
716 : // Allocator-extended constructors.
717 :
718 : template<typename _Alloc>
719 : tuple(allocator_arg_t __tag, const _Alloc& __a)
720 : : _Inherited(__tag, __a) { }
721 :
722 : template<typename _Alloc, typename _Dummy = void,
723 : typename enable_if<
724 : _TCC<_Dummy>::template
725 : _ConstructibleTuple<_Elements...>()
726 : && _TCC<_Dummy>::template
727 : _ImplicitlyConvertibleTuple<_Elements...>(),
728 : bool>::type=true>
729 : tuple(allocator_arg_t __tag, const _Alloc& __a,
730 : const _Elements&... __elements)
731 : : _Inherited(__tag, __a, __elements...) { }
732 :
733 : template<typename _Alloc, typename _Dummy = void,
734 : typename enable_if<
735 : _TCC<_Dummy>::template
736 : _ConstructibleTuple<_Elements...>()
737 : && !_TCC<_Dummy>::template
738 : _ImplicitlyConvertibleTuple<_Elements...>(),
739 : bool>::type=false>
740 : explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
741 : const _Elements&... __elements)
742 : : _Inherited(__tag, __a, __elements...) { }
743 :
744 : template<typename _Alloc, typename... _UElements, typename
745 : enable_if<_TMC<_UElements...>::template
746 : _MoveConstructibleTuple<_UElements...>()
747 : && _TMC<_UElements...>::template
748 : _ImplicitlyMoveConvertibleTuple<_UElements...>(),
749 : bool>::type=true>
750 : tuple(allocator_arg_t __tag, const _Alloc& __a,
751 : _UElements&&... __elements)
752 : : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
753 : { }
754 :
755 : template<typename _Alloc, typename... _UElements, typename
756 : enable_if<_TMC<_UElements...>::template
757 : _MoveConstructibleTuple<_UElements...>()
758 : && !_TMC<_UElements...>::template
759 : _ImplicitlyMoveConvertibleTuple<_UElements...>(),
760 : bool>::type=false>
761 : explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
762 : _UElements&&... __elements)
763 : : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
764 : { }
765 :
766 : template<typename _Alloc>
767 : tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
768 : : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
769 :
770 : template<typename _Alloc>
771 : tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
772 : : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
773 :
774 : template<typename _Alloc, typename _Dummy = void,
775 : typename... _UElements, typename
776 : enable_if<_TMCT<_UElements...>::template
777 : _ConstructibleTuple<_UElements...>()
778 : && _TMCT<_UElements...>::template
779 : _ImplicitlyConvertibleTuple<_UElements...>()
780 : && _TNTC<_Dummy>::template
781 : _NonNestedTuple<tuple<_UElements...>&&>(),
782 : bool>::type=true>
783 : tuple(allocator_arg_t __tag, const _Alloc& __a,
784 : const tuple<_UElements...>& __in)
785 : : _Inherited(__tag, __a,
786 : static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
787 : { }
788 :
789 : template<typename _Alloc, typename _Dummy = void,
790 : typename... _UElements, typename
791 : enable_if<_TMCT<_UElements...>::template
792 : _ConstructibleTuple<_UElements...>()
793 : && !_TMCT<_UElements...>::template
794 : _ImplicitlyConvertibleTuple<_UElements...>()
795 : && _TNTC<_Dummy>::template
796 : _NonNestedTuple<tuple<_UElements...>&&>(),
797 : bool>::type=false>
798 : explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
799 : const tuple<_UElements...>& __in)
800 : : _Inherited(__tag, __a,
801 : static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
802 : { }
803 :
804 : template<typename _Alloc, typename _Dummy = void,
805 : typename... _UElements, typename
806 : enable_if<_TMCT<_UElements...>::template
807 : _MoveConstructibleTuple<_UElements...>()
808 : && _TMCT<_UElements...>::template
809 : _ImplicitlyMoveConvertibleTuple<_UElements...>()
810 : && _TNTC<_Dummy>::template
811 : _NonNestedTuple<tuple<_UElements...>&&>(),
812 : bool>::type=true>
813 : tuple(allocator_arg_t __tag, const _Alloc& __a,
814 : tuple<_UElements...>&& __in)
815 : : _Inherited(__tag, __a,
816 : static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
817 : { }
818 :
819 : template<typename _Alloc, typename _Dummy = void,
820 : typename... _UElements, typename
821 : enable_if<_TMCT<_UElements...>::template
822 : _MoveConstructibleTuple<_UElements...>()
823 : && !_TMCT<_UElements...>::template
824 : _ImplicitlyMoveConvertibleTuple<_UElements...>()
825 : && _TNTC<_Dummy>::template
826 : _NonNestedTuple<tuple<_UElements...>&&>(),
827 : bool>::type=false>
828 : explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
829 : tuple<_UElements...>&& __in)
830 : : _Inherited(__tag, __a,
831 : static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
832 : { }
833 :
834 : tuple&
835 : operator=(const tuple& __in)
836 : {
837 : static_cast<_Inherited&>(*this) = __in;
838 : return *this;
839 : }
840 :
841 : tuple&
842 : operator=(tuple&& __in)
843 : noexcept(is_nothrow_move_assignable<_Inherited>::value)
844 : {
845 : static_cast<_Inherited&>(*this) = std::move(__in);
846 : return *this;
847 : }
848 :
849 : template<typename... _UElements>
850 : typename
851 : enable_if<sizeof...(_UElements)
852 : == sizeof...(_Elements), tuple&>::type
853 : operator=(const tuple<_UElements...>& __in)
854 : {
855 : static_cast<_Inherited&>(*this) = __in;
856 : return *this;
857 : }
858 :
859 : template<typename... _UElements>
860 : typename
861 : enable_if<sizeof...(_UElements)
862 : == sizeof...(_Elements), tuple&>::type
863 : operator=(tuple<_UElements...>&& __in)
864 : {
865 : static_cast<_Inherited&>(*this) = std::move(__in);
866 : return *this;
867 : }
868 :
869 : void
870 : swap(tuple& __in)
871 : noexcept(noexcept(__in._M_swap(__in)))
872 : { _Inherited::_M_swap(__in); }
873 : };
874 :
875 : #if __cpp_deduction_guides >= 201606
876 : template<typename... _UTypes>
877 : tuple(_UTypes...) -> tuple<_UTypes...>;
878 : template<typename _T1, typename _T2>
879 : tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
880 : template<typename _Alloc, typename... _UTypes>
881 : tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
882 : template<typename _Alloc, typename _T1, typename _T2>
883 : tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
884 : template<typename _Alloc, typename... _UTypes>
885 : tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;
886 : #endif
887 :
888 : // Explicit specialization, zero-element tuple.
889 : template<>
890 : class tuple<>
891 : {
892 : public:
893 : void swap(tuple&) noexcept { /* no-op */ }
894 : // We need the default since we're going to define no-op
895 : // allocator constructors.
896 : tuple() = default;
897 : // No-op allocator constructors.
898 : template<typename _Alloc>
899 : tuple(allocator_arg_t, const _Alloc&) { }
900 : template<typename _Alloc>
901 : tuple(allocator_arg_t, const _Alloc&, const tuple&) { }
902 : };
903 :
904 : /// Partial specialization, 2-element tuple.
905 : /// Includes construction and assignment from a pair.
906 : template<typename _T1, typename _T2>
907 : class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
908 : {
909 : typedef _Tuple_impl<0, _T1, _T2> _Inherited;
910 :
911 : public:
912 : template <typename _U1 = _T1,
913 : typename _U2 = _T2,
914 : typename enable_if<__and_<
915 : __is_implicitly_default_constructible<_U1>,
916 : __is_implicitly_default_constructible<_U2>>
917 : ::value, bool>::type = true>
918 :
919 10 : constexpr tuple()
920 10 : : _Inherited() { }
921 :
922 : template <typename _U1 = _T1,
923 : typename _U2 = _T2,
924 : typename enable_if<
925 : __and_<
926 : is_default_constructible<_U1>,
927 : is_default_constructible<_U2>,
928 : __not_<
929 : __and_<__is_implicitly_default_constructible<_U1>,
930 : __is_implicitly_default_constructible<_U2>>>>
931 : ::value, bool>::type = false>
932 :
933 : explicit constexpr tuple()
934 : : _Inherited() { }
935 :
936 : // Shortcut for the cases where constructors taking _T1, _T2
937 : // need to be constrained.
938 : template<typename _Dummy> using _TCC =
939 : _TC<is_same<_Dummy, void>::value, _T1, _T2>;
940 :
941 : template<typename _Dummy = void, typename
942 : enable_if<_TCC<_Dummy>::template
943 : _ConstructibleTuple<_T1, _T2>()
944 : && _TCC<_Dummy>::template
945 : _ImplicitlyConvertibleTuple<_T1, _T2>(),
946 : bool>::type = true>
947 : constexpr tuple(const _T1& __a1, const _T2& __a2)
948 : : _Inherited(__a1, __a2) { }
949 :
950 : template<typename _Dummy = void, typename
951 : enable_if<_TCC<_Dummy>::template
952 : _ConstructibleTuple<_T1, _T2>()
953 : && !_TCC<_Dummy>::template
954 : _ImplicitlyConvertibleTuple<_T1, _T2>(),
955 : bool>::type = false>
956 : explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
957 : : _Inherited(__a1, __a2) { }
958 :
959 : // Shortcut for the cases where constructors taking _U1, _U2
960 : // need to be constrained.
961 : using _TMC = _TC<true, _T1, _T2>;
962 :
963 : template<typename _U1, typename _U2, typename
964 : enable_if<_TMC::template
965 : _MoveConstructibleTuple<_U1, _U2>()
966 : && _TMC::template
967 : _ImplicitlyMoveConvertibleTuple<_U1, _U2>()
968 : && !is_same<typename decay<_U1>::type,
969 : allocator_arg_t>::value,
970 : bool>::type = true>
971 : constexpr tuple(_U1&& __a1, _U2&& __a2)
972 : : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
973 :
974 : template<typename _U1, typename _U2, typename
975 : enable_if<_TMC::template
976 : _MoveConstructibleTuple<_U1, _U2>()
977 : && !_TMC::template
978 : _ImplicitlyMoveConvertibleTuple<_U1, _U2>()
979 : && !is_same<typename decay<_U1>::type,
980 : allocator_arg_t>::value,
981 : bool>::type = false>
982 : explicit constexpr tuple(_U1&& __a1, _U2&& __a2)
983 : : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
984 :
985 : constexpr tuple(const tuple&) = default;
986 :
987 : constexpr tuple(tuple&&) = default;
988 :
989 : template<typename _U1, typename _U2, typename
990 : enable_if<_TMC::template
991 : _ConstructibleTuple<_U1, _U2>()
992 : && _TMC::template
993 : _ImplicitlyConvertibleTuple<_U1, _U2>(),
994 : bool>::type = true>
995 : constexpr tuple(const tuple<_U1, _U2>& __in)
996 : : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
997 :
998 : template<typename _U1, typename _U2, typename
999 : enable_if<_TMC::template
1000 : _ConstructibleTuple<_U1, _U2>()
1001 : && !_TMC::template
1002 : _ImplicitlyConvertibleTuple<_U1, _U2>(),
1003 : bool>::type = false>
1004 : explicit constexpr tuple(const tuple<_U1, _U2>& __in)
1005 : : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
1006 :
1007 : template<typename _U1, typename _U2, typename
1008 : enable_if<_TMC::template
1009 : _MoveConstructibleTuple<_U1, _U2>()
1010 : && _TMC::template
1011 : _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1012 : bool>::type = true>
1013 : constexpr tuple(tuple<_U1, _U2>&& __in)
1014 : : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
1015 :
1016 : template<typename _U1, typename _U2, typename
1017 : enable_if<_TMC::template
1018 : _MoveConstructibleTuple<_U1, _U2>()
1019 : && !_TMC::template
1020 : _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1021 : bool>::type = false>
1022 : explicit constexpr tuple(tuple<_U1, _U2>&& __in)
1023 : : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
1024 :
1025 : template<typename _U1, typename _U2, typename
1026 : enable_if<_TMC::template
1027 : _ConstructibleTuple<_U1, _U2>()
1028 : && _TMC::template
1029 : _ImplicitlyConvertibleTuple<_U1, _U2>(),
1030 : bool>::type = true>
1031 : constexpr tuple(const pair<_U1, _U2>& __in)
1032 : : _Inherited(__in.first, __in.second) { }
1033 :
1034 : template<typename _U1, typename _U2, typename
1035 : enable_if<_TMC::template
1036 : _ConstructibleTuple<_U1, _U2>()
1037 : && !_TMC::template
1038 : _ImplicitlyConvertibleTuple<_U1, _U2>(),
1039 : bool>::type = false>
1040 : explicit constexpr tuple(const pair<_U1, _U2>& __in)
1041 : : _Inherited(__in.first, __in.second) { }
1042 :
1043 : template<typename _U1, typename _U2, typename
1044 : enable_if<_TMC::template
1045 : _MoveConstructibleTuple<_U1, _U2>()
1046 : && _TMC::template
1047 : _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1048 : bool>::type = true>
1049 : constexpr tuple(pair<_U1, _U2>&& __in)
1050 : : _Inherited(std::forward<_U1>(__in.first),
1051 : std::forward<_U2>(__in.second)) { }
1052 :
1053 : template<typename _U1, typename _U2, typename
1054 : enable_if<_TMC::template
1055 : _MoveConstructibleTuple<_U1, _U2>()
1056 : && !_TMC::template
1057 : _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1058 : bool>::type = false>
1059 : explicit constexpr tuple(pair<_U1, _U2>&& __in)
1060 : : _Inherited(std::forward<_U1>(__in.first),
1061 : std::forward<_U2>(__in.second)) { }
1062 :
1063 : // Allocator-extended constructors.
1064 :
1065 : template<typename _Alloc>
1066 : tuple(allocator_arg_t __tag, const _Alloc& __a)
1067 : : _Inherited(__tag, __a) { }
1068 :
1069 : template<typename _Alloc, typename _Dummy = void,
1070 : typename enable_if<
1071 : _TCC<_Dummy>::template
1072 : _ConstructibleTuple<_T1, _T2>()
1073 : && _TCC<_Dummy>::template
1074 : _ImplicitlyConvertibleTuple<_T1, _T2>(),
1075 : bool>::type=true>
1076 :
1077 : tuple(allocator_arg_t __tag, const _Alloc& __a,
1078 : const _T1& __a1, const _T2& __a2)
1079 : : _Inherited(__tag, __a, __a1, __a2) { }
1080 :
1081 : template<typename _Alloc, typename _Dummy = void,
1082 : typename enable_if<
1083 : _TCC<_Dummy>::template
1084 : _ConstructibleTuple<_T1, _T2>()
1085 : && !_TCC<_Dummy>::template
1086 : _ImplicitlyConvertibleTuple<_T1, _T2>(),
1087 : bool>::type=false>
1088 :
1089 : explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1090 : const _T1& __a1, const _T2& __a2)
1091 : : _Inherited(__tag, __a, __a1, __a2) { }
1092 :
1093 : template<typename _Alloc, typename _U1, typename _U2, typename
1094 : enable_if<_TMC::template
1095 : _MoveConstructibleTuple<_U1, _U2>()
1096 : && _TMC::template
1097 : _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1098 : bool>::type = true>
1099 : tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
1100 : : _Inherited(__tag, __a, std::forward<_U1>(__a1),
1101 : std::forward<_U2>(__a2)) { }
1102 :
1103 : template<typename _Alloc, typename _U1, typename _U2, typename
1104 : enable_if<_TMC::template
1105 : _MoveConstructibleTuple<_U1, _U2>()
1106 : && !_TMC::template
1107 : _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1108 : bool>::type = false>
1109 : explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1110 : _U1&& __a1, _U2&& __a2)
1111 : : _Inherited(__tag, __a, std::forward<_U1>(__a1),
1112 : std::forward<_U2>(__a2)) { }
1113 :
1114 : template<typename _Alloc>
1115 : tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
1116 : : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
1117 :
1118 : template<typename _Alloc>
1119 : tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
1120 : : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
1121 :
1122 : template<typename _Alloc, typename _U1, typename _U2, typename
1123 : enable_if<_TMC::template
1124 : _ConstructibleTuple<_U1, _U2>()
1125 : && _TMC::template
1126 : _ImplicitlyConvertibleTuple<_U1, _U2>(),
1127 : bool>::type = true>
1128 : tuple(allocator_arg_t __tag, const _Alloc& __a,
1129 : const tuple<_U1, _U2>& __in)
1130 : : _Inherited(__tag, __a,
1131 : static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
1132 : { }
1133 :
1134 : template<typename _Alloc, typename _U1, typename _U2, typename
1135 : enable_if<_TMC::template
1136 : _ConstructibleTuple<_U1, _U2>()
1137 : && !_TMC::template
1138 : _ImplicitlyConvertibleTuple<_U1, _U2>(),
1139 : bool>::type = false>
1140 : explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1141 : const tuple<_U1, _U2>& __in)
1142 : : _Inherited(__tag, __a,
1143 : static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
1144 : { }
1145 :
1146 : template<typename _Alloc, typename _U1, typename _U2, typename
1147 : enable_if<_TMC::template
1148 : _MoveConstructibleTuple<_U1, _U2>()
1149 : && _TMC::template
1150 : _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1151 : bool>::type = true>
1152 : tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
1153 : : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
1154 : { }
1155 :
1156 : template<typename _Alloc, typename _U1, typename _U2, typename
1157 : enable_if<_TMC::template
1158 : _MoveConstructibleTuple<_U1, _U2>()
1159 : && !_TMC::template
1160 : _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1161 : bool>::type = false>
1162 : explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1163 : tuple<_U1, _U2>&& __in)
1164 : : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
1165 : { }
1166 :
1167 : template<typename _Alloc, typename _U1, typename _U2, typename
1168 : enable_if<_TMC::template
1169 : _ConstructibleTuple<_U1, _U2>()
1170 : && _TMC::template
1171 : _ImplicitlyConvertibleTuple<_U1, _U2>(),
1172 : bool>::type = true>
1173 : tuple(allocator_arg_t __tag, const _Alloc& __a,
1174 : const pair<_U1, _U2>& __in)
1175 : : _Inherited(__tag, __a, __in.first, __in.second) { }
1176 :
1177 : template<typename _Alloc, typename _U1, typename _U2, typename
1178 : enable_if<_TMC::template
1179 : _ConstructibleTuple<_U1, _U2>()
1180 : && !_TMC::template
1181 : _ImplicitlyConvertibleTuple<_U1, _U2>(),
1182 : bool>::type = false>
1183 : explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1184 : const pair<_U1, _U2>& __in)
1185 : : _Inherited(__tag, __a, __in.first, __in.second) { }
1186 :
1187 : template<typename _Alloc, typename _U1, typename _U2, typename
1188 : enable_if<_TMC::template
1189 : _MoveConstructibleTuple<_U1, _U2>()
1190 : && _TMC::template
1191 : _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1192 : bool>::type = true>
1193 : tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
1194 : : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
1195 : std::forward<_U2>(__in.second)) { }
1196 :
1197 : template<typename _Alloc, typename _U1, typename _U2, typename
1198 : enable_if<_TMC::template
1199 : _MoveConstructibleTuple<_U1, _U2>()
1200 : && !_TMC::template
1201 : _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1202 : bool>::type = false>
1203 : explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1204 : pair<_U1, _U2>&& __in)
1205 : : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
1206 : std::forward<_U2>(__in.second)) { }
1207 :
1208 : tuple&
1209 : operator=(const tuple& __in)
1210 : {
1211 : static_cast<_Inherited&>(*this) = __in;
1212 : return *this;
1213 : }
1214 :
1215 : tuple&
1216 : operator=(tuple&& __in)
1217 : noexcept(is_nothrow_move_assignable<_Inherited>::value)
1218 : {
1219 : static_cast<_Inherited&>(*this) = std::move(__in);
1220 : return *this;
1221 : }
1222 :
1223 : template<typename _U1, typename _U2>
1224 : tuple&
1225 : operator=(const tuple<_U1, _U2>& __in)
1226 : {
1227 : static_cast<_Inherited&>(*this) = __in;
1228 : return *this;
1229 : }
1230 :
1231 : template<typename _U1, typename _U2>
1232 : tuple&
1233 : operator=(tuple<_U1, _U2>&& __in)
1234 : {
1235 : static_cast<_Inherited&>(*this) = std::move(__in);
1236 : return *this;
1237 : }
1238 :
1239 : template<typename _U1, typename _U2>
1240 : tuple&
1241 : operator=(const pair<_U1, _U2>& __in)
1242 : {
1243 : this->_M_head(*this) = __in.first;
1244 : this->_M_tail(*this)._M_head(*this) = __in.second;
1245 : return *this;
1246 : }
1247 :
1248 : template<typename _U1, typename _U2>
1249 : tuple&
1250 : operator=(pair<_U1, _U2>&& __in)
1251 : {
1252 : this->_M_head(*this) = std::forward<_U1>(__in.first);
1253 : this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
1254 : return *this;
1255 : }
1256 :
1257 : void
1258 : swap(tuple& __in)
1259 : noexcept(noexcept(__in._M_swap(__in)))
1260 : { _Inherited::_M_swap(__in); }
1261 : };
1262 :
1263 :
1264 : /// class tuple_size
1265 : template<typename... _Elements>
1266 : struct tuple_size<tuple<_Elements...>>
1267 : : public integral_constant<std::size_t, sizeof...(_Elements)> { };
1268 :
1269 : #if __cplusplus > 201402L
1270 : template <typename _Tp>
1271 : inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
1272 : #endif
1273 :
1274 : /**
1275 : * Recursive case for tuple_element: strip off the first element in
1276 : * the tuple and retrieve the (i-1)th element of the remaining tuple.
1277 : */
1278 : template<std::size_t __i, typename _Head, typename... _Tail>
1279 : struct tuple_element<__i, tuple<_Head, _Tail...> >
1280 : : tuple_element<__i - 1, tuple<_Tail...> > { };
1281 :
1282 : /**
1283 : * Basis case for tuple_element: The first element is the one we're seeking.
1284 : */
1285 : template<typename _Head, typename... _Tail>
1286 : struct tuple_element<0, tuple<_Head, _Tail...> >
1287 : {
1288 : typedef _Head type;
1289 : };
1290 :
1291 : /**
1292 : * Error case for tuple_element: invalid index.
1293 : */
1294 : template<size_t __i>
1295 : struct tuple_element<__i, tuple<>>
1296 : {
1297 : static_assert(__i < tuple_size<tuple<>>::value,
1298 : "tuple index is in range");
1299 : };
1300 :
1301 : template<std::size_t __i, typename _Head, typename... _Tail>
1302 : constexpr _Head&
1303 1224 : __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1304 1224 : { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1305 :
1306 : template<std::size_t __i, typename _Head, typename... _Tail>
1307 : constexpr const _Head&
1308 34 : __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1309 34 : { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1310 :
1311 : /// Return a reference to the ith element of a tuple.
1312 : template<std::size_t __i, typename... _Elements>
1313 : constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1314 1224 : get(tuple<_Elements...>& __t) noexcept
1315 1224 : { return std::__get_helper<__i>(__t); }
1316 :
1317 : /// Return a const reference to the ith element of a const tuple.
1318 : template<std::size_t __i, typename... _Elements>
1319 : constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1320 34 : get(const tuple<_Elements...>& __t) noexcept
1321 34 : { return std::__get_helper<__i>(__t); }
1322 :
1323 : /// Return an rvalue reference to the ith element of a tuple rvalue.
1324 : template<std::size_t __i, typename... _Elements>
1325 : constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1326 : get(tuple<_Elements...>&& __t) noexcept
1327 : {
1328 : typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
1329 : return std::forward<__element_type&&>(std::get<__i>(__t));
1330 : }
1331 :
1332 : #if __cplusplus > 201103L
1333 :
1334 : #define __cpp_lib_tuples_by_type 201304
1335 :
1336 : template<typename _Head, size_t __i, typename... _Tail>
1337 : constexpr _Head&
1338 : __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1339 : { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1340 :
1341 : template<typename _Head, size_t __i, typename... _Tail>
1342 : constexpr const _Head&
1343 : __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1344 : { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1345 :
1346 : /// Return a reference to the unique element of type _Tp of a tuple.
1347 : template <typename _Tp, typename... _Types>
1348 : constexpr _Tp&
1349 : get(tuple<_Types...>& __t) noexcept
1350 : { return std::__get_helper2<_Tp>(__t); }
1351 :
1352 : /// Return a reference to the unique element of type _Tp of a tuple rvalue.
1353 : template <typename _Tp, typename... _Types>
1354 : constexpr _Tp&&
1355 : get(tuple<_Types...>&& __t) noexcept
1356 : { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
1357 :
1358 : /// Return a const reference to the unique element of type _Tp of a tuple.
1359 : template <typename _Tp, typename... _Types>
1360 : constexpr const _Tp&
1361 : get(const tuple<_Types...>& __t) noexcept
1362 : { return std::__get_helper2<_Tp>(__t); }
1363 : #endif
1364 :
1365 : // This class performs the comparison operations on tuples
1366 : template<typename _Tp, typename _Up, size_t __i, size_t __size>
1367 : struct __tuple_compare
1368 : {
1369 : static constexpr bool
1370 : __eq(const _Tp& __t, const _Up& __u)
1371 : {
1372 : return bool(std::get<__i>(__t) == std::get<__i>(__u))
1373 : && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
1374 : }
1375 :
1376 : static constexpr bool
1377 : __less(const _Tp& __t, const _Up& __u)
1378 : {
1379 : return bool(std::get<__i>(__t) < std::get<__i>(__u))
1380 : || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
1381 : && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
1382 : }
1383 : };
1384 :
1385 : template<typename _Tp, typename _Up, size_t __size>
1386 : struct __tuple_compare<_Tp, _Up, __size, __size>
1387 : {
1388 : static constexpr bool
1389 : __eq(const _Tp&, const _Up&) { return true; }
1390 :
1391 : static constexpr bool
1392 : __less(const _Tp&, const _Up&) { return false; }
1393 : };
1394 :
1395 : template<typename... _TElements, typename... _UElements>
1396 : constexpr bool
1397 : operator==(const tuple<_TElements...>& __t,
1398 : const tuple<_UElements...>& __u)
1399 : {
1400 : static_assert(sizeof...(_TElements) == sizeof...(_UElements),
1401 : "tuple objects can only be compared if they have equal sizes.");
1402 : using __compare = __tuple_compare<tuple<_TElements...>,
1403 : tuple<_UElements...>,
1404 : 0, sizeof...(_TElements)>;
1405 : return __compare::__eq(__t, __u);
1406 : }
1407 :
1408 : template<typename... _TElements, typename... _UElements>
1409 : constexpr bool
1410 : operator<(const tuple<_TElements...>& __t,
1411 : const tuple<_UElements...>& __u)
1412 : {
1413 : static_assert(sizeof...(_TElements) == sizeof...(_UElements),
1414 : "tuple objects can only be compared if they have equal sizes.");
1415 : using __compare = __tuple_compare<tuple<_TElements...>,
1416 : tuple<_UElements...>,
1417 : 0, sizeof...(_TElements)>;
1418 : return __compare::__less(__t, __u);
1419 : }
1420 :
1421 : template<typename... _TElements, typename... _UElements>
1422 : constexpr bool
1423 : operator!=(const tuple<_TElements...>& __t,
1424 : const tuple<_UElements...>& __u)
1425 : { return !(__t == __u); }
1426 :
1427 : template<typename... _TElements, typename... _UElements>
1428 : constexpr bool
1429 : operator>(const tuple<_TElements...>& __t,
1430 : const tuple<_UElements...>& __u)
1431 : { return __u < __t; }
1432 :
1433 : template<typename... _TElements, typename... _UElements>
1434 : constexpr bool
1435 : operator<=(const tuple<_TElements...>& __t,
1436 : const tuple<_UElements...>& __u)
1437 : { return !(__u < __t); }
1438 :
1439 : template<typename... _TElements, typename... _UElements>
1440 : constexpr bool
1441 : operator>=(const tuple<_TElements...>& __t,
1442 : const tuple<_UElements...>& __u)
1443 : { return !(__t < __u); }
1444 :
1445 : // NB: DR 705.
1446 : template<typename... _Elements>
1447 : constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
1448 : make_tuple(_Elements&&... __args)
1449 : {
1450 : typedef tuple<typename __decay_and_strip<_Elements>::__type...>
1451 : __result_type;
1452 : return __result_type(std::forward<_Elements>(__args)...);
1453 : }
1454 :
1455 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
1456 : // 2275. Why is forward_as_tuple not constexpr?
1457 : template<typename... _Elements>
1458 : constexpr tuple<_Elements&&...>
1459 : forward_as_tuple(_Elements&&... __args) noexcept
1460 : { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
1461 :
1462 : template<size_t, typename, typename, size_t>
1463 : struct __make_tuple_impl;
1464 :
1465 : template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
1466 : struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
1467 : : __make_tuple_impl<_Idx + 1,
1468 : tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
1469 : _Tuple, _Nm>
1470 : { };
1471 :
1472 : template<std::size_t _Nm, typename _Tuple, typename... _Tp>
1473 : struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
1474 : {
1475 : typedef tuple<_Tp...> __type;
1476 : };
1477 :
1478 : template<typename _Tuple>
1479 : struct __do_make_tuple
1480 : : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
1481 : { };
1482 :
1483 : // Returns the std::tuple equivalent of a tuple-like type.
1484 : template<typename _Tuple>
1485 : struct __make_tuple
1486 : : public __do_make_tuple<typename std::remove_cv
1487 : <typename std::remove_reference<_Tuple>::type>::type>
1488 : { };
1489 :
1490 : // Combines several std::tuple's into a single one.
1491 : template<typename...>
1492 : struct __combine_tuples;
1493 :
1494 : template<>
1495 : struct __combine_tuples<>
1496 : {
1497 : typedef tuple<> __type;
1498 : };
1499 :
1500 : template<typename... _Ts>
1501 : struct __combine_tuples<tuple<_Ts...>>
1502 : {
1503 : typedef tuple<_Ts...> __type;
1504 : };
1505 :
1506 : template<typename... _T1s, typename... _T2s, typename... _Rem>
1507 : struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
1508 : {
1509 : typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
1510 : _Rem...>::__type __type;
1511 : };
1512 :
1513 : // Computes the result type of tuple_cat given a set of tuple-like types.
1514 : template<typename... _Tpls>
1515 : struct __tuple_cat_result
1516 : {
1517 : typedef typename __combine_tuples
1518 : <typename __make_tuple<_Tpls>::__type...>::__type __type;
1519 : };
1520 :
1521 : // Helper to determine the index set for the first tuple-like
1522 : // type of a given set.
1523 : template<typename...>
1524 : struct __make_1st_indices;
1525 :
1526 : template<>
1527 : struct __make_1st_indices<>
1528 : {
1529 : typedef std::_Index_tuple<> __type;
1530 : };
1531 :
1532 : template<typename _Tp, typename... _Tpls>
1533 : struct __make_1st_indices<_Tp, _Tpls...>
1534 : {
1535 : typedef typename std::_Build_index_tuple<std::tuple_size<
1536 : typename std::remove_reference<_Tp>::type>::value>::__type __type;
1537 : };
1538 :
1539 : // Performs the actual concatenation by step-wise expanding tuple-like
1540 : // objects into the elements, which are finally forwarded into the
1541 : // result tuple.
1542 : template<typename _Ret, typename _Indices, typename... _Tpls>
1543 : struct __tuple_concater;
1544 :
1545 : template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
1546 : struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
1547 : {
1548 : template<typename... _Us>
1549 : static constexpr _Ret
1550 : _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
1551 : {
1552 : typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1553 : typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
1554 : return __next::_S_do(std::forward<_Tpls>(__tps)...,
1555 : std::forward<_Us>(__us)...,
1556 : std::get<_Is>(std::forward<_Tp>(__tp))...);
1557 : }
1558 : };
1559 :
1560 : template<typename _Ret>
1561 : struct __tuple_concater<_Ret, std::_Index_tuple<>>
1562 : {
1563 : template<typename... _Us>
1564 : static constexpr _Ret
1565 : _S_do(_Us&&... __us)
1566 : {
1567 : return _Ret(std::forward<_Us>(__us)...);
1568 : }
1569 : };
1570 :
1571 : /// tuple_cat
1572 : template<typename... _Tpls, typename = typename
1573 : enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
1574 : constexpr auto
1575 : tuple_cat(_Tpls&&... __tpls)
1576 : -> typename __tuple_cat_result<_Tpls...>::__type
1577 : {
1578 : typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
1579 : typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1580 : typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
1581 : return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
1582 : }
1583 :
1584 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
1585 : // 2301. Why is tie not constexpr?
1586 : /// tie
1587 : template<typename... _Elements>
1588 : constexpr tuple<_Elements&...>
1589 : tie(_Elements&... __args) noexcept
1590 : { return tuple<_Elements&...>(__args...); }
1591 :
1592 : /// swap
1593 : template<typename... _Elements>
1594 : inline
1595 : #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
1596 : // Constrained free swap overload, see p0185r1
1597 : typename enable_if<__and_<__is_swappable<_Elements>...>::value
1598 : >::type
1599 : #else
1600 : void
1601 : #endif
1602 : swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
1603 : noexcept(noexcept(__x.swap(__y)))
1604 : { __x.swap(__y); }
1605 :
1606 : #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
1607 : template<typename... _Elements>
1608 : typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
1609 : swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
1610 : #endif
1611 :
1612 : // A class (and instance) which can be used in 'tie' when an element
1613 : // of a tuple is not required.
1614 : // _GLIBCXX14_CONSTEXPR
1615 : // 2933. PR for LWG 2773 could be clearer
1616 : struct _Swallow_assign
1617 : {
1618 : template<class _Tp>
1619 : _GLIBCXX14_CONSTEXPR const _Swallow_assign&
1620 : operator=(const _Tp&) const
1621 : { return *this; }
1622 : };
1623 :
1624 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
1625 : // 2773. Making std::ignore constexpr
1626 : _GLIBCXX17_INLINE constexpr _Swallow_assign ignore{};
1627 :
1628 : /// Partial specialization for tuples
1629 : template<typename... _Types, typename _Alloc>
1630 : struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
1631 :
1632 : // See stl_pair.h...
1633 : template<class _T1, class _T2>
1634 : template<typename... _Args1, typename... _Args2>
1635 : inline
1636 1194 : pair<_T1, _T2>::
1637 : pair(piecewise_construct_t,
1638 : tuple<_Args1...> __first, tuple<_Args2...> __second)
1639 : : pair(__first, __second,
1640 : typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
1641 1194 : typename _Build_index_tuple<sizeof...(_Args2)>::__type())
1642 1194 : { }
1643 :
1644 : template<class _T1, class _T2>
1645 : template<typename... _Args1, std::size_t... _Indexes1,
1646 : typename... _Args2, std::size_t... _Indexes2>
1647 : inline
1648 1194 : pair<_T1, _T2>::
1649 : pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
1650 : _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
1651 1194 : : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
1652 1194 : second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
1653 1194 : { }
1654 :
1655 : #if __cplusplus > 201402L
1656 : # define __cpp_lib_apply 201603
1657 :
1658 : template <typename _Fn, typename _Tuple, size_t... _Idx>
1659 : constexpr decltype(auto)
1660 : __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
1661 : {
1662 : return std::__invoke(std::forward<_Fn>(__f),
1663 : std::get<_Idx>(std::forward<_Tuple>(__t))...);
1664 : }
1665 :
1666 : template <typename _Fn, typename _Tuple>
1667 : constexpr decltype(auto)
1668 : apply(_Fn&& __f, _Tuple&& __t)
1669 : {
1670 : using _Indices = make_index_sequence<tuple_size_v<decay_t<_Tuple>>>;
1671 : return std::__apply_impl(std::forward<_Fn>(__f),
1672 : std::forward<_Tuple>(__t),
1673 : _Indices{});
1674 : }
1675 :
1676 : #define __cpp_lib_make_from_tuple 201606
1677 :
1678 : template <typename _Tp, typename _Tuple, size_t... _Idx>
1679 : constexpr _Tp
1680 : __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
1681 : { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); }
1682 :
1683 : template <typename _Tp, typename _Tuple>
1684 : constexpr _Tp
1685 : make_from_tuple(_Tuple&& __t)
1686 : {
1687 : return __make_from_tuple_impl<_Tp>(
1688 : std::forward<_Tuple>(__t),
1689 : make_index_sequence<tuple_size_v<decay_t<_Tuple>>>{});
1690 : }
1691 : #endif // C++17
1692 :
1693 : /// @}
1694 :
1695 : _GLIBCXX_END_NAMESPACE_VERSION
1696 : } // namespace std
1697 :
1698 : #endif // C++11
1699 :
1700 : #endif // _GLIBCXX_TUPLE
|