blob: 19e2893a3ac1b0abddf86019d32d821abe36dcd3 [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//
6// This file is distributed under the University of Illinois Open Source
7// License. See LICENSE.TXT for details.
8//
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
32template<class T> void swap(T& a, T& b);
33template <class T, size_t N> void swap(T (&a)[N], T (&b)[N]);
34
35template <class T, class U> T&& forward(U&&);
36template <class T> typename remove_reference<T>::type&& move(T&&);
37
38template <class T>
39 typename conditional
40 <
41 !has_nothrow_move_constructor<T>::value && has_copy_constructor<T>::value,
42 const T&,
43 T&&
44 >::type
45 move_if_noexcept(T& x);
46
47template <class T> typename add_rvalue_reference<T>::type declval() noexcept;
48
49template <class T1, class T2>
50struct pair
51{
52 typedef T1 first_type;
53 typedef T2 second_type;
54
55 T1 first;
56 T2 second;
57
58 pair(const pair&) = default;
59 constexpr pair();
60 pair(const T1& x, const T2& y);
61 template <class U, class V> pair(U&& x, V&& y);
62 template <class U, class V> pair(const pair<U, V>& p);
63 template <class U, class V> pair(pair<U, V>&& p);
64 template <class... Args1, class... Args2>
65 pair(piecewise_construct_t, tuple<Args1...> first_args,
66 tuple<Args2...> second_args);
67
68 template <class U, class V> pair& operator=(const pair<U, V>& p);
69 pair& operator=(pair&& p);
70 template <class U, class V> pair& operator=(pair<U, V>&& p);
71
72 void swap(pair& p);
73};
74
75template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&);
76template <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&);
77template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&);
78template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&);
79template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&);
80template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&);
81
82template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&);
83template <class T1, class T2> void swap(pair<T1, T2>& x, pair<T1, T2>& y);
84
85struct piecewise_construct_t { };
86constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
87
88template <class T> class tuple_size;
89template <size_t I, class T> class tuple_element;
90
91template <class T1, class T2> struct tuple_size<std::pair<T1, T2> >;
92template <class T1, class T2> struct tuple_element<0, std::pair<T1, T2> >;
93template <class T1, class T2> struct tuple_element<1, std::pair<T1, T2> >;
94
95template<size_t I, class T1, class T2>
96 typename tuple_element<I, std::pair<T1, T2> >::type&
97 get(std::pair<T1, T2>&);
98
99template<size_t I, class T1, class T2>
100 const typename const tuple_element<I, std::pair<T1, T2> >::type&
101 get(const std::pair<T1, T2>&);
102
103template <class InputIterator>
104 InputIterator begin(const std::pair<InputIterator, InputIterator>& p);
105template <class InputIterator>
106 InputIterator end(const std::pair<InputIterator, InputIterator>& p);
107
108} // std
109
110*/
111
112#include <__config>
113#include <__tuple>
114#include <type_traits>
115
116#pragma GCC system_header
117
118_LIBCPP_BEGIN_NAMESPACE_STD
119
120namespace rel_ops
121{
122
123template<class _Tp>
124inline _LIBCPP_INLINE_VISIBILITY
125bool
126operator!=(const _Tp& __x, const _Tp& __y)
127{
128 return !(__x == __y);
129}
130
131template<class _Tp>
132inline _LIBCPP_INLINE_VISIBILITY
133bool
134operator> (const _Tp& __x, const _Tp& __y)
135{
136 return __y < __x;
137}
138
139template<class _Tp>
140inline _LIBCPP_INLINE_VISIBILITY
141bool
142operator<=(const _Tp& __x, const _Tp& __y)
143{
144 return !(__y < __x);
145}
146
147template<class _Tp>
148inline _LIBCPP_INLINE_VISIBILITY
149bool
150operator>=(const _Tp& __x, const _Tp& __y)
151{
152 return !(__x < __y);
153}
154
155} // rel_ops
156
157// swap_ranges
158
159template <class _ForwardIterator1, class _ForwardIterator2>
160inline _LIBCPP_INLINE_VISIBILITY
161_ForwardIterator2
162swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
163{
164 for(; __first1 != __last1; ++__first1, ++__first2)
165 swap(*__first1, *__first2);
166 return __first2;
167}
168
169template<class _Tp, size_t _N>
170inline _LIBCPP_INLINE_VISIBILITY
171void
172swap(_Tp (&__a)[_N], _Tp (&__b)[_N])
173{
174 _STD::swap_ranges(__a, __a + _N, __b);
175}
176
177template <class _Tp>
178inline _LIBCPP_INLINE_VISIBILITY
179#ifdef _LIBCPP_MOVE
180typename conditional
181<
182 !has_nothrow_move_constructor<_Tp>::value && has_copy_constructor<_Tp>::value,
183 const _Tp&,
184 _Tp&&
185>::type
186#else
187const _Tp&
188#endif
189move_if_noexcept(_Tp& __x)
190{
191 return _STD::move(__x);
192}
193
194struct piecewise_construct_t { };
195//constexpr
196extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();
197
198template <class _T1, class _T2> struct pair;
199template <class _T1, class _T2> void swap(pair<_T1, _T2>&, pair<_T1, _T2>&);
200
201template <class _T1, class _T2>
202struct pair
203{
204 typedef _T1 first_type;
205 typedef _T2 second_type;
206
207 _T1 first;
208 _T2 second;
209
210 _LIBCPP_INLINE_VISIBILITY pair() : first(), second() {}
211
212 _LIBCPP_INLINE_VISIBILITY pair(const _T1& __x, const _T2& __y)
213 : first(__x), second(__y) {}
214
215#ifdef _LIBCPP_MOVE
216
217 template <class _U1, class _U2,
218 class = typename enable_if<is_convertible<_U1, first_type >::value &&
219 is_convertible<_U2, second_type>::value>::type>
220 _LIBCPP_INLINE_VISIBILITY
221 pair(_U1&& __u1, _U2&& __u2)
222 : first(_STD::forward<_U1>(__u1)),
223 second(_STD::forward<_U2>(__u2))
224 {}
225
Howard Hinnant60a0a8e2010-08-10 20:48:29 +0000226#ifndef _LIBCPP_HAS_NO_VARIADICS
227
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000228 template<class _Tuple,
229 class = typename enable_if<__tuple_convertible<_Tuple, pair>::value>::type>
230 _LIBCPP_INLINE_VISIBILITY
231 pair(_Tuple&& __p)
232 : first(_STD::forward<typename tuple_element<0,
233 typename __make_tuple_types<_Tuple>::type>::type>(get<0>(__p))),
234 second(_STD::forward<typename tuple_element<1,
235 typename __make_tuple_types<_Tuple>::type>::type>(get<1>(__p)))
236 {}
237
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000238 template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
239 pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
240 tuple<_Args2...> __second_args)
241 : pair(__pc, __first_args, __second_args,
242 typename __make_tuple_indices<sizeof...(_Args1)>::type(),
243 typename __make_tuple_indices<sizeof...(_Args2) >::type())
244 {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000245
246 template <class _Tuple,
247 class = typename enable_if<__tuple_assignable<_Tuple, pair>::value>::type>
248 pair&
249 operator=(_Tuple&& __p)
250 {
251 typedef typename __make_tuple_types<_Tuple>::type _TupleRef;
252 typedef typename tuple_element<0, _TupleRef>::type _U0;
253 typedef typename tuple_element<1, _TupleRef>::type _U1;
254 first = _STD::forward<_U0>(_STD::get<0>(__p));
255 second = _STD::forward<_U1>(_STD::get<1>(__p));
256 return *this;
257 }
258
Howard Hinnant60a0a8e2010-08-10 20:48:29 +0000259#endif
260
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000261#else
262 template<class _U1, class _U2>
263 _LIBCPP_INLINE_VISIBILITY pair(const pair<_U1, _U2>& __p)
264 : first(__p.first), second(__p.second) {}
265#endif
266 void _LIBCPP_INLINE_VISIBILITY swap(pair& __p) {_STD::swap(*this, __p);}
267private:
268
269#ifndef _LIBCPP_HAS_NO_VARIADICS
270 template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
271 pair(piecewise_construct_t,
272 tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
273 __tuple_indices<_I1...>, __tuple_indices<_I2...>);
274#endif
275};
276
277template <class _T1, class _T2>
278inline _LIBCPP_INLINE_VISIBILITY
279bool
280operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
281{
282 return __x.first == __y.first && __x.second == __y.second;
283}
284
285template <class _T1, class _T2>
286inline _LIBCPP_INLINE_VISIBILITY
287bool
288operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
289{
290 return !(__x == __y);
291}
292
293template <class _T1, class _T2>
294inline _LIBCPP_INLINE_VISIBILITY
295bool
296operator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
297{
298 return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
299}
300
301template <class _T1, class _T2>
302inline _LIBCPP_INLINE_VISIBILITY
303bool
304operator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
305{
306 return __y < __x;
307}
308
309template <class _T1, class _T2>
310inline _LIBCPP_INLINE_VISIBILITY
311bool
312operator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
313{
314 return !(__x < __y);
315}
316
317template <class _T1, class _T2>
318inline _LIBCPP_INLINE_VISIBILITY
319bool
320operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
321{
322 return !(__y < __x);
323}
324
325template <class _T1, class _T2>
326inline _LIBCPP_INLINE_VISIBILITY
327void
328swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
329{
330 swap(__x.first, __y.first);
331 swap(__x.second, __y.second);
332}
333
334#ifdef _LIBCPP_MOVE
335
336template <class _Tp> class reference_wrapper;
337
338template <class _Tp>
339struct ___make_pair_return
340{
341 typedef _Tp type;
342};
343
344template <class _Tp>
345struct ___make_pair_return<reference_wrapper<_Tp>>
346{
347 typedef _Tp& type;
348};
349
350template <class _Tp>
351struct __make_pair_return
352{
353 typedef typename ___make_pair_return<typename decay<_Tp>::type>::type type;
354};
355
356template <class _T1, class _T2>
357inline
358pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
359make_pair(_T1&& __t1, _T2&& __t2)
360{
361 return pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
362 (_STD::forward<_T1>(__t1), _STD::forward<_T2>(__t2));
363}
364
365#else
366
367template <class _T1, class _T2>
368inline _LIBCPP_INLINE_VISIBILITY
369pair<_T1,_T2>
370make_pair(_T1 __x, _T2 __y)
371{
372 return pair<_T1, _T2>(__x, __y);
373}
374
375#endif
376
377#ifndef _LIBCPP_HAS_NO_VARIADICS
378
379template <class _T1, class _T2>
380 class tuple_size<pair<_T1, _T2> > : public integral_constant<size_t, 2> {};
381
382template <class _T1, class _T2>
383 class tuple_size<const pair<_T1, _T2> > : public integral_constant<size_t, 2> {};
384
385template <class _T1, class _T2>
386class tuple_element<0, pair<_T1, _T2> >
387{
388public:
389 typedef _T1 type;
390};
391
392template <class _T1, class _T2>
393class tuple_element<1, pair<_T1, _T2> >
394{
395public:
396 typedef _T2 type;
397};
398
399template <class _T1, class _T2>
400class tuple_element<0, const pair<_T1, _T2> >
401{
402public:
403 typedef const _T1 type;
404};
405
406template <class _T1, class _T2>
407class tuple_element<1, const pair<_T1, _T2> >
408{
409public:
410 typedef const _T2 type;
411};
412
413template <size_t _Ip> struct __get_pair;
414
415template <>
416struct __get_pair<0>
417{
418 template <class _T1, class _T2>
419 static
420 _LIBCPP_INLINE_VISIBILITY
421 _T1&
422 get(pair<_T1, _T2>& __p) {return __p.first;}
423
424 template <class _T1, class _T2>
425 static
426 _LIBCPP_INLINE_VISIBILITY
427 const _T1&
428 get(const pair<_T1, _T2>& __p) {return __p.first;}
429};
430
431template <>
432struct __get_pair<1>
433{
434 template <class _T1, class _T2>
435 static
436 _LIBCPP_INLINE_VISIBILITY
437 _T2&
438 get(pair<_T1, _T2>& __p) {return __p.second;}
439
440 template <class _T1, class _T2>
441 static
442 _LIBCPP_INLINE_VISIBILITY
443 const _T2&
444 get(const pair<_T1, _T2>& __p) {return __p.second;}
445};
446
447template <size_t _Ip, class _T1, class _T2>
448_LIBCPP_INLINE_VISIBILITY inline
449typename tuple_element<_Ip, pair<_T1, _T2> >::type&
450get(pair<_T1, _T2>& __p)
451{
452 return __get_pair<_Ip>::get(__p);
453}
454
455template <size_t _Ip, class _T1, class _T2>
456_LIBCPP_INLINE_VISIBILITY inline
457const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
458get(const pair<_T1, _T2>& __p)
459{
460 return __get_pair<_Ip>::get(__p);
461}
462
463#endif
464
465template <class _InputIterator>
466_LIBCPP_INLINE_VISIBILITY inline
467_InputIterator
468begin(const pair<_InputIterator, _InputIterator>& __p)
469{
470 return __p.first;
471}
472
473template <class _InputIterator>
474_LIBCPP_INLINE_VISIBILITY inline
475_InputIterator
476end(const pair<_InputIterator, _InputIterator>& __p)
477{
478 return __p.second;
479}
480
481_LIBCPP_END_NAMESPACE_STD
482
483#endif // _LIBCPP_UTILITY