55 #ifndef _GLIBCXX_UTILITY
56 #define _GLIBCXX_UTILITY 1
58 #pragma GCC system_header
72 #if __cplusplus >= 201103L
78 namespace std _GLIBCXX_VISIBILITY(default)
80 _GLIBCXX_BEGIN_NAMESPACE_VERSION
83 template<
typename _Tp>
90 template<
typename _Tp,
91 typename _Up =
typename remove_cv<_Tp>::type,
92 typename =
typename enable_if<is_same<_Tp, _Up>::value>::type,
93 size_t = tuple_size<_Tp>::value>
94 using __enable_if_has_tuple_size = _Tp;
96 template<
typename _Tp>
97 struct tuple_size<const __enable_if_has_tuple_size<_Tp>>
98 :
public tuple_size<_Tp> { };
100 template<
typename _Tp>
101 struct tuple_size<volatile __enable_if_has_tuple_size<_Tp>>
102 :
public tuple_size<_Tp> { };
104 template<
typename _Tp>
105 struct tuple_size<const volatile __enable_if_has_tuple_size<_Tp>>
106 :
public tuple_size<_Tp> { };
109 template<std::
size_t __i,
typename _Tp>
110 struct tuple_element;
113 template<std::
size_t __i,
typename _Tp>
114 using __tuple_element_t =
typename tuple_element<__i, _Tp>::type;
116 template<std::
size_t __i,
typename _Tp>
117 struct tuple_element<__i, const _Tp>
119 typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
122 template<std::
size_t __i,
typename _Tp>
123 struct tuple_element<__i, volatile _Tp>
125 typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
128 template<std::
size_t __i,
typename _Tp>
129 struct tuple_element<__i, const volatile _Tp>
131 typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
134 #if __cplusplus > 201103L
135 #define __cpp_lib_tuple_element_t 201402
137 template<std::
size_t __i,
typename _Tp>
138 using tuple_element_t =
typename tuple_element<__i, _Tp>::type;
144 template<
typename _T1,
typename _T2>
149 template<
class _Tp1,
class _Tp2>
154 template<
class _Tp1,
class _Tp2>
156 {
typedef _Tp1 type; };
159 template<
class _Tp1,
class _Tp2>
161 {
typedef _Tp2 type; };
163 template<std::
size_t _Int>
169 template<
typename _Tp1,
typename _Tp2>
170 static constexpr _Tp1&
172 {
return __pair.first; }
174 template<
typename _Tp1,
typename _Tp2>
175 static constexpr _Tp1&&
177 {
return std::forward<_Tp1>(__pair.first); }
179 template<
typename _Tp1,
typename _Tp2>
180 static constexpr
const _Tp1&
182 {
return __pair.first; }
184 template<
typename _Tp1,
typename _Tp2>
185 static constexpr
const _Tp1&&
187 {
return std::forward<const _Tp1>(__pair.first); }
193 template<
typename _Tp1,
typename _Tp2>
194 static constexpr _Tp2&
196 {
return __pair.second; }
198 template<
typename _Tp1,
typename _Tp2>
199 static constexpr _Tp2&&
201 {
return std::forward<_Tp2>(__pair.second); }
203 template<
typename _Tp1,
typename _Tp2>
204 static constexpr
const _Tp2&
206 {
return __pair.second; }
208 template<
typename _Tp1,
typename _Tp2>
209 static constexpr
const _Tp2&&
211 {
return std::forward<const _Tp2>(__pair.second); }
214 template<std::
size_t _Int,
class _Tp1,
class _Tp2>
215 constexpr
typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
217 {
return __pair_get<_Int>::__get(__in); }
219 template<std::
size_t _Int,
class _Tp1,
class _Tp2>
220 constexpr
typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
222 {
return __pair_get<_Int>::__move_get(std::move(__in)); }
224 template<std::
size_t _Int,
class _Tp1,
class _Tp2>
225 constexpr
const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
227 {
return __pair_get<_Int>::__const_get(__in); }
229 template<std::
size_t _Int,
class _Tp1,
class _Tp2>
230 constexpr
const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
232 {
return __pair_get<_Int>::__const_move_get(std::move(__in)); }
234 #if __cplusplus > 201103L
236 #define __cpp_lib_tuples_by_type 201304
238 template <
typename _Tp,
typename _Up>
241 {
return __p.first; }
243 template <
typename _Tp,
typename _Up>
245 get(
const pair<_Tp, _Up>& __p)
noexcept
246 {
return __p.first; }
248 template <
typename _Tp,
typename _Up>
251 {
return std::move(__p.first); }
253 template <
typename _Tp,
typename _Up>
254 constexpr
const _Tp&&
255 get(
const pair<_Tp, _Up>&& __p)
noexcept
256 {
return std::move(__p.first); }
258 template <
typename _Tp,
typename _Up>
261 {
return __p.second; }
263 template <
typename _Tp,
typename _Up>
265 get(
const pair<_Up, _Tp>& __p)
noexcept
266 {
return __p.second; }
268 template <
typename _Tp,
typename _Up>
271 {
return std::move(__p.second); }
273 template <
typename _Tp,
typename _Up>
274 constexpr
const _Tp&&
275 get(
const pair<_Up, _Tp>&& __p)
noexcept
276 {
return std::move(__p.second); }
278 #define __cpp_lib_exchange_function 201304
281 template <
typename _Tp,
typename _Up = _Tp>
284 {
return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
289 template<
size_t... _Indexes>
struct _Index_tuple { };
292 # if __has_builtin(__make_integer_seq)
293 # define _GLIBCXX_USE_MAKE_INTEGER_SEQ 1
298 template<
size_t _Num>
299 struct _Build_index_tuple
301 #if _GLIBCXX_USE_MAKE_INTEGER_SEQ
302 template<
typename,
size_t... _Indices>
303 using _IdxTuple = _Index_tuple<_Indices...>;
305 using __type = __make_integer_seq<_IdxTuple, size_t, _Num>;
307 using __type = _Index_tuple<__integer_pack(_Num)...>;
311 #if __cplusplus > 201103L
313 #define __cpp_lib_integer_sequence 201304
316 template<
typename _Tp, _Tp... _Idx>
319 typedef _Tp value_type;
320 static constexpr
size_t size()
noexcept {
return sizeof...(_Idx); }
324 template<
typename _Tp, _Tp _Num>
326 #if _GLIBCXX_USE_MAKE_INTEGER_SEQ
327 = __make_integer_seq<integer_sequence, _Tp, _Num>;
332 #undef _GLIBCXX_USE_MAKE_INTEGER_SEQ
335 template<
size_t... _Idx>
339 template<
size_t _Num>
343 template<
typename... _Types>
347 #if __cplusplus > 201402L
350 explicit in_place_t() =
default;
353 inline constexpr in_place_t
in_place{};
355 template<
typename _Tp>
struct in_place_type_t
357 explicit in_place_type_t() =
default;
360 template<
typename _Tp>
361 inline constexpr in_place_type_t<_Tp> in_place_type{};
363 template<
size_t _Idx>
struct in_place_index_t
365 explicit in_place_index_t() =
default;
368 template<
size_t _Idx>
369 inline constexpr in_place_index_t<_Idx> in_place_index{};
375 template<
typename _Tp>
376 struct __is_in_place_type_impl<in_place_type_t<_Tp>> :
true_type
379 template<
typename _Tp>
380 struct __is_in_place_type
381 :
public __is_in_place_type_impl<_Tp>
384 #define __cpp_lib_as_const 201510
385 template<
typename _Tp>
386 constexpr add_const_t<_Tp>& as_const(_Tp& __t)
noexcept {
return __t; }
388 template<
typename _Tp>
389 void as_const(
const _Tp&&) =
delete;
393 _GLIBCXX_END_NAMESPACE_VERSION
Class template integer_sequence.
enable_if< ::__array_traits< _Tp, _Nm >::_Is_swappable::value >::type noexcept(noexcept(__one.swap(__two)))
swap
integral_constant< bool, false > false_type
The type used as a compile-time boolean with false value.
Struct holding two objects of arbitrary type.
integral_constant< bool, true > true_type
The type used as a compile-time boolean with true value.
constexpr in_place_t in_place
Tag for in-place construction.
_Tp exchange(_Tp &__obj, _Up &&__new_val)
Assign __new_val to __obj and return its previous value.