/home/ntakagi/work/STLport-5.1.5/stlport/stl/debug/_list.h Source File

00001 /*
00002  *
00003  * Copyright (c) 1994
00004  * Hewlett-Packard Company
00005  *
00006  * Copyright (c) 1996,1997
00007  * Silicon Graphics Computer Systems, Inc.
00008  *
00009  * Copyright (c) 1997
00010  * Moscow Center for SPARC Technology
00011  *
00012  * Copyright (c) 1999
00013  * Boris Fomitchev
00014  *
00015  * This material is provided "as is", with absolutely no warranty expressed
00016  * or implied. Any use is at your own risk.
00017  *
00018  * Permission to use or copy this software for any purpose is hereby granted
00019  * without fee, provided the above notices are retained on all copies.
00020  * Permission to modify the code and to distribute modified code is granted,
00021  * provided the above notices are retained, and a notice that the code was
00022  * modified is included with the above copyright notice.
00023  *
00024  */
00025 
00026 /* NOTE: This is an internal header file, included by other STL headers.
00027  *   You should not attempt to use it directly.
00028  */
00029 
00030 #ifndef _STLP_INTERNAL_DBG_LIST_H
00031 #define _STLP_INTERNAL_DBG_LIST_H
00032 
00033 #ifndef _STLP_INTERNAL_ALGO_H
00034 #  include <stl/_algo.h>
00035 #endif
00036 
00037 #ifndef _STLP_DBG_ITERATOR_H
00038 #  include <stl/debug/_iterator.h>
00039 #endif
00040 
00041 #define _STLP_NON_DBG_LIST _STLP_PRIV _STLP_NON_DBG_NAME(list) <_Tp, _Alloc>
00042 
00043 _STLP_BEGIN_NAMESPACE
00044 
00045 #if defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
00046 template <class _Tp, class _Alloc>
00047 inline _Tp*
00048 value_type(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_LIST >&)
00049 { return (_Tp*)0; }
00050 template <class _Tp, class _Alloc>
00051 inline bidirectional_iterator_tag
00052 iterator_category(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_LIST >&)
00053 { return bidirectional_iterator_tag(); }
00054 #endif
00055 
00056 template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) >
00057 class list :
00058 #if !defined (__DMC__)
00059              private
00060 #endif
00061                      _STLP_PRIV __construct_checker<_STLP_NON_DBG_LIST >
00062 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
00063            , public __stlport_class<list<_Tp, _Alloc> >
00064 #endif
00065 {
00066   typedef _STLP_NON_DBG_LIST _Base;
00067   typedef list<_Tp, _Alloc> _Self;
00068   typedef _STLP_PRIV __construct_checker<_STLP_NON_DBG_LIST > _ConstructCheck;
00069 
00070 public:
00071   __IMPORT_CONTAINER_TYPEDEFS(_Base)
00072 
00073 public:
00074   typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_Nonconst_traits<value_type> > > iterator;
00075   typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_Const_traits<value_type> > >    const_iterator;
00076 
00077   _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS;
00078 
00079 private:
00080   _Base _M_non_dbg_impl;
00081   _STLP_PRIV __owned_list _M_iter_list;
00082 
00083   void _Invalidate_iterator(const iterator& __it)
00084   { _STLP_PRIV __invalidate_iterator(&_M_iter_list, __it); }
00085   void _Invalidate_iterators(const iterator& __first, const iterator& __last)
00086   { _STLP_PRIV __invalidate_range(&_M_iter_list, __first, __last); }
00087 
00088   typedef typename _Base::iterator _Base_iterator;
00089 
00090 public:
00091   explicit list(const allocator_type& __a = allocator_type()) :
00092     _M_non_dbg_impl(__a), _M_iter_list(&_M_non_dbg_impl) {}
00093 
00094 #if !defined(_STLP_DONT_SUP_DFLT_PARAM)
00095   explicit list(size_type __n, const _Tp& __x = _Tp(),
00096 #else
00097   list(size_type __n, const _Tp& __x,
00098 #endif 
00099             const allocator_type& __a = allocator_type())
00100     : _M_non_dbg_impl(__n, __x, __a), _M_iter_list(&_M_non_dbg_impl) {}
00101 
00102 #if defined(_STLP_DONT_SUP_DFLT_PARAM)
00103   explicit list(size_type __n)
00104     : _M_non_dbg_impl(__n), _M_iter_list(&_M_non_dbg_impl) {}
00105 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
00106 
00107   list(__move_source<_Self> src)
00108     : _M_non_dbg_impl(__move_source<_Base>(src.get()._M_non_dbg_impl)),
00109       _M_iter_list(&_M_non_dbg_impl) {
00110 #if defined (_STLP_NO_EXTENSIONS) || (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
00111     src.get()._M_iter_list._Invalidate_all();
00112 #else
00113     src.get()._M_iter_list._Set_owner(_M_iter_list);
00114 #endif
00115   }
00116 
00117 #if defined (_STLP_MEMBER_TEMPLATES)
00118   // We don't need any dispatching tricks here, because insert does all of
00119   // that anyway.
00120   template <class _InputIterator>
00121   list(_InputIterator __first, _InputIterator __last,
00122        const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
00123     : _ConstructCheck(__first, __last),
00124       _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last), __a),
00125       _M_iter_list(&_M_non_dbg_impl) {}
00126 #  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
00127   template <class _InputIterator>
00128   list(_InputIterator __first, _InputIterator __last)
00129     : _ConstructCheck(__first, __last),
00130       _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last)),
00131       _M_iter_list(&_M_non_dbg_impl) {}
00132 #  endif
00133 #else
00134 
00135   list(const value_type* __first, const value_type* __last,
00136        const allocator_type& __a = allocator_type())
00137     : _ConstructCheck(__first, __last),
00138       _M_non_dbg_impl(__first, __last, __a),
00139       _M_iter_list(&_M_non_dbg_impl) {}
00140   list(const_iterator __first, const_iterator __last,
00141        const allocator_type& __a = allocator_type())
00142     : _ConstructCheck(__first, __last),
00143       _M_non_dbg_impl(__first._M_iterator, __last._M_iterator, __a),
00144       _M_iter_list(&_M_non_dbg_impl) {}
00145 
00146 #endif
00147 
00148   list(const _Self& __x) :
00149     _ConstructCheck(__x),
00150     _M_non_dbg_impl(__x._M_non_dbg_impl) , _M_iter_list(&_M_non_dbg_impl) {}
00151 
00152   _Self& operator=(const _Self& __x) {
00153     if (this != &__x) {
00154       //Should not invalidate end iterator
00155       _Invalidate_iterators(begin(), end());
00156       _M_non_dbg_impl = __x._M_non_dbg_impl;
00157     }
00158     return *this;
00159   }
00160 
00161   allocator_type get_allocator() const { return _M_non_dbg_impl.get_allocator(); }
00162 
00163   iterator begin()             { return iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
00164   const_iterator begin() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
00165 
00166   iterator end()               { return iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
00167   const_iterator end() const   { return const_iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
00168 
00169   reverse_iterator rbegin()    { return reverse_iterator(end()); }
00170   reverse_iterator rend()      { return reverse_iterator(begin()); }
00171 
00172   const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
00173   const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
00174 
00175   size_type size() const { return _M_non_dbg_impl.size(); }
00176   size_type max_size() const { return _M_non_dbg_impl.max_size(); }
00177   bool empty() const { return _M_non_dbg_impl.empty(); }
00178 
00179   // those are here to enforce checking
00180   reference front() {
00181     _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
00182     return *begin();
00183   }
00184   const_reference front() const {
00185     _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
00186     return *begin();
00187   }
00188   reference back() {
00189     _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
00190     return *(--end());
00191   }
00192   const_reference back() const {
00193     _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
00194     return *(--end());
00195   }
00196 
00197   void swap(_Self& __x) {
00198     _M_iter_list._Swap_owners(__x._M_iter_list);
00199     _M_non_dbg_impl.swap(__x._M_non_dbg_impl);
00200   }
00201 
00202 #if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
00203   iterator insert(iterator __pos, const _Tp& __x = _Tp()) {
00204 #else
00205   iterator insert(iterator __pos, const _Tp& __x) {
00206 #endif 
00207     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
00208     return iterator(&_M_iter_list,_M_non_dbg_impl.insert(__pos._M_iterator, __x) );
00209   }
00210 
00211 #if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
00212   iterator insert(iterator __pos) { return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
00213 #endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
00214 
00215 #if defined (_STLP_MEMBER_TEMPLATES)
00216   template <class _InputIterator>
00217   void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
00218 #  if (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
00219     typedef typename _AreSameUnCVTypes<_InputIterator, iterator>::_Ret _IsListIterator;
00220     typedef typename _AreSameUnCVTypes<_InputIterator, const_iterator>::_Ret _IsListConstIterator;
00221     typedef typename _Lor2<_IsListIterator, _IsListConstIterator>::_Ret _DoCheck;
00222 #  endif
00223     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
00224     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
00225     _STLP_STD_DEBUG_CHECK(__check_if_not_owner(&_M_iter_list, __first, _DoCheck()))
00226     _M_non_dbg_impl.insert(__pos._M_iterator,
00227                            _STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
00228   }
00229 #else
00230   void insert(iterator __pos, const _Tp* __first, const _Tp* __last) {
00231     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
00232     _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
00233     _M_non_dbg_impl.insert(__pos._M_iterator, __first, __last);
00234   }
00235 
00236   void insert(iterator __pos,
00237               const_iterator __first, const_iterator __last) {
00238     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
00239     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
00240     _STLP_STD_DEBUG_CHECK(__check_if_not_owner(&_M_iter_list, __first, _DoCheck()))
00241     _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
00242   }
00243 #endif
00244 
00245   void insert(iterator __pos, size_type __n, const _Tp& __x) {
00246     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
00247     _M_non_dbg_impl.insert(__pos._M_iterator, __n, __x);
00248   }
00249 
00250   void push_back(const_reference __x) { _M_non_dbg_impl.push_back(__x); }
00251   void pop_back() {
00252     _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
00253     _Invalidate_iterator(end());
00254     _M_non_dbg_impl.pop_back();
00255   }
00256 
00257   void push_front(const_reference __x) { _M_non_dbg_impl.push_front(__x); }
00258   void pop_front() {
00259     _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
00260     _Invalidate_iterator(begin());
00261     _M_non_dbg_impl.pop_front();
00262   }
00263 
00264   iterator erase(iterator __pos) {
00265     _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
00266     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
00267     _Invalidate_iterator(__pos);
00268     return iterator(&_M_iter_list,_M_non_dbg_impl.erase(__pos._M_iterator));
00269   }
00270   iterator erase(iterator __first, iterator __last) {
00271     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
00272     _Invalidate_iterators(__first, __last);
00273     return iterator (&_M_iter_list, _M_non_dbg_impl.erase(__first._M_iterator, __last._M_iterator));
00274   }
00275 
00276 #if !defined(_STLP_DONT_SUP_DFLT_PARAM)
00277   void resize(size_type __new_size, const _Tp& __x = _Tp()) {
00278 #else
00279   void resize(size_type __new_size, const _Tp& __x) {
00280 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
00281     _Base_iterator __i = _M_non_dbg_impl.begin();
00282     size_type __len = 0;
00283     for ( ; __i != _M_non_dbg_impl.end() && __len < __new_size; ++__i, ++__len);
00284 
00285     if (__len == __new_size)
00286       erase(iterator(&_M_iter_list, __i), end());
00287     else                          // __i == end()
00288       _M_non_dbg_impl.insert(_M_non_dbg_impl.end(), __new_size - __len, __x);
00289   }
00290 
00291 #if defined(_STLP_DONT_SUP_DFLT_PARAM)
00292   void resize(size_type __new_size) { resize(__new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
00293 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
00294 
00295 #if defined (_STLP_MEMBER_TEMPLATES)
00296 private:
00297   template <class _Integer>
00298   void _M_assign_dispatch(_Integer __n, _Integer __val,
00299                           const __true_type& /*_IsIntegral*/) {
00300     _M_check_assign(__n);
00301     _M_non_dbg_impl.assign(__n, __val);
00302   }
00303 
00304   template <class _InputIter>
00305   void _M_assign_dispatch(_InputIter __first, _InputIter __last,
00306                           const __false_type& /*_IsIntegral*/) {
00307     size_type __len = distance(__first, __last);
00308     _M_check_assign(__len);
00309     _M_non_dbg_impl.assign(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
00310   }
00311 
00312 public:
00313   template <class _InputIterator>
00314   void assign(_InputIterator __first, _InputIterator __last) {
00315     typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
00316     _M_assign_dispatch(__first, __last, _Integral());
00317   }
00318 #else
00319   void assign(const _Tp* __first, const _Tp* __last) {
00320     _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
00321     _M_non_dbg_impl.assign(__first, __last);
00322   }
00323 
00324   void assign(const_iterator __first, const_iterator __last) {
00325     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
00326     _M_non_dbg_impl.assign(__first._M_iterator, __last._M_iterator);
00327   }
00328 #endif
00329 
00330 private:
00331   void _M_check_assign(size_type __n) {
00332     size_type __size = size();
00333     if (__n < __size) {
00334       iterator __it = begin();
00335       advance(__it, __n + 1);
00336       _Invalidate_iterators(__it, end());
00337     }
00338   }
00339 
00340 public:
00341   void assign(size_type __n, const _Tp& __val) {
00342     _M_check_assign(__n);
00343     _M_non_dbg_impl.assign(__n, __val);
00344   }
00345 
00346   void remove(const _Tp& __x) {
00347     _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
00348     while (__first != __last) {
00349       _Base_iterator __next = __first;
00350       ++__next;
00351       if (__x == *__first) {
00352         _Invalidate_iterator(iterator(&_M_iter_list, __first));
00353         _M_non_dbg_impl.erase(__first);
00354       }
00355       __first = __next;
00356     }
00357   }
00358 
00359   void clear() {
00360     _Invalidate_iterators(begin(), end());
00361     _M_non_dbg_impl.clear();
00362   }
00363 
00364 public:
00365   void splice(iterator __pos, _Self& __x) {
00366     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
00367     _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl);
00368 #if (_STLP_DEBUG_LEVEL != _STLP_STANDARD_DBG_LEVEL)
00369     if (get_allocator() == __x.get_allocator())
00370       __x._M_iter_list._Set_owner(_M_iter_list);
00371     else
00372 #endif
00373       // Std: 23.2.2.4:4
00374       // end iterator is not invalidated:
00375       __x._Invalidate_iterators(__x.begin(), __x.end());
00376   }
00377 
00378   void splice(iterator __pos, _Self& __x, iterator __i) {
00379     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
00380     _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__i))
00381     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&(__x._M_iter_list),__i))
00382     _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl, __i._M_iterator);
00383 #if (_STLP_DEBUG_LEVEL != _STLP_STANDARD_DBG_LEVEL)
00384     if (get_allocator() == __x.get_allocator())
00385       _STLP_PRIV __change_ite_owner(__i, &_M_iter_list);
00386     else
00387 #endif
00388       // Std: 23.2.2.4:7
00389       __x._Invalidate_iterator(__i);
00390   }
00391 
00392   void splice(iterator __pos, _Self& __x, iterator __first, iterator __last) {
00393     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
00394     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, __x.begin(), __x.end()))
00395     _STLP_DEBUG_CHECK(this == &__x ? !_STLP_PRIV __check_range(__pos, __first, __last) : true)
00396 #if (_STLP_DEBUG_LEVEL != _STLP_STANDARD_DBG_LEVEL)
00397     if (this->get_allocator() == __x.get_allocator())
00398       _STLP_PRIV __change_range_owner(__first, __last, &_M_iter_list);
00399     else
00400 #endif
00401       // Std: 23.2.2.4:12
00402       __x._Invalidate_iterators(__first, __last);
00403     _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl, __first._M_iterator, __last._M_iterator);
00404   }
00405 
00406   void merge(_Self& __x) {
00407 #if !defined (_STLP_NO_EXTENSIONS)
00408     _STLP_DEBUG_CHECK(_STLP_STD::is_sorted(begin()._M_iterator, end()._M_iterator))
00409     _STLP_DEBUG_CHECK(_STLP_STD::is_sorted(__x.begin()._M_iterator, __x.end()._M_iterator))
00410 #endif
00411     _M_non_dbg_impl.merge(__x._M_non_dbg_impl);
00412     if (this->get_allocator() == __x.get_allocator()) {
00413       __x._M_iter_list._Set_owner(_M_iter_list);
00414     }
00415     else {
00416       __x._Invalidate_iterators(__x.begin(), __x.end());
00417     }
00418   }
00419   void reverse() {
00420     _M_non_dbg_impl.reverse();
00421   }
00422   void unique() {
00423     _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
00424     if (__first == __last) return;
00425     _Base_iterator __next = __first;
00426     while (++__next != __last) {
00427       if (*__first == *__next) {
00428         _Invalidate_iterator(iterator(&_M_iter_list, __next));
00429         _M_non_dbg_impl.erase(__next);
00430       }
00431       else
00432         __first = __next;
00433       __next = __first;
00434     }
00435   }
00436   void sort() {
00437     _M_non_dbg_impl.sort();
00438   }
00439 
00440 #if defined (_STLP_MEMBER_TEMPLATES)
00441   template <class _Predicate>
00442   void remove_if(_Predicate __pred) {
00443     _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
00444     while (__first != __last) {
00445       _Base_iterator __next = __first;
00446       ++__next;
00447       if (__pred(*__first)) {
00448         _Invalidate_iterator(iterator(&_M_iter_list, __first));
00449         _M_non_dbg_impl.erase(__first);
00450       }
00451       __first = __next;
00452     }
00453   }
00454 
00455   template <class _BinaryPredicate>
00456   void unique(_BinaryPredicate __binary_pred) {
00457     _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
00458     if (__first == __last) return;
00459     _Base_iterator __next = __first;
00460     while (++__next != __last) {
00461       if (__binary_pred(*__first, *__next)) {
00462         _Invalidate_iterator(iterator(&_M_iter_list, __next));
00463         _M_non_dbg_impl.erase(__next);
00464       }
00465       else
00466         __first = __next;
00467       __next = __first;
00468     }
00469   }
00470 
00471   template <class _StrictWeakOrdering>
00472   void merge(_Self& __x, _StrictWeakOrdering __comp) {
00473 #if !defined (_STLP_NO_EXTENSIONS)
00474     _STLP_DEBUG_CHECK(_STLP_STD::is_sorted(_M_non_dbg_impl.begin(), _M_non_dbg_impl.end(), __comp))
00475     _STLP_DEBUG_CHECK(_STLP_STD::is_sorted(__x.begin()._M_iterator, __x.end()._M_iterator, __comp))
00476 #endif
00477     _M_non_dbg_impl.merge(__x._M_non_dbg_impl, __comp);
00478     if (this->get_allocator() == __x.get_allocator()) {
00479       __x._M_iter_list._Set_owner(_M_iter_list);
00480     }
00481     else {
00482       __x._Invalidate_iterators(__x.begin(), __x.end());
00483     }
00484   }
00485 
00486   template <class _StrictWeakOrdering>
00487   void sort(_StrictWeakOrdering __comp) {
00488     _M_non_dbg_impl.sort(__comp);
00489   }
00490 #endif
00491 };
00492 
00493 
00494 _STLP_END_NAMESPACE
00495 
00496 #undef _STLP_NON_DBG_LIST
00497 
00498 #endif /* _STLP_INTERNAL_LIST_H */
00499 
00500 // Local Variables:
00501 // mode:C++
00502 // End: