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