// -*- C++ -*- //===-------------------------- utility -----------------------------------===// // // The LLVM Compiler Infrastructure // // This file is dual licensed under the MIT and the University of Illinois Open // Source Licenses. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_UTILITY #define _LIBCPP_UTILITY /* utility synopsis namespace std { template void swap(T& a, T& b); namespace rel_ops { template bool operator!=(const T&, const T&); template bool operator> (const T&, const T&); template bool operator<=(const T&, const T&); template bool operator>=(const T&, const T&); } template void swap(T& a, T& b) noexcept(is_nothrow_move_constructible::value && is_nothrow_move_assignable::value); template void swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b))); template T&& forward(typename remove_reference::type& t) noexcept; template T&& forward(typename remove_reference::type&& t) noexcept; template typename remove_reference::type&& move(T&&) noexcept; template typename conditional < !is_nothrow_move_constructible::value && is_copy_constructible::value, const T&, T&& >::type move_if_noexcept(T& x) noexcept; template typename add_rvalue_reference::type declval() noexcept; template struct pair { typedef T1 first_type; typedef T2 second_type; T1 first; T2 second; pair(const pair&) = default; pair(pair&&) = default; constexpr pair(); pair(const T1& x, const T2& y); template pair(U&& x, V&& y); template pair(const pair& p); template pair(pair&& p); template pair(piecewise_construct_t, tuple first_args, tuple second_args); template pair& operator=(const pair& p); pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable::value && is_nothrow_move_assignable::value); template pair& operator=(pair&& p); void swap(pair& p) noexcept(noexcept(swap(first, p.first)) && noexcept(swap(second, p.second))); }; template bool operator==(const pair&, const pair&); template bool operator!=(const pair&, const pair&); template bool operator< (const pair&, const pair&); template bool operator> (const pair&, const pair&); template bool operator>=(const pair&, const pair&); template bool operator<=(const pair&, const pair&); template pair make_pair(T1&&, T2&&); template void swap(pair& x, pair& y) noexcept(noexcept(x.swap(y))); struct piecewise_construct_t { }; constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); template class tuple_size; template class tuple_element; template struct tuple_size >; template struct tuple_element<0, std::pair >; template struct tuple_element<1, std::pair >; template typename tuple_element >::type& get(std::pair&) noexcept; template const typename const tuple_element >::type& get(const std::pair&) noexcept; template typename tuple_element >::type&& get(std::pair&&) noexcept; } // std */ #include <__config> #include <__tuple> #include #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif _LIBCPP_BEGIN_NAMESPACE_STD namespace rel_ops { template inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const _Tp& __x, const _Tp& __y) { return !(__x == __y); } template inline _LIBCPP_INLINE_VISIBILITY bool operator> (const _Tp& __x, const _Tp& __y) { return __y < __x; } template inline _LIBCPP_INLINE_VISIBILITY bool operator<=(const _Tp& __x, const _Tp& __y) { return !(__y < __x); } template inline _LIBCPP_INLINE_VISIBILITY bool operator>=(const _Tp& __x, const _Tp& __y) { return !(__x < __y); } } // rel_ops // swap_ranges template inline _LIBCPP_INLINE_VISIBILITY _ForwardIterator2 swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) { for(; __first1 != __last1; ++__first1, ++__first2) swap(*__first1, *__first2); return __first2; } template inline _LIBCPP_INLINE_VISIBILITY void swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) { _VSTD::swap_ranges(__a, __a + _Np, __b); } template inline _LIBCPP_INLINE_VISIBILITY #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES typename conditional < !is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value, const _Tp&, _Tp&& >::type #else // _LIBCPP_HAS_NO_RVALUE_REFERENCES const _Tp& #endif move_if_noexcept(_Tp& __x) _NOEXCEPT { return _VSTD::move(__x); } struct _LIBCPP_VISIBLE piecewise_construct_t { }; #if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_UTILITY) extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t(); #else constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); #endif template struct _LIBCPP_VISIBLE pair { typedef _T1 first_type; typedef _T2 second_type; _T1 first; _T2 second; // pair(const pair&) = default; // pair(pair&&) = default; _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR pair() : first(), second() {} _LIBCPP_INLINE_VISIBILITY pair(const _T1& __x, const _T2& __y) : first(__x), second(__y) {} template _LIBCPP_INLINE_VISIBILITY pair(const pair<_U1, _U2>& __p #ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE ,typename enable_if::value && is_convertible::value>::type* = 0 #endif ) : first(__p.first), second(__p.second) {} _LIBCPP_INLINE_VISIBILITY pair(const pair& __p) _NOEXCEPT_(is_nothrow_copy_constructible::value && is_nothrow_copy_constructible::value) : first(__p.first), second(__p.second) { } _LIBCPP_INLINE_VISIBILITY pair& operator=(const pair& __p) _NOEXCEPT_(is_nothrow_copy_assignable::value && is_nothrow_copy_assignable::value) { first = __p.first; second = __p.second; return *this; } #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES template ::value && is_convertible<_U2, second_type>::value>::type> _LIBCPP_INLINE_VISIBILITY pair(_U1&& __u1, _U2&& __u2) : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {} template _LIBCPP_INLINE_VISIBILITY pair(pair<_U1, _U2>&& __p, typename enable_if::value && is_convertible<_U2, _T2>::value>::type* = 0) : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {} _LIBCPP_INLINE_VISIBILITY pair(pair&& __p) _NOEXCEPT_(is_nothrow_move_constructible::value && is_nothrow_move_constructible::value) : first(_VSTD::forward(__p.first)), second(_VSTD::forward(__p.second)) { } _LIBCPP_INLINE_VISIBILITY pair& operator=(pair&& __p) _NOEXCEPT_(is_nothrow_move_assignable::value && is_nothrow_move_assignable::value) { first = _VSTD::forward(__p.first); second = _VSTD::forward(__p.second); return *this; } #ifndef _LIBCPP_HAS_NO_VARIADICS template::value>::type> _LIBCPP_INLINE_VISIBILITY pair(_Tuple&& __p) : first(_VSTD::forward::type>::type>(get<0>(__p))), second(_VSTD::forward::type>::type>(get<1>(__p))) {} template _LIBCPP_INLINE_VISIBILITY pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args, tuple<_Args2...> __second_args) : pair(__pc, __first_args, __second_args, typename __make_tuple_indices::type(), typename __make_tuple_indices::type()) {} template ::value>::type> _LIBCPP_INLINE_VISIBILITY pair& operator=(_Tuple&& __p) { typedef typename __make_tuple_types<_Tuple>::type _TupleRef; typedef typename tuple_element<0, _TupleRef>::type _U0; typedef typename tuple_element<1, _TupleRef>::type _U1; first = _VSTD::forward<_U0>(_VSTD::get<0>(__p)); second = _VSTD::forward<_U1>(_VSTD::get<1>(__p)); return *this; } #endif // _LIBCPP_HAS_NO_VARIADICS #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY void swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable::value && __is_nothrow_swappable::value) { _VSTD::iter_swap(&first, &__p.first); _VSTD::iter_swap(&second, &__p.second); } private: #ifndef _LIBCPP_HAS_NO_VARIADICS template _LIBCPP_INLINE_VISIBILITY pair(piecewise_construct_t, tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args, __tuple_indices<_I1...>, __tuple_indices<_I2...>); #endif // _LIBCPP_HAS_NO_VARIADICS }; template inline _LIBCPP_INLINE_VISIBILITY bool operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) { return __x.first == __y.first && __x.second == __y.second; } template inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) { return !(__x == __y); } template inline _LIBCPP_INLINE_VISIBILITY bool operator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) { return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second); } template inline _LIBCPP_INLINE_VISIBILITY bool operator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) { return __y < __x; } template inline _LIBCPP_INLINE_VISIBILITY bool operator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) { return !(__x < __y); } template inline _LIBCPP_INLINE_VISIBILITY bool operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) { return !(__y < __x); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_swappable<_T1>::value && __is_swappable<_T2>::value, void >::type swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) _NOEXCEPT_((__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T2>::value)) { __x.swap(__y); } #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES template class reference_wrapper; template struct ___make_pair_return { typedef _Tp type; }; template struct ___make_pair_return> { typedef _Tp& type; }; template struct __make_pair_return { typedef typename ___make_pair_return::type>::type type; }; template inline _LIBCPP_INLINE_VISIBILITY pair::type, typename __make_pair_return<_T2>::type> make_pair(_T1&& __t1, _T2&& __t2) { return pair::type, typename __make_pair_return<_T2>::type> (_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2)); } #else // _LIBCPP_HAS_NO_RVALUE_REFERENCES template inline _LIBCPP_INLINE_VISIBILITY pair<_T1,_T2> make_pair(_T1 __x, _T2 __y) { return pair<_T1, _T2>(__x, __y); } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_VARIADICS template class _LIBCPP_VISIBLE tuple_size > : public integral_constant {}; template class _LIBCPP_VISIBLE tuple_size > : public integral_constant {}; template class _LIBCPP_VISIBLE tuple_element<0, pair<_T1, _T2> > { public: typedef _T1 type; }; template class _LIBCPP_VISIBLE tuple_element<1, pair<_T1, _T2> > { public: typedef _T2 type; }; template class _LIBCPP_VISIBLE tuple_element<0, const pair<_T1, _T2> > { public: typedef const _T1 type; }; template class _LIBCPP_VISIBLE tuple_element<1, const pair<_T1, _T2> > { public: typedef const _T2 type; }; template struct __get_pair; template <> struct __get_pair<0> { template static _LIBCPP_INLINE_VISIBILITY _T1& get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;} template static _LIBCPP_INLINE_VISIBILITY const _T1& get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;} #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES template static _LIBCPP_INLINE_VISIBILITY _T1&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);} #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES }; template <> struct __get_pair<1> { template static _LIBCPP_INLINE_VISIBILITY _T2& get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;} template static _LIBCPP_INLINE_VISIBILITY const _T2& get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;} #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES template static _LIBCPP_INLINE_VISIBILITY _T2&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);} #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES }; template _LIBCPP_INLINE_VISIBILITY inline typename tuple_element<_Ip, pair<_T1, _T2> >::type& get(pair<_T1, _T2>& __p) _NOEXCEPT { return __get_pair<_Ip>::get(__p); } template _LIBCPP_INLINE_VISIBILITY inline const typename tuple_element<_Ip, pair<_T1, _T2> >::type& get(const pair<_T1, _T2>& __p) _NOEXCEPT { return __get_pair<_Ip>::get(__p); } #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES template _LIBCPP_INLINE_VISIBILITY inline typename tuple_element<_Ip, pair<_T1, _T2> >::type&& get(pair<_T1, _T2>&& __p) _NOEXCEPT { return __get_pair<_Ip>::get(_VSTD::move(__p)); } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES #endif // _LIBCPP_HAS_NO_VARIADICS _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_UTILITY