30 #ifndef _FORWARD_LIST_H
31 #define _FORWARD_LIST_H 1
33 #pragma GCC system_header
36 #if __cplusplus >= 201103L
40 namespace std _GLIBCXX_VISIBILITY(default)
42 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
62 __begin->_M_next = __end->_M_next;
63 __end->_M_next = _M_next;
72 _M_reverse_after() noexcept
81 __tail->_M_next = __temp->_M_next;
82 _M_next->_M_next = __keep;
93 template<
typename _Tp>
105 return static_cast<_Tp*
>(
static_cast<void*
>(&_M_storage));
109 _M_valptr()
const noexcept
111 return static_cast<const _Tp*
>(
static_cast<const void*
>(&_M_storage));
120 template<
typename _Tp>
126 typedef _Tp value_type;
127 typedef _Tp* pointer;
128 typedef _Tp& reference;
129 typedef ptrdiff_t difference_type;
141 {
return *
static_cast<_Node*
>(this->_M_node)->_M_valptr(); }
145 {
return static_cast<_Node*
>(this->_M_node)->_M_valptr(); }
150 _M_node = _M_node->_M_next;
158 _M_node = _M_node->_M_next;
163 operator==(
const _Self& __x)
const
164 {
return _M_node == __x._M_node; }
167 operator!=(
const _Self& __x)
const
168 {
return _M_node != __x._M_node; }
187 template<
typename _Tp>
194 typedef _Tp value_type;
195 typedef const _Tp* pointer;
196 typedef const _Tp& reference;
197 typedef ptrdiff_t difference_type;
208 : _M_node(__iter._M_node) { }
212 {
return *
static_cast<_Node*
>(this->_M_node)->_M_valptr(); }
216 {
return static_cast<_Node*
>(this->_M_node)->_M_valptr(); }
221 _M_node = _M_node->_M_next;
229 _M_node = _M_node->_M_next;
234 operator==(
const _Self& __x)
const
235 {
return _M_node == __x._M_node; }
238 operator!=(
const _Self& __x)
const
239 {
return _M_node != __x._M_node; }
256 template<
typename _Tp>
260 {
return __x._M_node == __y._M_node; }
265 template<
typename _Tp>
269 {
return __x._M_node != __y._M_node; }
274 template<
typename _Tp,
typename _Alloc>
279 typedef typename _Alloc_traits::template rebind<_Tp>::other
282 typedef typename _Alloc_traits::template
283 rebind<_Fwd_list_node<_Tp>>::other _Node_alloc_type;
287 struct _Fwd_list_impl
288 :
public _Node_alloc_type
293 : _Node_alloc_type(), _M_head()
296 _Fwd_list_impl(
const _Node_alloc_type& __a)
297 : _Node_alloc_type(__a), _M_head()
300 _Fwd_list_impl(_Node_alloc_type&& __a)
301 : _Node_alloc_type(std::move(__a)), _M_head()
305 _Fwd_list_impl _M_impl;
313 _M_get_Node_allocator() noexcept
314 {
return *
static_cast<_Node_alloc_type*
>(&this->_M_impl); }
316 const _Node_alloc_type&
317 _M_get_Node_allocator()
const noexcept
318 {
return *
static_cast<const _Node_alloc_type*
>(&this->_M_impl); }
329 : _M_impl(std::move(__lst._M_get_Node_allocator()))
331 this->_M_impl._M_head._M_next = __lst._M_impl._M_head._M_next;
332 __lst._M_impl._M_head._M_next = 0;
336 { _M_erase_after(&_M_impl._M_head, 0); }
344 template<
typename... _Args>
346 _M_create_node(_Args&&... __args)
348 _Node* __node = this->_M_get_node();
351 _Tp_alloc_type __a(_M_get_Node_allocator());
353 ::new ((
void*)__node)
_Node();
354 _Alloc_traits::construct(__a, __node->_M_valptr(),
355 std::forward<_Args>(__args)...);
359 this->_M_put_node(__node);
360 __throw_exception_again;
365 template<
typename... _Args>
370 _M_put_node(
_Node* __p)
407 template<
typename _Tp,
typename _Alloc = allocator<_Tp> >
414 typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
415 typedef typename _Base::_Node_alloc_type _Node_alloc_type;
421 typedef _Tp value_type;
422 typedef typename _Alloc_traits::pointer pointer;
423 typedef typename _Alloc_traits::const_pointer const_pointer;
424 typedef typename _Alloc_traits::reference reference;
425 typedef typename _Alloc_traits::const_reference const_reference;
429 typedef std::size_t size_type;
430 typedef std::ptrdiff_t difference_type;
431 typedef _Alloc allocator_type;
441 :
_Base(_Node_alloc_type(__al))
450 :
_Base(_Node_alloc_type(__al))
451 { _M_range_initialize(__list.
begin(), __list.
end()); }
459 noexcept(_Node_alloc_traits::_S_always_equal())
460 :
_Base(std::move(__list), _Node_alloc_type(__al))
472 :
_Base(_Node_alloc_type(__al))
473 { _M_default_initialize(__n); }
485 const _Alloc& __al = _Alloc())
486 :
_Base(_Node_alloc_type(__al))
487 { _M_fill_initialize(__n, __value); }
499 template<
typename _InputIterator,
500 typename = std::_RequireInputIter<_InputIterator>>
502 const _Alloc& __al = _Alloc())
503 :
_Base(_Node_alloc_type(__al))
504 { _M_range_initialize(__first, __last); }
513 __list._M_get_Node_allocator()))
514 { _M_range_initialize(__list.
begin(), __list.
end()); }
526 :
_Base(std::move(__list)) { }
537 const _Alloc& __al = _Alloc())
538 :
_Base(_Node_alloc_type(__al))
539 { _M_range_initialize(__il.begin(), __il.end()); }
571 constexpr
bool __move_storage =
572 _Node_alloc_traits::_S_propagate_on_move_assign()
573 || _Node_alloc_traits::_S_always_equal();
574 _M_move_assign(std::move(__list),
606 template<
typename _InputIterator,
607 typename = std::_RequireInputIter<_InputIterator>>
609 assign(_InputIterator __first, _InputIterator __last)
612 _M_assign(__first, __last, __assignable());
639 {
assign(__il.begin(), __il.end()); }
644 {
return allocator_type(this->_M_get_Node_allocator()); }
654 {
return iterator(&this->_M_impl._M_head); }
671 {
return iterator(this->_M_impl._M_head._M_next); }
733 {
return this->_M_impl._M_head._M_next == 0; }
751 _Node* __front =
static_cast<_Node*
>(this->_M_impl._M_head._M_next);
752 return *__front->_M_valptr();
762 _Node* __front =
static_cast<_Node*
>(this->_M_impl._M_head._M_next);
763 return *__front->_M_valptr();
779 template<
typename... _Args>
783 std::forward<_Args>(__args)...); }
804 { this->_M_insert_after(
cbefore_begin(), std::move(__val)); }
820 { this->_M_erase_after(&this->_M_impl._M_head); }
835 template<
typename... _Args>
838 {
return iterator(this->_M_insert_after(__pos,
839 std::forward<_Args>(__args)...)); }
855 {
return iterator(this->_M_insert_after(__pos, __val)); }
862 {
return iterator(this->_M_insert_after(__pos, std::move(__val))); }
880 insert_after(const_iterator __pos, size_type __n,
const _Tp& __val);
897 template<
typename _InputIterator,
898 typename = std::_RequireInputIter<_InputIterator>>
901 _InputIterator __first, _InputIterator __last);
920 {
return insert_after(__pos, __il.begin(), __il.end()); }
941 {
return iterator(this->_M_erase_after(const_cast<_Node_base*>
964 {
return iterator(this->_M_erase_after(const_cast<_Node_base*>
966 const_cast<_Node_base*>
967 (__last._M_node))); }
981 noexcept(_Node_alloc_traits::_S_nothrow_swap())
983 std::swap(this->_M_impl._M_head._M_next,
984 __list._M_impl._M_head._M_next);
985 _Node_alloc_traits::_S_on_swap(this->_M_get_Node_allocator(),
986 __list._M_get_Node_allocator());
1016 resize(size_type __sz,
const value_type& __val);
1028 { this->_M_erase_after(&this->_M_impl._M_head, 0); }
1046 if (!__list.empty())
1047 _M_splice_after(__pos, __list.before_begin(), __list.end());
1066 const_iterator __i);
1089 { _M_splice_after(__pos, __before, __last); }
1093 const_iterator __before, const_iterator __last)
1094 { _M_splice_after(__pos, __before, __last); }
1108 remove(
const _Tp& __val);
1121 template<
typename _Pred>
1151 template<
typename _BinPred>
1153 unique(_BinPred __binary_pred);
1170 {
merge(std::move(__list)); }
1183 template<
typename _Comp>
1187 template<
typename _Comp>
1190 {
merge(std::move(__list), __comp); }
1208 template<
typename _Comp>
1219 { this->_M_impl._M_head._M_reverse_after(); }
1223 template<
typename _InputIterator>
1225 _M_range_initialize(_InputIterator __first, _InputIterator __last);
1230 _M_fill_initialize(size_type __n,
const value_type& __value);
1234 _M_splice_after(const_iterator __pos, const_iterator __before,
1235 const_iterator __last);
1239 _M_default_initialize(size_type __n);
1243 _M_default_insert_after(const_iterator __pos, size_type __n);
1250 std::swap(this->_M_impl._M_head._M_next,
1251 __list._M_impl._M_head._M_next);
1252 std::__alloc_on_move(this->_M_get_Node_allocator(),
1253 __list._M_get_Node_allocator());
1260 if (__list._M_get_Node_allocator() == this->_M_get_Node_allocator())
1265 this->
assign(std::__make_move_if_noexcept_iterator(__list.begin()),
1266 std::__make_move_if_noexcept_iterator(__list.end()));
1271 template<
typename _InputIterator>
1273 _M_assign(_InputIterator __first, _InputIterator __last,
true_type)
1276 auto __curr =
begin();
1278 while (__curr != __end && __first != __last)
1285 if (__first != __last)
1287 else if (__curr != __end)
1293 template<
typename _InputIterator>
1295 _M_assign(_InputIterator __first, _InputIterator __last,
false_type)
1303 _M_assign_n(size_type __n,
const _Tp& __val,
true_type)
1306 auto __curr =
begin();
1308 while (__curr != __end && __n > 0)
1317 else if (__curr != __end)
1323 _M_assign_n(size_type __n,
const _Tp& __val,
false_type)
1340 template<
typename _Tp,
typename _Alloc>
1342 operator==(
const forward_list<_Tp, _Alloc>& __lx,
1343 const forward_list<_Tp, _Alloc>& __ly);
1357 template<
typename _Tp,
typename _Alloc>
1359 operator<(const forward_list<_Tp, _Alloc>& __lx,
1362 __ly.cbegin(), __ly.cend()); }
1365 template<
typename _Tp,
typename _Alloc>
1369 {
return !(__lx == __ly); }
1372 template<
typename _Tp,
typename _Alloc>
1376 {
return (__ly < __lx); }
1379 template<
typename _Tp,
typename _Alloc>
1383 {
return !(__lx < __ly); }
1386 template<
typename _Tp,
typename _Alloc>
1388 operator<=(const forward_list<_Tp, _Alloc>& __lx,
1390 {
return !(__ly < __lx); }
1393 template<
typename _Tp,
typename _Alloc>
1397 { __lx.
swap(__ly); }
1399 _GLIBCXX_END_NAMESPACE_CONTAINER
1402 #endif // _FORWARD_LIST_H