00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
00023 
00024 
00025 
00026 
00027 
00028 
00029 
00030 
00031 
00032 
00033 
00034 
00035 
00036 
00037 
00038 
00039 
00040 
00041 
00042 
00043 
00044 
00045 
00046 
00047 
00048 
00049 
00050 
00051 
00052 
00053 
00054 
00055 
00061 #ifndef __GLIBCPP_INTERNAL_LIST_H
00062 #define __GLIBCPP_INTERNAL_LIST_H
00063 
00064 #include <bits/concept_check.h>
00065 
00066 namespace std
00067 {
00068 
00069   struct _List_node_base
00070   {
00071     _List_node_base* _M_next;
00072     _List_node_base* _M_prev;
00073   };
00074 
00075   template<typename _Tp>
00076     struct _List_node : public _List_node_base
00077     {
00078       _Tp _M_data;
00079     };
00080 
00081   struct _List_iterator_base
00082   {
00083     typedef size_t                     size_type;
00084     typedef ptrdiff_t                  difference_type;
00085     typedef bidirectional_iterator_tag iterator_category;
00086 
00087     _List_node_base* _M_node;
00088 
00089     _List_iterator_base(_List_node_base* __x)
00090     : _M_node(__x)
00091     { }
00092 
00093     _List_iterator_base()
00094     { }
00095 
00096     void
00097     _M_incr()
00098     { _M_node = _M_node->_M_next; }
00099 
00100     void
00101     _M_decr()
00102     { _M_node = _M_node->_M_prev; }
00103 
00104     bool
00105     operator==(const _List_iterator_base& __x) const
00106     { return _M_node == __x._M_node; }
00107 
00108     bool
00109     operator!=(const _List_iterator_base& __x) const
00110     { return _M_node != __x._M_node; }
00111   };  
00112 
00113   template<typename _Tp, typename _Ref, typename _Ptr>
00114     struct _List_iterator : public _List_iterator_base
00115     {
00116       typedef _List_iterator<_Tp,_Tp&,_Tp*>             iterator;
00117       typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
00118       typedef _List_iterator<_Tp,_Ref,_Ptr>             _Self;
00119 
00120       typedef _Tp value_type;
00121       typedef _Ptr pointer;
00122       typedef _Ref reference;
00123       typedef _List_node<_Tp> _Node;
00124 
00125       _List_iterator(_Node* __x)
00126       : _List_iterator_base(__x)
00127       { }
00128 
00129       _List_iterator()
00130       { }
00131 
00132       _List_iterator(const iterator& __x)
00133       : _List_iterator_base(__x._M_node)
00134       { }
00135 
00136       reference
00137       operator*() const
00138       { return ((_Node*) _M_node)->_M_data; }
00139 
00140       pointer
00141       operator->() const
00142       { return &(operator*()); }
00143 
00144       _Self&
00145       operator++()
00146       { 
00147         this->_M_incr();
00148         return *this;
00149       }
00150 
00151       _Self
00152       operator++(int)
00153       { 
00154         _Self __tmp = *this;
00155         this->_M_incr();
00156         return __tmp;
00157       }
00158 
00159       _Self&
00160       operator--()
00161       { 
00162         this->_M_decr();
00163         return *this;
00164       }
00165 
00166       _Self
00167       operator--(int)
00168       { 
00169         _Self __tmp = *this;
00170         this->_M_decr();
00171         return __tmp;
00172       }
00173     };
00174 
00175 
00176   
00177   
00178   
00179   
00180   
00181   
00182 
00183 
00184   
00185   template<typename _Tp, typename _Allocator, bool _IsStatic>
00186     class _List_alloc_base
00187     {
00188     public:
00189       typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
00190               allocator_type;
00191 
00192       allocator_type
00193       get_allocator() const
00194       { return _Node_allocator; }
00195 
00196       _List_alloc_base(const allocator_type& __a)
00197       : _Node_allocator(__a)
00198       { }
00199 
00200     protected:
00201       _List_node<_Tp>*
00202       _M_get_node()
00203       { return _Node_allocator.allocate(1); }
00204 
00205       void
00206       _M_put_node(_List_node<_Tp>* __p)
00207       { _Node_allocator.deallocate(__p, 1); }
00208 
00209     protected:
00210       typename _Alloc_traits<_List_node<_Tp>, _Allocator>::allocator_type
00211                _Node_allocator;
00212 
00213       _List_node<_Tp>* _M_node;
00214     };
00215 
00216   
00217 
00218   template<typename _Tp, typename _Allocator>
00219     class _List_alloc_base<_Tp, _Allocator, true>
00220     {
00221     public:
00222       typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
00223               allocator_type;
00224 
00225       allocator_type
00226       get_allocator() const
00227       { return allocator_type(); }
00228 
00229       _List_alloc_base(const allocator_type&)
00230       { }
00231 
00232     protected:
00233       typedef typename _Alloc_traits<_List_node<_Tp>, _Allocator>::_Alloc_type
00234               _Alloc_type;
00235 
00236       _List_node<_Tp>*
00237       _M_get_node()
00238       { return _Alloc_type::allocate(1); }
00239 
00240       void
00241       _M_put_node(_List_node<_Tp>* __p)
00242       { _Alloc_type::deallocate(__p, 1); }
00243 
00244     protected:
00245       _List_node<_Tp>* _M_node;
00246     };
00247 
00248   template<typename _Tp, typename _Alloc>
00249     class _List_base 
00250       : public _List_alloc_base<_Tp, _Alloc,
00251                                 _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
00252     {
00253     public:
00254       typedef _List_alloc_base<_Tp, _Alloc,
00255                                _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
00256               _Base; 
00257       typedef typename _Base::allocator_type allocator_type;
00258 
00259       _List_base(const allocator_type& __a)
00260       : _Base(__a)
00261       {
00262         _M_node = _M_get_node();
00263         _M_node->_M_next = _M_node;
00264         _M_node->_M_prev = _M_node;
00265       }
00266 
00267       ~_List_base()
00268       {
00269         clear();
00270         _M_put_node(_M_node);
00271       }
00272 
00273       void clear();
00274     };
00275 
00289   template<typename _Tp, typename _Alloc = allocator<_Tp> >
00290     class list : protected _List_base<_Tp, _Alloc>
00291     {
00292       
00293       __glibcpp_class_requires(_Tp, _SGIAssignableConcept)
00294 
00295       typedef _List_base<_Tp, _Alloc> _Base;
00296     protected:
00297       typedef void* _Void_pointer;
00298 
00299     public:      
00300       typedef _Tp value_type;
00301       typedef value_type* pointer;
00302       typedef const value_type* const_pointer;
00303       typedef value_type& reference;
00304       typedef const value_type& const_reference;
00305       typedef _List_node<_Tp> _Node;
00306       typedef size_t size_type;
00307       typedef ptrdiff_t difference_type;
00308 
00309       typedef typename _Base::allocator_type allocator_type;
00310 
00311       typedef _List_iterator<_Tp,_Tp&,_Tp*>             iterator;
00312       typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
00313 
00314       typedef reverse_iterator<const_iterator> const_reverse_iterator;
00315       typedef reverse_iterator<iterator>       reverse_iterator;
00316 
00317     protected:
00318       using _Base::_M_node;
00319       using _Base::_M_put_node;
00320       using _Base::_M_get_node;
00321 
00322     protected:
00323       _Node*
00324       _M_create_node(const _Tp& __x)
00325       {
00326         _Node* __p = _M_get_node();
00327         try {
00328           _Construct(&__p->_M_data, __x);
00329         }
00330         catch(...)
00331         { 
00332           _M_put_node(__p);
00333           __throw_exception_again; 
00334         }
00335         return __p;
00336       }
00337 
00338       _Node*
00339       _M_create_node()
00340       {
00341         _Node* __p = _M_get_node();
00342         try {
00343           _Construct(&__p->_M_data);
00344         }
00345         catch(...)
00346         { 
00347           _M_put_node(__p);
00348           __throw_exception_again; 
00349         }
00350         return __p;
00351       }
00352 
00353     public:
00354       allocator_type
00355       get_allocator() const
00356       { return _Base::get_allocator(); }
00357 
00358       explicit
00359       list(const allocator_type& __a = allocator_type())
00360       : _Base(__a)
00361       { }
00362 
00363       iterator
00364       begin()
00365       { return static_cast<_Node*>(_M_node->_M_next); }
00366 
00367       const_iterator
00368       begin() const
00369       { return static_cast<_Node*>(_M_node->_M_next); }
00370 
00371       iterator
00372       end()
00373       { return _M_node; }
00374 
00375       const_iterator
00376       end() const
00377       { return _M_node; }
00378 
00379       reverse_iterator
00380       rbegin() 
00381       { return reverse_iterator(end()); }
00382 
00383       const_reverse_iterator
00384       rbegin() const 
00385       { return const_reverse_iterator(end()); }
00386 
00387       reverse_iterator
00388       rend()
00389       { return reverse_iterator(begin()); }
00390 
00391       const_reverse_iterator
00392       rend() const
00393       { return const_reverse_iterator(begin()); }
00394 
00395       bool
00396       empty() const
00397       { return _M_node->_M_next == _M_node; }
00398 
00399       size_type
00400       size() const
00401       { return distance(begin(), end()); }
00402 
00403       size_type
00404       max_size() const
00405       { return size_type(-1); }
00406 
00407       reference
00408       front()
00409       { return *begin(); }
00410 
00411       const_reference
00412       front() const
00413       { return *begin(); }
00414 
00415       reference
00416       back()
00417       { return *(--end()); }
00418 
00419       const_reference
00420       back() const
00421       { return *(--end()); }
00422 
00423       void
00424       swap(list<_Tp, _Alloc>& __x)
00425       { std::swap(_M_node, __x._M_node); }
00426 
00427       iterator
00428       insert(iterator __position, const _Tp& __x)
00429       {
00430         _Node* __tmp = _M_create_node(__x);
00431         __tmp->_M_next = __position._M_node;
00432         __tmp->_M_prev = __position._M_node->_M_prev;
00433         __position._M_node->_M_prev->_M_next = __tmp;
00434         __position._M_node->_M_prev = __tmp;
00435         return __tmp;
00436       }
00437 
00438       iterator
00439       insert(iterator __position)
00440       { return insert(__position, _Tp()); }
00441 
00442       
00443       template<typename _Integer>
00444         void
00445         _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x, __true_type)
00446         { _M_fill_insert(__pos, (size_type) __n, (_Tp) __x); }
00447 
00448       template<typename _InputIterator>
00449         void
00450         _M_insert_dispatch(iterator __pos,
00451                            _InputIterator __first, _InputIterator __last,
00452                            __false_type);
00453 
00454       template<typename _InputIterator>
00455         void
00456         insert(iterator __pos, _InputIterator __first, _InputIterator __last)
00457         {
00458           typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
00459           _M_insert_dispatch(__pos, __first, __last, _Integral());
00460         }
00461 
00462       void
00463       insert(iterator __pos, size_type __n, const _Tp& __x)
00464       { _M_fill_insert(__pos, __n, __x); }
00465 
00466       void
00467       _M_fill_insert(iterator __pos, size_type __n, const _Tp& __x); 
00468 
00469       void
00470       push_front(const _Tp& __x)
00471       { insert(begin(), __x); }
00472 
00473       void
00474       push_front()
00475       { insert(begin()); }
00476 
00477       void
00478       push_back(const _Tp& __x)
00479       { insert(end(), __x); }
00480 
00481       void
00482       push_back()
00483       { insert(end()); }
00484 
00485       iterator
00486       erase(iterator __position)
00487       {
00488         _List_node_base* __next_node = __position._M_node->_M_next;
00489         _List_node_base* __prev_node = __position._M_node->_M_prev;
00490         _Node* __n = static_cast<_Node*>(__position._M_node);
00491         __prev_node->_M_next = __next_node;
00492         __next_node->_M_prev = __prev_node;
00493         _Destroy(&__n->_M_data);
00494         _M_put_node(__n);
00495         return iterator(static_cast<_Node*>(__next_node));
00496       }
00497 
00498       iterator
00499       erase(iterator __first, iterator __last);
00500 
00501       void
00502       clear()
00503       { _Base::clear(); }
00504 
00505       void
00506       resize(size_type __new_size, const _Tp& __x);
00507       
00508       void
00509       resize(size_type __new_size)
00510       { this->resize(__new_size, _Tp()); }
00511 
00512       void
00513       pop_front()
00514       { erase(begin()); }
00515 
00516       void
00517       pop_back()
00518       { 
00519         iterator __tmp = end();
00520         erase(--__tmp);
00521       }
00522 
00523       list(size_type __n, const _Tp& __value,
00524            const allocator_type& __a = allocator_type())
00525       : _Base(__a)
00526       { insert(begin(), __n, __value); }
00527 
00528       explicit
00529       list(size_type __n)
00530       : _Base(allocator_type())
00531       { insert(begin(), __n, _Tp()); }
00532 
00533       
00534       
00535       template<typename _InputIterator>
00536       list(_InputIterator __first, _InputIterator __last,
00537            const allocator_type& __a = allocator_type())
00538       : _Base(__a)
00539       { insert(begin(), __first, __last); }
00540 
00541       list(const list<_Tp, _Alloc>& __x)
00542       : _Base(__x.get_allocator())
00543       { insert(begin(), __x.begin(), __x.end()); }
00544 
00545       ~list()
00546       { }
00547 
00548       list<_Tp, _Alloc>&
00549       operator=(const list<_Tp, _Alloc>& __x);
00550 
00551     public:
00552       
00553       
00554       
00555       
00556 
00557       void
00558       assign(size_type __n, const _Tp& __val)
00559       { _M_fill_assign(__n, __val); }
00560 
00561       void
00562       _M_fill_assign(size_type __n, const _Tp& __val);
00563 
00564       template<typename _InputIterator>
00565         void
00566         assign(_InputIterator __first, _InputIterator __last)
00567         {
00568           typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
00569           _M_assign_dispatch(__first, __last, _Integral());
00570         }
00571 
00572       template<typename _Integer>
00573         void
00574         _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
00575         { _M_fill_assign((size_type) __n, (_Tp) __val); }
00576 
00577       template<typename _InputIterator>
00578         void
00579         _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
00580                            __false_type);
00581 
00582     protected:
00583       void
00584       _M_transfer(iterator __position, iterator __first, iterator __last)
00585       {
00586         if (__position != __last) {
00587           
00588           __last._M_node->_M_prev->_M_next     = __position._M_node;
00589           __first._M_node->_M_prev->_M_next    = __last._M_node;
00590           __position._M_node->_M_prev->_M_next = __first._M_node; 
00591 
00592           
00593           _List_node_base* __tmp      = __position._M_node->_M_prev;
00594           __position._M_node->_M_prev = __last._M_node->_M_prev;
00595           __last._M_node->_M_prev     = __first._M_node->_M_prev; 
00596           __first._M_node->_M_prev    = __tmp;
00597         }
00598       }
00599 
00600     public:
00601       void
00602       splice(iterator __position, list& __x)
00603       {
00604         if (!__x.empty()) 
00605           this->_M_transfer(__position, __x.begin(), __x.end());
00606       }
00607 
00608       void
00609       splice(iterator __position, list&, iterator __i)
00610       {
00611         iterator __j = __i;
00612         ++__j;
00613         if (__position == __i || __position == __j) return;
00614         this->_M_transfer(__position, __i, __j);
00615       }
00616 
00617       void
00618       splice(iterator __position, list&, iterator __first, iterator __last)
00619       {
00620         if (__first != __last) 
00621           this->_M_transfer(__position, __first, __last);
00622       }
00623 
00624       void
00625       remove(const _Tp& __value);
00626 
00627       void
00628       unique();
00629 
00630       void
00631       merge(list& __x);
00632 
00633       void
00634       reverse();
00635 
00636       void
00637       sort();
00638 
00639       template<typename _Predicate>
00640         void
00641         remove_if(_Predicate);
00642 
00643       template<typename _BinaryPredicate>
00644         void
00645         unique(_BinaryPredicate);
00646 
00647       template<typename _StrictWeakOrdering>
00648         void
00649         merge(list&, _StrictWeakOrdering);
00650 
00651       template<typename _StrictWeakOrdering>
00652         void
00653         sort(_StrictWeakOrdering);
00654     };
00655 
00656   template<typename _Tp, typename _Alloc>
00657     inline bool 
00658     operator==(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
00659     {
00660       typedef typename list<_Tp,_Alloc>::const_iterator const_iterator;
00661       const_iterator __end1 = __x.end();
00662       const_iterator __end2 = __y.end();
00663 
00664       const_iterator __i1 = __x.begin();
00665       const_iterator __i2 = __y.begin();
00666       while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) {
00667         ++__i1;
00668         ++__i2;
00669       }
00670       return __i1 == __end1 && __i2 == __end2;
00671     }
00672 
00673   template<typename _Tp, typename _Alloc>
00674     inline bool
00675     operator<(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
00676     {
00677       return lexicographical_compare(__x.begin(), __x.end(),
00678                                      __y.begin(), __y.end());
00679     }
00680 
00681   template<typename _Tp, typename _Alloc>
00682     inline bool
00683     operator!=(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
00684     { return !(__x == __y); }
00685 
00686   template<typename _Tp, typename _Alloc>
00687     inline bool
00688     operator>(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
00689     { return __y < __x; }
00690 
00691   template<typename _Tp, typename _Alloc>
00692     inline bool
00693     operator<=(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
00694     { return !(__y < __x); }
00695 
00696   template<typename _Tp, typename _Alloc>
00697     inline bool
00698     operator>=(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
00699     { return !(__x < __y); }
00700 
00701   template<typename _Tp, typename _Alloc>
00702     inline void 
00703     swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
00704     { __x.swap(__y); }
00705 
00706   
00707 
00708   template<typename _Tp, typename _Alloc>
00709     void _List_base<_Tp,_Alloc>::
00710     clear() 
00711     {
00712       _List_node<_Tp>* __cur = static_cast<_List_node<_Tp>*>(_M_node->_M_next);
00713       while (__cur != _M_node) {
00714         _List_node<_Tp>* __tmp = __cur;
00715         __cur = static_cast<_List_node<_Tp>*>(__cur->_M_next);
00716         _Destroy(&__tmp->_M_data);
00717         _M_put_node(__tmp);
00718       }
00719       _M_node->_M_next = _M_node;
00720       _M_node->_M_prev = _M_node;
00721     }
00722 
00723   template<typename _Tp, typename _Alloc>
00724     template <typename _InputIter>
00725       void list<_Tp, _Alloc>::
00726       _M_insert_dispatch(iterator __position, _InputIter __first, _InputIter __last,
00727                                             __false_type)
00728       {
00729         for ( ; __first != __last; ++__first)
00730           insert(__position, *__first);
00731       
00732       }
00733 
00734   template<typename _Tp, typename _Alloc>
00735     void list<_Tp, _Alloc>::
00736     _M_fill_insert(iterator __position, size_type __n, const _Tp& __x)
00737     {
00738       for ( ; __n > 0; --__n)
00739         insert(__position, __x);
00740     }
00741 
00742   template<typename _Tp, typename _Alloc>
00743     typename list<_Tp,_Alloc>::iterator list<_Tp, _Alloc>::
00744     erase(iterator __first, iterator __last)
00745     {
00746       while (__first != __last)
00747         erase(__first++);
00748       return __last;
00749     }
00750 
00751   template<typename _Tp, typename _Alloc>
00752     void list<_Tp, _Alloc>::
00753     resize(size_type __new_size, const _Tp& __x)
00754     {
00755       iterator __i = begin();
00756       size_type __len = 0;
00757       for ( ; __i != end() && __len < __new_size; ++__i, ++__len)
00758         ;
00759       if (__len == __new_size)
00760         erase(__i, end());
00761       else                          
00762         insert(end(), __new_size - __len, __x);
00763     }
00764 
00765   template<typename _Tp, typename _Alloc>
00766     list<_Tp, _Alloc>& list<_Tp, _Alloc>::
00767     operator=(const list<_Tp, _Alloc>& __x)
00768     {
00769       if (this != &__x) {
00770         iterator __first1 = begin();
00771         iterator __last1 = end();
00772         const_iterator __first2 = __x.begin();
00773         const_iterator __last2 = __x.end();
00774         while (__first1 != __last1 && __first2 != __last2) 
00775           *__first1++ = *__first2++;
00776         if (__first2 == __last2)
00777           erase(__first1, __last1);
00778         else
00779           insert(__last1, __first2, __last2);
00780       }
00781       return *this;
00782     }
00783 
00784   template<typename _Tp, typename _Alloc>
00785     void list<_Tp, _Alloc>::
00786     _M_fill_assign(size_type __n, const _Tp& __val) {
00787       iterator __i = begin();
00788       for ( ; __i != end() && __n > 0; ++__i, --__n)
00789         *__i = __val;
00790       if (__n > 0)
00791         insert(end(), __n, __val);
00792       else
00793         erase(__i, end());
00794     }
00795 
00796   template<typename _Tp, typename _Alloc>
00797     template <typename _InputIter>
00798       void list<_Tp, _Alloc>::
00799       _M_assign_dispatch(_InputIter __first2, _InputIter __last2, __false_type)
00800       {
00801         iterator __first1 = begin();
00802         iterator __last1 = end();
00803         for ( ; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
00804           *__first1 = *__first2;
00805         if (__first2 == __last2)
00806           erase(__first1, __last1);
00807         else
00808           insert(__last1, __first2, __last2);
00809       }
00810 
00811   template<typename _Tp, typename _Alloc>
00812     void list<_Tp, _Alloc>::
00813     remove(const _Tp& __value)
00814     {
00815       iterator __first = begin();
00816       iterator __last = end();
00817       while (__first != __last) {
00818         iterator __next = __first;
00819         ++__next;
00820         if (*__first == __value) erase(__first);
00821         __first = __next;
00822       }
00823     }
00824 
00825   template<typename _Tp, typename _Alloc>
00826     void list<_Tp, _Alloc>::
00827     unique()
00828     {
00829       iterator __first = begin();
00830       iterator __last = end();
00831       if (__first == __last) return;
00832       iterator __next = __first;
00833       while (++__next != __last) {
00834         if (*__first == *__next)
00835           erase(__next);
00836         else
00837           __first = __next;
00838         __next = __first;
00839       }
00840     }
00841 
00842   template<typename _Tp, typename _Alloc>
00843     void list<_Tp, _Alloc>::
00844     merge(list<_Tp, _Alloc>& __x)
00845     {
00846       iterator __first1 = begin();
00847       iterator __last1 = end();
00848       iterator __first2 = __x.begin();
00849       iterator __last2 = __x.end();
00850       while (__first1 != __last1 && __first2 != __last2)
00851         if (*__first2 < *__first1) {
00852           iterator __next = __first2;
00853           _M_transfer(__first1, __first2, ++__next);
00854           __first2 = __next;
00855         }
00856         else
00857           ++__first1;
00858       if (__first2 != __last2) _M_transfer(__last1, __first2, __last2);
00859     }
00860 
00861   inline void
00862   __List_base_reverse(_List_node_base* __p)
00863   {
00864     _List_node_base* __tmp = __p;
00865     do {
00866       std::swap(__tmp->_M_next, __tmp->_M_prev);
00867       __tmp = __tmp->_M_prev;     
00868     } while (__tmp != __p);
00869   }
00870 
00871   template<typename _Tp, typename _Alloc>
00872   inline void list<_Tp, _Alloc>::
00873   reverse() 
00874   { __List_base_reverse(this->_M_node); }    
00875 
00876   template<typename _Tp, typename _Alloc>
00877     void list<_Tp, _Alloc>::
00878     sort()
00879     {
00880       
00881       if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) {
00882         list<_Tp, _Alloc> __carry;
00883         list<_Tp, _Alloc> __counter[64];
00884         int __fill = 0;
00885         while (!empty()) {
00886           __carry.splice(__carry.begin(), *this, begin());
00887           int __i = 0;
00888           while(__i < __fill && !__counter[__i].empty()) {
00889             __counter[__i].merge(__carry);
00890             __carry.swap(__counter[__i++]);
00891           }
00892           __carry.swap(__counter[__i]);         
00893           if (__i == __fill) ++__fill;
00894         } 
00895 
00896         for (int __i = 1; __i < __fill; ++__i)
00897           __counter[__i].merge(__counter[__i-1]);
00898         swap(__counter[__fill-1]);
00899       }
00900     }
00901 
00902   template<typename _Tp, typename _Alloc>
00903     template <typename _Predicate>
00904       void list<_Tp, _Alloc>::
00905       remove_if(_Predicate __pred)
00906       {
00907         iterator __first = begin();
00908         iterator __last = end();
00909         while (__first != __last) {
00910           iterator __next = __first;
00911           ++__next;
00912           if (__pred(*__first)) erase(__first);
00913           __first = __next;
00914         }
00915       }
00916 
00917   template<typename _Tp, typename _Alloc>
00918     template <typename _BinaryPredicate>
00919       void list<_Tp, _Alloc>::
00920       unique(_BinaryPredicate __binary_pred)
00921       {
00922         iterator __first = begin();
00923         iterator __last = end();
00924         if (__first == __last) return;
00925         iterator __next = __first;
00926         while (++__next != __last) {
00927           if (__binary_pred(*__first, *__next))
00928             erase(__next);
00929           else
00930             __first = __next;
00931           __next = __first;
00932         }
00933       }
00934 
00935   template<typename _Tp, typename _Alloc>
00936     template <typename _StrictWeakOrdering>
00937       void list<_Tp, _Alloc>::
00938       merge(list<_Tp, _Alloc>& __x, _StrictWeakOrdering __comp)
00939       {
00940         iterator __first1 = begin();
00941         iterator __last1 = end();
00942         iterator __first2 = __x.begin();
00943         iterator __last2 = __x.end();
00944         while (__first1 != __last1 && __first2 != __last2)
00945           if (__comp(*__first2, *__first1)) {
00946             iterator __next = __first2;
00947             _M_transfer(__first1, __first2, ++__next);
00948             __first2 = __next;
00949           }
00950           else
00951             ++__first1;
00952         if (__first2 != __last2) _M_transfer(__last1, __first2, __last2);
00953       }
00954 
00955   template<typename _Tp, typename _Alloc>
00956     template <typename _StrictWeakOrdering>
00957     void list<_Tp, _Alloc>::
00958     sort(_StrictWeakOrdering __comp)
00959     {
00960       
00961       if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) {
00962         list<_Tp, _Alloc> __carry;
00963         list<_Tp, _Alloc> __counter[64];
00964         int __fill = 0;
00965         while (!empty()) {
00966           __carry.splice(__carry.begin(), *this, begin());
00967           int __i = 0;
00968           while(__i < __fill && !__counter[__i].empty()) {
00969             __counter[__i].merge(__carry, __comp);
00970             __carry.swap(__counter[__i++]);
00971           }
00972           __carry.swap(__counter[__i]);         
00973           if (__i == __fill) ++__fill;
00974         } 
00975 
00976         for (int __i = 1; __i < __fill; ++__i) 
00977           __counter[__i].merge(__counter[__i-1], __comp);
00978         swap(__counter[__fill-1]);
00979       }
00980     }
00981 
00982 } 
00983 
00984 #endif 
00985 
00986 
00987 
00988 
00989