55 #ifndef _GLIBCXX_UTILITY
56 #define _GLIBCXX_UTILITY 1
58 #pragma GCC system_header
72 #if __cplusplus >= 201103L
78 #if __cplusplus > 201402L
82 namespace std _GLIBCXX_VISIBILITY(default)
84 _GLIBCXX_BEGIN_NAMESPACE_VERSION
87 template<
typename _Tp>
93 #if __cplusplus <= 201402L
94 template<
typename _Tp,
typename =
void>
95 struct __tuple_size_cv_impl { };
97 template<
typename _Tp>
98 struct __tuple_size_cv_impl<_Tp, __void_t<decltype(tuple_size<_Tp>::value)>>
99 : integral_constant<size_t, tuple_size<_Tp>::value> { };
103 template<
typename _Tp>
104 struct tuple_size<const _Tp> : __tuple_size_cv_impl<_Tp> { };
106 template<
typename _Tp>
107 struct tuple_size<volatile _Tp> : __tuple_size_cv_impl<_Tp> { };
109 template<
typename _Tp>
110 struct tuple_size<const volatile _Tp> : __tuple_size_cv_impl<_Tp> { };
112 template<
typename _Tp,
113 typename _Up =
typename remove_cv<_Tp>::type,
114 typename =
typename enable_if<is_same<_Tp, _Up>::value>::type,
115 size_t = tuple_size<_Tp>::value>
116 using __enable_if_has_tuple_size = _Tp;
118 template<
typename _Tp>
119 struct tuple_size<const __enable_if_has_tuple_size<_Tp>>
120 :
public tuple_size<_Tp> { };
122 template<
typename _Tp>
123 struct tuple_size<volatile __enable_if_has_tuple_size<_Tp>>
124 :
public tuple_size<_Tp> { };
126 template<
typename _Tp>
127 struct tuple_size<const volatile __enable_if_has_tuple_size<_Tp>>
128 :
public tuple_size<_Tp> { };
132 template<std::
size_t __i,
typename _Tp>
133 struct tuple_element;
136 template<std::
size_t __i,
typename _Tp>
137 using __tuple_element_t =
typename tuple_element<__i, _Tp>::type;
139 template<std::
size_t __i,
typename _Tp>
140 struct tuple_element<__i, const _Tp>
142 typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
145 template<std::
size_t __i,
typename _Tp>
146 struct tuple_element<__i, volatile _Tp>
148 typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
151 template<std::
size_t __i,
typename _Tp>
152 struct tuple_element<__i, const volatile _Tp>
154 typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
157 #if __cplusplus > 201103L
158 #define __cpp_lib_tuple_element_t 201402
160 template<std::
size_t __i,
typename _Tp>
161 using tuple_element_t =
typename tuple_element<__i, _Tp>::type;
167 template<
typename _T1,
typename _T2>
172 template<
class _Tp1,
class _Tp2>
177 template<
class _Tp1,
class _Tp2>
179 {
typedef _Tp1 type; };
182 template<
class _Tp1,
class _Tp2>
184 {
typedef _Tp2 type; };
186 template<std::
size_t _Int>
192 template<
typename _Tp1,
typename _Tp2>
193 static constexpr _Tp1&
195 {
return __pair.first; }
197 template<
typename _Tp1,
typename _Tp2>
198 static constexpr _Tp1&&
200 {
return std::forward<_Tp1>(__pair.first); }
202 template<
typename _Tp1,
typename _Tp2>
203 static constexpr
const _Tp1&
205 {
return __pair.first; }
211 template<
typename _Tp1,
typename _Tp2>
212 static constexpr _Tp2&
214 {
return __pair.second; }
216 template<
typename _Tp1,
typename _Tp2>
217 static constexpr _Tp2&&
219 {
return std::forward<_Tp2>(__pair.second); }
221 template<
typename _Tp1,
typename _Tp2>
222 static constexpr
const _Tp2&
224 {
return __pair.second; }
227 template<std::
size_t _Int,
class _Tp1,
class _Tp2>
228 constexpr
typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
230 {
return __pair_get<_Int>::__get(__in); }
232 template<std::
size_t _Int,
class _Tp1,
class _Tp2>
233 constexpr
typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
235 {
return __pair_get<_Int>::__move_get(std::move(__in)); }
237 template<std::
size_t _Int,
class _Tp1,
class _Tp2>
238 constexpr
const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
240 {
return __pair_get<_Int>::__const_get(__in); }
242 #if __cplusplus > 201103L
244 #define __cpp_lib_tuples_by_type 201304
246 template <
typename _Tp,
typename _Up>
248 get(pair<_Tp, _Up>& __p) noexcept
249 {
return __p.first; }
251 template <
typename _Tp,
typename _Up>
253 get(
const pair<_Tp, _Up>& __p) noexcept
254 {
return __p.first; }
256 template <
typename _Tp,
typename _Up>
258 get(pair<_Tp, _Up>&& __p) noexcept
259 {
return std::move(__p.first); }
261 template <
typename _Tp,
typename _Up>
263 get(pair<_Up, _Tp>& __p) noexcept
264 {
return __p.second; }
266 template <
typename _Tp,
typename _Up>
268 get(
const pair<_Up, _Tp>& __p) noexcept
269 {
return __p.second; }
271 template <
typename _Tp,
typename _Up>
273 get(pair<_Up, _Tp>&& __p) noexcept
274 {
return std::move(__p.second); }
276 #define __cpp_lib_exchange_function 201304
279 template <
typename _Tp,
typename _Up = _Tp>
282 {
return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
287 template<
size_t... _Indexes>
struct _Index_tuple { };
290 template<
typename _Itup1,
typename _Itup2>
struct _Itup_cat;
292 template<
size_t... _Ind1,
size_t... _Ind2>
293 struct _Itup_cat<_Index_tuple<_Ind1...>, _Index_tuple<_Ind2...>>
295 using __type = _Index_tuple<_Ind1..., (_Ind2 +
sizeof...(_Ind1))...>;
299 template<
size_t _Num>
300 struct _Build_index_tuple
301 : _Itup_cat<typename _Build_index_tuple<_Num / 2>::__type,
302 typename _Build_index_tuple<_Num - _Num / 2>::__type>
306 struct _Build_index_tuple<1>
308 typedef _Index_tuple<0> __type;
312 struct _Build_index_tuple<0>
314 typedef _Index_tuple<> __type;
317 #if __cplusplus > 201103L
319 #define __cpp_lib_integer_sequence 201304
322 template<
typename _Tp, _Tp... _Idx>
325 typedef _Tp value_type;
326 static constexpr
size_t size() noexcept {
return sizeof...(_Idx); }
329 template<
typename _Tp, _Tp _Num,
330 typename _ISeq =
typename _Build_index_tuple<_Num>::__type>
331 struct _Make_integer_sequence;
333 template<
typename _Tp, _Tp _Num,
size_t... _Idx>
334 struct _Make_integer_sequence<_Tp, _Num, _Index_tuple<_Idx...>>
336 static_assert( _Num >= 0,
337 "Cannot make integer sequence of negative length" );
343 template<
typename _Tp, _Tp _Num>
345 =
typename _Make_integer_sequence<_Tp, _Num>::__type;
348 template<
size_t... _Idx>
352 template<
size_t _Num>
356 template<
typename... _Types>
360 #if __cplusplus > 201402L
363 explicit in_place_t() =
default;
366 inline constexpr in_place_t
in_place{};
368 template<
typename _Tp>
struct in_place_type_t
370 explicit in_place_type_t() =
default;
373 template<
typename _Tp>
374 inline constexpr in_place_type_t<_Tp> in_place_type{};
376 template<
size_t _Idx>
struct in_place_index_t
378 explicit in_place_index_t() =
default;
381 template<
size_t _Idx>
382 inline constexpr in_place_index_t<_Idx> in_place_index{};
388 template<
typename _Tp>
389 struct __is_in_place_type_impl<in_place_type_t<_Tp>> :
true_type
392 template<
typename _Tp>
393 struct __is_in_place_type
394 :
public __is_in_place_type_impl<_Tp>
397 #define __cpp_lib_as_const 201510
398 template<
typename _Tp>
399 constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept {
return __t; }
401 template<
typename _Tp>
402 void as_const(
const _Tp&&) =
delete;
406 _GLIBCXX_END_NAMESPACE_VERSION
_Tp exchange(_Tp &__obj, _Up &&__new_val)
Assign __new_val to __obj and return its previous value.
make_integer_sequence< size_t, _Num > make_index_sequence
Alias template make_index_sequence.
typename _Make_integer_sequence< _Tp, _Num >::__type make_integer_sequence
Alias template make_integer_sequence.
integral_constant< bool, false > false_type
The type used as a compile-time boolean with false value.
constexpr in_place_t in_place
Tag for in-place construction.
integral_constant< bool, true > true_type
The type used as a compile-time boolean with true value.
Class template integer_sequence.
make_index_sequence< sizeof...(_Types)> index_sequence_for
Alias template index_sequence_for.
Struct holding two objects of arbitrary type.