1*4d6fc14bSjoerg// -*- C++ -*- 2*4d6fc14bSjoerg//===-------------------------- utility -----------------------------------===// 3*4d6fc14bSjoerg// 4*4d6fc14bSjoerg// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5*4d6fc14bSjoerg// See https://llvm.org/LICENSE.txt for license information. 6*4d6fc14bSjoerg// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7*4d6fc14bSjoerg// 8*4d6fc14bSjoerg//===----------------------------------------------------------------------===// 9*4d6fc14bSjoerg 10*4d6fc14bSjoerg#ifndef _LIBCPP_UTILITY 11*4d6fc14bSjoerg#define _LIBCPP_UTILITY 12*4d6fc14bSjoerg 13*4d6fc14bSjoerg/* 14*4d6fc14bSjoerg utility synopsis 15*4d6fc14bSjoerg 16*4d6fc14bSjoerg#include <initializer_list> 17*4d6fc14bSjoerg 18*4d6fc14bSjoergnamespace std 19*4d6fc14bSjoerg{ 20*4d6fc14bSjoerg 21*4d6fc14bSjoergtemplate <class T> 22*4d6fc14bSjoerg void 23*4d6fc14bSjoerg swap(T& a, T& b); 24*4d6fc14bSjoerg 25*4d6fc14bSjoergnamespace rel_ops 26*4d6fc14bSjoerg{ 27*4d6fc14bSjoerg template<class T> bool operator!=(const T&, const T&); 28*4d6fc14bSjoerg template<class T> bool operator> (const T&, const T&); 29*4d6fc14bSjoerg template<class T> bool operator<=(const T&, const T&); 30*4d6fc14bSjoerg template<class T> bool operator>=(const T&, const T&); 31*4d6fc14bSjoerg} 32*4d6fc14bSjoerg 33*4d6fc14bSjoergtemplate<class T> 34*4d6fc14bSjoergvoid 35*4d6fc14bSjoergswap(T& a, T& b) noexcept(is_nothrow_move_constructible<T>::value && 36*4d6fc14bSjoerg is_nothrow_move_assignable<T>::value); 37*4d6fc14bSjoerg 38*4d6fc14bSjoergtemplate <class T, size_t N> 39*4d6fc14bSjoergvoid 40*4d6fc14bSjoergswap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b))); 41*4d6fc14bSjoerg 42*4d6fc14bSjoergtemplate <class T> T&& forward(typename remove_reference<T>::type& t) noexcept; // constexpr in C++14 43*4d6fc14bSjoergtemplate <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept; // constexpr in C++14 44*4d6fc14bSjoerg 45*4d6fc14bSjoergtemplate <class T> typename remove_reference<T>::type&& move(T&&) noexcept; // constexpr in C++14 46*4d6fc14bSjoerg 47*4d6fc14bSjoergtemplate <class T> 48*4d6fc14bSjoerg typename conditional 49*4d6fc14bSjoerg < 50*4d6fc14bSjoerg !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value, 51*4d6fc14bSjoerg const T&, 52*4d6fc14bSjoerg T&& 53*4d6fc14bSjoerg >::type 54*4d6fc14bSjoerg move_if_noexcept(T& x) noexcept; // constexpr in C++14 55*4d6fc14bSjoerg 56*4d6fc14bSjoergtemplate <class T> constexpr add_const_t<T>& as_const(T& t) noexcept; // C++17 57*4d6fc14bSjoergtemplate <class T> void as_const(const T&&) = delete; // C++17 58*4d6fc14bSjoerg 59*4d6fc14bSjoergtemplate <class T> typename add_rvalue_reference<T>::type declval() noexcept; 60*4d6fc14bSjoerg 61*4d6fc14bSjoergtemplate<class T, class U> constexpr bool cmp_equal(T t, U u) noexcept; // C++20 62*4d6fc14bSjoergtemplate<class T, class U> constexpr bool cmp_not_equal(T t, U u) noexcept; // C++20 63*4d6fc14bSjoergtemplate<class T, class U> constexpr bool cmp_less(T t, U u) noexcept; // C++20 64*4d6fc14bSjoergtemplate<class T, class U> constexpr bool cmp_greater(T t, U u) noexcept; // C++20 65*4d6fc14bSjoergtemplate<class T, class U> constexpr bool cmp_less_equal(T t, U u) noexcept; // C++20 66*4d6fc14bSjoergtemplate<class T, class U> constexpr bool cmp_greater_equal(T t, U u) noexcept; // C++20 67*4d6fc14bSjoergtemplate<class R, class T> constexpr bool in_range(T t) noexcept; // C++20 68*4d6fc14bSjoerg 69*4d6fc14bSjoergtemplate <class T1, class T2> 70*4d6fc14bSjoergstruct pair 71*4d6fc14bSjoerg{ 72*4d6fc14bSjoerg typedef T1 first_type; 73*4d6fc14bSjoerg typedef T2 second_type; 74*4d6fc14bSjoerg 75*4d6fc14bSjoerg T1 first; 76*4d6fc14bSjoerg T2 second; 77*4d6fc14bSjoerg 78*4d6fc14bSjoerg pair(const pair&) = default; 79*4d6fc14bSjoerg pair(pair&&) = default; 80*4d6fc14bSjoerg explicit(see-below) constexpr pair(); 81*4d6fc14bSjoerg explicit(see-below) pair(const T1& x, const T2& y); // constexpr in C++14 82*4d6fc14bSjoerg template <class U, class V> explicit(see-below) pair(U&& x, V&& y); // constexpr in C++14 83*4d6fc14bSjoerg template <class U, class V> explicit(see-below) pair(const pair<U, V>& p); // constexpr in C++14 84*4d6fc14bSjoerg template <class U, class V> explicit(see-below) pair(pair<U, V>&& p); // constexpr in C++14 85*4d6fc14bSjoerg template <class... Args1, class... Args2> 86*4d6fc14bSjoerg pair(piecewise_construct_t, tuple<Args1...> first_args, 87*4d6fc14bSjoerg tuple<Args2...> second_args); // constexpr in C++20 88*4d6fc14bSjoerg 89*4d6fc14bSjoerg template <class U, class V> pair& operator=(const pair<U, V>& p); // constexpr in C++20 90*4d6fc14bSjoerg pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value && 91*4d6fc14bSjoerg is_nothrow_move_assignable<T2>::value); // constexpr in C++20 92*4d6fc14bSjoerg template <class U, class V> pair& operator=(pair<U, V>&& p); // constexpr in C++20 93*4d6fc14bSjoerg 94*4d6fc14bSjoerg void swap(pair& p) noexcept(is_nothrow_swappable_v<T1> && 95*4d6fc14bSjoerg is_nothrow_swappable_v<T2>); // constexpr in C++20 96*4d6fc14bSjoerg}; 97*4d6fc14bSjoerg 98*4d6fc14bSjoergtemplate <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14 99*4d6fc14bSjoergtemplate <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14 100*4d6fc14bSjoergtemplate <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14 101*4d6fc14bSjoergtemplate <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14 102*4d6fc14bSjoergtemplate <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14 103*4d6fc14bSjoergtemplate <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14 104*4d6fc14bSjoerg 105*4d6fc14bSjoergtemplate <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&); // constexpr in C++14 106*4d6fc14bSjoergtemplate <class T1, class T2> 107*4d6fc14bSjoergvoid 108*4d6fc14bSjoergswap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y))); // constexpr in C++20 109*4d6fc14bSjoerg 110*4d6fc14bSjoergstruct piecewise_construct_t { explicit piecewise_construct_t() = default; }; 111*4d6fc14bSjoerginline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); 112*4d6fc14bSjoerg 113*4d6fc14bSjoergtemplate <class T> struct tuple_size; 114*4d6fc14bSjoergtemplate <size_t I, class T> struct tuple_element; 115*4d6fc14bSjoerg 116*4d6fc14bSjoergtemplate <class T1, class T2> struct tuple_size<pair<T1, T2> >; 117*4d6fc14bSjoergtemplate <class T1, class T2> struct tuple_element<0, pair<T1, T2> >; 118*4d6fc14bSjoergtemplate <class T1, class T2> struct tuple_element<1, pair<T1, T2> >; 119*4d6fc14bSjoerg 120*4d6fc14bSjoergtemplate<size_t I, class T1, class T2> 121*4d6fc14bSjoerg typename tuple_element<I, pair<T1, T2> >::type& 122*4d6fc14bSjoerg get(pair<T1, T2>&) noexcept; // constexpr in C++14 123*4d6fc14bSjoerg 124*4d6fc14bSjoergtemplate<size_t I, class T1, class T2> 125*4d6fc14bSjoerg const typename tuple_element<I, pair<T1, T2> >::type& 126*4d6fc14bSjoerg get(const pair<T1, T2>&) noexcept; // constexpr in C++14 127*4d6fc14bSjoerg 128*4d6fc14bSjoergtemplate<size_t I, class T1, class T2> 129*4d6fc14bSjoerg typename tuple_element<I, pair<T1, T2> >::type&& 130*4d6fc14bSjoerg get(pair<T1, T2>&&) noexcept; // constexpr in C++14 131*4d6fc14bSjoerg 132*4d6fc14bSjoergtemplate<size_t I, class T1, class T2> 133*4d6fc14bSjoerg const typename tuple_element<I, pair<T1, T2> >::type&& 134*4d6fc14bSjoerg get(const pair<T1, T2>&&) noexcept; // constexpr in C++14 135*4d6fc14bSjoerg 136*4d6fc14bSjoergtemplate<class T1, class T2> 137*4d6fc14bSjoerg constexpr T1& get(pair<T1, T2>&) noexcept; // C++14 138*4d6fc14bSjoerg 139*4d6fc14bSjoergtemplate<class T1, class T2> 140*4d6fc14bSjoerg constexpr const T1& get(const pair<T1, T2>&) noexcept; // C++14 141*4d6fc14bSjoerg 142*4d6fc14bSjoergtemplate<class T1, class T2> 143*4d6fc14bSjoerg constexpr T1&& get(pair<T1, T2>&&) noexcept; // C++14 144*4d6fc14bSjoerg 145*4d6fc14bSjoergtemplate<class T1, class T2> 146*4d6fc14bSjoerg constexpr const T1&& get(const pair<T1, T2>&&) noexcept; // C++14 147*4d6fc14bSjoerg 148*4d6fc14bSjoergtemplate<class T1, class T2> 149*4d6fc14bSjoerg constexpr T1& get(pair<T2, T1>&) noexcept; // C++14 150*4d6fc14bSjoerg 151*4d6fc14bSjoergtemplate<class T1, class T2> 152*4d6fc14bSjoerg constexpr const T1& get(const pair<T2, T1>&) noexcept; // C++14 153*4d6fc14bSjoerg 154*4d6fc14bSjoergtemplate<class T1, class T2> 155*4d6fc14bSjoerg constexpr T1&& get(pair<T2, T1>&&) noexcept; // C++14 156*4d6fc14bSjoerg 157*4d6fc14bSjoergtemplate<class T1, class T2> 158*4d6fc14bSjoerg constexpr const T1&& get(const pair<T2, T1>&&) noexcept; // C++14 159*4d6fc14bSjoerg 160*4d6fc14bSjoerg// C++14 161*4d6fc14bSjoerg 162*4d6fc14bSjoergtemplate<class T, T... I> 163*4d6fc14bSjoergstruct integer_sequence 164*4d6fc14bSjoerg{ 165*4d6fc14bSjoerg typedef T value_type; 166*4d6fc14bSjoerg 167*4d6fc14bSjoerg static constexpr size_t size() noexcept; 168*4d6fc14bSjoerg}; 169*4d6fc14bSjoerg 170*4d6fc14bSjoergtemplate<size_t... I> 171*4d6fc14bSjoerg using index_sequence = integer_sequence<size_t, I...>; 172*4d6fc14bSjoerg 173*4d6fc14bSjoergtemplate<class T, T N> 174*4d6fc14bSjoerg using make_integer_sequence = integer_sequence<T, 0, 1, ..., N-1>; 175*4d6fc14bSjoergtemplate<size_t N> 176*4d6fc14bSjoerg using make_index_sequence = make_integer_sequence<size_t, N>; 177*4d6fc14bSjoerg 178*4d6fc14bSjoergtemplate<class... T> 179*4d6fc14bSjoerg using index_sequence_for = make_index_sequence<sizeof...(T)>; 180*4d6fc14bSjoerg 181*4d6fc14bSjoergtemplate<class T, class U=T> 182*4d6fc14bSjoerg T exchange(T& obj, U&& new_value); 183*4d6fc14bSjoerg 184*4d6fc14bSjoerg// 20.2.7, in-place construction // C++17 185*4d6fc14bSjoergstruct in_place_t { 186*4d6fc14bSjoerg explicit in_place_t() = default; 187*4d6fc14bSjoerg}; 188*4d6fc14bSjoerginline constexpr in_place_t in_place{}; 189*4d6fc14bSjoergtemplate <class T> 190*4d6fc14bSjoerg struct in_place_type_t { 191*4d6fc14bSjoerg explicit in_place_type_t() = default; 192*4d6fc14bSjoerg }; 193*4d6fc14bSjoergtemplate <class T> 194*4d6fc14bSjoerg inline constexpr in_place_type_t<T> in_place_type{}; 195*4d6fc14bSjoergtemplate <size_t I> 196*4d6fc14bSjoerg struct in_place_index_t { 197*4d6fc14bSjoerg explicit in_place_index_t() = default; 198*4d6fc14bSjoerg }; 199*4d6fc14bSjoergtemplate <size_t I> 200*4d6fc14bSjoerg inline constexpr in_place_index_t<I> in_place_index{}; 201*4d6fc14bSjoerg 202*4d6fc14bSjoerg// [utility.underlying], to_underlying 203*4d6fc14bSjoergtemplate <class T> 204*4d6fc14bSjoerg constexpr underlying_type_t<T> to_underlying( T value ) noexcept; // C++2b 205*4d6fc14bSjoerg 206*4d6fc14bSjoerg} // std 207*4d6fc14bSjoerg 208*4d6fc14bSjoerg*/ 209*4d6fc14bSjoerg 210*4d6fc14bSjoerg#include <__config> 211*4d6fc14bSjoerg#include <__tuple> 212*4d6fc14bSjoerg#include <__utility/to_underlying.h> 213*4d6fc14bSjoerg#include <compare> 214*4d6fc14bSjoerg#include <type_traits> 215*4d6fc14bSjoerg#include <initializer_list> 216*4d6fc14bSjoerg#include <cstddef> 217*4d6fc14bSjoerg#include <cstring> 218*4d6fc14bSjoerg#include <cstdint> 219*4d6fc14bSjoerg#include <limits> 220*4d6fc14bSjoerg#include <version> 221*4d6fc14bSjoerg#include <__debug> 222*4d6fc14bSjoerg 223*4d6fc14bSjoerg#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 224*4d6fc14bSjoerg#pragma GCC system_header 225*4d6fc14bSjoerg#endif 226*4d6fc14bSjoerg 227*4d6fc14bSjoerg_LIBCPP_PUSH_MACROS 228*4d6fc14bSjoerg#include <__undef_macros> 229*4d6fc14bSjoerg 230*4d6fc14bSjoerg_LIBCPP_BEGIN_NAMESPACE_STD 231*4d6fc14bSjoerg 232*4d6fc14bSjoergnamespace rel_ops 233*4d6fc14bSjoerg{ 234*4d6fc14bSjoerg 235*4d6fc14bSjoergtemplate<class _Tp> 236*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 237*4d6fc14bSjoergbool 238*4d6fc14bSjoergoperator!=(const _Tp& __x, const _Tp& __y) 239*4d6fc14bSjoerg{ 240*4d6fc14bSjoerg return !(__x == __y); 241*4d6fc14bSjoerg} 242*4d6fc14bSjoerg 243*4d6fc14bSjoergtemplate<class _Tp> 244*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 245*4d6fc14bSjoergbool 246*4d6fc14bSjoergoperator> (const _Tp& __x, const _Tp& __y) 247*4d6fc14bSjoerg{ 248*4d6fc14bSjoerg return __y < __x; 249*4d6fc14bSjoerg} 250*4d6fc14bSjoerg 251*4d6fc14bSjoergtemplate<class _Tp> 252*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 253*4d6fc14bSjoergbool 254*4d6fc14bSjoergoperator<=(const _Tp& __x, const _Tp& __y) 255*4d6fc14bSjoerg{ 256*4d6fc14bSjoerg return !(__y < __x); 257*4d6fc14bSjoerg} 258*4d6fc14bSjoerg 259*4d6fc14bSjoergtemplate<class _Tp> 260*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 261*4d6fc14bSjoergbool 262*4d6fc14bSjoergoperator>=(const _Tp& __x, const _Tp& __y) 263*4d6fc14bSjoerg{ 264*4d6fc14bSjoerg return !(__x < __y); 265*4d6fc14bSjoerg} 266*4d6fc14bSjoerg 267*4d6fc14bSjoerg} // rel_ops 268*4d6fc14bSjoerg 269*4d6fc14bSjoerg// swap_ranges is defined in <type_traits>` 270*4d6fc14bSjoerg 271*4d6fc14bSjoerg// swap is defined in <type_traits> 272*4d6fc14bSjoerg 273*4d6fc14bSjoerg// move_if_noexcept 274*4d6fc14bSjoerg 275*4d6fc14bSjoergtemplate <class _Tp> 276*4d6fc14bSjoerg_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 277*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG 278*4d6fc14bSjoergtypename conditional 279*4d6fc14bSjoerg< 280*4d6fc14bSjoerg !is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value, 281*4d6fc14bSjoerg const _Tp&, 282*4d6fc14bSjoerg _Tp&& 283*4d6fc14bSjoerg>::type 284*4d6fc14bSjoerg#else // _LIBCPP_CXX03_LANG 285*4d6fc14bSjoergconst _Tp& 286*4d6fc14bSjoerg#endif 287*4d6fc14bSjoergmove_if_noexcept(_Tp& __x) _NOEXCEPT 288*4d6fc14bSjoerg{ 289*4d6fc14bSjoerg return _VSTD::move(__x); 290*4d6fc14bSjoerg} 291*4d6fc14bSjoerg 292*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 14 293*4d6fc14bSjoergtemplate <class _Tp> 294*4d6fc14bSjoerg_LIBCPP_NODISCARD_EXT constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; } 295*4d6fc14bSjoerg 296*4d6fc14bSjoergtemplate <class _Tp> 297*4d6fc14bSjoergvoid as_const(const _Tp&&) = delete; 298*4d6fc14bSjoerg#endif 299*4d6fc14bSjoerg 300*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) 301*4d6fc14bSjoergtemplate<class _Tp, class... _Up> 302*4d6fc14bSjoergstruct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...> {}; 303*4d6fc14bSjoerg 304*4d6fc14bSjoergtemplate<class _Tp> 305*4d6fc14bSjoergconcept __is_safe_integral_cmp = is_integral_v<_Tp> && 306*4d6fc14bSjoerg !_IsSameAsAny<_Tp, bool, char, 307*4d6fc14bSjoerg#ifndef _LIBCPP_HAS_NO_CHAR8_T 308*4d6fc14bSjoerg char8_t, 309*4d6fc14bSjoerg#endif 310*4d6fc14bSjoerg#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS 311*4d6fc14bSjoerg char16_t, char32_t, 312*4d6fc14bSjoerg#endif 313*4d6fc14bSjoerg wchar_t>::value; 314*4d6fc14bSjoerg 315*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up> 316*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr 317*4d6fc14bSjoergbool cmp_equal(_Tp __t, _Up __u) noexcept 318*4d6fc14bSjoerg{ 319*4d6fc14bSjoerg if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>) 320*4d6fc14bSjoerg return __t == __u; 321*4d6fc14bSjoerg else if constexpr (is_signed_v<_Tp>) 322*4d6fc14bSjoerg return __t < 0 ? false : make_unsigned_t<_Tp>(__t) == __u; 323*4d6fc14bSjoerg else 324*4d6fc14bSjoerg return __u < 0 ? false : __t == make_unsigned_t<_Up>(__u); 325*4d6fc14bSjoerg} 326*4d6fc14bSjoerg 327*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up> 328*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr 329*4d6fc14bSjoergbool cmp_not_equal(_Tp __t, _Up __u) noexcept 330*4d6fc14bSjoerg{ 331*4d6fc14bSjoerg return !_VSTD::cmp_equal(__t, __u); 332*4d6fc14bSjoerg} 333*4d6fc14bSjoerg 334*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up> 335*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr 336*4d6fc14bSjoergbool cmp_less(_Tp __t, _Up __u) noexcept 337*4d6fc14bSjoerg{ 338*4d6fc14bSjoerg if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>) 339*4d6fc14bSjoerg return __t < __u; 340*4d6fc14bSjoerg else if constexpr (is_signed_v<_Tp>) 341*4d6fc14bSjoerg return __t < 0 ? true : make_unsigned_t<_Tp>(__t) < __u; 342*4d6fc14bSjoerg else 343*4d6fc14bSjoerg return __u < 0 ? false : __t < make_unsigned_t<_Up>(__u); 344*4d6fc14bSjoerg} 345*4d6fc14bSjoerg 346*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up> 347*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr 348*4d6fc14bSjoergbool cmp_greater(_Tp __t, _Up __u) noexcept 349*4d6fc14bSjoerg{ 350*4d6fc14bSjoerg return _VSTD::cmp_less(__u, __t); 351*4d6fc14bSjoerg} 352*4d6fc14bSjoerg 353*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up> 354*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr 355*4d6fc14bSjoergbool cmp_less_equal(_Tp __t, _Up __u) noexcept 356*4d6fc14bSjoerg{ 357*4d6fc14bSjoerg return !_VSTD::cmp_greater(__t, __u); 358*4d6fc14bSjoerg} 359*4d6fc14bSjoerg 360*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up> 361*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr 362*4d6fc14bSjoergbool cmp_greater_equal(_Tp __t, _Up __u) noexcept 363*4d6fc14bSjoerg{ 364*4d6fc14bSjoerg return !_VSTD::cmp_less(__t, __u); 365*4d6fc14bSjoerg} 366*4d6fc14bSjoerg 367*4d6fc14bSjoergtemplate<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up> 368*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY constexpr 369*4d6fc14bSjoergbool in_range(_Up __u) noexcept 370*4d6fc14bSjoerg{ 371*4d6fc14bSjoerg return _VSTD::cmp_less_equal(__u, numeric_limits<_Tp>::max()) && 372*4d6fc14bSjoerg _VSTD::cmp_greater_equal(__u, numeric_limits<_Tp>::min()); 373*4d6fc14bSjoerg} 374*4d6fc14bSjoerg#endif 375*4d6fc14bSjoerg 376*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS piecewise_construct_t { explicit piecewise_construct_t() = default; }; 377*4d6fc14bSjoerg#if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY) 378*4d6fc14bSjoergextern _LIBCPP_EXPORTED_FROM_ABI const piecewise_construct_t piecewise_construct;// = piecewise_construct_t(); 379*4d6fc14bSjoerg#else 380*4d6fc14bSjoerg/* _LIBCPP_INLINE_VAR */ constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); 381*4d6fc14bSjoerg#endif 382*4d6fc14bSjoerg 383*4d6fc14bSjoerg#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR) 384*4d6fc14bSjoergtemplate <class, class> 385*4d6fc14bSjoergstruct __non_trivially_copyable_base { 386*4d6fc14bSjoerg _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY 387*4d6fc14bSjoerg __non_trivially_copyable_base() _NOEXCEPT {} 388*4d6fc14bSjoerg _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 389*4d6fc14bSjoerg __non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {} 390*4d6fc14bSjoerg}; 391*4d6fc14bSjoerg#endif 392*4d6fc14bSjoerg 393*4d6fc14bSjoergtemplate <class _T1, class _T2> 394*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS pair 395*4d6fc14bSjoerg#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR) 396*4d6fc14bSjoerg: private __non_trivially_copyable_base<_T1, _T2> 397*4d6fc14bSjoerg#endif 398*4d6fc14bSjoerg{ 399*4d6fc14bSjoerg typedef _T1 first_type; 400*4d6fc14bSjoerg typedef _T2 second_type; 401*4d6fc14bSjoerg 402*4d6fc14bSjoerg _T1 first; 403*4d6fc14bSjoerg _T2 second; 404*4d6fc14bSjoerg 405*4d6fc14bSjoerg#if !defined(_LIBCPP_CXX03_LANG) 406*4d6fc14bSjoerg pair(pair const&) = default; 407*4d6fc14bSjoerg pair(pair&&) = default; 408*4d6fc14bSjoerg#else 409*4d6fc14bSjoerg // Use the implicitly declared copy constructor in C++03 410*4d6fc14bSjoerg#endif 411*4d6fc14bSjoerg 412*4d6fc14bSjoerg#ifdef _LIBCPP_CXX03_LANG 413*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 414*4d6fc14bSjoerg pair() : first(), second() {} 415*4d6fc14bSjoerg 416*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 417*4d6fc14bSjoerg pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {} 418*4d6fc14bSjoerg 419*4d6fc14bSjoerg template <class _U1, class _U2> 420*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 421*4d6fc14bSjoerg pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {} 422*4d6fc14bSjoerg 423*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 424*4d6fc14bSjoerg pair& operator=(pair const& __p) { 425*4d6fc14bSjoerg first = __p.first; 426*4d6fc14bSjoerg second = __p.second; 427*4d6fc14bSjoerg return *this; 428*4d6fc14bSjoerg } 429*4d6fc14bSjoerg#else 430*4d6fc14bSjoerg template <bool _Val> 431*4d6fc14bSjoerg using _EnableB _LIBCPP_NODEBUG_TYPE = typename enable_if<_Val, bool>::type; 432*4d6fc14bSjoerg 433*4d6fc14bSjoerg struct _CheckArgs { 434*4d6fc14bSjoerg template <int&...> 435*4d6fc14bSjoerg static constexpr bool __enable_explicit_default() { 436*4d6fc14bSjoerg return is_default_constructible<_T1>::value 437*4d6fc14bSjoerg && is_default_constructible<_T2>::value 438*4d6fc14bSjoerg && !__enable_implicit_default<>(); 439*4d6fc14bSjoerg } 440*4d6fc14bSjoerg 441*4d6fc14bSjoerg template <int&...> 442*4d6fc14bSjoerg static constexpr bool __enable_implicit_default() { 443*4d6fc14bSjoerg return __is_implicitly_default_constructible<_T1>::value 444*4d6fc14bSjoerg && __is_implicitly_default_constructible<_T2>::value; 445*4d6fc14bSjoerg } 446*4d6fc14bSjoerg 447*4d6fc14bSjoerg template <class _U1, class _U2> 448*4d6fc14bSjoerg static constexpr bool __enable_explicit() { 449*4d6fc14bSjoerg return is_constructible<first_type, _U1>::value 450*4d6fc14bSjoerg && is_constructible<second_type, _U2>::value 451*4d6fc14bSjoerg && (!is_convertible<_U1, first_type>::value 452*4d6fc14bSjoerg || !is_convertible<_U2, second_type>::value); 453*4d6fc14bSjoerg } 454*4d6fc14bSjoerg 455*4d6fc14bSjoerg template <class _U1, class _U2> 456*4d6fc14bSjoerg static constexpr bool __enable_implicit() { 457*4d6fc14bSjoerg return is_constructible<first_type, _U1>::value 458*4d6fc14bSjoerg && is_constructible<second_type, _U2>::value 459*4d6fc14bSjoerg && is_convertible<_U1, first_type>::value 460*4d6fc14bSjoerg && is_convertible<_U2, second_type>::value; 461*4d6fc14bSjoerg } 462*4d6fc14bSjoerg }; 463*4d6fc14bSjoerg 464*4d6fc14bSjoerg template <bool _MaybeEnable> 465*4d6fc14bSjoerg using _CheckArgsDep _LIBCPP_NODEBUG_TYPE = typename conditional< 466*4d6fc14bSjoerg _MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type; 467*4d6fc14bSjoerg 468*4d6fc14bSjoerg struct _CheckTupleLikeConstructor { 469*4d6fc14bSjoerg template <class _Tuple> 470*4d6fc14bSjoerg static constexpr bool __enable_implicit() { 471*4d6fc14bSjoerg return __tuple_convertible<_Tuple, pair>::value; 472*4d6fc14bSjoerg } 473*4d6fc14bSjoerg 474*4d6fc14bSjoerg template <class _Tuple> 475*4d6fc14bSjoerg static constexpr bool __enable_explicit() { 476*4d6fc14bSjoerg return __tuple_constructible<_Tuple, pair>::value 477*4d6fc14bSjoerg && !__tuple_convertible<_Tuple, pair>::value; 478*4d6fc14bSjoerg } 479*4d6fc14bSjoerg 480*4d6fc14bSjoerg template <class _Tuple> 481*4d6fc14bSjoerg static constexpr bool __enable_assign() { 482*4d6fc14bSjoerg return __tuple_assignable<_Tuple, pair>::value; 483*4d6fc14bSjoerg } 484*4d6fc14bSjoerg }; 485*4d6fc14bSjoerg 486*4d6fc14bSjoerg template <class _Tuple> 487*4d6fc14bSjoerg using _CheckTLC _LIBCPP_NODEBUG_TYPE = typename conditional< 488*4d6fc14bSjoerg __tuple_like_with_size<_Tuple, 2>::value 489*4d6fc14bSjoerg && !is_same<typename decay<_Tuple>::type, pair>::value, 490*4d6fc14bSjoerg _CheckTupleLikeConstructor, 491*4d6fc14bSjoerg __check_tuple_constructor_fail 492*4d6fc14bSjoerg >::type; 493*4d6fc14bSjoerg 494*4d6fc14bSjoerg template<bool _Dummy = true, _EnableB< 495*4d6fc14bSjoerg _CheckArgsDep<_Dummy>::__enable_explicit_default() 496*4d6fc14bSjoerg > = false> 497*4d6fc14bSjoerg explicit _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 498*4d6fc14bSjoerg pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value && 499*4d6fc14bSjoerg is_nothrow_default_constructible<second_type>::value) 500*4d6fc14bSjoerg : first(), second() {} 501*4d6fc14bSjoerg 502*4d6fc14bSjoerg template<bool _Dummy = true, _EnableB< 503*4d6fc14bSjoerg _CheckArgsDep<_Dummy>::__enable_implicit_default() 504*4d6fc14bSjoerg > = false> 505*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 506*4d6fc14bSjoerg pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value && 507*4d6fc14bSjoerg is_nothrow_default_constructible<second_type>::value) 508*4d6fc14bSjoerg : first(), second() {} 509*4d6fc14bSjoerg 510*4d6fc14bSjoerg template <bool _Dummy = true, _EnableB< 511*4d6fc14bSjoerg _CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>() 512*4d6fc14bSjoerg > = false> 513*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 514*4d6fc14bSjoerg explicit pair(_T1 const& __t1, _T2 const& __t2) 515*4d6fc14bSjoerg _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value && 516*4d6fc14bSjoerg is_nothrow_copy_constructible<second_type>::value) 517*4d6fc14bSjoerg : first(__t1), second(__t2) {} 518*4d6fc14bSjoerg 519*4d6fc14bSjoerg template<bool _Dummy = true, _EnableB< 520*4d6fc14bSjoerg _CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>() 521*4d6fc14bSjoerg > = false> 522*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 523*4d6fc14bSjoerg pair(_T1 const& __t1, _T2 const& __t2) 524*4d6fc14bSjoerg _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value && 525*4d6fc14bSjoerg is_nothrow_copy_constructible<second_type>::value) 526*4d6fc14bSjoerg : first(__t1), second(__t2) {} 527*4d6fc14bSjoerg 528*4d6fc14bSjoerg template<class _U1, class _U2, _EnableB< 529*4d6fc14bSjoerg _CheckArgs::template __enable_explicit<_U1, _U2>() 530*4d6fc14bSjoerg > = false> 531*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 532*4d6fc14bSjoerg explicit pair(_U1&& __u1, _U2&& __u2) 533*4d6fc14bSjoerg _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value && 534*4d6fc14bSjoerg is_nothrow_constructible<second_type, _U2>::value)) 535*4d6fc14bSjoerg : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {} 536*4d6fc14bSjoerg 537*4d6fc14bSjoerg template<class _U1, class _U2, _EnableB< 538*4d6fc14bSjoerg _CheckArgs::template __enable_implicit<_U1, _U2>() 539*4d6fc14bSjoerg > = false> 540*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 541*4d6fc14bSjoerg pair(_U1&& __u1, _U2&& __u2) 542*4d6fc14bSjoerg _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value && 543*4d6fc14bSjoerg is_nothrow_constructible<second_type, _U2>::value)) 544*4d6fc14bSjoerg : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {} 545*4d6fc14bSjoerg 546*4d6fc14bSjoerg template<class _U1, class _U2, _EnableB< 547*4d6fc14bSjoerg _CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>() 548*4d6fc14bSjoerg > = false> 549*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 550*4d6fc14bSjoerg explicit pair(pair<_U1, _U2> const& __p) 551*4d6fc14bSjoerg _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value && 552*4d6fc14bSjoerg is_nothrow_constructible<second_type, _U2 const&>::value)) 553*4d6fc14bSjoerg : first(__p.first), second(__p.second) {} 554*4d6fc14bSjoerg 555*4d6fc14bSjoerg template<class _U1, class _U2, _EnableB< 556*4d6fc14bSjoerg _CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>() 557*4d6fc14bSjoerg > = false> 558*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 559*4d6fc14bSjoerg pair(pair<_U1, _U2> const& __p) 560*4d6fc14bSjoerg _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value && 561*4d6fc14bSjoerg is_nothrow_constructible<second_type, _U2 const&>::value)) 562*4d6fc14bSjoerg : first(__p.first), second(__p.second) {} 563*4d6fc14bSjoerg 564*4d6fc14bSjoerg template<class _U1, class _U2, _EnableB< 565*4d6fc14bSjoerg _CheckArgs::template __enable_explicit<_U1, _U2>() 566*4d6fc14bSjoerg > = false> 567*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 568*4d6fc14bSjoerg explicit pair(pair<_U1, _U2>&&__p) 569*4d6fc14bSjoerg _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value && 570*4d6fc14bSjoerg is_nothrow_constructible<second_type, _U2&&>::value)) 571*4d6fc14bSjoerg : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {} 572*4d6fc14bSjoerg 573*4d6fc14bSjoerg template<class _U1, class _U2, _EnableB< 574*4d6fc14bSjoerg _CheckArgs::template __enable_implicit<_U1, _U2>() 575*4d6fc14bSjoerg > = false> 576*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 577*4d6fc14bSjoerg pair(pair<_U1, _U2>&& __p) 578*4d6fc14bSjoerg _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value && 579*4d6fc14bSjoerg is_nothrow_constructible<second_type, _U2&&>::value)) 580*4d6fc14bSjoerg : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {} 581*4d6fc14bSjoerg 582*4d6fc14bSjoerg template<class _Tuple, _EnableB< 583*4d6fc14bSjoerg _CheckTLC<_Tuple>::template __enable_explicit<_Tuple>() 584*4d6fc14bSjoerg > = false> 585*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 586*4d6fc14bSjoerg explicit pair(_Tuple&& __p) 587*4d6fc14bSjoerg : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))), 588*4d6fc14bSjoerg second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {} 589*4d6fc14bSjoerg 590*4d6fc14bSjoerg template<class _Tuple, _EnableB< 591*4d6fc14bSjoerg _CheckTLC<_Tuple>::template __enable_implicit<_Tuple>() 592*4d6fc14bSjoerg > = false> 593*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 594*4d6fc14bSjoerg pair(_Tuple&& __p) 595*4d6fc14bSjoerg : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))), 596*4d6fc14bSjoerg second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {} 597*4d6fc14bSjoerg 598*4d6fc14bSjoerg template <class... _Args1, class... _Args2> 599*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 600*4d6fc14bSjoerg pair(piecewise_construct_t __pc, 601*4d6fc14bSjoerg tuple<_Args1...> __first_args, tuple<_Args2...> __second_args) 602*4d6fc14bSjoerg _NOEXCEPT_((is_nothrow_constructible<first_type, _Args1...>::value && 603*4d6fc14bSjoerg is_nothrow_constructible<second_type, _Args2...>::value)) 604*4d6fc14bSjoerg : pair(__pc, __first_args, __second_args, 605*4d6fc14bSjoerg typename __make_tuple_indices<sizeof...(_Args1)>::type(), 606*4d6fc14bSjoerg typename __make_tuple_indices<sizeof...(_Args2) >::type()) {} 607*4d6fc14bSjoerg 608*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 609*4d6fc14bSjoerg pair& operator=(typename conditional< 610*4d6fc14bSjoerg is_copy_assignable<first_type>::value && 611*4d6fc14bSjoerg is_copy_assignable<second_type>::value, 612*4d6fc14bSjoerg pair, __nat>::type const& __p) 613*4d6fc14bSjoerg _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value && 614*4d6fc14bSjoerg is_nothrow_copy_assignable<second_type>::value) 615*4d6fc14bSjoerg { 616*4d6fc14bSjoerg first = __p.first; 617*4d6fc14bSjoerg second = __p.second; 618*4d6fc14bSjoerg return *this; 619*4d6fc14bSjoerg } 620*4d6fc14bSjoerg 621*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 622*4d6fc14bSjoerg pair& operator=(typename conditional< 623*4d6fc14bSjoerg is_move_assignable<first_type>::value && 624*4d6fc14bSjoerg is_move_assignable<second_type>::value, 625*4d6fc14bSjoerg pair, __nat>::type&& __p) 626*4d6fc14bSjoerg _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value && 627*4d6fc14bSjoerg is_nothrow_move_assignable<second_type>::value) 628*4d6fc14bSjoerg { 629*4d6fc14bSjoerg first = _VSTD::forward<first_type>(__p.first); 630*4d6fc14bSjoerg second = _VSTD::forward<second_type>(__p.second); 631*4d6fc14bSjoerg return *this; 632*4d6fc14bSjoerg } 633*4d6fc14bSjoerg 634*4d6fc14bSjoerg template <class _Tuple, _EnableB< 635*4d6fc14bSjoerg _CheckTLC<_Tuple>::template __enable_assign<_Tuple>() 636*4d6fc14bSjoerg > = false> 637*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 638*4d6fc14bSjoerg pair& operator=(_Tuple&& __p) { 639*4d6fc14bSjoerg first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p)); 640*4d6fc14bSjoerg second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p)); 641*4d6fc14bSjoerg return *this; 642*4d6fc14bSjoerg } 643*4d6fc14bSjoerg#endif 644*4d6fc14bSjoerg 645*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 646*4d6fc14bSjoerg void 647*4d6fc14bSjoerg swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value && 648*4d6fc14bSjoerg __is_nothrow_swappable<second_type>::value) 649*4d6fc14bSjoerg { 650*4d6fc14bSjoerg using _VSTD::swap; 651*4d6fc14bSjoerg swap(first, __p.first); 652*4d6fc14bSjoerg swap(second, __p.second); 653*4d6fc14bSjoerg } 654*4d6fc14bSjoergprivate: 655*4d6fc14bSjoerg 656*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG 657*4d6fc14bSjoerg template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> 658*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 659*4d6fc14bSjoerg pair(piecewise_construct_t, 660*4d6fc14bSjoerg tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args, 661*4d6fc14bSjoerg __tuple_indices<_I1...>, __tuple_indices<_I2...>); 662*4d6fc14bSjoerg#endif 663*4d6fc14bSjoerg}; 664*4d6fc14bSjoerg 665*4d6fc14bSjoerg#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES 666*4d6fc14bSjoergtemplate<class _T1, class _T2> 667*4d6fc14bSjoergpair(_T1, _T2) -> pair<_T1, _T2>; 668*4d6fc14bSjoerg#endif // _LIBCPP_HAS_NO_DEDUCTION_GUIDES 669*4d6fc14bSjoerg 670*4d6fc14bSjoergtemplate <class _T1, class _T2> 671*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 672*4d6fc14bSjoergbool 673*4d6fc14bSjoergoperator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) 674*4d6fc14bSjoerg{ 675*4d6fc14bSjoerg return __x.first == __y.first && __x.second == __y.second; 676*4d6fc14bSjoerg} 677*4d6fc14bSjoerg 678*4d6fc14bSjoergtemplate <class _T1, class _T2> 679*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 680*4d6fc14bSjoergbool 681*4d6fc14bSjoergoperator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) 682*4d6fc14bSjoerg{ 683*4d6fc14bSjoerg return !(__x == __y); 684*4d6fc14bSjoerg} 685*4d6fc14bSjoerg 686*4d6fc14bSjoergtemplate <class _T1, class _T2> 687*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 688*4d6fc14bSjoergbool 689*4d6fc14bSjoergoperator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) 690*4d6fc14bSjoerg{ 691*4d6fc14bSjoerg return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second); 692*4d6fc14bSjoerg} 693*4d6fc14bSjoerg 694*4d6fc14bSjoergtemplate <class _T1, class _T2> 695*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 696*4d6fc14bSjoergbool 697*4d6fc14bSjoergoperator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) 698*4d6fc14bSjoerg{ 699*4d6fc14bSjoerg return __y < __x; 700*4d6fc14bSjoerg} 701*4d6fc14bSjoerg 702*4d6fc14bSjoergtemplate <class _T1, class _T2> 703*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 704*4d6fc14bSjoergbool 705*4d6fc14bSjoergoperator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) 706*4d6fc14bSjoerg{ 707*4d6fc14bSjoerg return !(__x < __y); 708*4d6fc14bSjoerg} 709*4d6fc14bSjoerg 710*4d6fc14bSjoergtemplate <class _T1, class _T2> 711*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 712*4d6fc14bSjoergbool 713*4d6fc14bSjoergoperator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) 714*4d6fc14bSjoerg{ 715*4d6fc14bSjoerg return !(__y < __x); 716*4d6fc14bSjoerg} 717*4d6fc14bSjoerg 718*4d6fc14bSjoergtemplate <class _T1, class _T2> 719*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 720*4d6fc14bSjoergtypename enable_if 721*4d6fc14bSjoerg< 722*4d6fc14bSjoerg __is_swappable<_T1>::value && 723*4d6fc14bSjoerg __is_swappable<_T2>::value, 724*4d6fc14bSjoerg void 725*4d6fc14bSjoerg>::type 726*4d6fc14bSjoergswap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) 727*4d6fc14bSjoerg _NOEXCEPT_((__is_nothrow_swappable<_T1>::value && 728*4d6fc14bSjoerg __is_nothrow_swappable<_T2>::value)) 729*4d6fc14bSjoerg{ 730*4d6fc14bSjoerg __x.swap(__y); 731*4d6fc14bSjoerg} 732*4d6fc14bSjoerg 733*4d6fc14bSjoergtemplate <class _Tp> 734*4d6fc14bSjoergstruct __unwrap_reference { typedef _LIBCPP_NODEBUG_TYPE _Tp type; }; 735*4d6fc14bSjoerg 736*4d6fc14bSjoergtemplate <class _Tp> 737*4d6fc14bSjoergstruct __unwrap_reference<reference_wrapper<_Tp> > { typedef _LIBCPP_NODEBUG_TYPE _Tp& type; }; 738*4d6fc14bSjoerg 739*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 17 740*4d6fc14bSjoergtemplate <class _Tp> 741*4d6fc14bSjoergstruct unwrap_reference : __unwrap_reference<_Tp> { }; 742*4d6fc14bSjoerg 743*4d6fc14bSjoergtemplate <class _Tp> 744*4d6fc14bSjoergstruct unwrap_ref_decay : unwrap_reference<typename decay<_Tp>::type> { }; 745*4d6fc14bSjoerg#endif // > C++17 746*4d6fc14bSjoerg 747*4d6fc14bSjoergtemplate <class _Tp> 748*4d6fc14bSjoergstruct __unwrap_ref_decay 749*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 17 750*4d6fc14bSjoerg : unwrap_ref_decay<_Tp> 751*4d6fc14bSjoerg#else 752*4d6fc14bSjoerg : __unwrap_reference<typename decay<_Tp>::type> 753*4d6fc14bSjoerg#endif 754*4d6fc14bSjoerg{ }; 755*4d6fc14bSjoerg 756*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG 757*4d6fc14bSjoerg 758*4d6fc14bSjoergtemplate <class _T1, class _T2> 759*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 760*4d6fc14bSjoergpair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type> 761*4d6fc14bSjoergmake_pair(_T1&& __t1, _T2&& __t2) 762*4d6fc14bSjoerg{ 763*4d6fc14bSjoerg return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type> 764*4d6fc14bSjoerg (_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2)); 765*4d6fc14bSjoerg} 766*4d6fc14bSjoerg 767*4d6fc14bSjoerg#else // _LIBCPP_CXX03_LANG 768*4d6fc14bSjoerg 769*4d6fc14bSjoergtemplate <class _T1, class _T2> 770*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 771*4d6fc14bSjoergpair<_T1,_T2> 772*4d6fc14bSjoergmake_pair(_T1 __x, _T2 __y) 773*4d6fc14bSjoerg{ 774*4d6fc14bSjoerg return pair<_T1, _T2>(__x, __y); 775*4d6fc14bSjoerg} 776*4d6fc14bSjoerg 777*4d6fc14bSjoerg#endif // _LIBCPP_CXX03_LANG 778*4d6fc14bSjoerg 779*4d6fc14bSjoergtemplate <class _T1, class _T2> 780*4d6fc14bSjoerg struct _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> > 781*4d6fc14bSjoerg : public integral_constant<size_t, 2> {}; 782*4d6fc14bSjoerg 783*4d6fc14bSjoergtemplate <size_t _Ip, class _T1, class _T2> 784*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> > 785*4d6fc14bSjoerg{ 786*4d6fc14bSjoerg static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>"); 787*4d6fc14bSjoerg}; 788*4d6fc14bSjoerg 789*4d6fc14bSjoergtemplate <class _T1, class _T2> 790*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> > 791*4d6fc14bSjoerg{ 792*4d6fc14bSjoerg typedef _LIBCPP_NODEBUG_TYPE _T1 type; 793*4d6fc14bSjoerg}; 794*4d6fc14bSjoerg 795*4d6fc14bSjoergtemplate <class _T1, class _T2> 796*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> > 797*4d6fc14bSjoerg{ 798*4d6fc14bSjoerg typedef _LIBCPP_NODEBUG_TYPE _T2 type; 799*4d6fc14bSjoerg}; 800*4d6fc14bSjoerg 801*4d6fc14bSjoergtemplate <size_t _Ip> struct __get_pair; 802*4d6fc14bSjoerg 803*4d6fc14bSjoergtemplate <> 804*4d6fc14bSjoergstruct __get_pair<0> 805*4d6fc14bSjoerg{ 806*4d6fc14bSjoerg template <class _T1, class _T2> 807*4d6fc14bSjoerg static 808*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 809*4d6fc14bSjoerg _T1& 810*4d6fc14bSjoerg get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;} 811*4d6fc14bSjoerg 812*4d6fc14bSjoerg template <class _T1, class _T2> 813*4d6fc14bSjoerg static 814*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 815*4d6fc14bSjoerg const _T1& 816*4d6fc14bSjoerg get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;} 817*4d6fc14bSjoerg 818*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG 819*4d6fc14bSjoerg template <class _T1, class _T2> 820*4d6fc14bSjoerg static 821*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 822*4d6fc14bSjoerg _T1&& 823*4d6fc14bSjoerg get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);} 824*4d6fc14bSjoerg 825*4d6fc14bSjoerg template <class _T1, class _T2> 826*4d6fc14bSjoerg static 827*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 828*4d6fc14bSjoerg const _T1&& 829*4d6fc14bSjoerg get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T1>(__p.first);} 830*4d6fc14bSjoerg#endif // _LIBCPP_CXX03_LANG 831*4d6fc14bSjoerg}; 832*4d6fc14bSjoerg 833*4d6fc14bSjoergtemplate <> 834*4d6fc14bSjoergstruct __get_pair<1> 835*4d6fc14bSjoerg{ 836*4d6fc14bSjoerg template <class _T1, class _T2> 837*4d6fc14bSjoerg static 838*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 839*4d6fc14bSjoerg _T2& 840*4d6fc14bSjoerg get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;} 841*4d6fc14bSjoerg 842*4d6fc14bSjoerg template <class _T1, class _T2> 843*4d6fc14bSjoerg static 844*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 845*4d6fc14bSjoerg const _T2& 846*4d6fc14bSjoerg get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;} 847*4d6fc14bSjoerg 848*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG 849*4d6fc14bSjoerg template <class _T1, class _T2> 850*4d6fc14bSjoerg static 851*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 852*4d6fc14bSjoerg _T2&& 853*4d6fc14bSjoerg get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);} 854*4d6fc14bSjoerg 855*4d6fc14bSjoerg template <class _T1, class _T2> 856*4d6fc14bSjoerg static 857*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 858*4d6fc14bSjoerg const _T2&& 859*4d6fc14bSjoerg get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T2>(__p.second);} 860*4d6fc14bSjoerg#endif // _LIBCPP_CXX03_LANG 861*4d6fc14bSjoerg}; 862*4d6fc14bSjoerg 863*4d6fc14bSjoergtemplate <size_t _Ip, class _T1, class _T2> 864*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 865*4d6fc14bSjoergtypename tuple_element<_Ip, pair<_T1, _T2> >::type& 866*4d6fc14bSjoergget(pair<_T1, _T2>& __p) _NOEXCEPT 867*4d6fc14bSjoerg{ 868*4d6fc14bSjoerg return __get_pair<_Ip>::get(__p); 869*4d6fc14bSjoerg} 870*4d6fc14bSjoerg 871*4d6fc14bSjoergtemplate <size_t _Ip, class _T1, class _T2> 872*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 873*4d6fc14bSjoergconst typename tuple_element<_Ip, pair<_T1, _T2> >::type& 874*4d6fc14bSjoergget(const pair<_T1, _T2>& __p) _NOEXCEPT 875*4d6fc14bSjoerg{ 876*4d6fc14bSjoerg return __get_pair<_Ip>::get(__p); 877*4d6fc14bSjoerg} 878*4d6fc14bSjoerg 879*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG 880*4d6fc14bSjoergtemplate <size_t _Ip, class _T1, class _T2> 881*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 882*4d6fc14bSjoergtypename tuple_element<_Ip, pair<_T1, _T2> >::type&& 883*4d6fc14bSjoergget(pair<_T1, _T2>&& __p) _NOEXCEPT 884*4d6fc14bSjoerg{ 885*4d6fc14bSjoerg return __get_pair<_Ip>::get(_VSTD::move(__p)); 886*4d6fc14bSjoerg} 887*4d6fc14bSjoerg 888*4d6fc14bSjoergtemplate <size_t _Ip, class _T1, class _T2> 889*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 890*4d6fc14bSjoergconst typename tuple_element<_Ip, pair<_T1, _T2> >::type&& 891*4d6fc14bSjoergget(const pair<_T1, _T2>&& __p) _NOEXCEPT 892*4d6fc14bSjoerg{ 893*4d6fc14bSjoerg return __get_pair<_Ip>::get(_VSTD::move(__p)); 894*4d6fc14bSjoerg} 895*4d6fc14bSjoerg#endif // _LIBCPP_CXX03_LANG 896*4d6fc14bSjoerg 897*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 11 898*4d6fc14bSjoergtemplate <class _T1, class _T2> 899*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 900*4d6fc14bSjoergconstexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT 901*4d6fc14bSjoerg{ 902*4d6fc14bSjoerg return __get_pair<0>::get(__p); 903*4d6fc14bSjoerg} 904*4d6fc14bSjoerg 905*4d6fc14bSjoergtemplate <class _T1, class _T2> 906*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 907*4d6fc14bSjoergconstexpr _T1 const & get(pair<_T1, _T2> const& __p) _NOEXCEPT 908*4d6fc14bSjoerg{ 909*4d6fc14bSjoerg return __get_pair<0>::get(__p); 910*4d6fc14bSjoerg} 911*4d6fc14bSjoerg 912*4d6fc14bSjoergtemplate <class _T1, class _T2> 913*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 914*4d6fc14bSjoergconstexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT 915*4d6fc14bSjoerg{ 916*4d6fc14bSjoerg return __get_pair<0>::get(_VSTD::move(__p)); 917*4d6fc14bSjoerg} 918*4d6fc14bSjoerg 919*4d6fc14bSjoergtemplate <class _T1, class _T2> 920*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 921*4d6fc14bSjoergconstexpr _T1 const && get(pair<_T1, _T2> const&& __p) _NOEXCEPT 922*4d6fc14bSjoerg{ 923*4d6fc14bSjoerg return __get_pair<0>::get(_VSTD::move(__p)); 924*4d6fc14bSjoerg} 925*4d6fc14bSjoerg 926*4d6fc14bSjoergtemplate <class _T1, class _T2> 927*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 928*4d6fc14bSjoergconstexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT 929*4d6fc14bSjoerg{ 930*4d6fc14bSjoerg return __get_pair<1>::get(__p); 931*4d6fc14bSjoerg} 932*4d6fc14bSjoerg 933*4d6fc14bSjoergtemplate <class _T1, class _T2> 934*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 935*4d6fc14bSjoergconstexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT 936*4d6fc14bSjoerg{ 937*4d6fc14bSjoerg return __get_pair<1>::get(__p); 938*4d6fc14bSjoerg} 939*4d6fc14bSjoerg 940*4d6fc14bSjoergtemplate <class _T1, class _T2> 941*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 942*4d6fc14bSjoergconstexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT 943*4d6fc14bSjoerg{ 944*4d6fc14bSjoerg return __get_pair<1>::get(_VSTD::move(__p)); 945*4d6fc14bSjoerg} 946*4d6fc14bSjoerg 947*4d6fc14bSjoergtemplate <class _T1, class _T2> 948*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 949*4d6fc14bSjoergconstexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT 950*4d6fc14bSjoerg{ 951*4d6fc14bSjoerg return __get_pair<1>::get(_VSTD::move(__p)); 952*4d6fc14bSjoerg} 953*4d6fc14bSjoerg 954*4d6fc14bSjoerg#endif 955*4d6fc14bSjoerg 956*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 11 957*4d6fc14bSjoerg 958*4d6fc14bSjoergtemplate<class _Tp, _Tp... _Ip> 959*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS integer_sequence 960*4d6fc14bSjoerg{ 961*4d6fc14bSjoerg typedef _Tp value_type; 962*4d6fc14bSjoerg static_assert( is_integral<_Tp>::value, 963*4d6fc14bSjoerg "std::integer_sequence can only be instantiated with an integral type" ); 964*4d6fc14bSjoerg static 965*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 966*4d6fc14bSjoerg constexpr 967*4d6fc14bSjoerg size_t 968*4d6fc14bSjoerg size() noexcept { return sizeof...(_Ip); } 969*4d6fc14bSjoerg}; 970*4d6fc14bSjoerg 971*4d6fc14bSjoergtemplate<size_t... _Ip> 972*4d6fc14bSjoerg using index_sequence = integer_sequence<size_t, _Ip...>; 973*4d6fc14bSjoerg 974*4d6fc14bSjoerg#if __has_builtin(__make_integer_seq) && !defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE) 975*4d6fc14bSjoerg 976*4d6fc14bSjoergtemplate <class _Tp, _Tp _Ep> 977*4d6fc14bSjoergusing __make_integer_sequence _LIBCPP_NODEBUG_TYPE = __make_integer_seq<integer_sequence, _Tp, _Ep>; 978*4d6fc14bSjoerg 979*4d6fc14bSjoerg#else 980*4d6fc14bSjoerg 981*4d6fc14bSjoergtemplate<typename _Tp, _Tp _Np> using __make_integer_sequence_unchecked _LIBCPP_NODEBUG_TYPE = 982*4d6fc14bSjoerg typename __detail::__make<_Np>::type::template __convert<integer_sequence, _Tp>; 983*4d6fc14bSjoerg 984*4d6fc14bSjoergtemplate <class _Tp, _Tp _Ep> 985*4d6fc14bSjoergstruct __make_integer_sequence_checked 986*4d6fc14bSjoerg{ 987*4d6fc14bSjoerg static_assert(is_integral<_Tp>::value, 988*4d6fc14bSjoerg "std::make_integer_sequence can only be instantiated with an integral type" ); 989*4d6fc14bSjoerg static_assert(0 <= _Ep, "std::make_integer_sequence must have a non-negative sequence length"); 990*4d6fc14bSjoerg // Workaround GCC bug by preventing bad installations when 0 <= _Ep 991*4d6fc14bSjoerg // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68929 992*4d6fc14bSjoerg typedef _LIBCPP_NODEBUG_TYPE __make_integer_sequence_unchecked<_Tp, 0 <= _Ep ? _Ep : 0> type; 993*4d6fc14bSjoerg}; 994*4d6fc14bSjoerg 995*4d6fc14bSjoergtemplate <class _Tp, _Tp _Ep> 996*4d6fc14bSjoergusing __make_integer_sequence _LIBCPP_NODEBUG_TYPE = typename __make_integer_sequence_checked<_Tp, _Ep>::type; 997*4d6fc14bSjoerg 998*4d6fc14bSjoerg#endif 999*4d6fc14bSjoerg 1000*4d6fc14bSjoergtemplate<class _Tp, _Tp _Np> 1001*4d6fc14bSjoerg using make_integer_sequence = __make_integer_sequence<_Tp, _Np>; 1002*4d6fc14bSjoerg 1003*4d6fc14bSjoergtemplate<size_t _Np> 1004*4d6fc14bSjoerg using make_index_sequence = make_integer_sequence<size_t, _Np>; 1005*4d6fc14bSjoerg 1006*4d6fc14bSjoergtemplate<class... _Tp> 1007*4d6fc14bSjoerg using index_sequence_for = make_index_sequence<sizeof...(_Tp)>; 1008*4d6fc14bSjoerg 1009*4d6fc14bSjoerg#endif // _LIBCPP_STD_VER > 11 1010*4d6fc14bSjoerg 1011*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 11 1012*4d6fc14bSjoergtemplate<class _T1, class _T2 = _T1> 1013*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 1014*4d6fc14bSjoerg_T1 exchange(_T1& __obj, _T2 && __new_value) 1015*4d6fc14bSjoerg{ 1016*4d6fc14bSjoerg _T1 __old_value = _VSTD::move(__obj); 1017*4d6fc14bSjoerg __obj = _VSTD::forward<_T2>(__new_value); 1018*4d6fc14bSjoerg return __old_value; 1019*4d6fc14bSjoerg} 1020*4d6fc14bSjoerg#endif // _LIBCPP_STD_VER > 11 1021*4d6fc14bSjoerg 1022*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 14 1023*4d6fc14bSjoerg 1024*4d6fc14bSjoergstruct _LIBCPP_TYPE_VIS in_place_t { 1025*4d6fc14bSjoerg explicit in_place_t() = default; 1026*4d6fc14bSjoerg}; 1027*4d6fc14bSjoerg_LIBCPP_INLINE_VAR constexpr in_place_t in_place{}; 1028*4d6fc14bSjoerg 1029*4d6fc14bSjoergtemplate <class _Tp> 1030*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS in_place_type_t { 1031*4d6fc14bSjoerg explicit in_place_type_t() = default; 1032*4d6fc14bSjoerg}; 1033*4d6fc14bSjoergtemplate <class _Tp> 1034*4d6fc14bSjoerg_LIBCPP_INLINE_VAR constexpr in_place_type_t<_Tp> in_place_type{}; 1035*4d6fc14bSjoerg 1036*4d6fc14bSjoergtemplate <size_t _Idx> 1037*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS in_place_index_t { 1038*4d6fc14bSjoerg explicit in_place_index_t() = default; 1039*4d6fc14bSjoerg}; 1040*4d6fc14bSjoergtemplate <size_t _Idx> 1041*4d6fc14bSjoerg_LIBCPP_INLINE_VAR constexpr in_place_index_t<_Idx> in_place_index{}; 1042*4d6fc14bSjoerg 1043*4d6fc14bSjoergtemplate <class _Tp> struct __is_inplace_type_imp : false_type {}; 1044*4d6fc14bSjoergtemplate <class _Tp> struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {}; 1045*4d6fc14bSjoerg 1046*4d6fc14bSjoergtemplate <class _Tp> 1047*4d6fc14bSjoergusing __is_inplace_type = __is_inplace_type_imp<__uncvref_t<_Tp>>; 1048*4d6fc14bSjoerg 1049*4d6fc14bSjoergtemplate <class _Tp> struct __is_inplace_index_imp : false_type {}; 1050*4d6fc14bSjoergtemplate <size_t _Idx> struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type {}; 1051*4d6fc14bSjoerg 1052*4d6fc14bSjoergtemplate <class _Tp> 1053*4d6fc14bSjoergusing __is_inplace_index = __is_inplace_index_imp<__uncvref_t<_Tp>>; 1054*4d6fc14bSjoerg 1055*4d6fc14bSjoerg#endif // _LIBCPP_STD_VER > 14 1056*4d6fc14bSjoerg 1057*4d6fc14bSjoergtemplate <class _Arg, class _Result> 1058*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS unary_function 1059*4d6fc14bSjoerg{ 1060*4d6fc14bSjoerg typedef _Arg argument_type; 1061*4d6fc14bSjoerg typedef _Result result_type; 1062*4d6fc14bSjoerg}; 1063*4d6fc14bSjoerg 1064*4d6fc14bSjoergtemplate <class _Size> 1065*4d6fc14bSjoerginline _LIBCPP_INLINE_VISIBILITY 1066*4d6fc14bSjoerg_Size 1067*4d6fc14bSjoerg__loadword(const void* __p) 1068*4d6fc14bSjoerg{ 1069*4d6fc14bSjoerg _Size __r; 1070*4d6fc14bSjoerg _VSTD::memcpy(&__r, __p, sizeof(__r)); 1071*4d6fc14bSjoerg return __r; 1072*4d6fc14bSjoerg} 1073*4d6fc14bSjoerg 1074*4d6fc14bSjoerg// We use murmur2 when size_t is 32 bits, and cityhash64 when size_t 1075*4d6fc14bSjoerg// is 64 bits. This is because cityhash64 uses 64bit x 64bit 1076*4d6fc14bSjoerg// multiplication, which can be very slow on 32-bit systems. 1077*4d6fc14bSjoergtemplate <class _Size, size_t = sizeof(_Size)*__CHAR_BIT__> 1078*4d6fc14bSjoergstruct __murmur2_or_cityhash; 1079*4d6fc14bSjoerg 1080*4d6fc14bSjoergtemplate <class _Size> 1081*4d6fc14bSjoergstruct __murmur2_or_cityhash<_Size, 32> 1082*4d6fc14bSjoerg{ 1083*4d6fc14bSjoerg inline _Size operator()(const void* __key, _Size __len) 1084*4d6fc14bSjoerg _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK; 1085*4d6fc14bSjoerg}; 1086*4d6fc14bSjoerg 1087*4d6fc14bSjoerg// murmur2 1088*4d6fc14bSjoergtemplate <class _Size> 1089*4d6fc14bSjoerg_Size 1090*4d6fc14bSjoerg__murmur2_or_cityhash<_Size, 32>::operator()(const void* __key, _Size __len) 1091*4d6fc14bSjoerg{ 1092*4d6fc14bSjoerg const _Size __m = 0x5bd1e995; 1093*4d6fc14bSjoerg const _Size __r = 24; 1094*4d6fc14bSjoerg _Size __h = __len; 1095*4d6fc14bSjoerg const unsigned char* __data = static_cast<const unsigned char*>(__key); 1096*4d6fc14bSjoerg for (; __len >= 4; __data += 4, __len -= 4) 1097*4d6fc14bSjoerg { 1098*4d6fc14bSjoerg _Size __k = __loadword<_Size>(__data); 1099*4d6fc14bSjoerg __k *= __m; 1100*4d6fc14bSjoerg __k ^= __k >> __r; 1101*4d6fc14bSjoerg __k *= __m; 1102*4d6fc14bSjoerg __h *= __m; 1103*4d6fc14bSjoerg __h ^= __k; 1104*4d6fc14bSjoerg } 1105*4d6fc14bSjoerg switch (__len) 1106*4d6fc14bSjoerg { 1107*4d6fc14bSjoerg case 3: 1108*4d6fc14bSjoerg __h ^= __data[2] << 16; 1109*4d6fc14bSjoerg _LIBCPP_FALLTHROUGH(); 1110*4d6fc14bSjoerg case 2: 1111*4d6fc14bSjoerg __h ^= __data[1] << 8; 1112*4d6fc14bSjoerg _LIBCPP_FALLTHROUGH(); 1113*4d6fc14bSjoerg case 1: 1114*4d6fc14bSjoerg __h ^= __data[0]; 1115*4d6fc14bSjoerg __h *= __m; 1116*4d6fc14bSjoerg } 1117*4d6fc14bSjoerg __h ^= __h >> 13; 1118*4d6fc14bSjoerg __h *= __m; 1119*4d6fc14bSjoerg __h ^= __h >> 15; 1120*4d6fc14bSjoerg return __h; 1121*4d6fc14bSjoerg} 1122*4d6fc14bSjoerg 1123*4d6fc14bSjoergtemplate <class _Size> 1124*4d6fc14bSjoergstruct __murmur2_or_cityhash<_Size, 64> 1125*4d6fc14bSjoerg{ 1126*4d6fc14bSjoerg inline _Size operator()(const void* __key, _Size __len) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK; 1127*4d6fc14bSjoerg 1128*4d6fc14bSjoerg private: 1129*4d6fc14bSjoerg // Some primes between 2^63 and 2^64. 1130*4d6fc14bSjoerg static const _Size __k0 = 0xc3a5c85c97cb3127ULL; 1131*4d6fc14bSjoerg static const _Size __k1 = 0xb492b66fbe98f273ULL; 1132*4d6fc14bSjoerg static const _Size __k2 = 0x9ae16a3b2f90404fULL; 1133*4d6fc14bSjoerg static const _Size __k3 = 0xc949d7c7509e6557ULL; 1134*4d6fc14bSjoerg 1135*4d6fc14bSjoerg static _Size __rotate(_Size __val, int __shift) { 1136*4d6fc14bSjoerg return __shift == 0 ? __val : ((__val >> __shift) | (__val << (64 - __shift))); 1137*4d6fc14bSjoerg } 1138*4d6fc14bSjoerg 1139*4d6fc14bSjoerg static _Size __rotate_by_at_least_1(_Size __val, int __shift) { 1140*4d6fc14bSjoerg return (__val >> __shift) | (__val << (64 - __shift)); 1141*4d6fc14bSjoerg } 1142*4d6fc14bSjoerg 1143*4d6fc14bSjoerg static _Size __shift_mix(_Size __val) { 1144*4d6fc14bSjoerg return __val ^ (__val >> 47); 1145*4d6fc14bSjoerg } 1146*4d6fc14bSjoerg 1147*4d6fc14bSjoerg static _Size __hash_len_16(_Size __u, _Size __v) 1148*4d6fc14bSjoerg _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK 1149*4d6fc14bSjoerg { 1150*4d6fc14bSjoerg const _Size __mul = 0x9ddfea08eb382d69ULL; 1151*4d6fc14bSjoerg _Size __a = (__u ^ __v) * __mul; 1152*4d6fc14bSjoerg __a ^= (__a >> 47); 1153*4d6fc14bSjoerg _Size __b = (__v ^ __a) * __mul; 1154*4d6fc14bSjoerg __b ^= (__b >> 47); 1155*4d6fc14bSjoerg __b *= __mul; 1156*4d6fc14bSjoerg return __b; 1157*4d6fc14bSjoerg } 1158*4d6fc14bSjoerg 1159*4d6fc14bSjoerg static _Size __hash_len_0_to_16(const char* __s, _Size __len) 1160*4d6fc14bSjoerg _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK 1161*4d6fc14bSjoerg { 1162*4d6fc14bSjoerg if (__len > 8) { 1163*4d6fc14bSjoerg const _Size __a = __loadword<_Size>(__s); 1164*4d6fc14bSjoerg const _Size __b = __loadword<_Size>(__s + __len - 8); 1165*4d6fc14bSjoerg return __hash_len_16(__a, __rotate_by_at_least_1(__b + __len, __len)) ^ __b; 1166*4d6fc14bSjoerg } 1167*4d6fc14bSjoerg if (__len >= 4) { 1168*4d6fc14bSjoerg const uint32_t __a = __loadword<uint32_t>(__s); 1169*4d6fc14bSjoerg const uint32_t __b = __loadword<uint32_t>(__s + __len - 4); 1170*4d6fc14bSjoerg return __hash_len_16(__len + (__a << 3), __b); 1171*4d6fc14bSjoerg } 1172*4d6fc14bSjoerg if (__len > 0) { 1173*4d6fc14bSjoerg const unsigned char __a = __s[0]; 1174*4d6fc14bSjoerg const unsigned char __b = __s[__len >> 1]; 1175*4d6fc14bSjoerg const unsigned char __c = __s[__len - 1]; 1176*4d6fc14bSjoerg const uint32_t __y = static_cast<uint32_t>(__a) + 1177*4d6fc14bSjoerg (static_cast<uint32_t>(__b) << 8); 1178*4d6fc14bSjoerg const uint32_t __z = __len + (static_cast<uint32_t>(__c) << 2); 1179*4d6fc14bSjoerg return __shift_mix(__y * __k2 ^ __z * __k3) * __k2; 1180*4d6fc14bSjoerg } 1181*4d6fc14bSjoerg return __k2; 1182*4d6fc14bSjoerg } 1183*4d6fc14bSjoerg 1184*4d6fc14bSjoerg static _Size __hash_len_17_to_32(const char *__s, _Size __len) 1185*4d6fc14bSjoerg _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK 1186*4d6fc14bSjoerg { 1187*4d6fc14bSjoerg const _Size __a = __loadword<_Size>(__s) * __k1; 1188*4d6fc14bSjoerg const _Size __b = __loadword<_Size>(__s + 8); 1189*4d6fc14bSjoerg const _Size __c = __loadword<_Size>(__s + __len - 8) * __k2; 1190*4d6fc14bSjoerg const _Size __d = __loadword<_Size>(__s + __len - 16) * __k0; 1191*4d6fc14bSjoerg return __hash_len_16(__rotate(__a - __b, 43) + __rotate(__c, 30) + __d, 1192*4d6fc14bSjoerg __a + __rotate(__b ^ __k3, 20) - __c + __len); 1193*4d6fc14bSjoerg } 1194*4d6fc14bSjoerg 1195*4d6fc14bSjoerg // Return a 16-byte hash for 48 bytes. Quick and dirty. 1196*4d6fc14bSjoerg // Callers do best to use "random-looking" values for a and b. 1197*4d6fc14bSjoerg static pair<_Size, _Size> __weak_hash_len_32_with_seeds( 1198*4d6fc14bSjoerg _Size __w, _Size __x, _Size __y, _Size __z, _Size __a, _Size __b) 1199*4d6fc14bSjoerg _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK 1200*4d6fc14bSjoerg { 1201*4d6fc14bSjoerg __a += __w; 1202*4d6fc14bSjoerg __b = __rotate(__b + __a + __z, 21); 1203*4d6fc14bSjoerg const _Size __c = __a; 1204*4d6fc14bSjoerg __a += __x; 1205*4d6fc14bSjoerg __a += __y; 1206*4d6fc14bSjoerg __b += __rotate(__a, 44); 1207*4d6fc14bSjoerg return pair<_Size, _Size>(__a + __z, __b + __c); 1208*4d6fc14bSjoerg } 1209*4d6fc14bSjoerg 1210*4d6fc14bSjoerg // Return a 16-byte hash for s[0] ... s[31], a, and b. Quick and dirty. 1211*4d6fc14bSjoerg static pair<_Size, _Size> __weak_hash_len_32_with_seeds( 1212*4d6fc14bSjoerg const char* __s, _Size __a, _Size __b) 1213*4d6fc14bSjoerg _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK 1214*4d6fc14bSjoerg { 1215*4d6fc14bSjoerg return __weak_hash_len_32_with_seeds(__loadword<_Size>(__s), 1216*4d6fc14bSjoerg __loadword<_Size>(__s + 8), 1217*4d6fc14bSjoerg __loadword<_Size>(__s + 16), 1218*4d6fc14bSjoerg __loadword<_Size>(__s + 24), 1219*4d6fc14bSjoerg __a, 1220*4d6fc14bSjoerg __b); 1221*4d6fc14bSjoerg } 1222*4d6fc14bSjoerg 1223*4d6fc14bSjoerg // Return an 8-byte hash for 33 to 64 bytes. 1224*4d6fc14bSjoerg static _Size __hash_len_33_to_64(const char *__s, size_t __len) 1225*4d6fc14bSjoerg _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK 1226*4d6fc14bSjoerg { 1227*4d6fc14bSjoerg _Size __z = __loadword<_Size>(__s + 24); 1228*4d6fc14bSjoerg _Size __a = __loadword<_Size>(__s) + 1229*4d6fc14bSjoerg (__len + __loadword<_Size>(__s + __len - 16)) * __k0; 1230*4d6fc14bSjoerg _Size __b = __rotate(__a + __z, 52); 1231*4d6fc14bSjoerg _Size __c = __rotate(__a, 37); 1232*4d6fc14bSjoerg __a += __loadword<_Size>(__s + 8); 1233*4d6fc14bSjoerg __c += __rotate(__a, 7); 1234*4d6fc14bSjoerg __a += __loadword<_Size>(__s + 16); 1235*4d6fc14bSjoerg _Size __vf = __a + __z; 1236*4d6fc14bSjoerg _Size __vs = __b + __rotate(__a, 31) + __c; 1237*4d6fc14bSjoerg __a = __loadword<_Size>(__s + 16) + __loadword<_Size>(__s + __len - 32); 1238*4d6fc14bSjoerg __z += __loadword<_Size>(__s + __len - 8); 1239*4d6fc14bSjoerg __b = __rotate(__a + __z, 52); 1240*4d6fc14bSjoerg __c = __rotate(__a, 37); 1241*4d6fc14bSjoerg __a += __loadword<_Size>(__s + __len - 24); 1242*4d6fc14bSjoerg __c += __rotate(__a, 7); 1243*4d6fc14bSjoerg __a += __loadword<_Size>(__s + __len - 16); 1244*4d6fc14bSjoerg _Size __wf = __a + __z; 1245*4d6fc14bSjoerg _Size __ws = __b + __rotate(__a, 31) + __c; 1246*4d6fc14bSjoerg _Size __r = __shift_mix((__vf + __ws) * __k2 + (__wf + __vs) * __k0); 1247*4d6fc14bSjoerg return __shift_mix(__r * __k0 + __vs) * __k2; 1248*4d6fc14bSjoerg } 1249*4d6fc14bSjoerg}; 1250*4d6fc14bSjoerg 1251*4d6fc14bSjoerg// cityhash64 1252*4d6fc14bSjoergtemplate <class _Size> 1253*4d6fc14bSjoerg_Size 1254*4d6fc14bSjoerg__murmur2_or_cityhash<_Size, 64>::operator()(const void* __key, _Size __len) 1255*4d6fc14bSjoerg{ 1256*4d6fc14bSjoerg const char* __s = static_cast<const char*>(__key); 1257*4d6fc14bSjoerg if (__len <= 32) { 1258*4d6fc14bSjoerg if (__len <= 16) { 1259*4d6fc14bSjoerg return __hash_len_0_to_16(__s, __len); 1260*4d6fc14bSjoerg } else { 1261*4d6fc14bSjoerg return __hash_len_17_to_32(__s, __len); 1262*4d6fc14bSjoerg } 1263*4d6fc14bSjoerg } else if (__len <= 64) { 1264*4d6fc14bSjoerg return __hash_len_33_to_64(__s, __len); 1265*4d6fc14bSjoerg } 1266*4d6fc14bSjoerg 1267*4d6fc14bSjoerg // For strings over 64 bytes we hash the end first, and then as we 1268*4d6fc14bSjoerg // loop we keep 56 bytes of state: v, w, x, y, and z. 1269*4d6fc14bSjoerg _Size __x = __loadword<_Size>(__s + __len - 40); 1270*4d6fc14bSjoerg _Size __y = __loadword<_Size>(__s + __len - 16) + 1271*4d6fc14bSjoerg __loadword<_Size>(__s + __len - 56); 1272*4d6fc14bSjoerg _Size __z = __hash_len_16(__loadword<_Size>(__s + __len - 48) + __len, 1273*4d6fc14bSjoerg __loadword<_Size>(__s + __len - 24)); 1274*4d6fc14bSjoerg pair<_Size, _Size> __v = __weak_hash_len_32_with_seeds(__s + __len - 64, __len, __z); 1275*4d6fc14bSjoerg pair<_Size, _Size> __w = __weak_hash_len_32_with_seeds(__s + __len - 32, __y + __k1, __x); 1276*4d6fc14bSjoerg __x = __x * __k1 + __loadword<_Size>(__s); 1277*4d6fc14bSjoerg 1278*4d6fc14bSjoerg // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks. 1279*4d6fc14bSjoerg __len = (__len - 1) & ~static_cast<_Size>(63); 1280*4d6fc14bSjoerg do { 1281*4d6fc14bSjoerg __x = __rotate(__x + __y + __v.first + __loadword<_Size>(__s + 8), 37) * __k1; 1282*4d6fc14bSjoerg __y = __rotate(__y + __v.second + __loadword<_Size>(__s + 48), 42) * __k1; 1283*4d6fc14bSjoerg __x ^= __w.second; 1284*4d6fc14bSjoerg __y += __v.first + __loadword<_Size>(__s + 40); 1285*4d6fc14bSjoerg __z = __rotate(__z + __w.first, 33) * __k1; 1286*4d6fc14bSjoerg __v = __weak_hash_len_32_with_seeds(__s, __v.second * __k1, __x + __w.first); 1287*4d6fc14bSjoerg __w = __weak_hash_len_32_with_seeds(__s + 32, __z + __w.second, 1288*4d6fc14bSjoerg __y + __loadword<_Size>(__s + 16)); 1289*4d6fc14bSjoerg _VSTD::swap(__z, __x); 1290*4d6fc14bSjoerg __s += 64; 1291*4d6fc14bSjoerg __len -= 64; 1292*4d6fc14bSjoerg } while (__len != 0); 1293*4d6fc14bSjoerg return __hash_len_16( 1294*4d6fc14bSjoerg __hash_len_16(__v.first, __w.first) + __shift_mix(__y) * __k1 + __z, 1295*4d6fc14bSjoerg __hash_len_16(__v.second, __w.second) + __x); 1296*4d6fc14bSjoerg} 1297*4d6fc14bSjoerg 1298*4d6fc14bSjoergtemplate <class _Tp, size_t = sizeof(_Tp) / sizeof(size_t)> 1299*4d6fc14bSjoergstruct __scalar_hash; 1300*4d6fc14bSjoerg 1301*4d6fc14bSjoergtemplate <class _Tp> 1302*4d6fc14bSjoergstruct __scalar_hash<_Tp, 0> 1303*4d6fc14bSjoerg : public unary_function<_Tp, size_t> 1304*4d6fc14bSjoerg{ 1305*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1306*4d6fc14bSjoerg size_t operator()(_Tp __v) const _NOEXCEPT 1307*4d6fc14bSjoerg { 1308*4d6fc14bSjoerg union 1309*4d6fc14bSjoerg { 1310*4d6fc14bSjoerg _Tp __t; 1311*4d6fc14bSjoerg size_t __a; 1312*4d6fc14bSjoerg } __u; 1313*4d6fc14bSjoerg __u.__a = 0; 1314*4d6fc14bSjoerg __u.__t = __v; 1315*4d6fc14bSjoerg return __u.__a; 1316*4d6fc14bSjoerg } 1317*4d6fc14bSjoerg}; 1318*4d6fc14bSjoerg 1319*4d6fc14bSjoergtemplate <class _Tp> 1320*4d6fc14bSjoergstruct __scalar_hash<_Tp, 1> 1321*4d6fc14bSjoerg : public unary_function<_Tp, size_t> 1322*4d6fc14bSjoerg{ 1323*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1324*4d6fc14bSjoerg size_t operator()(_Tp __v) const _NOEXCEPT 1325*4d6fc14bSjoerg { 1326*4d6fc14bSjoerg union 1327*4d6fc14bSjoerg { 1328*4d6fc14bSjoerg _Tp __t; 1329*4d6fc14bSjoerg size_t __a; 1330*4d6fc14bSjoerg } __u; 1331*4d6fc14bSjoerg __u.__t = __v; 1332*4d6fc14bSjoerg return __u.__a; 1333*4d6fc14bSjoerg } 1334*4d6fc14bSjoerg}; 1335*4d6fc14bSjoerg 1336*4d6fc14bSjoergtemplate <class _Tp> 1337*4d6fc14bSjoergstruct __scalar_hash<_Tp, 2> 1338*4d6fc14bSjoerg : public unary_function<_Tp, size_t> 1339*4d6fc14bSjoerg{ 1340*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1341*4d6fc14bSjoerg size_t operator()(_Tp __v) const _NOEXCEPT 1342*4d6fc14bSjoerg { 1343*4d6fc14bSjoerg union 1344*4d6fc14bSjoerg { 1345*4d6fc14bSjoerg _Tp __t; 1346*4d6fc14bSjoerg struct 1347*4d6fc14bSjoerg { 1348*4d6fc14bSjoerg size_t __a; 1349*4d6fc14bSjoerg size_t __b; 1350*4d6fc14bSjoerg } __s; 1351*4d6fc14bSjoerg } __u; 1352*4d6fc14bSjoerg __u.__t = __v; 1353*4d6fc14bSjoerg return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); 1354*4d6fc14bSjoerg } 1355*4d6fc14bSjoerg}; 1356*4d6fc14bSjoerg 1357*4d6fc14bSjoergtemplate <class _Tp> 1358*4d6fc14bSjoergstruct __scalar_hash<_Tp, 3> 1359*4d6fc14bSjoerg : public unary_function<_Tp, size_t> 1360*4d6fc14bSjoerg{ 1361*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1362*4d6fc14bSjoerg size_t operator()(_Tp __v) const _NOEXCEPT 1363*4d6fc14bSjoerg { 1364*4d6fc14bSjoerg union 1365*4d6fc14bSjoerg { 1366*4d6fc14bSjoerg _Tp __t; 1367*4d6fc14bSjoerg struct 1368*4d6fc14bSjoerg { 1369*4d6fc14bSjoerg size_t __a; 1370*4d6fc14bSjoerg size_t __b; 1371*4d6fc14bSjoerg size_t __c; 1372*4d6fc14bSjoerg } __s; 1373*4d6fc14bSjoerg } __u; 1374*4d6fc14bSjoerg __u.__t = __v; 1375*4d6fc14bSjoerg return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); 1376*4d6fc14bSjoerg } 1377*4d6fc14bSjoerg}; 1378*4d6fc14bSjoerg 1379*4d6fc14bSjoergtemplate <class _Tp> 1380*4d6fc14bSjoergstruct __scalar_hash<_Tp, 4> 1381*4d6fc14bSjoerg : public unary_function<_Tp, size_t> 1382*4d6fc14bSjoerg{ 1383*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1384*4d6fc14bSjoerg size_t operator()(_Tp __v) const _NOEXCEPT 1385*4d6fc14bSjoerg { 1386*4d6fc14bSjoerg union 1387*4d6fc14bSjoerg { 1388*4d6fc14bSjoerg _Tp __t; 1389*4d6fc14bSjoerg struct 1390*4d6fc14bSjoerg { 1391*4d6fc14bSjoerg size_t __a; 1392*4d6fc14bSjoerg size_t __b; 1393*4d6fc14bSjoerg size_t __c; 1394*4d6fc14bSjoerg size_t __d; 1395*4d6fc14bSjoerg } __s; 1396*4d6fc14bSjoerg } __u; 1397*4d6fc14bSjoerg __u.__t = __v; 1398*4d6fc14bSjoerg return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); 1399*4d6fc14bSjoerg } 1400*4d6fc14bSjoerg}; 1401*4d6fc14bSjoerg 1402*4d6fc14bSjoergstruct _PairT { 1403*4d6fc14bSjoerg size_t first; 1404*4d6fc14bSjoerg size_t second; 1405*4d6fc14bSjoerg}; 1406*4d6fc14bSjoerg 1407*4d6fc14bSjoerg_LIBCPP_INLINE_VISIBILITY 1408*4d6fc14bSjoerginline size_t __hash_combine(size_t __lhs, size_t __rhs) _NOEXCEPT { 1409*4d6fc14bSjoerg typedef __scalar_hash<_PairT> _HashT; 1410*4d6fc14bSjoerg const _PairT __p = {__lhs, __rhs}; 1411*4d6fc14bSjoerg return _HashT()(__p); 1412*4d6fc14bSjoerg} 1413*4d6fc14bSjoerg 1414*4d6fc14bSjoergtemplate<class _Tp> 1415*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<_Tp*> 1416*4d6fc14bSjoerg : public unary_function<_Tp*, size_t> 1417*4d6fc14bSjoerg{ 1418*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1419*4d6fc14bSjoerg size_t operator()(_Tp* __v) const _NOEXCEPT 1420*4d6fc14bSjoerg { 1421*4d6fc14bSjoerg union 1422*4d6fc14bSjoerg { 1423*4d6fc14bSjoerg _Tp* __t; 1424*4d6fc14bSjoerg size_t __a; 1425*4d6fc14bSjoerg } __u; 1426*4d6fc14bSjoerg __u.__t = __v; 1427*4d6fc14bSjoerg return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u)); 1428*4d6fc14bSjoerg } 1429*4d6fc14bSjoerg}; 1430*4d6fc14bSjoerg 1431*4d6fc14bSjoerg 1432*4d6fc14bSjoergtemplate <> 1433*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<bool> 1434*4d6fc14bSjoerg : public unary_function<bool, size_t> 1435*4d6fc14bSjoerg{ 1436*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1437*4d6fc14bSjoerg size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1438*4d6fc14bSjoerg}; 1439*4d6fc14bSjoerg 1440*4d6fc14bSjoergtemplate <> 1441*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<char> 1442*4d6fc14bSjoerg : public unary_function<char, size_t> 1443*4d6fc14bSjoerg{ 1444*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1445*4d6fc14bSjoerg size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1446*4d6fc14bSjoerg}; 1447*4d6fc14bSjoerg 1448*4d6fc14bSjoergtemplate <> 1449*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<signed char> 1450*4d6fc14bSjoerg : public unary_function<signed char, size_t> 1451*4d6fc14bSjoerg{ 1452*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1453*4d6fc14bSjoerg size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1454*4d6fc14bSjoerg}; 1455*4d6fc14bSjoerg 1456*4d6fc14bSjoergtemplate <> 1457*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<unsigned char> 1458*4d6fc14bSjoerg : public unary_function<unsigned char, size_t> 1459*4d6fc14bSjoerg{ 1460*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1461*4d6fc14bSjoerg size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1462*4d6fc14bSjoerg}; 1463*4d6fc14bSjoerg 1464*4d6fc14bSjoerg#ifndef _LIBCPP_HAS_NO_CHAR8_T 1465*4d6fc14bSjoergtemplate <> 1466*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<char8_t> 1467*4d6fc14bSjoerg : public unary_function<char8_t, size_t> 1468*4d6fc14bSjoerg{ 1469*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1470*4d6fc14bSjoerg size_t operator()(char8_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1471*4d6fc14bSjoerg}; 1472*4d6fc14bSjoerg#endif // !_LIBCPP_HAS_NO_CHAR8_T 1473*4d6fc14bSjoerg 1474*4d6fc14bSjoerg#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS 1475*4d6fc14bSjoerg 1476*4d6fc14bSjoergtemplate <> 1477*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<char16_t> 1478*4d6fc14bSjoerg : public unary_function<char16_t, size_t> 1479*4d6fc14bSjoerg{ 1480*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1481*4d6fc14bSjoerg size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1482*4d6fc14bSjoerg}; 1483*4d6fc14bSjoerg 1484*4d6fc14bSjoergtemplate <> 1485*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<char32_t> 1486*4d6fc14bSjoerg : public unary_function<char32_t, size_t> 1487*4d6fc14bSjoerg{ 1488*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1489*4d6fc14bSjoerg size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1490*4d6fc14bSjoerg}; 1491*4d6fc14bSjoerg 1492*4d6fc14bSjoerg#endif // _LIBCPP_HAS_NO_UNICODE_CHARS 1493*4d6fc14bSjoerg 1494*4d6fc14bSjoergtemplate <> 1495*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<wchar_t> 1496*4d6fc14bSjoerg : public unary_function<wchar_t, size_t> 1497*4d6fc14bSjoerg{ 1498*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1499*4d6fc14bSjoerg size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1500*4d6fc14bSjoerg}; 1501*4d6fc14bSjoerg 1502*4d6fc14bSjoergtemplate <> 1503*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<short> 1504*4d6fc14bSjoerg : public unary_function<short, size_t> 1505*4d6fc14bSjoerg{ 1506*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1507*4d6fc14bSjoerg size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1508*4d6fc14bSjoerg}; 1509*4d6fc14bSjoerg 1510*4d6fc14bSjoergtemplate <> 1511*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<unsigned short> 1512*4d6fc14bSjoerg : public unary_function<unsigned short, size_t> 1513*4d6fc14bSjoerg{ 1514*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1515*4d6fc14bSjoerg size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1516*4d6fc14bSjoerg}; 1517*4d6fc14bSjoerg 1518*4d6fc14bSjoergtemplate <> 1519*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<int> 1520*4d6fc14bSjoerg : public unary_function<int, size_t> 1521*4d6fc14bSjoerg{ 1522*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1523*4d6fc14bSjoerg size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1524*4d6fc14bSjoerg}; 1525*4d6fc14bSjoerg 1526*4d6fc14bSjoergtemplate <> 1527*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<unsigned int> 1528*4d6fc14bSjoerg : public unary_function<unsigned int, size_t> 1529*4d6fc14bSjoerg{ 1530*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1531*4d6fc14bSjoerg size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1532*4d6fc14bSjoerg}; 1533*4d6fc14bSjoerg 1534*4d6fc14bSjoergtemplate <> 1535*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<long> 1536*4d6fc14bSjoerg : public unary_function<long, size_t> 1537*4d6fc14bSjoerg{ 1538*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1539*4d6fc14bSjoerg size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1540*4d6fc14bSjoerg}; 1541*4d6fc14bSjoerg 1542*4d6fc14bSjoergtemplate <> 1543*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<unsigned long> 1544*4d6fc14bSjoerg : public unary_function<unsigned long, size_t> 1545*4d6fc14bSjoerg{ 1546*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1547*4d6fc14bSjoerg size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);} 1548*4d6fc14bSjoerg}; 1549*4d6fc14bSjoerg 1550*4d6fc14bSjoergtemplate <> 1551*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<long long> 1552*4d6fc14bSjoerg : public __scalar_hash<long long> 1553*4d6fc14bSjoerg{ 1554*4d6fc14bSjoerg}; 1555*4d6fc14bSjoerg 1556*4d6fc14bSjoergtemplate <> 1557*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<unsigned long long> 1558*4d6fc14bSjoerg : public __scalar_hash<unsigned long long> 1559*4d6fc14bSjoerg{ 1560*4d6fc14bSjoerg}; 1561*4d6fc14bSjoerg 1562*4d6fc14bSjoerg#ifndef _LIBCPP_HAS_NO_INT128 1563*4d6fc14bSjoerg 1564*4d6fc14bSjoergtemplate <> 1565*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<__int128_t> 1566*4d6fc14bSjoerg : public __scalar_hash<__int128_t> 1567*4d6fc14bSjoerg{ 1568*4d6fc14bSjoerg}; 1569*4d6fc14bSjoerg 1570*4d6fc14bSjoergtemplate <> 1571*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<__uint128_t> 1572*4d6fc14bSjoerg : public __scalar_hash<__uint128_t> 1573*4d6fc14bSjoerg{ 1574*4d6fc14bSjoerg}; 1575*4d6fc14bSjoerg 1576*4d6fc14bSjoerg#endif 1577*4d6fc14bSjoerg 1578*4d6fc14bSjoergtemplate <> 1579*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<float> 1580*4d6fc14bSjoerg : public __scalar_hash<float> 1581*4d6fc14bSjoerg{ 1582*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1583*4d6fc14bSjoerg size_t operator()(float __v) const _NOEXCEPT 1584*4d6fc14bSjoerg { 1585*4d6fc14bSjoerg // -0.0 and 0.0 should return same hash 1586*4d6fc14bSjoerg if (__v == 0.0f) 1587*4d6fc14bSjoerg return 0; 1588*4d6fc14bSjoerg return __scalar_hash<float>::operator()(__v); 1589*4d6fc14bSjoerg } 1590*4d6fc14bSjoerg}; 1591*4d6fc14bSjoerg 1592*4d6fc14bSjoergtemplate <> 1593*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<double> 1594*4d6fc14bSjoerg : public __scalar_hash<double> 1595*4d6fc14bSjoerg{ 1596*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1597*4d6fc14bSjoerg size_t operator()(double __v) const _NOEXCEPT 1598*4d6fc14bSjoerg { 1599*4d6fc14bSjoerg // -0.0 and 0.0 should return same hash 1600*4d6fc14bSjoerg if (__v == 0.0) 1601*4d6fc14bSjoerg return 0; 1602*4d6fc14bSjoerg return __scalar_hash<double>::operator()(__v); 1603*4d6fc14bSjoerg } 1604*4d6fc14bSjoerg}; 1605*4d6fc14bSjoerg 1606*4d6fc14bSjoergtemplate <> 1607*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<long double> 1608*4d6fc14bSjoerg : public __scalar_hash<long double> 1609*4d6fc14bSjoerg{ 1610*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1611*4d6fc14bSjoerg size_t operator()(long double __v) const _NOEXCEPT 1612*4d6fc14bSjoerg { 1613*4d6fc14bSjoerg // -0.0 and 0.0 should return same hash 1614*4d6fc14bSjoerg if (__v == 0.0L) 1615*4d6fc14bSjoerg return 0; 1616*4d6fc14bSjoerg#if defined(__i386__) || (defined(__x86_64__) && defined(__ILP32__)) 1617*4d6fc14bSjoerg // Zero out padding bits 1618*4d6fc14bSjoerg union 1619*4d6fc14bSjoerg { 1620*4d6fc14bSjoerg long double __t; 1621*4d6fc14bSjoerg struct 1622*4d6fc14bSjoerg { 1623*4d6fc14bSjoerg size_t __a; 1624*4d6fc14bSjoerg size_t __b; 1625*4d6fc14bSjoerg size_t __c; 1626*4d6fc14bSjoerg size_t __d; 1627*4d6fc14bSjoerg } __s; 1628*4d6fc14bSjoerg } __u; 1629*4d6fc14bSjoerg __u.__s.__a = 0; 1630*4d6fc14bSjoerg __u.__s.__b = 0; 1631*4d6fc14bSjoerg __u.__s.__c = 0; 1632*4d6fc14bSjoerg __u.__s.__d = 0; 1633*4d6fc14bSjoerg __u.__t = __v; 1634*4d6fc14bSjoerg return __u.__s.__a ^ __u.__s.__b ^ __u.__s.__c ^ __u.__s.__d; 1635*4d6fc14bSjoerg#elif defined(__x86_64__) 1636*4d6fc14bSjoerg // Zero out padding bits 1637*4d6fc14bSjoerg union 1638*4d6fc14bSjoerg { 1639*4d6fc14bSjoerg long double __t; 1640*4d6fc14bSjoerg struct 1641*4d6fc14bSjoerg { 1642*4d6fc14bSjoerg size_t __a; 1643*4d6fc14bSjoerg size_t __b; 1644*4d6fc14bSjoerg } __s; 1645*4d6fc14bSjoerg } __u; 1646*4d6fc14bSjoerg __u.__s.__a = 0; 1647*4d6fc14bSjoerg __u.__s.__b = 0; 1648*4d6fc14bSjoerg __u.__t = __v; 1649*4d6fc14bSjoerg return __u.__s.__a ^ __u.__s.__b; 1650*4d6fc14bSjoerg#else 1651*4d6fc14bSjoerg return __scalar_hash<long double>::operator()(__v); 1652*4d6fc14bSjoerg#endif 1653*4d6fc14bSjoerg } 1654*4d6fc14bSjoerg}; 1655*4d6fc14bSjoerg 1656*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 11 1657*4d6fc14bSjoerg 1658*4d6fc14bSjoergtemplate <class _Tp, bool = is_enum<_Tp>::value> 1659*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS __enum_hash 1660*4d6fc14bSjoerg : public unary_function<_Tp, size_t> 1661*4d6fc14bSjoerg{ 1662*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1663*4d6fc14bSjoerg size_t operator()(_Tp __v) const _NOEXCEPT 1664*4d6fc14bSjoerg { 1665*4d6fc14bSjoerg typedef typename underlying_type<_Tp>::type type; 1666*4d6fc14bSjoerg return hash<type>{}(static_cast<type>(__v)); 1667*4d6fc14bSjoerg } 1668*4d6fc14bSjoerg}; 1669*4d6fc14bSjoergtemplate <class _Tp> 1670*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS __enum_hash<_Tp, false> { 1671*4d6fc14bSjoerg __enum_hash() = delete; 1672*4d6fc14bSjoerg __enum_hash(__enum_hash const&) = delete; 1673*4d6fc14bSjoerg __enum_hash& operator=(__enum_hash const&) = delete; 1674*4d6fc14bSjoerg}; 1675*4d6fc14bSjoerg 1676*4d6fc14bSjoergtemplate <class _Tp> 1677*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash : public __enum_hash<_Tp> 1678*4d6fc14bSjoerg{ 1679*4d6fc14bSjoerg}; 1680*4d6fc14bSjoerg#endif 1681*4d6fc14bSjoerg 1682*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 14 1683*4d6fc14bSjoerg 1684*4d6fc14bSjoergtemplate <> 1685*4d6fc14bSjoergstruct _LIBCPP_TEMPLATE_VIS hash<nullptr_t> 1686*4d6fc14bSjoerg : public unary_function<nullptr_t, size_t> 1687*4d6fc14bSjoerg{ 1688*4d6fc14bSjoerg _LIBCPP_INLINE_VISIBILITY 1689*4d6fc14bSjoerg size_t operator()(nullptr_t) const _NOEXCEPT { 1690*4d6fc14bSjoerg return 662607004ull; 1691*4d6fc14bSjoerg } 1692*4d6fc14bSjoerg}; 1693*4d6fc14bSjoerg#endif 1694*4d6fc14bSjoerg 1695*4d6fc14bSjoerg#ifndef _LIBCPP_CXX03_LANG 1696*4d6fc14bSjoergtemplate <class _Key, class _Hash> 1697*4d6fc14bSjoergusing __check_hash_requirements _LIBCPP_NODEBUG_TYPE = integral_constant<bool, 1698*4d6fc14bSjoerg is_copy_constructible<_Hash>::value && 1699*4d6fc14bSjoerg is_move_constructible<_Hash>::value && 1700*4d6fc14bSjoerg __invokable_r<size_t, _Hash, _Key const&>::value 1701*4d6fc14bSjoerg>; 1702*4d6fc14bSjoerg 1703*4d6fc14bSjoergtemplate <class _Key, class _Hash = hash<_Key> > 1704*4d6fc14bSjoergusing __has_enabled_hash _LIBCPP_NODEBUG_TYPE = integral_constant<bool, 1705*4d6fc14bSjoerg __check_hash_requirements<_Key, _Hash>::value && 1706*4d6fc14bSjoerg is_default_constructible<_Hash>::value 1707*4d6fc14bSjoerg>; 1708*4d6fc14bSjoerg 1709*4d6fc14bSjoerg#if _LIBCPP_STD_VER > 14 1710*4d6fc14bSjoergtemplate <class _Type, class> 1711*4d6fc14bSjoergusing __enable_hash_helper_imp _LIBCPP_NODEBUG_TYPE = _Type; 1712*4d6fc14bSjoerg 1713*4d6fc14bSjoergtemplate <class _Type, class ..._Keys> 1714*4d6fc14bSjoergusing __enable_hash_helper _LIBCPP_NODEBUG_TYPE = __enable_hash_helper_imp<_Type, 1715*4d6fc14bSjoerg typename enable_if<__all<__has_enabled_hash<_Keys>::value...>::value>::type 1716*4d6fc14bSjoerg>; 1717*4d6fc14bSjoerg#else 1718*4d6fc14bSjoergtemplate <class _Type, class ...> 1719*4d6fc14bSjoergusing __enable_hash_helper _LIBCPP_NODEBUG_TYPE = _Type; 1720*4d6fc14bSjoerg#endif 1721*4d6fc14bSjoerg 1722*4d6fc14bSjoerg#endif // !_LIBCPP_CXX03_LANG 1723*4d6fc14bSjoerg 1724*4d6fc14bSjoerg_LIBCPP_END_NAMESPACE_STD 1725*4d6fc14bSjoerg 1726*4d6fc14bSjoerg_LIBCPP_POP_MACROS 1727*4d6fc14bSjoerg 1728*4d6fc14bSjoerg#endif // _LIBCPP_UTILITY 1729