30 #ifndef _FORWARD_LIST_H 31 #define _FORWARD_LIST_H 1 33 #pragma GCC system_header 44 namespace std _GLIBCXX_VISIBILITY(default)
46 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
66 __begin->_M_next = __end->_M_next;
67 __end->_M_next = _M_next;
76 _M_reverse_after() noexcept
85 __tail->_M_next = __temp->_M_next;
86 _M_next->_M_next = __keep;
97 template<
typename _Tp>
103 __gnu_cxx::__aligned_buffer<_Tp> _M_storage;
107 {
return _M_storage._M_ptr(); }
110 _M_valptr()
const noexcept
111 {
return _M_storage._M_ptr(); }
119 template<
typename _Tp>
125 typedef _Tp value_type;
126 typedef _Tp* pointer;
127 typedef _Tp& reference;
128 typedef ptrdiff_t difference_type;
140 {
return *
static_cast<_Node*
>(this->_M_node)->_M_valptr(); }
143 operator->()
const noexcept
144 {
return static_cast<_Node*
>(this->_M_node)->_M_valptr(); }
147 operator++() noexcept
149 _M_node = _M_node->_M_next;
154 operator++(
int) noexcept
157 _M_node = _M_node->_M_next;
162 operator==(
const _Self& __x)
const noexcept
163 {
return _M_node == __x._M_node; }
166 operator!=(
const _Self& __x)
const noexcept
167 {
return _M_node != __x._M_node; }
170 _M_next()
const noexcept
186 template<
typename _Tp>
193 typedef _Tp value_type;
194 typedef const _Tp* pointer;
195 typedef const _Tp& reference;
196 typedef ptrdiff_t difference_type;
207 : _M_node(__iter._M_node) { }
211 {
return *
static_cast<_Node*
>(this->_M_node)->_M_valptr(); }
214 operator->()
const noexcept
215 {
return static_cast<_Node*
>(this->_M_node)->_M_valptr(); }
218 operator++() noexcept
220 _M_node = _M_node->_M_next;
225 operator++(
int) noexcept
228 _M_node = _M_node->_M_next;
233 operator==(
const _Self& __x)
const noexcept
234 {
return _M_node == __x._M_node; }
237 operator!=(
const _Self& __x)
const noexcept
238 {
return _M_node != __x._M_node; }
241 _M_next()
const noexcept
255 template<
typename _Tp>
259 {
return __x._M_node == __y._M_node; }
264 template<
typename _Tp>
268 {
return __x._M_node != __y._M_node; }
273 template<
typename _Tp,
typename _Alloc>
277 typedef __alloc_rebind<_Alloc, _Fwd_list_node<_Tp>> _Node_alloc_type;
280 struct _Fwd_list_impl
281 :
public _Node_alloc_type
286 : _Node_alloc_type(), _M_head()
289 _Fwd_list_impl(
const _Node_alloc_type& __a)
290 : _Node_alloc_type(__a), _M_head()
293 _Fwd_list_impl(_Node_alloc_type&& __a)
294 : _Node_alloc_type(std::move(__a)), _M_head()
298 _Fwd_list_impl _M_impl;
306 _M_get_Node_allocator() noexcept
307 {
return this->_M_impl; }
309 const _Node_alloc_type&
310 _M_get_Node_allocator()
const noexcept
311 {
return this->_M_impl; }
317 : _M_impl(std::move(__a)) { }
322 : _M_impl(std::move(__lst._M_get_Node_allocator()))
324 this->_M_impl._M_head._M_next = __lst._M_impl._M_head._M_next;
325 __lst._M_impl._M_head._M_next = 0;
329 { _M_erase_after(&_M_impl._M_head, 0); }
336 auto __ptr = _Node_alloc_traits::allocate(_M_get_Node_allocator(), 1);
340 template<
typename... _Args>
342 _M_create_node(_Args&&... __args)
344 _Node* __node = this->_M_get_node();
347 ::new ((
void*)__node) _Node;
348 _Node_alloc_traits::construct(_M_get_Node_allocator(),
350 std::forward<_Args>(__args)...);
354 this->_M_put_node(__node);
355 __throw_exception_again;
360 template<
typename... _Args>
362 _M_insert_after(const_iterator __pos, _Args&&... __args);
365 _M_put_node(_Node* __p)
367 typedef typename _Node_alloc_traits::pointer _Ptr;
369 _Node_alloc_traits::deallocate(_M_get_Node_allocator(), __ptr, 1);
406 template<
typename _Tp,
typename _Alloc = allocator<_Tp> >
413 typedef typename _Base::_Node_alloc_type _Node_alloc_type;
419 typedef _Tp value_type;
422 typedef value_type& reference;
423 typedef const value_type& const_reference;
427 typedef std::size_t size_type;
428 typedef std::ptrdiff_t difference_type;
429 typedef _Alloc allocator_type;
437 noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value)
447 : _Base(_Node_alloc_type(__al))
457 : _Base(_Node_alloc_type(__al))
458 { _M_range_initialize(__list.
begin(), __list.
end()); }
466 noexcept(_Node_alloc_traits::_S_always_equal())
467 : _Base(
std::move(__list), _Node_alloc_type(__al))
471 insert_after(cbefore_begin(),
472 std::__make_move_if_noexcept_iterator(__list.begin()),
473 std::__make_move_if_noexcept_iterator(__list.end()));
486 : _Base(_Node_alloc_type(__al))
487 { _M_default_initialize(__n); }
499 const _Alloc& __al = _Alloc())
500 : _Base(_Node_alloc_type(__al))
501 { _M_fill_initialize(__n, __value); }
513 template<
typename _InputIterator,
514 typename = std::_RequireInputIter<_InputIterator>>
516 const _Alloc& __al = _Alloc())
517 : _Base(_Node_alloc_type(__al))
518 { _M_range_initialize(__first, __last); }
526 : _Base(_Node_alloc_traits::_S_select_on_copy(
527 __list._M_get_Node_allocator()))
528 { _M_range_initialize(__list.
begin(), __list.
end()); }
540 : _Base(std::move(__list)) { }
551 const _Alloc& __al = _Alloc())
552 : _Base(_Node_alloc_type(__al))
553 { _M_range_initialize(__il.begin(), __il.end()); }
587 noexcept(_Node_alloc_traits::_S_nothrow_move())
589 constexpr
bool __move_storage =
590 _Node_alloc_traits::_S_propagate_on_move_assign()
591 || _Node_alloc_traits::_S_always_equal();
623 template<
typename _InputIterator,
624 typename = std::_RequireInputIter<_InputIterator>>
626 assign(_InputIterator __first, _InputIterator __last)
628 typedef is_assignable<_Tp, decltype(*__first)> __assignable;
629 _M_assign(__first, __last, __assignable());
644 { _M_assign_n(__n, __val, is_copy_assignable<_Tp>()); }
656 { assign(__il.begin(), __il.end()); }
661 {
return allocator_type(this->_M_get_Node_allocator()); }
671 {
return iterator(&this->_M_impl._M_head); }
680 {
return const_iterator(&this->_M_impl._M_head); }
688 {
return iterator(this->_M_impl._M_head._M_next); }
697 {
return const_iterator(this->_M_impl._M_head._M_next); }
706 {
return iterator(0); }
715 {
return const_iterator(0); }
724 {
return const_iterator(this->_M_impl._M_head._M_next); }
733 {
return const_iterator(&this->_M_impl._M_head); }
742 {
return const_iterator(0); }
750 {
return this->_M_impl._M_head._M_next == 0; }
757 {
return _Node_alloc_traits::max_size(this->_M_get_Node_allocator()); }
768 _Node* __front =
static_cast<_Node*
>(this->_M_impl._M_head._M_next);
769 return *__front->_M_valptr();
779 _Node* __front =
static_cast<_Node*
>(this->_M_impl._M_head._M_next);
780 return *__front->_M_valptr();
796 template<
typename... _Args>
797 #if __cplusplus > 201402L 804 this->_M_insert_after(cbefore_begin(),
805 std::forward<_Args>(__args)...);
806 #if __cplusplus > 201402L 823 { this->_M_insert_after(cbefore_begin(), __val); }
829 push_front(_Tp&& __val)
830 { this->_M_insert_after(cbefore_begin(), std::move(__val)); }
846 { this->_M_erase_after(&this->_M_impl._M_head); }
861 template<
typename... _Args>
864 {
return iterator(this->_M_insert_after(__pos,
865 std::forward<_Args>(__args)...)); }
881 {
return iterator(this->_M_insert_after(__pos, __val)); }
887 insert_after(const_iterator __pos, _Tp&& __val)
888 {
return iterator(this->_M_insert_after(__pos, std::move(__val))); }
906 insert_after(const_iterator __pos, size_type __n,
const _Tp& __val);
923 template<
typename _InputIterator,
924 typename = std::_RequireInputIter<_InputIterator>>
926 insert_after(const_iterator __pos,
927 _InputIterator __first, _InputIterator __last);
946 {
return insert_after(__pos, __il.begin(), __il.end()); }
967 {
return iterator(this->_M_erase_after(const_cast<_Node_base*>
990 {
return iterator(this->_M_erase_after(const_cast<_Node_base*>
992 const_cast<_Node_base*>
993 (__last._M_node))); }
1010 std::swap(this->_M_impl._M_head._M_next,
1011 __list._M_impl._M_head._M_next);
1012 _Node_alloc_traits::_S_on_swap(this->_M_get_Node_allocator(),
1013 __list._M_get_Node_allocator());
1028 resize(size_type __sz);
1043 resize(size_type __sz,
const value_type& __val);
1055 { this->_M_erase_after(&this->_M_impl._M_head, 0); }
1073 if (!__list.
empty())
1078 splice_after(const_iterator __pos,
forward_list& __list) noexcept
1079 { splice_after(__pos, std::move(__list)); }
1092 splice_after(const_iterator __pos,
forward_list&& __list,
1093 const_iterator __i) noexcept;
1096 splice_after(const_iterator __pos,
forward_list& __list,
1097 const_iterator __i) noexcept
1098 { splice_after(__pos, std::move(__list), __i); }
1116 const_iterator __before, const_iterator __last) noexcept
1117 { _M_splice_after(__pos, __before, __last); }
1121 const_iterator __before, const_iterator __last) noexcept
1122 { _M_splice_after(__pos, __before, __last); }
1137 remove(
const _Tp& __val);
1150 template<
typename _Pred>
1152 remove_if(_Pred __pred);
1180 template<
typename _BinPred>
1182 unique(_BinPred __binary_pred);
1199 { merge(std::move(__list)); }
1212 template<
typename _Comp>
1216 template<
typename _Comp>
1219 { merge(std::move(__list), __comp); }
1237 template<
typename _Comp>
1248 { this->_M_impl._M_head._M_reverse_after(); }
1252 template<
typename _InputIterator>
1254 _M_range_initialize(_InputIterator __first, _InputIterator __last);
1259 _M_fill_initialize(size_type __n,
const value_type& __value);
1263 _M_splice_after(const_iterator __pos, const_iterator __before,
1264 const_iterator __last);
1268 _M_default_initialize(size_type __n);
1272 _M_default_insert_after(const_iterator __pos, size_type __n);
1279 this->_M_impl._M_head._M_next = __list._M_impl._M_head._M_next;
1280 __list._M_impl._M_head._M_next =
nullptr;
1281 std::__alloc_on_move(this->_M_get_Node_allocator(),
1282 __list._M_get_Node_allocator());
1289 if (__list._M_get_Node_allocator() == this->_M_get_Node_allocator())
1294 this->assign(std::__make_move_if_noexcept_iterator(__list.
begin()),
1295 std::__make_move_if_noexcept_iterator(__list.
end()));
1300 template<
typename _InputIterator>
1302 _M_assign(_InputIterator __first, _InputIterator __last,
true_type)
1304 auto __prev = before_begin();
1305 auto __curr =
begin();
1307 while (__curr != __end && __first != __last)
1314 if (__first != __last)
1315 insert_after(__prev, __first, __last);
1316 else if (__curr != __end)
1317 erase_after(__prev, __end);
1322 template<
typename _InputIterator>
1324 _M_assign(_InputIterator __first, _InputIterator __last,
false_type)
1327 insert_after(cbefore_begin(), __first, __last);
1332 _M_assign_n(size_type __n,
const _Tp& __val,
true_type)
1334 auto __prev = before_begin();
1335 auto __curr =
begin();
1337 while (__curr != __end && __n > 0)
1345 insert_after(__prev, __n, __val);
1346 else if (__curr != __end)
1347 erase_after(__prev, __end);
1352 _M_assign_n(size_type __n,
const _Tp& __val,
false_type)
1355 insert_after(cbefore_begin(), __n, __val);
1369 template<
typename _Tp,
typename _Alloc>
1386 template<
typename _Tp,
typename _Alloc>
1388 operator<(const forward_list<_Tp, _Alloc>& __lx,
1394 template<
typename _Tp,
typename _Alloc>
1398 {
return !(__lx == __ly); }
1401 template<
typename _Tp,
typename _Alloc>
1405 {
return (__ly < __lx); }
1408 template<
typename _Tp,
typename _Alloc>
1412 {
return !(__lx < __ly); }
1415 template<
typename _Tp,
typename _Alloc>
1417 operator<=(const forward_list<_Tp, _Alloc>& __lx,
1419 {
return !(__ly < __lx); }
1422 template<
typename _Tp,
typename _Alloc>
1426 noexcept(noexcept(__lx.swap(__ly)))
1427 { __lx.swap(__ly); }
1429 _GLIBCXX_END_NAMESPACE_CONTAINER
1432 #endif // _FORWARD_LIST_H void pop_front()
Removes first element.
forward_list & operator=(forward_list &&__list) noexcept(_Node_alloc_traits::_S_nothrow_move())
The forward_list move assignment operator.
const_reference front() const
void push_front(const _Tp &__val)
Add data to the front of the forward_list.
constexpr const _Tp * end(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to one past the last element of the initializer_list. ...
void splice_after(const_iterator __pos, forward_list &&__list) noexcept
Insert contents of another forward_list.
iterator emplace_after(const_iterator __pos, _Args &&... __args)
Constructs object in forward_list after the specified iterator.
forward_list(const forward_list &__list)
The forward_list copy constructor.
void splice_after(const_iterator __pos, forward_list &&, const_iterator __before, const_iterator __last) noexcept
Insert range from another forward_list.
iterator begin() noexcept
void merge(forward_list &&__list)
Merge sorted lists.
const_iterator end() const noexcept
constexpr const _Tp * begin(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to the first element of the initializer_list.
iterator before_begin() noexcept
A helper node class for forward_list. This is just a linked list with uninitialized storage for a dat...
One of the comparison functors.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
forward_list(_InputIterator __first, _InputIterator __last, const _Alloc &__al=_Alloc())
Builds a forward_list from a range.
Forward iterators support a superset of input iterator operations.
iterator insert_after(const_iterator __pos, const _Tp &__val)
Inserts given value into forward_list after specified iterator.
One of the comparison functors.
Uniform interface to all allocator types.
forward_list & operator=(std::initializer_list< _Tp > __il)
The forward_list initializer list assignment operator.
A standard container with linear time access to elements, and fixed time insertion/deletion at any po...
Uniform interface to all pointer-like types.
typename _Ptr< __c_pointer, const value_type >::type const_pointer
The allocator's const pointer type.
size_type max_size() const noexcept
A forward_list::const_iterator.
iterator insert_after(const_iterator __pos, std::initializer_list< _Tp > __il)
Inserts the contents of an initializer_list into forward_list after the specified iterator...
forward_list(forward_list &&__list, const _Alloc &__al) noexcept(_Node_alloc_traits::_S_always_equal())
Move constructor with allocator argument.
forward_list(forward_list &&__list) noexcept
The forward_list move constructor.
const_iterator begin() const noexcept
void unique()
Remove consecutive duplicate elements.
integral_constant< bool, true > true_type
The type used as a compile-time boolean with true value.
forward_list(const _Alloc &__al) noexcept
Creates a forward_list with no elements.
void emplace_front(_Args &&... __args)
Constructs object in forward_list at the front of the list.
forward_list() noexcept(is_nothrow_default_constructible< _Node_alloc_type >::value)
Creates a forward_list with no elements.
forward_list(std::initializer_list< _Tp > __il, const _Alloc &__al=_Alloc())
Builds a forward_list from an initializer_list.
forward_list(size_type __n, const _Tp &__value, const _Alloc &__al=_Alloc())
Creates a forward_list with copies of an exemplar element.
ISO C++ entities toplevel namespace is std.
const_iterator cbefore_begin() const noexcept
void clear() noexcept
Erases all the elements.
Uniform interface to C++98 and C++11 allocators.
iterator erase_after(const_iterator __pos)
Removes the element pointed to by the iterator following pos.
forward_list(size_type __n, const _Alloc &__al=_Alloc())
Creates a forward_list with default constructed elements.
void assign(_InputIterator __first, _InputIterator __last)
Assigns a range to a forward_list.
__detected_or_t< value_type *, __pointer, _Alloc > pointer
The allocator's pointer type.
void reverse() noexcept
Reverse the elements in list.
A helper basic node class for forward_list. This is just a linked list with nothing inside it...
bool lexicographical_compare(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _Compare __comp)
Performs dictionary comparison on ranges.
~forward_list() noexcept
The forward_list dtor.
A forward_list::iterator.
void splice_after(const_iterator __pos, forward_list &, const_iterator __before, const_iterator __last) noexcept
Insert range from another forward_list.
const_iterator cend() const noexcept
const_iterator cbegin() const noexcept
forward_list(const forward_list &__list, const _Alloc &__al)
Copy constructor with allocator argument.
iterator erase_after(const_iterator __pos, const_iterator __last)
Remove a range of elements.
void swap(forward_list &__list) noexcept
Swaps data with another forward_list.
Base class for forward_list.
const_iterator before_begin() const noexcept
void assign(std::initializer_list< _Tp > __il)
Assigns an initializer_list to a forward_list.
void sort()
Sort the elements of the list.
bool empty() const noexcept
allocator_type get_allocator() const noexcept
Get a copy of the memory allocation object.
complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
void assign(size_type __n, const _Tp &__val)
Assigns a given value to a forward_list.