1/*
2 *
3 * Copyright (c) 1996,1997
4 * Silicon Graphics Computer Systems, Inc.
5 *
6 * Copyright (c) 1997
7 * Moscow Center for SPARC Technology
8 *
9 * Copyright (c) 1999
10 * Boris Fomitchev
11 *
12 * This material is provided "as is", with absolutely no warranty expressed
13 * or implied. Any use is at your own risk.
14 *
15 * Permission to use or copy this software for any purpose is hereby granted
16 * without fee, provided the above notices are retained on all copies.
17 * Permission to modify the code and to distribute modified code is granted,
18 * provided the above notices are retained, and a notice that the code was
19 * modified is included with the above copyright notice.
20 *
21 */
22
23/* NOTE: This is an internal header file, included by other STL headers.
24 *   You should not attempt to use it directly.
25 */
26
27#ifndef _STLP_INTERNAL_DBG_SLIST_H
28#define _STLP_INTERNAL_DBG_SLIST_H
29
30#ifndef _STLP_DBG_ITERATOR_H
31#  include <stl/debug/_iterator.h>
32#endif
33
34#define _STLP_NON_DBG_SLIST _STLP_PRIV _STLP_NON_DBG_NAME(slist) <_Tp, _Alloc>
35
36_STLP_BEGIN_NAMESPACE
37
38#if defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
39template <class _Tp, class _Alloc>
40inline _Tp*
41value_type(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_SLIST >&)
42{ return (_Tp*)0; }
43
44template <class _Tp, class _Alloc>
45inline forward_iterator_tag
46iterator_category(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_SLIST >&)
47{ return forward_iterator_tag(); }
48#endif
49
50_STLP_MOVE_TO_PRIV_NAMESPACE
51
52/*
53 * slist special debug traits version.
54 */
55template <class _Traits>
56struct _SlistDbgTraits : _Traits {
57  typedef _SlistDbgTraits<typename _Traits::_ConstTraits> _ConstTraits;
58  typedef _SlistDbgTraits<typename _Traits::_NonConstTraits> _NonConstTraits;
59
60  /*
61   * We don't want the before_begin iterator to return false at _Dereferenceable
62   * call to do not break the current debug framework but calling * operator should
63   * fail.
64   */
65  template <class _Iterator>
66  static bool _Check(const _Iterator& __it)
67  { return !(__it._M_iterator == (__it._Get_container_ptr())->before_begin()); }
68};
69
70_STLP_MOVE_TO_STD_NAMESPACE
71
72template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
73class slist :
74#if !defined (__DMC__)
75             private
76#endif
77                     _STLP_PRIV __construct_checker<_STLP_NON_DBG_SLIST >
78#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
79            , public __stlport_class<slist<_Tp, _Alloc> >
80#endif
81{
82private:
83  typedef _STLP_NON_DBG_SLIST _Base;
84  typedef slist<_Tp,_Alloc> _Self;
85  typedef _STLP_PRIV __construct_checker<_STLP_NON_DBG_SLIST > _ConstructCheck;
86
87public:
88
89  __IMPORT_CONTAINER_TYPEDEFS(_Base)
90
91  typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _SlistDbgTraits<_Nonconst_traits<value_type> > > iterator;
92  typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _SlistDbgTraits<_Const_traits<value_type> > >    const_iterator;
93
94  allocator_type get_allocator() const { return _M_non_dbg_impl.get_allocator(); }
95private:
96  _Base _M_non_dbg_impl;
97  _STLP_PRIV __owned_list _M_iter_list;
98
99  void _Invalidate_iterator(const iterator& __it)
100  { _STLP_PRIV __invalidate_iterator(&_M_iter_list, __it); }
101  void _Invalidate_iterators(const iterator& __first, const iterator& __last)
102  { _STLP_PRIV __invalidate_range(&_M_iter_list, __first, __last); }
103
104  typedef typename _Base::iterator _Base_iterator;
105
106public:
107  explicit slist(const allocator_type& __a = allocator_type())
108    : _M_non_dbg_impl(__a) , _M_iter_list(&_M_non_dbg_impl) {}
109
110#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
111  explicit slist(size_type __n, const value_type& __x = _Tp(),
112#else
113  slist(size_type __n, const value_type& __x,
114#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
115        const allocator_type& __a =  allocator_type())
116    : _M_non_dbg_impl(__n, __x, __a), _M_iter_list(&_M_non_dbg_impl) {}
117
118#if defined(_STLP_DONT_SUP_DFLT_PARAM)
119  explicit slist(size_type __n) : _M_non_dbg_impl(__n) , _M_iter_list(&_M_non_dbg_impl) {}
120#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
121
122#if !defined (_STLP_NO_MOVE_SEMANTIC)
123  slist(__move_source<_Self> src)
124    : _M_non_dbg_impl(__move_source<_Base>(src.get()._M_non_dbg_impl)),
125      _M_iter_list(&_M_non_dbg_impl) {
126#  if defined (_STLP_NO_EXTENSIONS) || (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
127    src.get()._M_iter_list._Invalidate_all();
128#  else
129    src.get()._M_iter_list._Set_owner(_M_iter_list);
130#  endif
131  }
132#endif
133
134#if defined (_STLP_MEMBER_TEMPLATES)
135  // We don't need any dispatching tricks here, because _M_insert_after_range
136  // already does them.
137  template <class _InputIterator>
138  slist(_InputIterator __first, _InputIterator __last,
139        const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
140    : _ConstructCheck(__first, __last),
141      _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last), __a),
142      _M_iter_list(&_M_non_dbg_impl) {}
143#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
144  template <class _InputIterator>
145  slist(_InputIterator __first, _InputIterator __last)
146    : _ConstructCheck(__first, __last),
147      _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last)),
148      _M_iter_list(&_M_non_dbg_impl) {}
149#  endif
150#else
151
152  slist(const value_type* __first, const value_type* __last,
153        const allocator_type& __a =  allocator_type())
154    : _ConstructCheck(__first, __last),
155      _M_non_dbg_impl(__first, __last, __a),
156      _M_iter_list(&_M_non_dbg_impl) {}
157
158  slist(const_iterator __first, const_iterator __last,
159        const allocator_type& __a = allocator_type() )
160    : _ConstructCheck(__first, __last),
161      _M_non_dbg_impl(__first._M_iterator, __last._M_iterator, __a),
162      _M_iter_list(&_M_non_dbg_impl) {}
163#endif
164
165  slist(const _Self& __x) :
166    _ConstructCheck(__x),
167    _M_non_dbg_impl(__x._M_non_dbg_impl), _M_iter_list(&_M_non_dbg_impl) {}
168
169  _Self& operator= (const _Self& __x) {
170    if (this != &__x) {
171      _Invalidate_iterators(begin(), end());
172      _M_non_dbg_impl = __x._M_non_dbg_impl;
173    }
174    return *this;
175  }
176
177  ~slist() {}
178
179  void assign(size_type __n, const value_type& __val) {
180    _Invalidate_iterators(begin(), end());
181    _M_non_dbg_impl.assign(__n, __val);
182  }
183
184  iterator before_begin()
185  { return iterator(&_M_iter_list, _M_non_dbg_impl.before_begin()); }
186  const_iterator before_begin() const
187  { return const_iterator(&_M_iter_list, _M_non_dbg_impl.before_begin()); }
188
189  iterator begin()
190  { return iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
191  const_iterator begin() const
192  { return const_iterator(&_M_iter_list, _M_non_dbg_impl.begin());}
193
194  iterator end()
195  { return iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
196  const_iterator end() const
197  { return const_iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
198
199  bool empty() const { return _M_non_dbg_impl.empty(); }
200  size_type size() const { return _M_non_dbg_impl.size(); }
201  size_type max_size() const { return _M_non_dbg_impl.max_size(); }
202
203  void swap(_Self& __x) {
204    _M_iter_list._Swap_owners(__x._M_iter_list);
205    _M_non_dbg_impl.swap(__x._M_non_dbg_impl);
206  }
207#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
208  void _M_swap_workaround(_Self& __x) { swap(__x); }
209#endif
210
211  reference front() {
212    _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
213    return _M_non_dbg_impl.front();
214  }
215  const_reference front() const {
216    _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
217    return _M_non_dbg_impl.front();
218  }
219  void push_front(const_reference __x) { _M_non_dbg_impl.push_front(__x); }
220  void pop_front() {
221    _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
222    _M_non_dbg_impl.pop_front();
223  }
224  iterator previous(const_iterator __pos) {
225    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
226    _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
227    return iterator(&_M_iter_list, _M_non_dbg_impl.previous(__pos._M_iterator));
228  }
229  const_iterator previous(const_iterator __pos) const {
230    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
231    _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
232    return const_iterator(&_M_iter_list, _M_non_dbg_impl.previous(__pos._M_iterator));
233  }
234
235public:
236
237#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
238  iterator insert_after(iterator __pos, const value_type& __x = _Tp()) {
239#else
240  iterator insert_after(iterator __pos, const value_type& __x) {
241#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
242    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
243    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
244    return iterator(&_M_iter_list,_M_non_dbg_impl.insert_after(__pos._M_iterator, __x));
245  }
246
247#if defined (_STLP_DONT_SUP_DFLT_PARAM)
248  iterator insert_after(iterator __pos) {
249    return insert_after(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp));
250  }
251#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
252
253  void insert_after(iterator __pos, size_type __n, const value_type& __x) {
254    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
255    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
256    _M_non_dbg_impl.insert_after(__pos._M_iterator, __n, __x);
257  }
258
259#if defined (_STLP_MEMBER_TEMPLATES)
260  template <class _InputIterator>
261  void assign(_InputIterator __first, _InputIterator __last) {
262    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
263    _Invalidate_iterators(begin(), end());
264    _M_non_dbg_impl.assign(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
265  }
266#else
267  void assign(const_iterator __first, const_iterator __last) {
268    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
269    _Invalidate_iterators(begin(), end());
270    _M_non_dbg_impl.assign(__first._M_iterator, __last._M_iterator);
271  }
272  void assign(const value_type *__first, const value_type *__last) {
273    _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
274    _Invalidate_iterators(begin(), end());
275    _M_non_dbg_impl.assign(__first, __last);
276  }
277#endif
278
279#if defined (_STLP_MEMBER_TEMPLATES)
280  template <class _InIter>
281  void insert_after(iterator __pos, _InIter __first, _InIter __last) {
282    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
283    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
284    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
285    _M_non_dbg_impl.insert_after(__pos._M_iterator,
286                                 _STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
287  }
288
289  template <class _InIter>
290  void insert(iterator __pos, _InIter __first, _InIter __last) {
291    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
292    _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
293    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
294    _M_non_dbg_impl.insert(__pos._M_iterator,
295                           _STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
296  }
297#else
298  void insert_after(iterator __pos,
299                    const_iterator __first, const_iterator __last) {
300    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
301    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
302    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
303    _M_non_dbg_impl.insert_after(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
304  }
305  void insert_after(iterator __pos,
306                    const value_type* __first, const value_type* __last) {
307    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
308    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
309    _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
310    _M_non_dbg_impl.insert_after(__pos._M_iterator, __first, __last);
311  }
312
313  void insert(iterator __pos, const_iterator __first, const_iterator __last) {
314    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
315    _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
316    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
317    _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
318  }
319  void insert(iterator __pos, const value_type* __first,
320                              const value_type* __last) {
321    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
322    _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
323    _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
324    _M_non_dbg_impl.insert(__pos._M_iterator, __first, __last);
325  }
326#endif
327
328#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
329  iterator insert(iterator __pos, const value_type& __x = _Tp()) {
330#else
331  iterator insert(iterator __pos, const value_type& __x) {
332#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
333    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
334    _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
335    return iterator(&_M_iter_list, _M_non_dbg_impl.insert(__pos._M_iterator, __x));
336  }
337
338#if defined (_STLP_DONT_SUP_DFLT_PARAM)
339  iterator insert(iterator __pos) {
340    return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp));
341  }
342#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
343
344  void insert(iterator __pos, size_type __n, const value_type& __x) {
345    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
346    _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
347    _M_non_dbg_impl.insert(__pos._M_iterator, __n, __x);
348  }
349
350public:
351  iterator erase_after(iterator __pos) {
352    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
353    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
354    iterator __tmp = __pos; ++__tmp;
355    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__tmp))
356    _Invalidate_iterator(__tmp);
357    return iterator(&_M_iter_list, _M_non_dbg_impl.erase_after(__pos._M_iterator));
358  }
359  iterator erase_after(iterator __before_first, iterator __last) {
360    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__before_first))
361    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__before_first, __last, begin(), end()))
362    iterator __tmp = __before_first; ++__tmp;
363    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__tmp))
364    _Invalidate_iterators(__tmp, __last);
365    return iterator(&_M_iter_list, _M_non_dbg_impl.erase_after(__before_first._M_iterator, __last._M_iterator));
366  }
367
368  iterator erase(iterator __pos) {
369    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
370    _STLP_VERBOSE_ASSERT(__pos._M_iterator != _M_non_dbg_impl.before_begin(), _StlMsg_INVALID_ARGUMENT)
371    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
372    _Invalidate_iterator(__pos);
373    return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__pos._M_iterator));
374  }
375  iterator erase(iterator __first, iterator __last) {
376    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
377    _Invalidate_iterators(__first, __last);
378    return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__first._M_iterator, __last._M_iterator));
379  }
380
381#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
382  void resize(size_type __new_size, const value_type& __x = _Tp()) {
383#else
384  void resize(size_type __new_size, const value_type& __x) {
385#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
386    _M_non_dbg_impl.resize(__new_size, __x);
387  }
388
389#if defined(_STLP_DONT_SUP_DFLT_PARAM)
390  void resize(size_type __new_size) { resize(__new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
391#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
392
393  void clear() {
394    _Invalidate_iterators(begin(), end());
395    _M_non_dbg_impl.clear();
396  }
397
398public:
399  // Removes all of the elements from the list __x to *this, inserting
400  // them immediately after __pos.  __x must not be *this.  Complexity:
401  // linear in __x.size().
402  void splice_after(iterator __pos, _Self& __x) {
403    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
404    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
405    _STLP_VERBOSE_ASSERT(!(&__x == this), _StlMsg_INVALID_ARGUMENT)
406    _M_non_dbg_impl.splice_after(__pos._M_iterator, __x._M_non_dbg_impl);
407    if (get_allocator() == __x.get_allocator()) {
408      __x._M_iter_list._Set_owner(_M_iter_list);
409    }
410    else {
411      __x._Invalidate_iterators(__x.begin(), __x.end());
412    }
413  }
414
415  // Moves the element that follows __prev to *this, inserting it immediately
416  //  after __pos.  This is constant time.
417  void splice_after(iterator __pos, _Self& __x, iterator __prev) {
418    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
419    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
420    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__prev))
421    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&__x._M_iter_list, __prev))
422    iterator __elem = __prev; ++__elem;
423    _M_non_dbg_impl.splice_after(__pos._M_iterator, __x._M_non_dbg_impl, __prev._M_iterator);
424    if (get_allocator() == __x.get_allocator()) {
425      _STLP_PRIV __change_ite_owner(__elem, &_M_iter_list);
426    }
427    else {
428      __x._Invalidate_iterator(__elem);
429    }
430  }
431
432  // Moves the range [__before_first + 1, __before_last + 1) to *this,
433  //  inserting it immediately after __pos.  This is constant time.
434  void splice_after(iterator __pos, _Self& __x,
435                    iterator __before_first, iterator __before_last) {
436    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
437    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
438    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__before_first, __before_last))
439    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&__x._M_iter_list, __before_first))
440    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__before_first))
441    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__before_last))
442    iterator __first = __before_first; ++__first;
443    iterator __last = __before_last; ++__last;
444    if (get_allocator() == __x.get_allocator()) {
445      _STLP_PRIV __change_range_owner(__first, __last, &_M_iter_list);
446    }
447    else {
448      __x._Invalidate_iterators(__first, __last);
449    }
450    _M_non_dbg_impl.splice_after(__pos._M_iterator, __x._M_non_dbg_impl,
451                                 __before_first._M_iterator, __before_last._M_iterator);
452  }
453
454  void splice(iterator __pos, _Self& __x) {
455    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
456    _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
457    _STLP_VERBOSE_ASSERT(!(&__x == this), _StlMsg_INVALID_ARGUMENT)
458    _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl);
459    if (get_allocator() == __x.get_allocator()) {
460      __x._M_iter_list._Set_owner(_M_iter_list);
461    }
462    else {
463      __x._Invalidate_iterators(__x.begin(), __x.end());
464    }
465  }
466
467  void splice(iterator __pos, _Self& __x, iterator __i) {
468    //__pos should be owned by *this and not be the before_begin iterator
469    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
470    _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
471    //__i should be dereferenceable, not before_begin and be owned by __x
472    _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__i))
473    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&__x._M_iter_list ,__i))
474    _STLP_VERBOSE_ASSERT(!(__i == __x.before_begin()), _StlMsg_INVALID_ARGUMENT)
475    if (get_allocator() == __x.get_allocator()) {
476      _STLP_PRIV __change_ite_owner(__i, &_M_iter_list);
477    }
478    else {
479      __x._Invalidate_iterator(__i);
480    }
481    _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl, __i._M_iterator);
482  }
483
484  void splice(iterator __pos, _Self& __x, iterator __first, iterator __last) {
485    _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
486    _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
487    //_STLP_VERBOSE_ASSERT(&__x != this, _StlMsg_INVALID_ARGUMENT)
488    _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, __x.begin(), __x.end()))
489    if (get_allocator() == __x.get_allocator()) {
490      _STLP_PRIV __change_range_owner(__first, __last, &_M_iter_list);
491    }
492    else {
493      __x._Invalidate_iterators(__first, __last);
494    }
495    _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl,
496                           __first._M_iterator, __last._M_iterator);
497  }
498
499  void reverse()
500  { _M_non_dbg_impl.reverse(); }
501
502  void remove(const value_type& __val) {
503    _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
504    while (__first != __last) {
505      _Base_iterator __next = __first;
506      ++__next;
507      if (__val == *__first) {
508        _Invalidate_iterator(iterator(&_M_iter_list, __first));
509        _M_non_dbg_impl.erase(__first);
510      }
511      __first = __next;
512    }
513  }
514  void unique() {
515    _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
516    if (__first == __last) return;
517    _Base_iterator __next = __first;
518    while (++__next != __last) {
519      if (*__first == *__next) {
520        _Invalidate_iterator(iterator(&_M_iter_list, __next));
521        _M_non_dbg_impl.erase(__next);
522      }
523      else
524        __first = __next;
525      __next = __first;
526    }
527  }
528  void merge(_Self& __x) {
529    _STLP_VERBOSE_ASSERT(&__x != this, _StlMsg_INVALID_ARGUMENT)
530#if !defined (_STLP_NO_EXTENSIONS)
531    /* comments below due to bug in GCC compilers: ones eat all memory  and die if see
532     * something like namespace_name::func_name() - ptr
533     */
534    _STLP_DEBUG_CHECK( /* _STLP_STD:: */ is_sorted(_M_non_dbg_impl.begin(), _M_non_dbg_impl.end()))
535    _STLP_DEBUG_CHECK( /* _STLP_STD:: */ is_sorted(__x.begin()._M_iterator, __x.end()._M_iterator))
536#endif
537    _M_non_dbg_impl.merge(__x._M_non_dbg_impl);
538    if (get_allocator() == __x.get_allocator()) {
539      __x._M_iter_list._Set_owner(_M_iter_list);
540    }
541    else {
542      __x._Invalidate_iterators(__x.begin(), __x.end());
543    }
544  }
545  void sort() {
546    _M_non_dbg_impl.sort();
547  }
548
549#if defined (_STLP_MEMBER_TEMPLATES)
550  template <class _Predicate>
551  void remove_if(_Predicate __pred) {
552    _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
553    while (__first != __last) {
554      _Base_iterator __next = __first;
555      ++__next;
556      if (__pred(*__first)) {
557        _Invalidate_iterator(iterator(&_M_iter_list, __first));
558        _M_non_dbg_impl.erase(__first);
559      }
560      __first = __next;
561    }
562  }
563
564  template <class _BinaryPredicate>
565  void unique(_BinaryPredicate __pred) {
566    _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
567    if (__first == __last) return;
568    _Base_iterator __next = __first;
569    while (++__next != __last) {
570      if (__binary_pred(*__first, *__next)) {
571        _Invalidate_iterator(iterator(&_M_iter_list, __next));
572        _M_non_dbg_impl.erase(__next);
573      }
574      else
575        __first = __next;
576      __next = __first;
577    }
578  }
579
580  template <class _StrictWeakOrdering>
581  void merge(_Self& __x, _StrictWeakOrdering __ord) {
582    _STLP_VERBOSE_ASSERT(&__x != this, _StlMsg_INVALID_ARGUMENT)
583#if !defined (_STLP_NO_EXTENSIONS)
584    /* comments below due to bug in GCC compilers: ones eat all memory  and die if see
585     * something like namespace_name::func_name() - ptr
586     */
587    _STLP_DEBUG_CHECK( /* _STLP_STD:: */ is_sorted(_M_non_dbg_impl.begin(), _M_non_dbg_impl.end(), __ord))
588    _STLP_DEBUG_CHECK( /* _STLP_STD:: */ is_sorted(__x.begin()._M_iterator, __x.end()._M_iterator, __ord))
589#endif
590    _M_non_dbg_impl.merge(__x._M_non_dbg_impl, __ord);
591    if (get_allocator() == __x.get_allocator()) {
592      __x._M_iter_list._Set_owner(_M_iter_list);
593    }
594    else {
595      __x._Invalidate_iterators(__x.begin(), __x.end());
596    }
597  }
598
599  template <class _StrictWeakOrdering>
600  void sort(_StrictWeakOrdering __comp)
601  { _M_non_dbg_impl.sort(__comp); }
602#endif
603};
604
605_STLP_END_NAMESPACE
606
607#undef _STLP_NON_DBG_SLIST
608
609#endif /* _STLP_INTERNAL_DBG_SLIST_H */
610
611// Local Variables:
612// mode:C++
613// End:
614