STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Macros | Functions
forward_list.tcc File Reference

Macros

#define _FORWARD_LIST_TCC   1
 

Functions

namespace std _GLIBCXX_VISIBILITY (default)
 

Detailed Description

This is an internal header file, included by other library headers. Do not attempt to use it directly. {forward_list}

Macro Definition Documentation

#define _FORWARD_LIST_TCC   1

Function Documentation

namespace std _GLIBCXX_VISIBILITY ( default  )
34 {
35 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
36 
37  template<typename _Tp, typename _Alloc>
38  _Fwd_list_base<_Tp, _Alloc>::
39  _Fwd_list_base(_Fwd_list_base&& __lst, const _Node_alloc_type& __a)
40  : _M_impl(__a)
41  {
42  if (__lst._M_get_Node_allocator() == __a)
43  {
44  this->_M_impl._M_head._M_next = __lst._M_impl._M_head._M_next;
45  __lst._M_impl._M_head._M_next = 0;
46  }
47  else
48  {
49  this->_M_impl._M_head._M_next = 0;
50  _Fwd_list_node_base* __to = &this->_M_impl._M_head;
51  _Node* __curr = static_cast<_Node*>(__lst._M_impl._M_head._M_next);
52 
53  while (__curr)
54  {
55  __to->_M_next =
56  _M_create_node(std::move_if_noexcept(*__curr->_M_valptr()));
57  __to = __to->_M_next;
58  __curr = static_cast<_Node*>(__curr->_M_next);
59  }
60  }
61  }
62 
63  template<typename _Tp, typename _Alloc>
64  template<typename... _Args>
65  _Fwd_list_node_base*
66  _Fwd_list_base<_Tp, _Alloc>::
67  _M_insert_after(const_iterator __pos, _Args&&... __args)
68  {
69  _Fwd_list_node_base* __to
70  = const_cast<_Fwd_list_node_base*>(__pos._M_node);
71  _Node* __thing = _M_create_node(std::forward<_Args>(__args)...);
72  __thing->_M_next = __to->_M_next;
73  __to->_M_next = __thing;
74  return __to->_M_next;
75  }
76 
77  template<typename _Tp, typename _Alloc>
78  _Fwd_list_node_base*
79  _Fwd_list_base<_Tp, _Alloc>::
80  _M_erase_after(_Fwd_list_node_base* __pos)
81  {
82  _Node* __curr = static_cast<_Node*>(__pos->_M_next);
83  __pos->_M_next = __curr->_M_next;
84  _Tp_alloc_type __a(_M_get_Node_allocator());
85  allocator_traits<_Tp_alloc_type>::destroy(__a, __curr->_M_valptr());
86  __curr->~_Node();
87  _M_put_node(__curr);
88  return __pos->_M_next;
89  }
90 
91  template<typename _Tp, typename _Alloc>
92  _Fwd_list_node_base*
93  _Fwd_list_base<_Tp, _Alloc>::
94  _M_erase_after(_Fwd_list_node_base* __pos,
95  _Fwd_list_node_base* __last)
96  {
97  _Node* __curr = static_cast<_Node*>(__pos->_M_next);
98  while (__curr != __last)
99  {
100  _Node* __temp = __curr;
101  __curr = static_cast<_Node*>(__curr->_M_next);
102  _Tp_alloc_type __a(_M_get_Node_allocator());
103  allocator_traits<_Tp_alloc_type>::destroy(__a, __temp->_M_valptr());
104  __temp->~_Node();
105  _M_put_node(__temp);
106  }
107  __pos->_M_next = __last;
108  return __last;
109  }
110 
111  // Called by the range constructor to implement [23.3.4.2]/9
112  template<typename _Tp, typename _Alloc>
113  template<typename _InputIterator>
114  void
115  forward_list<_Tp, _Alloc>::
116  _M_range_initialize(_InputIterator __first, _InputIterator __last)
117  {
118  _Node_base* __to = &this->_M_impl._M_head;
119  for (; __first != __last; ++__first)
120  {
121  __to->_M_next = this->_M_create_node(*__first);
122  __to = __to->_M_next;
123  }
124  }
125 
126  // Called by forward_list(n,v,a).
127  template<typename _Tp, typename _Alloc>
128  void
129  forward_list<_Tp, _Alloc>::
130  _M_fill_initialize(size_type __n, const value_type& __value)
131  {
132  _Node_base* __to = &this->_M_impl._M_head;
133  for (; __n; --__n)
134  {
135  __to->_M_next = this->_M_create_node(__value);
136  __to = __to->_M_next;
137  }
138  }
139 
140  template<typename _Tp, typename _Alloc>
141  void
142  forward_list<_Tp, _Alloc>::
143  _M_default_initialize(size_type __n)
144  {
145  _Node_base* __to = &this->_M_impl._M_head;
146  for (; __n; --__n)
147  {
148  __to->_M_next = this->_M_create_node();
149  __to = __to->_M_next;
150  }
151  }
152 
153  template<typename _Tp, typename _Alloc>
154  forward_list<_Tp, _Alloc>&
155  forward_list<_Tp, _Alloc>::
156  operator=(const forward_list& __list)
157  {
158  if (&__list != this)
159  {
160  if (_Node_alloc_traits::_S_propagate_on_copy_assign())
161  {
162  auto& __this_alloc = this->_M_get_Node_allocator();
163  auto& __that_alloc = __list._M_get_Node_allocator();
164  if (!_Node_alloc_traits::_S_always_equal()
165  && __this_alloc != __that_alloc)
166  {
167  // replacement allocator cannot free existing storage
168  clear();
169  }
170  std::__alloc_on_copy(__this_alloc, __that_alloc);
171  }
172  assign(__list.cbegin(), __list.cend());
173  }
174  return *this;
175  }
176 
177  template<typename _Tp, typename _Alloc>
178  void
179  forward_list<_Tp, _Alloc>::
180  _M_default_insert_after(const_iterator __pos, size_type __n)
181  {
182  const_iterator __saved_pos = __pos;
183  __try
184  {
185  for (; __n; --__n)
186  __pos = emplace_after(__pos);
187  }
188  __catch(...)
189  {
190  erase_after(__saved_pos, ++__pos);
191  __throw_exception_again;
192  }
193  }
194 
195  template<typename _Tp, typename _Alloc>
196  void
197  forward_list<_Tp, _Alloc>::
198  resize(size_type __sz)
199  {
200  iterator __k = before_begin();
201 
202  size_type __len = 0;
203  while (__k._M_next() != end() && __len < __sz)
204  {
205  ++__k;
206  ++__len;
207  }
208  if (__len == __sz)
209  erase_after(__k, end());
210  else
211  _M_default_insert_after(__k, __sz - __len);
212  }
213 
214  template<typename _Tp, typename _Alloc>
215  void
216  forward_list<_Tp, _Alloc>::
217  resize(size_type __sz, const value_type& __val)
218  {
219  iterator __k = before_begin();
220 
221  size_type __len = 0;
222  while (__k._M_next() != end() && __len < __sz)
223  {
224  ++__k;
225  ++__len;
226  }
227  if (__len == __sz)
228  erase_after(__k, end());
229  else
230  insert_after(__k, __sz - __len, __val);
231  }
232 
233  template<typename _Tp, typename _Alloc>
234  typename forward_list<_Tp, _Alloc>::iterator
235  forward_list<_Tp, _Alloc>::
236  _M_splice_after(const_iterator __pos,
237  const_iterator __before, const_iterator __last)
238  {
239  _Node_base* __tmp = const_cast<_Node_base*>(__pos._M_node);
240  _Node_base* __b = const_cast<_Node_base*>(__before._M_node);
241  _Node_base* __end = __b;
242 
243  while (__end && __end->_M_next != __last._M_node)
244  __end = __end->_M_next;
245 
246  if (__b != __end)
247  return iterator(__tmp->_M_transfer_after(__b, __end));
248  else
249  return iterator(__tmp);
250  }
251 
252  template<typename _Tp, typename _Alloc>
253  void
254  forward_list<_Tp, _Alloc>::
255  splice_after(const_iterator __pos, forward_list&&,
256  const_iterator __i)
257  {
258  const_iterator __j = __i;
259  ++__j;
260 
261  if (__pos == __i || __pos == __j)
262  return;
263 
264  _Node_base* __tmp = const_cast<_Node_base*>(__pos._M_node);
265  __tmp->_M_transfer_after(const_cast<_Node_base*>(__i._M_node),
266  const_cast<_Node_base*>(__j._M_node));
267  }
268 
269  template<typename _Tp, typename _Alloc>
270  typename forward_list<_Tp, _Alloc>::iterator
271  forward_list<_Tp, _Alloc>::
272  insert_after(const_iterator __pos, size_type __n, const _Tp& __val)
273  {
274  if (__n)
275  {
276  forward_list __tmp(__n, __val, get_allocator());
277  return _M_splice_after(__pos, __tmp.before_begin(), __tmp.end());
278  }
279  else
280  return iterator(const_cast<_Node_base*>(__pos._M_node));
281  }
282 
283  template<typename _Tp, typename _Alloc>
284  template<typename _InputIterator, typename>
285  typename forward_list<_Tp, _Alloc>::iterator
286  forward_list<_Tp, _Alloc>::
287  insert_after(const_iterator __pos,
288  _InputIterator __first, _InputIterator __last)
289  {
290  forward_list __tmp(__first, __last, get_allocator());
291  if (!__tmp.empty())
292  return _M_splice_after(__pos, __tmp.before_begin(), __tmp.end());
293  else
294  return iterator(const_cast<_Node_base*>(__pos._M_node));
295  }
296 
297  template<typename _Tp, typename _Alloc>
298  void
299  forward_list<_Tp, _Alloc>::
300  remove(const _Tp& __val)
301  {
302  _Node* __curr = static_cast<_Node*>(&this->_M_impl._M_head);
303  _Node* __extra = 0;
304 
305  while (_Node* __tmp = static_cast<_Node*>(__curr->_M_next))
306  {
307  if (*__tmp->_M_valptr() == __val)
308  {
309  if (__tmp->_M_valptr() != std::__addressof(__val))
310  {
311  this->_M_erase_after(__curr);
312  continue;
313  }
314  else
315  __extra = __curr;
316  }
317  __curr = static_cast<_Node*>(__curr->_M_next);
318  }
319 
320  if (__extra)
321  this->_M_erase_after(__extra);
322  }
323 
324  template<typename _Tp, typename _Alloc>
325  template<typename _Pred>
326  void
327  forward_list<_Tp, _Alloc>::
328  remove_if(_Pred __pred)
329  {
330  _Node* __curr = static_cast<_Node*>(&this->_M_impl._M_head);
331  while (_Node* __tmp = static_cast<_Node*>(__curr->_M_next))
332  {
333  if (__pred(*__tmp->_M_valptr()))
334  this->_M_erase_after(__curr);
335  else
336  __curr = static_cast<_Node*>(__curr->_M_next);
337  }
338  }
339 
340  template<typename _Tp, typename _Alloc>
341  template<typename _BinPred>
342  void
343  forward_list<_Tp, _Alloc>::
344  unique(_BinPred __binary_pred)
345  {
346  iterator __first = begin();
347  iterator __last = end();
348  if (__first == __last)
349  return;
350  iterator __next = __first;
351  while (++__next != __last)
352  {
353  if (__binary_pred(*__first, *__next))
354  erase_after(__first);
355  else
356  __first = __next;
357  __next = __first;
358  }
359  }
360 
361  template<typename _Tp, typename _Alloc>
362  template<typename _Comp>
363  void
364  forward_list<_Tp, _Alloc>::
365  merge(forward_list&& __list, _Comp __comp)
366  {
367  _Node_base* __node = &this->_M_impl._M_head;
368  while (__node->_M_next && __list._M_impl._M_head._M_next)
369  {
370  if (__comp(*static_cast<_Node*>
371  (__list._M_impl._M_head._M_next)->_M_valptr(),
372  *static_cast<_Node*>
373  (__node->_M_next)->_M_valptr()))
374  __node->_M_transfer_after(&__list._M_impl._M_head,
375  __list._M_impl._M_head._M_next);
376  __node = __node->_M_next;
377  }
378  if (__list._M_impl._M_head._M_next)
379  {
380  __node->_M_next = __list._M_impl._M_head._M_next;
381  __list._M_impl._M_head._M_next = 0;
382  }
383  }
384 
385  template<typename _Tp, typename _Alloc>
386  bool
387  operator==(const forward_list<_Tp, _Alloc>& __lx,
388  const forward_list<_Tp, _Alloc>& __ly)
389  {
390  // We don't have size() so we need to walk through both lists
391  // making sure both iterators are valid.
392  auto __ix = __lx.cbegin();
393  auto __iy = __ly.cbegin();
394  while (__ix != __lx.cend() && __iy != __ly.cend())
395  {
396  if (*__ix != *__iy)
397  return false;
398  ++__ix;
399  ++__iy;
400  }
401  if (__ix == __lx.cend() && __iy == __ly.cend())
402  return true;
403  else
404  return false;
405  }
406 
407  template<typename _Tp, class _Alloc>
408  template<typename _Comp>
409  void
410  forward_list<_Tp, _Alloc>::
411  sort(_Comp __comp)
412  {
413  // If `next' is 0, return immediately.
414  _Node* __list = static_cast<_Node*>(this->_M_impl._M_head._M_next);
415  if (!__list)
416  return;
417 
418  unsigned long __insize = 1;
419 
420  while (1)
421  {
422  _Node* __p = __list;
423  __list = 0;
424  _Node* __tail = 0;
425 
426  // Count number of merges we do in this pass.
427  unsigned long __nmerges = 0;
428 
429  while (__p)
430  {
431  ++__nmerges;
432  // There exists a merge to be done.
433  // Step `insize' places along from p.
434  _Node* __q = __p;
435  unsigned long __psize = 0;
436  for (unsigned long __i = 0; __i < __insize; ++__i)
437  {
438  ++__psize;
439  __q = static_cast<_Node*>(__q->_M_next);
440  if (!__q)
441  break;
442  }
443 
444  // If q hasn't fallen off end, we have two lists to merge.
445  unsigned long __qsize = __insize;
446 
447  // Now we have two lists; merge them.
448  while (__psize > 0 || (__qsize > 0 && __q))
449  {
450  // Decide whether next node of merge comes from p or q.
451  _Node* __e;
452  if (__psize == 0)
453  {
454  // p is empty; e must come from q.
455  __e = __q;
456  __q = static_cast<_Node*>(__q->_M_next);
457  --__qsize;
458  }
459  else if (__qsize == 0 || !__q)
460  {
461  // q is empty; e must come from p.
462  __e = __p;
463  __p = static_cast<_Node*>(__p->_M_next);
464  --__psize;
465  }
466  else if (__comp(*__p->_M_valptr(), *__q->_M_valptr()))
467  {
468  // First node of p is lower; e must come from p.
469  __e = __p;
470  __p = static_cast<_Node*>(__p->_M_next);
471  --__psize;
472  }
473  else
474  {
475  // First node of q is lower; e must come from q.
476  __e = __q;
477  __q = static_cast<_Node*>(__q->_M_next);
478  --__qsize;
479  }
480 
481  // Add the next node to the merged list.
482  if (__tail)
483  __tail->_M_next = __e;
484  else
485  __list = __e;
486  __tail = __e;
487  }
488 
489  // Now p has stepped `insize' places along, and q has too.
490  __p = __q;
491  }
492  __tail->_M_next = 0;
493 
494  // If we have done only one merge, we're finished.
495  // Allow for nmerges == 0, the empty list case.
496  if (__nmerges <= 1)
497  {
498  this->_M_impl._M_head._M_next = __list;
499  return;
500  }
501 
502  // Otherwise repeat, merging lists twice the size.
503  __insize *= 2;
504  }
505  }
506 
507 _GLIBCXX_END_NAMESPACE_CONTAINER
508 } // namespace std
std::__exception_ptr::operator==
bool operator==(const exception_ptr &, const exception_ptr &) _GLIBCXX_USE_NOEXCEPT __attribute__((__pure__))
__try
#define __try
Definition: exception_defines.h:35
__throw_exception_again
#define __throw_exception_again
Definition: exception_defines.h:37
__catch
#define __catch(X)
Definition: exception_defines.h:36
Generated on Sat Jul 22 2017 14:41:13 for STLdoc by   doxygen 1.8.6