1// -*- C++ -*-
2//===-------------------------- utility -----------------------------------===//
3//
4//                     The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. 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        !is_nothrow_move_constructible<T>::value && is_copy_constructible<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<size_t I, class T1, class T2>
104    typename tuple_element<I, std::pair<T1, T2> >::type&&
105    get(std::pair<T1, T2>&&);
106
107}  // std
108
109*/
110
111#include <__config>
112#include <__tuple>
113#include <type_traits>
114
115#pragma GCC system_header
116
117_LIBCPP_BEGIN_NAMESPACE_STD
118
119namespace rel_ops
120{
121
122template<class _Tp>
123inline _LIBCPP_INLINE_VISIBILITY
124bool
125operator!=(const _Tp& __x, const _Tp& __y)
126{
127    return !(__x == __y);
128}
129
130template<class _Tp>
131inline _LIBCPP_INLINE_VISIBILITY
132bool
133operator> (const _Tp& __x, const _Tp& __y)
134{
135    return __y < __x;
136}
137
138template<class _Tp>
139inline _LIBCPP_INLINE_VISIBILITY
140bool
141operator<=(const _Tp& __x, const _Tp& __y)
142{
143    return !(__y < __x);
144}
145
146template<class _Tp>
147inline _LIBCPP_INLINE_VISIBILITY
148bool
149operator>=(const _Tp& __x, const _Tp& __y)
150{
151    return !(__x < __y);
152}
153
154}  // rel_ops
155
156// swap_ranges
157
158template <class _ForwardIterator1, class _ForwardIterator2>
159inline _LIBCPP_INLINE_VISIBILITY
160_ForwardIterator2
161swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
162{
163    for(; __first1 != __last1; ++__first1, ++__first2)
164        swap(*__first1, *__first2);
165    return __first2;
166}
167
168template<class _Tp, size_t _N>
169inline _LIBCPP_INLINE_VISIBILITY
170void
171swap(_Tp (&__a)[_N], _Tp (&__b)[_N])
172{
173    _STD::swap_ranges(__a, __a + _N, __b);
174}
175
176template <class _Tp>
177inline _LIBCPP_INLINE_VISIBILITY
178#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
179typename conditional
180<
181    !is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value,
182    const _Tp&,
183    _Tp&&
184>::type
185#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
186const _Tp&
187#endif
188move_if_noexcept(_Tp& __x)
189{
190    return _STD::move(__x);
191}
192
193struct _LIBCPP_VISIBLE piecewise_construct_t { };
194//constexpr
195extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();
196
197template <class _T1, class _T2> struct pair;
198template <class _T1, class _T2> void swap(pair<_T1, _T2>&, pair<_T1, _T2>&);
199
200template <class _T1, class _T2>
201struct _LIBCPP_VISIBLE pair
202{
203    typedef _T1 first_type;
204    typedef _T2 second_type;
205
206    _T1 first;
207    _T2 second;
208
209    _LIBCPP_INLINE_VISIBILITY pair() : first(), second() {}
210
211    _LIBCPP_INLINE_VISIBILITY pair(const _T1& __x, const _T2& __y)
212        : first(__x), second(__y) {}
213
214#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
215
216    template <class _U1, class _U2,
217              class = typename enable_if<is_convertible<_U1, first_type >::value &&
218                                         is_convertible<_U2, second_type>::value>::type>
219        _LIBCPP_INLINE_VISIBILITY
220        pair(_U1&& __u1, _U2&& __u2)
221            : first(_STD::forward<_U1>(__u1)),
222              second(_STD::forward<_U2>(__u2))
223            {}
224
225#ifndef _LIBCPP_HAS_NO_VARIADICS
226
227    template<class _Tuple,
228             class = typename enable_if<__tuple_convertible<_Tuple, pair>::value>::type>
229        _LIBCPP_INLINE_VISIBILITY
230        pair(_Tuple&& __p)
231            : first(_STD::forward<typename tuple_element<0,
232                                  typename __make_tuple_types<_Tuple>::type>::type>(get<0>(__p))),
233              second(_STD::forward<typename tuple_element<1,
234                                   typename __make_tuple_types<_Tuple>::type>::type>(get<1>(__p)))
235            {}
236
237
238
239    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
240        _LIBCPP_INLINE_VISIBILITY
241        pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
242                                    tuple<_Args2...> __second_args)
243            : pair(__pc, __first_args, __second_args,
244                   typename __make_tuple_indices<sizeof...(_Args1)>::type(),
245                   typename __make_tuple_indices<sizeof...(_Args2) >::type())
246            {}
247
248    template <class _Tuple,
249              class = typename enable_if<__tuple_assignable<_Tuple, pair>::value>::type>
250        _LIBCPP_INLINE_VISIBILITY
251        pair&
252        operator=(_Tuple&& __p)
253        {
254            typedef typename __make_tuple_types<_Tuple>::type _TupleRef;
255            typedef typename tuple_element<0, _TupleRef>::type _U0;
256            typedef typename tuple_element<1, _TupleRef>::type _U1;
257            first  = _STD::forward<_U0>(_STD::get<0>(__p));
258            second = _STD::forward<_U1>(_STD::get<1>(__p));
259            return *this;
260        }
261
262#endif  // _LIBCPP_HAS_NO_VARIADICS
263
264#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
265    template<class _U1, class _U2>
266        _LIBCPP_INLINE_VISIBILITY pair(const pair<_U1, _U2>& __p)
267            : first(__p.first), second(__p.second) {}
268#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
269    void _LIBCPP_INLINE_VISIBILITY swap(pair& __p) {_STD::swap(*this, __p);}
270private:
271
272#ifndef _LIBCPP_HAS_NO_VARIADICS
273    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
274        _LIBCPP_INLINE_VISIBILITY
275        pair(piecewise_construct_t,
276             tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
277             __tuple_indices<_I1...>, __tuple_indices<_I2...>);
278#endif  // _LIBCPP_HAS_NO_VARIADICS
279};
280
281template <class _T1, class _T2>
282inline _LIBCPP_INLINE_VISIBILITY
283bool
284operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
285{
286    return __x.first == __y.first && __x.second == __y.second;
287}
288
289template <class _T1, class _T2>
290inline _LIBCPP_INLINE_VISIBILITY
291bool
292operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
293{
294    return !(__x == __y);
295}
296
297template <class _T1, class _T2>
298inline _LIBCPP_INLINE_VISIBILITY
299bool
300operator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
301{
302    return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
303}
304
305template <class _T1, class _T2>
306inline _LIBCPP_INLINE_VISIBILITY
307bool
308operator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
309{
310    return __y < __x;
311}
312
313template <class _T1, class _T2>
314inline _LIBCPP_INLINE_VISIBILITY
315bool
316operator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
317{
318    return !(__x < __y);
319}
320
321template <class _T1, class _T2>
322inline _LIBCPP_INLINE_VISIBILITY
323bool
324operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
325{
326    return !(__y < __x);
327}
328
329template <class _T1, class _T2>
330inline _LIBCPP_INLINE_VISIBILITY
331void
332swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
333{
334    swap(__x.first, __y.first);
335    swap(__x.second, __y.second);
336}
337
338#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
339
340template <class _Tp> class reference_wrapper;
341
342template <class _Tp>
343struct ___make_pair_return
344{
345    typedef _Tp type;
346};
347
348template <class _Tp>
349struct ___make_pair_return<reference_wrapper<_Tp>>
350{
351    typedef _Tp& type;
352};
353
354template <class _Tp>
355struct __make_pair_return
356{
357    typedef typename ___make_pair_return<typename decay<_Tp>::type>::type type;
358};
359
360template <class _T1, class _T2>
361inline _LIBCPP_INLINE_VISIBILITY
362pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
363make_pair(_T1&& __t1, _T2&& __t2)
364{
365    return pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
366               (_STD::forward<_T1>(__t1), _STD::forward<_T2>(__t2));
367}
368
369#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
370
371template <class _T1, class _T2>
372inline _LIBCPP_INLINE_VISIBILITY
373pair<_T1,_T2>
374make_pair(_T1 __x, _T2 __y)
375{
376    return pair<_T1, _T2>(__x, __y);
377}
378
379#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
380
381#ifndef _LIBCPP_HAS_NO_VARIADICS
382
383template <class _T1, class _T2>
384  class _LIBCPP_VISIBLE tuple_size<pair<_T1, _T2> >
385    : public integral_constant<size_t, 2> {};
386
387template <class _T1, class _T2>
388  class _LIBCPP_VISIBLE tuple_size<const pair<_T1, _T2> >
389    : public integral_constant<size_t, 2> {};
390
391template <class _T1, class _T2>
392class _LIBCPP_VISIBLE tuple_element<0, pair<_T1, _T2> >
393{
394public:
395    typedef _T1 type;
396};
397
398template <class _T1, class _T2>
399class _LIBCPP_VISIBLE tuple_element<1, pair<_T1, _T2> >
400{
401public:
402    typedef _T2 type;
403};
404
405template <class _T1, class _T2>
406class _LIBCPP_VISIBLE tuple_element<0, const pair<_T1, _T2> >
407{
408public:
409    typedef const _T1 type;
410};
411
412template <class _T1, class _T2>
413class _LIBCPP_VISIBLE tuple_element<1, const pair<_T1, _T2> >
414{
415public:
416    typedef const _T2 type;
417};
418
419template <size_t _Ip> struct __get_pair;
420
421template <>
422struct __get_pair<0>
423{
424    template <class _T1, class _T2>
425    static
426    _LIBCPP_INLINE_VISIBILITY
427    _T1&
428    get(pair<_T1, _T2>& __p) {return __p.first;}
429
430    template <class _T1, class _T2>
431    static
432    _LIBCPP_INLINE_VISIBILITY
433    const _T1&
434    get(const pair<_T1, _T2>& __p) {return __p.first;}
435
436#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
437
438    template <class _T1, class _T2>
439    static
440    _LIBCPP_INLINE_VISIBILITY
441    _T1&&
442    get(pair<_T1, _T2>&& __p) {return _STD::forward<_T1>(__p.first);}
443
444#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
445};
446
447template <>
448struct __get_pair<1>
449{
450    template <class _T1, class _T2>
451    static
452    _LIBCPP_INLINE_VISIBILITY
453    _T2&
454    get(pair<_T1, _T2>& __p) {return __p.second;}
455
456    template <class _T1, class _T2>
457    static
458    _LIBCPP_INLINE_VISIBILITY
459    const _T2&
460    get(const pair<_T1, _T2>& __p) {return __p.second;}
461
462#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
463
464    template <class _T1, class _T2>
465    static
466    _LIBCPP_INLINE_VISIBILITY
467    _T2&&
468    get(pair<_T1, _T2>&& __p) {return _STD::forward<_T2>(__p.second);}
469
470#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
471};
472
473template <size_t _Ip, class _T1, class _T2>
474_LIBCPP_INLINE_VISIBILITY inline
475typename tuple_element<_Ip, pair<_T1, _T2> >::type&
476get(pair<_T1, _T2>& __p)
477{
478    return __get_pair<_Ip>::get(__p);
479}
480
481template <size_t _Ip, class _T1, class _T2>
482_LIBCPP_INLINE_VISIBILITY inline
483const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
484get(const pair<_T1, _T2>& __p)
485{
486    return __get_pair<_Ip>::get(__p);
487}
488
489#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
490
491template <size_t _Ip, class _T1, class _T2>
492_LIBCPP_INLINE_VISIBILITY inline
493typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
494get(pair<_T1, _T2>&& __p)
495{
496    return __get_pair<_Ip>::get(_STD::move(__p));
497}
498
499#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
500
501#endif  // _LIBCPP_HAS_NO_VARIADICS
502
503_LIBCPP_END_NAMESPACE_STD
504
505#endif  // _LIBCPP_UTILITY
506