blob: 2cb10189c0b5027e35bfe16421cf42a2faafdf53 [file] [log] [blame]
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001// -*- C++ -*-
2//===-------------------------- utility -----------------------------------===//
3//
Howard Hinnantf5256e12010-05-11 21:36:01 +00004// The LLVM Compiler Infrastructure
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00005//
Howard Hinnantb64f8b02010-11-16 22:09:02 +00006// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00008//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_UTILITY
12#define _LIBCPP_UTILITY
13
14/*
15 utility synopsis
16
17namespace std
18{
19
20template <class T>
21 void
22 swap(T& a, T& b);
23
24namespace rel_ops
25{
26 template<class T> bool operator!=(const T&, const T&);
27 template<class T> bool operator> (const T&, const T&);
28 template<class T> bool operator<=(const T&, const T&);
29 template<class T> bool operator>=(const T&, const T&);
30}
31
Howard Hinnante9b2c2d2011-05-27 15:04:19 +000032template<class T>
33void
34swap(T& a, T& b) noexcept(is_nothrow_move_constructible<T>::value &&
35 is_nothrow_move_assignable<T>::value);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000036
Howard Hinnante9b2c2d2011-05-27 15:04:19 +000037template <class T, size_t N>
38void
39swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b)));
40
Marshall Clow01a0e902013-07-15 20:46:11 +000041template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept; // constexpr in C++14
42template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept; // constexpr in C++14
Howard Hinnante9b2c2d2011-05-27 15:04:19 +000043
Marshall Clow01a0e902013-07-15 20:46:11 +000044template <class T> typename remove_reference<T>::type&& move(T&&) noexcept; // constexpr in C++14
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000045
46template <class T>
47 typename conditional
48 <
Howard Hinnant1468b662010-11-19 22:17:28 +000049 !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000050 const T&,
51 T&&
52 >::type
Marshall Clow01a0e902013-07-15 20:46:11 +000053 move_if_noexcept(T& x) noexcept; // constexpr in C++14
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000054
55template <class T> typename add_rvalue_reference<T>::type declval() noexcept;
56
57template <class T1, class T2>
58struct pair
59{
60 typedef T1 first_type;
61 typedef T2 second_type;
62
63 T1 first;
64 T2 second;
65
66 pair(const pair&) = default;
Howard Hinnante9b2c2d2011-05-27 15:04:19 +000067 pair(pair&&) = default;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000068 constexpr pair();
Marshall Clow206f6cd2013-07-16 17:45:44 +000069 pair(const T1& x, const T2& y); // constexpr in C++14
70 template <class U, class V> pair(U&& x, V&& y); // constexpr in C++14
71 template <class U, class V> pair(const pair<U, V>& p); // constexpr in C++14
72 template <class U, class V> pair(pair<U, V>&& p); // constexpr in C++14
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000073 template <class... Args1, class... Args2>
74 pair(piecewise_construct_t, tuple<Args1...> first_args,
75 tuple<Args2...> second_args);
76
77 template <class U, class V> pair& operator=(const pair<U, V>& p);
Howard Hinnante9b2c2d2011-05-27 15:04:19 +000078 pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value &&
79 is_nothrow_move_assignable<T2>::value);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000080 template <class U, class V> pair& operator=(pair<U, V>&& p);
81
Howard Hinnante9b2c2d2011-05-27 15:04:19 +000082 void swap(pair& p) noexcept(noexcept(swap(first, p.first)) &&
83 noexcept(swap(second, p.second)));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000084};
85
Marshall Clow206f6cd2013-07-16 17:45:44 +000086template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
87template <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
88template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
89template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
90template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
91template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000092
Marshall Clow206f6cd2013-07-16 17:45:44 +000093template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&); // constexpr in C++14
Howard Hinnante9b2c2d2011-05-27 15:04:19 +000094template <class T1, class T2>
95void
96swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000097
98struct piecewise_construct_t { };
99constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
100
101template <class T> class tuple_size;
102template <size_t I, class T> class tuple_element;
103
Marshall Clow50fe0c72014-03-03 06:18:11 +0000104template <class T1, class T2> struct tuple_size<pair<T1, T2> >;
105template <class T1, class T2> struct tuple_element<0, pair<T1, T2> >;
106template <class T1, class T2> struct tuple_element<1, pair<T1, T2> >;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000107
108template<size_t I, class T1, class T2>
Marshall Clow50fe0c72014-03-03 06:18:11 +0000109 typename tuple_element<I, pair<T1, T2> >::type&
110 get(pair<T1, T2>&) noexcept; // constexpr in C++14
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000111
112template<size_t I, class T1, class T2>
Marshall Clow50fe0c72014-03-03 06:18:11 +0000113 const typename const tuple_element<I, pair<T1, T2> >::type&
114 get(const pair<T1, T2>&) noexcept; // constexpr in C++14
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000115
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000116template<size_t I, class T1, class T2>
Marshall Clow50fe0c72014-03-03 06:18:11 +0000117 typename tuple_element<I, pair<T1, T2> >::type&&
118 get(pair<T1, T2>&&) noexcept; // constexpr in C++14
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000119
Marshall Clowe8029e52013-07-13 02:54:05 +0000120template<class T1, class T2>
Marshall Clow50fe0c72014-03-03 06:18:11 +0000121 constexpr T1& get(pair<T1, T2>&) noexcept; // C++14
Marshall Clowe8029e52013-07-13 02:54:05 +0000122
123template<size_t I, class T1, class T2>
Marshall Clow50fe0c72014-03-03 06:18:11 +0000124 constexpr T1 const& get(pair<T1, T2> const &) noexcept; // C++14
Marshall Clowe8029e52013-07-13 02:54:05 +0000125
126template<size_t I, class T1, class T2>
Marshall Clow50fe0c72014-03-03 06:18:11 +0000127 constexpr T1&& get(pair<T1, T2>&&) noexcept; // C++14
Marshall Clowe8029e52013-07-13 02:54:05 +0000128
Marshall Clow7ec46bc2013-07-01 16:26:55 +0000129// C++14
130
131template<class T, T... I>
132struct integer_sequence
133{
134 typedef T value_type;
135
136 static constexpr size_t size() noexcept;
137};
138
139template<size_t... I>
140 using index_sequence = integer_sequence<size_t, I...>;
141
142template<class T, T N>
143 using make_integer_sequence = integer_sequence<T, 0, 1, ..., N-1>;
144template<size_t N>
145 using make_index_sequence = make_integer_sequence<size_t, N>;
146
147template<class... T>
148 using index_sequence_for = make_index_sequence<sizeof...(T)>;
149
Marshall Clowe2735d12013-07-08 20:54:40 +0000150template<class T, class U=T>
151 T exchange(T& obj, U&& new_value);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000152} // std
153
154*/
155
156#include <__config>
157#include <__tuple>
158#include <type_traits>
159
Howard Hinnant08e17472011-10-17 20:05:10 +0000160#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000161#pragma GCC system_header
Howard Hinnant08e17472011-10-17 20:05:10 +0000162#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000163
164_LIBCPP_BEGIN_NAMESPACE_STD
165
166namespace rel_ops
167{
168
169template<class _Tp>
170inline _LIBCPP_INLINE_VISIBILITY
171bool
172operator!=(const _Tp& __x, const _Tp& __y)
173{
174 return !(__x == __y);
175}
176
177template<class _Tp>
178inline _LIBCPP_INLINE_VISIBILITY
179bool
180operator> (const _Tp& __x, const _Tp& __y)
181{
182 return __y < __x;
183}
184
185template<class _Tp>
186inline _LIBCPP_INLINE_VISIBILITY
187bool
188operator<=(const _Tp& __x, const _Tp& __y)
189{
190 return !(__y < __x);
191}
192
193template<class _Tp>
194inline _LIBCPP_INLINE_VISIBILITY
195bool
196operator>=(const _Tp& __x, const _Tp& __y)
197{
198 return !(__x < __y);
199}
200
201} // rel_ops
202
203// swap_ranges
204
Marshall Clowfd8ed7f2015-01-06 19:20:49 +0000205// forward
206template<class _Tp, size_t _Np>
207void swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value);
208
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000209template <class _ForwardIterator1, class _ForwardIterator2>
210inline _LIBCPP_INLINE_VISIBILITY
211_ForwardIterator2
212swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
213{
Eric Fiselierb9919752014-10-27 19:28:20 +0000214 for(; __first1 != __last1; ++__first1, (void) ++__first2)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000215 swap(*__first1, *__first2);
216 return __first2;
217}
218
Howard Hinnant99968442011-11-29 18:15:50 +0000219template<class _Tp, size_t _Np>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000220inline _LIBCPP_INLINE_VISIBILITY
221void
Howard Hinnant99968442011-11-29 18:15:50 +0000222swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000223{
Howard Hinnant99968442011-11-29 18:15:50 +0000224 _VSTD::swap_ranges(__a, __a + _Np, __b);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000225}
226
227template <class _Tp>
Marshall Clow01a0e902013-07-15 20:46:11 +0000228inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnant73d21a42010-09-04 23:28:19 +0000229#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000230typename conditional
231<
Howard Hinnant1468b662010-11-19 22:17:28 +0000232 !is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value,
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000233 const _Tp&,
234 _Tp&&
235>::type
Howard Hinnant73d21a42010-09-04 23:28:19 +0000236#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000237const _Tp&
238#endif
Howard Hinnante9b2c2d2011-05-27 15:04:19 +0000239move_if_noexcept(_Tp& __x) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000240{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000241 return _VSTD::move(__x);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000242}
243
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000244struct _LIBCPP_TYPE_VIS_ONLY piecewise_construct_t { };
Howard Hinnant616e92d2012-04-03 23:45:46 +0000245#if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_UTILITY)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000246extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();
Howard Hinnant2a5349b2012-04-03 21:09:48 +0000247#else
248constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
249#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000250
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000251template <class _T1, class _T2>
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000252struct _LIBCPP_TYPE_VIS_ONLY pair
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000253{
254 typedef _T1 first_type;
255 typedef _T2 second_type;
256
257 _T1 first;
258 _T2 second;
259
Howard Hinnante9b2c2d2011-05-27 15:04:19 +0000260 // pair(const pair&) = default;
261 // pair(pair&&) = default;
262
Howard Hinnant2a5349b2012-04-03 21:09:48 +0000263 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR pair() : first(), second() {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000264
Marshall Clow206f6cd2013-07-16 17:45:44 +0000265 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
266 pair(const _T1& __x, const _T2& __y)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000267 : first(__x), second(__y) {}
268
Howard Hinnant469d4192011-04-29 18:10:55 +0000269 template<class _U1, class _U2>
Marshall Clow206f6cd2013-07-16 17:45:44 +0000270 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnant9c59d382011-07-27 19:25:28 +0000271 pair(const pair<_U1, _U2>& __p
272#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
Howard Hinnantfe592762012-06-09 20:01:23 +0000273 ,typename enable_if<is_convertible<const _U1&, _T1>::value &&
274 is_convertible<const _U2&, _T2>::value>::type* = 0
Howard Hinnant9c59d382011-07-27 19:25:28 +0000275#endif
276 )
Howard Hinnant469d4192011-04-29 18:10:55 +0000277 : first(__p.first), second(__p.second) {}
278
Howard Hinnant65173fe2013-11-14 22:52:25 +0000279#if !defined(_LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS) && _LIBCPP_TRIVIAL_PAIR_COPY_CTOR
Marshall Clow206f6cd2013-07-16 17:45:44 +0000280 _LIBCPP_INLINE_VISIBILITY
281 pair(const pair& __p) = default;
Howard Hinnant65173fe2013-11-14 22:52:25 +0000282#elif !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) || !_LIBCPP_TRIVIAL_PAIR_COPY_CTOR
Howard Hinnante9b2c2d2011-05-27 15:04:19 +0000283 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant61aa6012011-07-01 19:24:36 +0000284 pair(const pair& __p)
285 _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
286 is_nothrow_copy_constructible<second_type>::value)
287 : first(__p.first),
288 second(__p.second)
289 {
290 }
Marshall Clow206f6cd2013-07-16 17:45:44 +0000291#endif
Howard Hinnant61aa6012011-07-01 19:24:36 +0000292
293 _LIBCPP_INLINE_VISIBILITY
Howard Hinnante9b2c2d2011-05-27 15:04:19 +0000294 pair& operator=(const pair& __p)
Howard Hinnant61aa6012011-07-01 19:24:36 +0000295 _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
296 is_nothrow_copy_assignable<second_type>::value)
Howard Hinnante9b2c2d2011-05-27 15:04:19 +0000297 {
298 first = __p.first;
299 second = __p.second;
300 return *this;
301 }
302
Howard Hinnant73d21a42010-09-04 23:28:19 +0000303#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000304
305 template <class _U1, class _U2,
Howard Hinnantfe592762012-06-09 20:01:23 +0000306 class = typename enable_if<is_convertible<_U1, first_type>::value &&
307 is_convertible<_U2, second_type>::value>::type>
Marshall Clow206f6cd2013-07-16 17:45:44 +0000308 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000309 pair(_U1&& __u1, _U2&& __u2)
Howard Hinnant0949eed2011-06-30 21:18:19 +0000310 : first(_VSTD::forward<_U1>(__u1)),
311 second(_VSTD::forward<_U2>(__u2))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000312 {}
313
Howard Hinnant469d4192011-04-29 18:10:55 +0000314 template<class _U1, class _U2>
Marshall Clow206f6cd2013-07-16 17:45:44 +0000315 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnant469d4192011-04-29 18:10:55 +0000316 pair(pair<_U1, _U2>&& __p,
Howard Hinnantfe592762012-06-09 20:01:23 +0000317 typename enable_if<is_convertible<_U1, _T1>::value &&
318 is_convertible<_U2, _T2>::value>::type* = 0)
Howard Hinnant0949eed2011-06-30 21:18:19 +0000319 : first(_VSTD::forward<_U1>(__p.first)),
320 second(_VSTD::forward<_U2>(__p.second)) {}
Howard Hinnant469d4192011-04-29 18:10:55 +0000321
Marshall Clow206f6cd2013-07-16 17:45:44 +0000322#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
323 _LIBCPP_INLINE_VISIBILITY
324 pair(pair&& __p) = default;
325#else
Howard Hinnante9b2c2d2011-05-27 15:04:19 +0000326 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant61aa6012011-07-01 19:24:36 +0000327 pair(pair&& __p) _NOEXCEPT_(is_nothrow_move_constructible<first_type>::value &&
328 is_nothrow_move_constructible<second_type>::value)
329 : first(_VSTD::forward<first_type>(__p.first)),
330 second(_VSTD::forward<second_type>(__p.second))
331 {
332 }
Marshall Clow206f6cd2013-07-16 17:45:44 +0000333#endif
Howard Hinnant61aa6012011-07-01 19:24:36 +0000334
335 _LIBCPP_INLINE_VISIBILITY
Howard Hinnante9b2c2d2011-05-27 15:04:19 +0000336 pair&
337 operator=(pair&& __p) _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
338 is_nothrow_move_assignable<second_type>::value)
339 {
Howard Hinnant0949eed2011-06-30 21:18:19 +0000340 first = _VSTD::forward<first_type>(__p.first);
341 second = _VSTD::forward<second_type>(__p.second);
Howard Hinnante9b2c2d2011-05-27 15:04:19 +0000342 return *this;
343 }
344
Michael J. Spencer626916f2010-12-10 19:47:54 +0000345#ifndef _LIBCPP_HAS_NO_VARIADICS
346
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000347 template<class _Tuple,
348 class = typename enable_if<__tuple_convertible<_Tuple, pair>::value>::type>
Marshall Clow206f6cd2013-07-16 17:45:44 +0000349 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000350 pair(_Tuple&& __p)
Howard Hinnant0949eed2011-06-30 21:18:19 +0000351 : first(_VSTD::forward<typename tuple_element<0,
Marshall Clowba6dbf42014-06-24 00:46:19 +0000352 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<0>(__p))),
Howard Hinnant0949eed2011-06-30 21:18:19 +0000353 second(_VSTD::forward<typename tuple_element<1,
Marshall Clowba6dbf42014-06-24 00:46:19 +0000354 typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<1>(__p)))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000355 {}
356
Michael J. Spencer626916f2010-12-10 19:47:54 +0000357
Howard Hinnant726a76f2010-11-16 21:10:23 +0000358
Howard Hinnant6cc99fa2011-12-19 17:58:44 +0000359 template <class... _Args1, class... _Args2>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000360 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000361 pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
362 tuple<_Args2...> __second_args)
Howard Hinnant324bb032010-08-22 00:02:43 +0000363 : pair(__pc, __first_args, __second_args,
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000364 typename __make_tuple_indices<sizeof...(_Args1)>::type(),
365 typename __make_tuple_indices<sizeof...(_Args2) >::type())
366 {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000367
368 template <class _Tuple,
369 class = typename enable_if<__tuple_assignable<_Tuple, pair>::value>::type>
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000370 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000371 pair&
372 operator=(_Tuple&& __p)
373 {
374 typedef typename __make_tuple_types<_Tuple>::type _TupleRef;
375 typedef typename tuple_element<0, _TupleRef>::type _U0;
376 typedef typename tuple_element<1, _TupleRef>::type _U1;
Howard Hinnant0949eed2011-06-30 21:18:19 +0000377 first = _VSTD::forward<_U0>(_VSTD::get<0>(__p));
378 second = _VSTD::forward<_U1>(_VSTD::get<1>(__p));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000379 return *this;
380 }
381
Michael J. Spencer626916f2010-12-10 19:47:54 +0000382#endif // _LIBCPP_HAS_NO_VARIADICS
383
Howard Hinnant73d21a42010-09-04 23:28:19 +0000384#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnante9b2c2d2011-05-27 15:04:19 +0000385 _LIBCPP_INLINE_VISIBILITY
386 void
Howard Hinnanta5e01212011-05-27 19:08:18 +0000387 swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
388 __is_nothrow_swappable<second_type>::value)
Howard Hinnante9b2c2d2011-05-27 15:04:19 +0000389 {
Howard Hinnant0949eed2011-06-30 21:18:19 +0000390 _VSTD::iter_swap(&first, &__p.first);
391 _VSTD::iter_swap(&second, &__p.second);
Howard Hinnante9b2c2d2011-05-27 15:04:19 +0000392 }
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000393private:
Howard Hinnant324bb032010-08-22 00:02:43 +0000394
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000395#ifndef _LIBCPP_HAS_NO_VARIADICS
396 template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
Howard Hinnant5f5859c2011-01-13 20:05:05 +0000397 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000398 pair(piecewise_construct_t,
399 tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
400 __tuple_indices<_I1...>, __tuple_indices<_I2...>);
Howard Hinnant324bb032010-08-22 00:02:43 +0000401#endif // _LIBCPP_HAS_NO_VARIADICS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000402};
403
404template <class _T1, class _T2>
Marshall Clow206f6cd2013-07-16 17:45:44 +0000405inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000406bool
407operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
408{
409 return __x.first == __y.first && __x.second == __y.second;
410}
411
412template <class _T1, class _T2>
Marshall Clow206f6cd2013-07-16 17:45:44 +0000413inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000414bool
415operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
416{
417 return !(__x == __y);
418}
419
420template <class _T1, class _T2>
Marshall Clow206f6cd2013-07-16 17:45:44 +0000421inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000422bool
423operator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
424{
425 return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
426}
427
428template <class _T1, class _T2>
Marshall Clow206f6cd2013-07-16 17:45:44 +0000429inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000430bool
431operator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
432{
433 return __y < __x;
434}
435
436template <class _T1, class _T2>
Marshall Clow206f6cd2013-07-16 17:45:44 +0000437inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000438bool
439operator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
440{
441 return !(__x < __y);
442}
443
444template <class _T1, class _T2>
Marshall Clow206f6cd2013-07-16 17:45:44 +0000445inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000446bool
447operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
448{
449 return !(__y < __x);
450}
451
452template <class _T1, class _T2>
453inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantaabf2872011-06-01 19:59:32 +0000454typename enable_if
455<
456 __is_swappable<_T1>::value &&
457 __is_swappable<_T2>::value,
458 void
459>::type
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000460swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
Howard Hinnanta5e01212011-05-27 19:08:18 +0000461 _NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
462 __is_nothrow_swappable<_T2>::value))
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000463{
Howard Hinnante9b2c2d2011-05-27 15:04:19 +0000464 __x.swap(__y);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000465}
466
Howard Hinnant73d21a42010-09-04 23:28:19 +0000467#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000468
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000469template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY reference_wrapper;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000470
471template <class _Tp>
Marshall Clowa71f9562014-01-03 22:55:49 +0000472struct __make_pair_return_impl
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000473{
474 typedef _Tp type;
475};
476
477template <class _Tp>
Marshall Clowa71f9562014-01-03 22:55:49 +0000478struct __make_pair_return_impl<reference_wrapper<_Tp>>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000479{
480 typedef _Tp& type;
481};
482
483template <class _Tp>
484struct __make_pair_return
485{
Marshall Clowa71f9562014-01-03 22:55:49 +0000486 typedef typename __make_pair_return_impl<typename decay<_Tp>::type>::type type;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000487};
488
489template <class _T1, class _T2>
Marshall Clow206f6cd2013-07-16 17:45:44 +0000490inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000491pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
492make_pair(_T1&& __t1, _T2&& __t2)
493{
494 return pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
Howard Hinnant0949eed2011-06-30 21:18:19 +0000495 (_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000496}
497
Howard Hinnant73d21a42010-09-04 23:28:19 +0000498#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000499
500template <class _T1, class _T2>
501inline _LIBCPP_INLINE_VISIBILITY
502pair<_T1,_T2>
503make_pair(_T1 __x, _T2 __y)
504{
505 return pair<_T1, _T2>(__x, __y);
506}
507
Howard Hinnant73d21a42010-09-04 23:28:19 +0000508#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000509
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000510template <class _T1, class _T2>
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000511 class _LIBCPP_TYPE_VIS_ONLY tuple_size<pair<_T1, _T2> >
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000512 : public integral_constant<size_t, 2> {};
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000513
514template <class _T1, class _T2>
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000515 class _LIBCPP_TYPE_VIS_ONLY tuple_size<const pair<_T1, _T2> >
Howard Hinnantee6ccd02010-09-23 18:58:28 +0000516 : public integral_constant<size_t, 2> {};
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000517
518template <class _T1, class _T2>
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000519class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, pair<_T1, _T2> >
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000520{
521public:
522 typedef _T1 type;
523};
524
525template <class _T1, class _T2>
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000526class _LIBCPP_TYPE_VIS_ONLY tuple_element<1, pair<_T1, _T2> >
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000527{
528public:
529 typedef _T2 type;
530};
531
532template <class _T1, class _T2>
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000533class _LIBCPP_TYPE_VIS_ONLY tuple_element<0, const pair<_T1, _T2> >
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000534{
535public:
536 typedef const _T1 type;
537};
538
539template <class _T1, class _T2>
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000540class _LIBCPP_TYPE_VIS_ONLY tuple_element<1, const pair<_T1, _T2> >
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000541{
542public:
543 typedef const _T2 type;
544};
545
546template <size_t _Ip> struct __get_pair;
547
548template <>
549struct __get_pair<0>
550{
551 template <class _T1, class _T2>
552 static
Marshall Clow8fc4f5a2013-07-17 18:25:36 +0000553 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000554 _T1&
Howard Hinnanta5e01212011-05-27 19:08:18 +0000555 get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000556
557 template <class _T1, class _T2>
558 static
Marshall Clow8fc4f5a2013-07-17 18:25:36 +0000559 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000560 const _T1&
Howard Hinnanta5e01212011-05-27 19:08:18 +0000561 get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000562
563#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
564
565 template <class _T1, class _T2>
566 static
Marshall Clow8fc4f5a2013-07-17 18:25:36 +0000567 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000568 _T1&&
Howard Hinnant0949eed2011-06-30 21:18:19 +0000569 get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);}
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000570
571#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000572};
573
574template <>
575struct __get_pair<1>
576{
577 template <class _T1, class _T2>
578 static
Marshall Clow8fc4f5a2013-07-17 18:25:36 +0000579 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000580 _T2&
Howard Hinnanta5e01212011-05-27 19:08:18 +0000581 get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000582
583 template <class _T1, class _T2>
584 static
Marshall Clow8fc4f5a2013-07-17 18:25:36 +0000585 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000586 const _T2&
Howard Hinnanta5e01212011-05-27 19:08:18 +0000587 get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000588
589#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
590
591 template <class _T1, class _T2>
592 static
Marshall Clow8fc4f5a2013-07-17 18:25:36 +0000593 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000594 _T2&&
Howard Hinnant0949eed2011-06-30 21:18:19 +0000595 get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);}
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000596
597#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000598};
599
600template <size_t _Ip, class _T1, class _T2>
Howard Hinnant1e564242013-10-04 22:09:00 +0000601inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000602typename tuple_element<_Ip, pair<_T1, _T2> >::type&
Howard Hinnanta5e01212011-05-27 19:08:18 +0000603get(pair<_T1, _T2>& __p) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000604{
605 return __get_pair<_Ip>::get(__p);
606}
607
608template <size_t _Ip, class _T1, class _T2>
Howard Hinnant1e564242013-10-04 22:09:00 +0000609inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000610const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
Howard Hinnanta5e01212011-05-27 19:08:18 +0000611get(const pair<_T1, _T2>& __p) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000612{
613 return __get_pair<_Ip>::get(__p);
614}
615
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000616#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
617
618template <size_t _Ip, class _T1, class _T2>
Howard Hinnant1e564242013-10-04 22:09:00 +0000619inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000620typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
Howard Hinnanta5e01212011-05-27 19:08:18 +0000621get(pair<_T1, _T2>&& __p) _NOEXCEPT
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000622{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000623 return __get_pair<_Ip>::get(_VSTD::move(__p));
Howard Hinnantcd2254b2010-11-17 19:52:17 +0000624}
625
626#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
627
Marshall Clow7ec46bc2013-07-01 16:26:55 +0000628#if _LIBCPP_STD_VER > 11
Marshall Clowe8029e52013-07-13 02:54:05 +0000629template <class _T1, class _T2>
Howard Hinnant1e564242013-10-04 22:09:00 +0000630inline _LIBCPP_INLINE_VISIBILITY
Marshall Clowe8029e52013-07-13 02:54:05 +0000631constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
632{
Marshall Clow206f6cd2013-07-16 17:45:44 +0000633 return __get_pair<0>::get(__p);
Marshall Clowe8029e52013-07-13 02:54:05 +0000634}
635
636template <class _T1, class _T2>
Howard Hinnant1e564242013-10-04 22:09:00 +0000637inline _LIBCPP_INLINE_VISIBILITY
Marshall Clowe8029e52013-07-13 02:54:05 +0000638constexpr _T1 const & get(pair<_T1, _T2> const& __p) _NOEXCEPT
639{
Marshall Clow206f6cd2013-07-16 17:45:44 +0000640 return __get_pair<0>::get(__p);
Marshall Clowe8029e52013-07-13 02:54:05 +0000641}
642
643template <class _T1, class _T2>
Howard Hinnant1e564242013-10-04 22:09:00 +0000644inline _LIBCPP_INLINE_VISIBILITY
Marshall Clowe8029e52013-07-13 02:54:05 +0000645constexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT
646{
Marshall Clow206f6cd2013-07-16 17:45:44 +0000647 return __get_pair<0>::get(_VSTD::move(__p));
Marshall Clowe8029e52013-07-13 02:54:05 +0000648}
649
650template <class _T1, class _T2>
Howard Hinnant1e564242013-10-04 22:09:00 +0000651inline _LIBCPP_INLINE_VISIBILITY
Marshall Clowe8029e52013-07-13 02:54:05 +0000652constexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT
653{
Marshall Clow206f6cd2013-07-16 17:45:44 +0000654 return __get_pair<1>::get(__p);
Marshall Clowe8029e52013-07-13 02:54:05 +0000655}
656
657template <class _T1, class _T2>
Howard Hinnant1e564242013-10-04 22:09:00 +0000658inline _LIBCPP_INLINE_VISIBILITY
Marshall Clowe8029e52013-07-13 02:54:05 +0000659constexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT
660{
Marshall Clow206f6cd2013-07-16 17:45:44 +0000661 return __get_pair<1>::get(__p);
Marshall Clowe8029e52013-07-13 02:54:05 +0000662}
663
664template <class _T1, class _T2>
Howard Hinnant1e564242013-10-04 22:09:00 +0000665inline _LIBCPP_INLINE_VISIBILITY
Marshall Clowe8029e52013-07-13 02:54:05 +0000666constexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT
667{
Marshall Clow206f6cd2013-07-16 17:45:44 +0000668 return __get_pair<1>::get(_VSTD::move(__p));
Marshall Clowe8029e52013-07-13 02:54:05 +0000669}
670
671#endif
672
673#if _LIBCPP_STD_VER > 11
Marshall Clow7ec46bc2013-07-01 16:26:55 +0000674
675template<class _Tp, _Tp... _Ip>
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000676struct _LIBCPP_TYPE_VIS_ONLY integer_sequence
Marshall Clow7ec46bc2013-07-01 16:26:55 +0000677{
678 typedef _Tp value_type;
679 static_assert( is_integral<_Tp>::value,
680 "std::integer_sequence can only be instantiated with an integral type" );
681 static
682 _LIBCPP_INLINE_VISIBILITY
683 constexpr
684 size_t
685 size() noexcept { return sizeof...(_Ip); }
686};
687
688template<size_t... _Ip>
689 using index_sequence = integer_sequence<size_t, _Ip...>;
690
Marshall Clow42e55e92013-07-03 19:20:30 +0000691namespace __detail {
Marshall Clow7ec46bc2013-07-01 16:26:55 +0000692
Marshall Clow42e55e92013-07-03 19:20:30 +0000693template<typename _Tp, size_t ..._Extra> struct __repeat;
694template<typename _Tp, _Tp ..._Np, size_t ..._Extra> struct __repeat<integer_sequence<_Tp, _Np...>, _Extra...> {
695 typedef integer_sequence<_Tp,
696 _Np...,
697 sizeof...(_Np) + _Np...,
698 2 * sizeof...(_Np) + _Np...,
699 3 * sizeof...(_Np) + _Np...,
700 4 * sizeof...(_Np) + _Np...,
701 5 * sizeof...(_Np) + _Np...,
702 6 * sizeof...(_Np) + _Np...,
703 7 * sizeof...(_Np) + _Np...,
704 _Extra...> type;
Marshall Clow7ec46bc2013-07-01 16:26:55 +0000705};
706
Marshall Clow42e55e92013-07-03 19:20:30 +0000707template<size_t _Np> struct __parity;
708template<size_t _Np> struct __make : __parity<_Np % 8>::template __pmake<_Np> {};
709
710template<> struct __make<0> { typedef integer_sequence<size_t> type; };
711template<> struct __make<1> { typedef integer_sequence<size_t, 0> type; };
712template<> struct __make<2> { typedef integer_sequence<size_t, 0, 1> type; };
713template<> struct __make<3> { typedef integer_sequence<size_t, 0, 1, 2> type; };
714template<> struct __make<4> { typedef integer_sequence<size_t, 0, 1, 2, 3> type; };
715template<> struct __make<5> { typedef integer_sequence<size_t, 0, 1, 2, 3, 4> type; };
716template<> struct __make<6> { typedef integer_sequence<size_t, 0, 1, 2, 3, 4, 5> type; };
717template<> struct __make<7> { typedef integer_sequence<size_t, 0, 1, 2, 3, 4, 5, 6> type; };
718
719template<> struct __parity<0> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type> {}; };
720template<> struct __parity<1> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 1> {}; };
721template<> struct __parity<2> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 2, _Np - 1> {}; };
722template<> struct __parity<3> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 3, _Np - 2, _Np - 1> {}; };
723template<> struct __parity<4> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
724template<> struct __parity<5> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
725template<> struct __parity<6> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
726template<> struct __parity<7> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
727
728template<typename _Tp, typename _Up> struct __convert {
729 template<typename> struct __result;
730 template<_Tp ..._Np> struct __result<integer_sequence<_Tp, _Np...> > { typedef integer_sequence<_Up, _Np...> type; };
Marshall Clow7ec46bc2013-07-01 16:26:55 +0000731};
Marshall Clow42e55e92013-07-03 19:20:30 +0000732template<typename _Tp> struct __convert<_Tp, _Tp> { template<typename _Up> struct __result { typedef _Up type; }; };
733
734}
735
736template<typename _Tp, _Tp _Np> using __make_integer_sequence_unchecked =
737 typename __detail::__convert<size_t, _Tp>::template __result<typename __detail::__make<_Np>::type>::type;
Marshall Clow7ec46bc2013-07-01 16:26:55 +0000738
739template <class _Tp, _Tp _Ep>
740struct __make_integer_sequence
741{
742 static_assert(is_integral<_Tp>::value,
743 "std::make_integer_sequence can only be instantiated with an integral type" );
744 static_assert(0 <= _Ep, "std::make_integer_sequence input shall not be negative");
Marshall Clow42e55e92013-07-03 19:20:30 +0000745 typedef __make_integer_sequence_unchecked<_Tp, _Ep> type;
Marshall Clow7ec46bc2013-07-01 16:26:55 +0000746};
747
748template<class _Tp, _Tp _Np>
749 using make_integer_sequence = typename __make_integer_sequence<_Tp, _Np>::type;
750
751template<size_t _Np>
752 using make_index_sequence = make_integer_sequence<size_t, _Np>;
753
754template<class... _Tp>
755 using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;
756
757#endif // _LIBCPP_STD_VER > 11
758
Marshall Clowe2735d12013-07-08 20:54:40 +0000759#if _LIBCPP_STD_VER > 11
760template<class _T1, class _T2 = _T1>
Howard Hinnant1e564242013-10-04 22:09:00 +0000761inline _LIBCPP_INLINE_VISIBILITY
Marshall Clowe2735d12013-07-08 20:54:40 +0000762_T1 exchange(_T1& __obj, _T2 && __new_value)
763{
Howard Hinnant171771a2013-07-08 21:06:38 +0000764 _T1 __old_value = _VSTD::move(__obj);
765 __obj = _VSTD::forward<_T2>(__new_value);
766 return __old_value;
767}
Marshall Clowe2735d12013-07-08 20:54:40 +0000768#endif // _LIBCPP_STD_VER > 11
769
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000770_LIBCPP_END_NAMESPACE_STD
771
772#endif // _LIBCPP_UTILITY