ReactOS  0.4.13-dev-455-g28ed234
_list.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright (c) 1994
4  * Hewlett-Packard Company
5  *
6  * Copyright (c) 1996,1997
7  * Silicon Graphics Computer Systems, Inc.
8  *
9  * Copyright (c) 1997
10  * Moscow Center for SPARC Technology
11  *
12  * Copyright (c) 1999
13  * Boris Fomitchev
14  *
15  * This material is provided "as is", with absolutely no warranty expressed
16  * or implied. Any use is at your own risk.
17  *
18  * Permission to use or copy this software for any purpose is hereby granted
19  * without fee, provided the above notices are retained on all copies.
20  * Permission to modify the code and to distribute modified code is granted,
21  * provided the above notices are retained, and a notice that the code was
22  * modified is included with the above copyright notice.
23  *
24  */
25 
26 /* NOTE: This is an internal header file, included by other STL headers.
27  * You should not attempt to use it directly.
28  */
29 
30 #ifndef _STLP_INTERNAL_DBG_LIST_H
31 #define _STLP_INTERNAL_DBG_LIST_H
32 
33 #ifndef _STLP_INTERNAL_ALGO_H
34 # include <stl/_algo.h>
35 #endif
36 
37 #ifndef _STLP_DBG_ITERATOR_H
38 # include <stl/debug/_iterator.h>
39 #endif
40 
41 #define _STLP_NON_DBG_LIST _STLP_PRIV _STLP_NON_DBG_NAME(list) <_Tp, _Alloc>
42 
44 
45 #if defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
46 template <class _Tp, class _Alloc>
47 inline _Tp*
49 { return (_Tp*)0; }
50 template <class _Tp, class _Alloc>
52 iterator_category(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_LIST >&)
53 { return bidirectional_iterator_tag(); }
54 #endif
55 
56 template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
57 class list :
58 #if !defined (__DMC__)
59  private
60 #endif
61  _STLP_PRIV __construct_checker<_STLP_NON_DBG_LIST >
62 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
63  , public __stlport_class<list<_Tp, _Alloc> >
64 #endif
65 {
69 
70 public:
72 
73 public:
76 
78 
79 private:
81  _STLP_PRIV __owned_list _M_iter_list;
82 
84  { _STLP_PRIV __invalidate_iterator(&_M_iter_list, __it); }
85  void _Invalidate_iterators(const iterator& __first, const iterator& __last)
86  { _STLP_PRIV __invalidate_range(&_M_iter_list, __first, __last); }
87 
88  typedef typename _Base::iterator _Base_iterator;
89 
90 public:
91  explicit list(const allocator_type& __a = allocator_type()) :
93 
94 #if !defined(_STLP_DONT_SUP_DFLT_PARAM)
95  explicit list(size_type __n, const _Tp& __x = _Tp(),
96 #else
97  list(size_type __n, const _Tp& __x,
98 #endif
99  const allocator_type& __a = allocator_type())
101 
102 #if defined(_STLP_DONT_SUP_DFLT_PARAM)
103  explicit list(size_type __n)
105 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
106 
107 #if !defined (_STLP_NO_MOVE_SEMANTIC)
111 # if defined (_STLP_NO_EXTENSIONS) || (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
112  src.get()._M_iter_list._Invalidate_all();
113 # else
114  src.get()._M_iter_list._Set_owner(_M_iter_list);
115 # endif
116  }
117 #endif
118 
119 #if defined (_STLP_MEMBER_TEMPLATES)
120  template <class _InputIterator>
121  list(_InputIterator __first, _InputIterator __last,
123  : _ConstructCheck(__first, __last),
126 # if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
127  template <class _InputIterator>
128  list(_InputIterator __first, _InputIterator __last)
129  : _ConstructCheck(__first, __last),
132 # endif
133 #else
134 
135  list(const value_type* __first, const value_type* __last,
136  const allocator_type& __a = allocator_type())
137  : _ConstructCheck(__first, __last),
138  _M_non_dbg_impl(__first, __last, __a),
141  const allocator_type& __a = allocator_type())
142  : _ConstructCheck(__first, __last),
143  _M_non_dbg_impl(__first._M_iterator, __last._M_iterator, __a),
145 
146 #endif
147 
148  list(const _Self& __x) :
149  _ConstructCheck(__x),
151 
152  _Self& operator=(const _Self& __x) {
153  if (this != &__x) {
154  //Should not invalidate end iterator
157  }
158  return *this;
159  }
160 
161  allocator_type get_allocator() const { return _M_non_dbg_impl.get_allocator(); }
162 
165 
168 
171 
172  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
173  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
174 
175  size_type size() const { return _M_non_dbg_impl.size(); }
176  size_type max_size() const { return _M_non_dbg_impl.max_size(); }
177  bool empty() const { return _M_non_dbg_impl.empty(); }
178 
179  // those are here to enforce checking
181  _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
182  return *begin();
183  }
185  _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
186  return *begin();
187  }
189  _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
190  return *(--end());
191  }
193  _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
194  return *(--end());
195  }
196 
197  void swap(_Self& __x) {
198  _M_iter_list._Swap_owners(__x._M_iter_list);
200  }
201 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
202  void _M_swap_workaround(_Self& __x) { swap(__x); }
203 #endif
204 
205 #if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
206  iterator insert(iterator __pos, const _Tp& __x = _Tp()) {
207 #else
208  iterator insert(iterator __pos, const _Tp& __x) {
209 #endif
210  _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
211  return iterator(&_M_iter_list,_M_non_dbg_impl.insert(__pos._M_iterator, __x) );
212  }
213 
214 #if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
215  iterator insert(iterator __pos) { return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
216 #endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
217 
218 #if defined (_STLP_MEMBER_TEMPLATES)
219  template <class _InputIterator>
220  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
221  _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
222  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
223  _M_non_dbg_impl.insert(__pos._M_iterator,
225  }
226 #endif
227 
228 #if !defined (_STLP_MEMBER_TEMPLATES)
229  void insert(iterator __pos, const _Tp* __first, const _Tp* __last) {
230  _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
231  _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
232  _M_non_dbg_impl.insert(__pos._M_iterator, __first, __last);
233  }
234 #endif
235 
236 #if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
237  void insert(iterator __pos,
239  _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
240  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
241 # if (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
242  _STLP_STD_DEBUG_CHECK(__check_if_not_owner(&_M_iter_list, __first))
243 # endif
244  _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
245  }
246  void insert(iterator __pos,
247  iterator __first, iterator __last) {
248  _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
249  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
250 # if (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
251  _STLP_STD_DEBUG_CHECK(__check_if_not_owner(&_M_iter_list, __first))
252 # endif
253  _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
254  }
255 #endif
256 
257  void insert(iterator __pos, size_type __n, const _Tp& __x) {
258  _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
259  _M_non_dbg_impl.insert(__pos._M_iterator, __n, __x);
260  }
261 
262  void push_back(const_reference __x) { _M_non_dbg_impl.push_back(__x); }
263  void pop_back() {
264  _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
266  _M_non_dbg_impl.pop_back();
267  }
268 
269  void push_front(const_reference __x) { _M_non_dbg_impl.push_front(__x); }
270  void pop_front() {
271  _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
273  _M_non_dbg_impl.pop_front();
274  }
275 
278  _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
279  _Invalidate_iterator(__pos);
280  return iterator(&_M_iter_list,_M_non_dbg_impl.erase(__pos._M_iterator));
281  }
283  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
284  _Invalidate_iterators(__first, __last);
285  return iterator (&_M_iter_list, _M_non_dbg_impl.erase(__first._M_iterator, __last._M_iterator));
286  }
287 
288 #if !defined(_STLP_DONT_SUP_DFLT_PARAM)
289  void resize(size_type __new_size, const _Tp& __x = _Tp()) {
290 #else
291  void resize(size_type __new_size, const _Tp& __x) {
292 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
293  _Base_iterator __i = _M_non_dbg_impl.begin();
294  size_type __len = 0;
295  for ( ; __i != _M_non_dbg_impl.end() && __len < __new_size; ++__i, ++__len);
296 
297  if (__len == __new_size)
298  erase(iterator(&_M_iter_list, __i), end());
299  else // __i == end()
300  _M_non_dbg_impl.insert(_M_non_dbg_impl.end(), __new_size - __len, __x);
301  }
302 
303 #if defined(_STLP_DONT_SUP_DFLT_PARAM)
304  void resize(size_type __new_size) { resize(__new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
305 #endif
306 
307 #if defined (_STLP_MEMBER_TEMPLATES)
308  template <class _InputIterator>
309  void assign(_InputIterator __first, _InputIterator __last) {
310  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
313  }
314 #else
315  void assign(const _Tp* __first, const _Tp* __last) {
316  _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
317  _M_non_dbg_impl.assign(__first, __last);
319  }
320 
321  void assign(iterator __first, iterator __last) {
322  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
323  _M_non_dbg_impl.assign(__first._M_iterator, __last._M_iterator);
325  }
326 
328  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
329  _M_non_dbg_impl.assign(__first._M_iterator, __last._M_iterator);
331  }
332 #endif
333 
334  void assign(size_type __n, const _Tp& __val) {
336  _M_non_dbg_impl.assign(__n, __val);
337  }
338 
339  void remove(const _Tp& __x) {
340  _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
341  while (__first != __last) {
342  _Base_iterator __next = __first;
343  ++__next;
344  if (__x == *__first) {
346  _M_non_dbg_impl.erase(__first);
347  }
348  __first = __next;
349  }
350  }
351 
352  void clear() {
354  _M_non_dbg_impl.clear();
355  }
356 
357 public:
358  void splice(iterator __pos, _Self& __x) {
359  _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
360  _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl);
361 #if (_STLP_DEBUG_LEVEL != _STLP_STANDARD_DBG_LEVEL)
362  if (get_allocator() == __x.get_allocator())
363  __x._M_iter_list._Set_owner(_M_iter_list);
364  else
365 #endif
366  // Std: 23.2.2.4:4
367  // end iterator is not invalidated:
368  __x._Invalidate_iterators(__x.begin(), __x.end());
369  }
370 
371  void splice(iterator __pos, _Self& __x, iterator __i) {
372  _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
374  _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&(__x._M_iter_list),__i))
375  _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl, __i._M_iterator);
376 #if (_STLP_DEBUG_LEVEL != _STLP_STANDARD_DBG_LEVEL)
377  if (get_allocator() == __x.get_allocator())
378  _STLP_PRIV __change_ite_owner(__i, &_M_iter_list);
379  else
380 #endif
381  // Std: 23.2.2.4:7
382  __x._Invalidate_iterator(__i);
383  }
384 
385  void splice(iterator __pos, _Self& __x, iterator __first, iterator __last) {
386  _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
387  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, __x.begin(), __x.end()))
388  _STLP_DEBUG_CHECK(this == &__x ? !_STLP_PRIV __check_range(__pos, __first, __last) : true)
389 #if (_STLP_DEBUG_LEVEL != _STLP_STANDARD_DBG_LEVEL)
390  if (this->get_allocator() == __x.get_allocator())
391  _STLP_PRIV __change_range_owner(__first, __last, &_M_iter_list);
392  else
393 #endif
394  // Std: 23.2.2.4:12
395  __x._Invalidate_iterators(__first, __last);
396  _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl, __first._M_iterator, __last._M_iterator);
397  }
398 
399  void merge(_Self& __x) {
400 #if !defined (_STLP_NO_EXTENSIONS)
401  _STLP_DEBUG_CHECK(_STLP_STD::is_sorted(begin()._M_iterator, end()._M_iterator))
402  _STLP_DEBUG_CHECK(_STLP_STD::is_sorted(__x.begin()._M_iterator, __x.end()._M_iterator))
403 #endif
404  _M_non_dbg_impl.merge(__x._M_non_dbg_impl);
405  if (this->get_allocator() == __x.get_allocator()) {
406  __x._M_iter_list._Set_owner(_M_iter_list);
407  }
408  else {
409  __x._Invalidate_iterators(__x.begin(), __x.end());
410  }
411  }
412  void reverse() {
413  _M_non_dbg_impl.reverse();
414  }
415  void unique() {
416  _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
417  if (__first == __last) return;
418  _Base_iterator __next = __first;
419  while (++__next != __last) {
420  if (*__first == *__next) {
422  _M_non_dbg_impl.erase(__next);
423  }
424  else
425  __first = __next;
426  __next = __first;
427  }
428  }
429  void sort() {
430  _M_non_dbg_impl.sort();
431  }
432 
433 #if defined (_STLP_MEMBER_TEMPLATES)
434  template <class _Predicate>
435  void remove_if(_Predicate __pred) {
436  _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
437  while (__first != __last) {
438  _Base_iterator __next = __first;
439  ++__next;
440  if (__pred(*__first)) {
442  _M_non_dbg_impl.erase(__first);
443  }
444  __first = __next;
445  }
446  }
447 
448  template <class _BinaryPredicate>
449  void unique(_BinaryPredicate __binary_pred) {
450  _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
451  if (__first == __last) return;
452  _Base_iterator __next = __first;
453  while (++__next != __last) {
454  if (__binary_pred(*__first, *__next)) {
456  _M_non_dbg_impl.erase(__next);
457  }
458  else
459  __first = __next;
460  __next = __first;
461  }
462  }
463 
464  template <class _StrictWeakOrdering>
465  void merge(_Self& __x, _StrictWeakOrdering __comp) {
466 #if !defined (_STLP_NO_EXTENSIONS)
468  _STLP_DEBUG_CHECK(_STLP_STD::is_sorted(__x.begin()._M_iterator, __x.end()._M_iterator, __comp))
469 #endif
470  _M_non_dbg_impl.merge(__x._M_non_dbg_impl, __comp);
471  if (this->get_allocator() == __x.get_allocator()) {
472  __x._M_iter_list._Set_owner(_M_iter_list);
473  }
474  else {
475  __x._Invalidate_iterators(__x.begin(), __x.end());
476  }
477  }
478 
479  template <class _StrictWeakOrdering>
480  void sort(_StrictWeakOrdering __comp) {
481  _M_non_dbg_impl.sort(__comp);
482  }
483 #endif
484 };
485 
486 
488 
489 #undef _STLP_NON_DBG_LIST
490 
491 #endif /* _STLP_INTERNAL_LIST_H */
492 
493 // Local Variables:
494 // mode:C++
495 // End:
#define bidirectional_iterator_tag
Definition: _abbrevs.h:27
void push_back(const_reference __x)
Definition: _list.h:262
void splice(iterator __pos, _Self &__x)
Definition: _list.h:358
void splice(iterator __pos, _Self &__x, iterator __first, iterator __last)
Definition: _list.h:385
void _Invalidate_iterator(const iterator &__it)
Definition: _list.h:83
iterator begin()
Definition: _list.h:367
void assign(iterator __first, iterator __last)
Definition: _list.h:321
#define _STLP_STD
Definition: features.h:516
void merge(_Self &__x)
Definition: _list.h:399
void splice(iterator __pos, _Self &__x, iterator __i)
Definition: _list.h:371
iterator erase(iterator __pos)
Definition: _list.h:276
list(const_iterator __first, const_iterator __last, const allocator_type &__a=allocator_type())
Definition: _list.h:140
void insert(iterator __pos, size_type __n, const _Tp &__x)
Definition: _list.h:257
return __n
Definition: _algo.h:75
void resize(size_type __new_size, const_reference __x=value_type())
_Base::allocator_type allocator_type
Definition: _list.h:271
list(const value_type *__first, const value_type *__last, const allocator_type &__a=allocator_type())
Definition: _list.h:135
void pop_back()
Definition: _list.h:263
#define reverse_iterator
Definition: _abbrevs.h:34
_STLP_INLINE_LOOP _InputIter _Predicate __pred
Definition: _algo.h:68
bool _Dereferenceable(const _Iterator &__it)
Definition: _iterator.h:93
GLuint GLuint end
Definition: gl.h:1545
void assign(size_type __n, const _Tp &__val)
Definition: _list.h:334
#define _STLP_NON_DBG_LIST
Definition: _list.h:41
_STLP_NON_DBG_LIST _Base
Definition: _list.h:66
void unique()
Definition: _list.h:415
reference back()
Definition: _list.h:188
allocator_type get_allocator() const
Definition: _list.h:161
_STLP_PRIV _DBG_iter< _Base, _STLP_PRIV _DbgTraits< _Const_traits< value_type > > > const_iterator
Definition: _list.h:75
const_reverse_iterator rbegin() const
Definition: _list.h:172
size_type size() const
Definition: _list.h:175
const_reference back() const
Definition: _list.h:192
const_iterator begin() const
Definition: _list.h:164
iterator insert(iterator __pos, const_reference __x=value_type())
Definition: _list.h:420
void sort()
Definition: _list.h:429
list(const allocator_type &__a=allocator_type())
Definition: _list.h:91
const_reverse_iterator rend() const
Definition: _list.h:173
#define _STLP_DEFAULT_CONSTRUCTED(_TTp)
Definition: _construct.h:265
size_t size_type
Definition: _list.h:268
void pop_front()
Definition: _list.h:270
_Self & operator=(const _Self &__x)
Definition: _list.h:152
void reverse()
Definition: _list.h:412
_STLP_PRIV __construct_checker< _STLP_NON_DBG_LIST > _ConstructCheck
Definition: _list.h:68
_STLP_INLINE_LOOP _InputIter __last
Definition: _algo.h:68
#define __IMPORT_CONTAINER_TYPEDEFS(_Super)
Definition: features.h:750
_Iterator _Non_Dbg_iter(_Iterator __it)
Definition: _iterator.h:362
void clear()
Definition: _list.h:352
_STLP_PRIV _List_iterator< BookmarkNode, _Const_traits< BookmarkNode > > const_iterator
Definition: _list.h:276
_STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS
Definition: _list.h:277
void _Invalidate_iterators(const iterator &__first, const iterator &__last)
Definition: _list.h:85
void get(int argc, const char *argv[])
Definition: cmds.c:480
_STLP_MOVE_TO_STD_NAMESPACE bool is_sorted(_ForwardIter __first, _ForwardIter __last)
Definition: _algo.h:722
void assign(const_iterator __first, const_iterator __last)
Definition: _list.h:327
list(const _Self &__x)
Definition: _list.h:148
#define _STLP_ALLOCATOR_TYPE_DFL
Definition: features.h:691
_STLP_INLINE_LOOP _InputIter const _Tp & __val
Definition: _algobase.h:656
_STLP_PRIV _List_base< BookmarkNode, _Alloc > _Base
Definition: _list.h:258
void insert(iterator __pos, iterator __first, iterator __last)
Definition: _list.h:246
void assign(const _Tp *__first, const _Tp *__last)
Definition: _list.h:315
const_reference front() const
Definition: _list.h:184
_Base::iterator _Base_iterator
Definition: _list.h:88
list< _Tp, _Alloc > _Self
Definition: _list.h:67
void remove(const _Tp &__x)
Definition: _list.h:339
void swap(_Self &__x)
Definition: _list.h:197
_STLP_MOVE_TO_PRIV_NAMESPACE const _InputIterator const input_iterator_tag &_InputIterator __it(__first)
_STLP_INLINE_LOOP _ForwardIter remove_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred)
Definition: _algo.h:278
list(size_type __n, const_reference __val=_STLP_DEFAULT_CONSTRUCTED(value_type), const allocator_type &__a=allocator_type())
Definition: _list.h:306
reference front()
Definition: _list.h:180
_STLP_PRIV _List_iterator< _Tp, _Nonconst_traits< _Tp > > iterator
Definition: _list.h:275
#define _STLP_PRIV
Definition: _dm.h:70
void insert(iterator __pos, const_iterator __first, const_iterator __last)
Definition: _list.h:237
Definition: _list.h:228
iterator insert(iterator __pos, const _Tp &__x=_Tp())
Definition: _list.h:206
#define _STLP_DEBUG_CHECK(expr)
Definition: _debug.h:440
GLenum src
Definition: glext.h:6340
void insert(iterator __pos, const _Tp *__first, const _Tp *__last)
Definition: _list.h:229
_STLP_PRIV __owned_list _M_iter_list
Definition: _list.h:81
void resize(size_type __new_size, const _Tp &__x=_Tp())
Definition: _list.h:289
const_iterator end() const
Definition: _list.h:167
iterator end()
Definition: _list.h:370
_STLP_PRIV _DBG_iter< _Base, _STLP_PRIV _DbgTraits< _Nonconst_traits< value_type > > > iterator
Definition: _list.h:74
#define _STLP_END_NAMESPACE
Definition: features.h:503
size_type max_size() const
Definition: _list.h:176
void push_front(const_reference __x)
Definition: _list.h:269
iterator erase(iterator __first, iterator __last)
Definition: _list.h:282
_Base _M_non_dbg_impl
Definition: _list.h:80
reverse_iterator rend()
Definition: _list.h:170
reverse_iterator rbegin()
Definition: _list.h:169
list(__move_source< _Self > src)
Definition: _list.h:108
bool empty() const
Definition: _list.h:177
#define _STLP_BEGIN_NAMESPACE
Definition: features.h:501
list(size_type __n, const _Tp &__x=_Tp(), const allocator_type &__a=allocator_type())
Definition: _list.h:95
void assign(size_type __n, const_reference __val)
Definition: _list.h:555
#define _STLP_VERBOSE_ASSERT(expr, diagnostic)
Definition: _debug.h:439