55 #ifndef _GLIBCXX_UTILITY
56 #define _GLIBCXX_UTILITY 1
58 #pragma GCC system_header
72 #if __cplusplus >= 201103L
77 namespace std _GLIBCXX_VISIBILITY(default)
79 _GLIBCXX_BEGIN_NAMESPACE_VERSION
84 template<std::
size_t _Int,
class _Tp>
90 template<
class _Tp1,
class _Tp2>
95 template<
class _Tp1,
class _Tp2>
97 {
typedef _Tp1 type; };
100 template<
class _Tp1,
class _Tp2>
102 {
typedef _Tp2 type; };
104 template<std::
size_t _Int>
110 template<
typename _Tp1,
typename _Tp2>
111 static constexpr _Tp1&
113 {
return __pair.first; }
115 template<
typename _Tp1,
typename _Tp2>
116 static constexpr _Tp1&&
118 {
return std::forward<_Tp1>(__pair.first); }
120 template<
typename _Tp1,
typename _Tp2>
121 static constexpr
const _Tp1&
123 {
return __pair.first; }
129 template<
typename _Tp1,
typename _Tp2>
130 static constexpr _Tp2&
132 {
return __pair.second; }
134 template<
typename _Tp1,
typename _Tp2>
135 static constexpr _Tp2&&
137 {
return std::forward<_Tp2>(__pair.second); }
139 template<
typename _Tp1,
typename _Tp2>
140 static constexpr
const _Tp2&
142 {
return __pair.second; }
145 template<std::
size_t _Int,
class _Tp1,
class _Tp2>
146 constexpr
typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
148 {
return __pair_get<_Int>::__get(__in); }
150 template<std::
size_t _Int,
class _Tp1,
class _Tp2>
151 constexpr
typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
153 {
return __pair_get<_Int>::__move_get(std::move(__in)); }
155 template<std::
size_t _Int,
class _Tp1,
class _Tp2>
156 constexpr
const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
158 {
return __pair_get<_Int>::__const_get(__in); }
160 #if __cplusplus > 201103L
162 #define __cpp_lib_tuples_by_type 201304
164 template <
typename _Tp,
typename _Up>
166 get(pair<_Tp, _Up>& __p) noexcept
167 {
return __p.first; }
169 template <
typename _Tp,
typename _Up>
171 get(
const pair<_Tp, _Up>& __p) noexcept
172 {
return __p.first; }
174 template <
typename _Tp,
typename _Up>
176 get(pair<_Tp, _Up>&& __p) noexcept
177 {
return std::move(__p.first); }
179 template <
typename _Tp,
typename _Up>
181 get(pair<_Up, _Tp>& __p) noexcept
182 {
return __p.second; }
184 template <
typename _Tp,
typename _Up>
186 get(
const pair<_Up, _Tp>& __p) noexcept
187 {
return __p.second; }
189 template <
typename _Tp,
typename _Up>
191 get(pair<_Up, _Tp>&& __p) noexcept
192 {
return std::move(__p.second); }
194 #define __cpp_lib_exchange_function 201304
197 template <
typename _Tp,
typename _Up = _Tp>
199 exchange(_Tp& __obj, _Up&& __new_val)
200 {
return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
205 template<
size_t... _Indexes>
208 typedef _Index_tuple<_Indexes...,
sizeof...(_Indexes)> __next;
212 template<
size_t _Num>
213 struct _Build_index_tuple
215 typedef typename _Build_index_tuple<_Num - 1>::__type::__next __type;
219 struct _Build_index_tuple<0>
221 typedef _Index_tuple<> __type;
224 #if __cplusplus > 201103L
226 #define __cpp_lib_integer_sequence 201304
229 template<
typename _Tp, _Tp... _Idx>
230 struct integer_sequence
232 typedef _Tp value_type;
233 static constexpr
size_t size() {
return sizeof...(_Idx); }
236 template<
typename _Tp, _Tp _Num,
237 typename _ISeq =
typename _Build_index_tuple<_Num>::__type>
238 struct _Make_integer_sequence;
240 template<
typename _Tp, _Tp _Num,
size_t... _Idx>
241 struct _Make_integer_sequence<_Tp, _Num, _Index_tuple<_Idx...>>
243 static_assert( _Num >= 0,
244 "Cannot make integer sequence of negative length" );
246 typedef integer_sequence<_Tp, static_cast<_Tp>(_Idx)...> __type;
250 template<
typename _Tp, _Tp _Num>
251 using make_integer_sequence
252 =
typename _Make_integer_sequence<_Tp, _Num>::__type;
255 template<
size_t... _Idx>
256 using index_sequence = integer_sequence<size_t, _Idx...>;
259 template<
size_t _Num>
260 using make_index_sequence = make_integer_sequence<size_t, _Num>;
263 template<
typename... _Types>
264 using index_sequence_for = make_index_sequence<
sizeof...(_Types)>;
267 _GLIBCXX_END_NAMESPACE_VERSION
constexpr size_t size() const noexcept
Returns the total number of bits.
Struct holding two objects of arbitrary type.