home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / stlpt453.zip / STLport-4.5.3 / stlport / stl / _list.h < prev    next >
C/C++ Source or Header  |  2002-02-02  |  17KB  |  587 lines
  1. /*
  2.  *
  3.  * Copyright (c) 1994
  4.  * Hewlett-Packard Company
  5.  *
  6.  * Copyright (c) 1996,1997
  7.  * Silicon Graphics Computer Systems, Inc.
  8.  *
  9.  * Copyright (c) 1997
  10.  * Moscow Center for SPARC Technology
  11.  *
  12.  * Copyright (c) 1999 
  13.  * Boris Fomitchev
  14.  *
  15.  * This material is provided "as is", with absolutely no warranty expressed
  16.  * or implied. Any use is at your own risk.
  17.  *
  18.  * Permission to use or copy this software for any purpose is hereby granted 
  19.  * without fee, provided the above notices are retained on all copies.
  20.  * Permission to modify the code and to distribute modified code is granted,
  21.  * provided the above notices are retained, and a notice that the code was
  22.  * modified is included with the above copyright notice.
  23.  *
  24.  */
  25.  
  26. /* NOTE: This is an internal header file, included by other STL headers.
  27.  *   You should not attempt to use it directly.
  28.  */
  29.  
  30. #ifndef _STLP_INTERNAL_LIST_H
  31. #define _STLP_INTERNAL_LIST_H
  32.  
  33. # ifndef _STLP_INTERNAL_ALGOBASE_H
  34. #  include <stl/_algobase.h>
  35. # endif
  36.  
  37. # ifndef _STLP_INTERNAL_ALLOC_H
  38. #  include <stl/_alloc.h>
  39. # endif
  40.  
  41. # ifndef _STLP_INTERNAL_ITERATOR_H
  42. #  include <stl/_iterator.h>
  43. # endif
  44.  
  45. # ifndef _STLP_INTERNAL_CONSTRUCT_H
  46. #  include <stl/_construct.h>
  47. # endif
  48.  
  49. # ifndef _STLP_INTERNAL_FUNCTION_BASE_H
  50. #  include <stl/_function_base.h>
  51. # endif
  52.  
  53. _STLP_BEGIN_NAMESPACE
  54.  
  55. # undef list
  56. # define  list  __WORKAROUND_DBG_RENAME(list)
  57.  
  58. struct _List_node_base {
  59.   _List_node_base* _M_next;
  60.   _List_node_base* _M_prev;
  61. };
  62.  
  63. template <class _Dummy>
  64. class _List_global {
  65. public:
  66.   typedef _List_node_base _Node;
  67.   static void  _STLP_CALL _Transfer(_List_node_base* __position, 
  68.                                     _List_node_base* __first, _List_node_base* __last);
  69. };
  70.  
  71. # if defined (_STLP_USE_TEMPLATE_EXPORT) 
  72. _STLP_EXPORT_TEMPLATE_CLASS _List_global<bool>;
  73. # endif
  74. typedef _List_global<bool> _List_global_inst;
  75.  
  76. template <class _Tp>
  77. struct _List_node : public _List_node_base {
  78.   _Tp _M_data;
  79.   __TRIVIAL_STUFF(_List_node)
  80. };
  81.  
  82. struct _List_iterator_base {
  83.   typedef size_t                     size_type;
  84.   typedef ptrdiff_t                  difference_type;
  85.   typedef bidirectional_iterator_tag iterator_category;
  86.  
  87.   _List_node_base* _M_node;
  88.  
  89.   _List_iterator_base(_List_node_base* __x) : _M_node(__x) {}
  90.   _List_iterator_base() {}
  91.  
  92.   void _M_incr() { _M_node = _M_node->_M_next; }
  93.   void _M_decr() { _M_node = _M_node->_M_prev; }
  94.   bool operator==(const _List_iterator_base& __y ) const { 
  95.     return _M_node == __y._M_node; 
  96.   }
  97.   bool operator!=(const _List_iterator_base& __y ) const { 
  98.     return _M_node != __y._M_node; 
  99.   }
  100. };  
  101.  
  102.  
  103.  
  104.  
  105. template<class _Tp, class _Traits>
  106. struct _List_iterator : public _List_iterator_base {
  107.   typedef _Tp value_type;
  108.   typedef typename _Traits::pointer    pointer;
  109.   typedef typename _Traits::reference  reference;
  110.  
  111.   typedef _List_iterator<_Tp, _Nonconst_traits<_Tp> > iterator;
  112.   typedef _List_iterator<_Tp, _Const_traits<_Tp> >    const_iterator;
  113.   typedef _List_iterator<_Tp, _Traits>                       _Self;
  114.  
  115.   typedef bidirectional_iterator_tag iterator_category;
  116.   typedef _List_node<_Tp> _Node;
  117.   typedef size_t size_type;
  118.   typedef ptrdiff_t difference_type;
  119.  
  120.   _List_iterator(_Node* __x) : _List_iterator_base(__x) {}
  121.   _List_iterator() {}
  122.   _List_iterator(const iterator& __x) :  _List_iterator_base(__x._M_node) {}
  123.  
  124.   reference operator*() const { return ((_Node*)_M_node)->_M_data; }
  125.  
  126.   _STLP_DEFINE_ARROW_OPERATOR
  127.  
  128.   _Self& operator++() { 
  129.     this->_M_incr();
  130.     return *this;
  131.   }
  132.   _Self operator++(int) { 
  133.     _Self __tmp = *this;
  134.     this->_M_incr();
  135.     return __tmp;
  136.   }
  137.   _Self& operator--() { 
  138.     this->_M_decr();
  139.     return *this;
  140.   }
  141.   _Self operator--(int) { 
  142.     _Self __tmp = *this;
  143.     this->_M_decr();
  144.     return __tmp;
  145.   }
  146. };
  147.  
  148.  
  149. #ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
  150. template <class _Tp, class _Traits>
  151. inline _Tp* value_type(const _List_iterator<_Tp, _Traits>&) { return 0; }
  152. inline bidirectional_iterator_tag iterator_category(const _List_iterator_base&) { return bidirectional_iterator_tag();}
  153. inline ptrdiff_t* distance_type(const _List_iterator_base&) { return 0; }
  154. #endif
  155.  
  156.  
  157. // Base class that encapsulates details of allocators and helps 
  158. // to simplify EH
  159.  
  160. template <class _Tp, class _Alloc>
  161. class _List_base 
  162. {
  163. protected:
  164.   _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
  165.   typedef _List_node<_Tp> _Node;
  166.   typedef typename _Alloc_traits<_Node, _Alloc>::allocator_type
  167.            _Node_allocator_type;
  168. public:
  169.   typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type
  170.           allocator_type;
  171.  
  172.   allocator_type get_allocator() const { 
  173.     return _STLP_CONVERT_ALLOCATOR((const _Node_allocator_type&)_M_node, _Tp);
  174.   }
  175.  
  176.   _List_base(const allocator_type& __a) : _M_node(_STLP_CONVERT_ALLOCATOR(__a, _Node), (_Node*)0) {
  177.     _Node* __n = _M_node.allocate(1);
  178.     __n->_M_next = __n;
  179.     __n->_M_prev = __n;
  180.     _M_node._M_data = __n;
  181.   }
  182.   ~_List_base() {
  183.     clear();
  184.     _M_node.deallocate(_M_node._M_data, 1);
  185.   }
  186.  
  187.   void clear();
  188.  
  189. public:
  190.   _STLP_alloc_proxy<_Node*, _Node, _Node_allocator_type>  _M_node;
  191. };
  192.  
  193. template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) >
  194. class list;
  195.  
  196. // helper functions to reduce code duplication
  197. template <class _Tp, class _Alloc, class _Predicate> 
  198. void _S_remove_if(list<_Tp, _Alloc>& __that, _Predicate __pred);
  199.  
  200. template <class _Tp, class _Alloc, class _BinaryPredicate>
  201. void _S_unique(list<_Tp, _Alloc>& __that, _BinaryPredicate __binary_pred);
  202.  
  203. template <class _Tp, class _Alloc, class _StrictWeakOrdering>
  204. void _S_merge(list<_Tp, _Alloc>& __that, list<_Tp, _Alloc>& __x,
  205.           _StrictWeakOrdering __comp);
  206.  
  207. template <class _Tp, class _Alloc, class _StrictWeakOrdering>
  208. void _S_sort(list<_Tp, _Alloc>& __that, _StrictWeakOrdering __comp);
  209.  
  210. template <class _Tp, class _Alloc>
  211. class list : public _List_base<_Tp, _Alloc> {
  212.   typedef _List_base<_Tp, _Alloc> _Base;
  213.   typedef list<_Tp, _Alloc> _Self;
  214. public:      
  215.   typedef _Tp value_type;
  216.   typedef value_type* pointer;
  217.   typedef const value_type* const_pointer;
  218.   typedef value_type& reference;
  219.   typedef const value_type& const_reference;
  220.   typedef _List_node<_Tp> _Node;
  221.   typedef size_t size_type;
  222.   typedef ptrdiff_t difference_type;
  223.   _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
  224.   typedef typename _Base::allocator_type allocator_type;
  225.   typedef bidirectional_iterator_tag _Iterator_category;
  226.  
  227. public:
  228.   typedef _List_iterator<_Tp, _Nonconst_traits<_Tp> > iterator;
  229.   typedef _List_iterator<_Tp, _Const_traits<_Tp> >    const_iterator;
  230.   _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS;
  231.  
  232. protected:
  233.   _Node* _M_create_node(const _Tp& __x)
  234.   {
  235.     _Node* __p = this->_M_node.allocate(1);
  236.     _STLP_TRY {
  237.       _Construct(&__p->_M_data, __x);
  238.     }
  239.     _STLP_UNWIND(this->_M_node.deallocate(__p, 1));
  240.     return __p;
  241.   }
  242.  
  243.   _Node* _M_create_node()
  244.   {
  245.     _Node* __p = this->_M_node.allocate(1);
  246.     _STLP_TRY {
  247.       _Construct(&__p->_M_data);
  248.     }
  249.     _STLP_UNWIND(this->_M_node.deallocate(__p, 1));
  250.     return __p;
  251.   }
  252.  
  253. public:
  254. # if !(defined(__MRC__)||defined(__SC__))
  255.   explicit
  256. # endif
  257.   list(const allocator_type& __a = allocator_type()) :
  258.     _List_base<_Tp, _Alloc>(__a) {}
  259.  
  260.   iterator begin()             { return iterator((_Node*)(this->_M_node._M_data->_M_next)); }
  261.   const_iterator begin() const { return const_iterator((_Node*)(this->_M_node._M_data->_M_next)); }
  262.  
  263.   iterator end()             { return this->_M_node._M_data; }
  264.   const_iterator end() const { return this->_M_node._M_data; }
  265.  
  266.   reverse_iterator rbegin() 
  267.     { return reverse_iterator(end()); }
  268.   const_reverse_iterator rbegin() const 
  269.     { return const_reverse_iterator(end()); }
  270.  
  271.   reverse_iterator rend()
  272.     { return reverse_iterator(begin()); }
  273.   const_reverse_iterator rend() const
  274.     { return const_reverse_iterator(begin()); }
  275.  
  276.   bool empty() const { return this->_M_node._M_data->_M_next == this->_M_node._M_data; }
  277.   size_type size() const {
  278.     size_type __result = distance(begin(), end());
  279.     return __result;
  280.   }
  281.   size_type max_size() const { return size_type(-1); }
  282.  
  283.   reference front() { return *begin(); }
  284.   const_reference front() const { return *begin(); }
  285.   reference back() { return *(--end()); }
  286.   const_reference back() const { return *(--end()); }
  287.  
  288.   void swap(list<_Tp, _Alloc>& __x) {
  289.     _STLP_STD::swap(this->_M_node, __x._M_node); 
  290.   }
  291.  
  292.   iterator insert(iterator __position, const _Tp& __x) {
  293.  
  294.     _Node* __tmp = _M_create_node(__x);
  295.     _List_node_base* __n = __position._M_node;
  296.     _List_node_base* __p = __n->_M_prev;
  297.     __tmp->_M_next = __n;
  298.     __tmp->_M_prev = __p;
  299.     __p->_M_next = __tmp;
  300.     __n->_M_prev = __tmp;
  301.     return __tmp;
  302.   }
  303.  
  304. #ifdef _STLP_MEMBER_TEMPLATES
  305.   template <class _InputIterator>
  306.   void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
  307.     typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
  308.     _M_insert_dispatch(__pos, __first, __last, _Integral());
  309.   }
  310.   // Check whether it's an integral type.  If so, it's not an iterator.
  311.   template<class _Integer>
  312.   void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
  313.                           const __true_type&) {
  314.     _M_fill_insert(__pos, (size_type) __n, (_Tp) __x);
  315.   }
  316.   template <class _InputIter>
  317.   void 
  318.   _M_insert_dispatch(iterator __position,
  319.              _InputIter __first, _InputIter __last,
  320.              const __false_type&) 
  321. #else /* _STLP_MEMBER_TEMPLATES */
  322.   void insert(iterator __position, const _Tp* __first, const _Tp* __last) {
  323.     for ( ; __first != __last; ++__first)
  324.       insert(__position, *__first);
  325.   }
  326.   void insert(iterator __position, const_iterator __first, const_iterator __last)
  327. #endif /* _STLP_MEMBER_TEMPLATES */
  328.   {
  329.     for ( ; __first != __last; ++__first)
  330.       insert(__position, *__first);
  331.   }
  332.   void insert(iterator __pos, size_type __n, const _Tp& __x) { _M_fill_insert(__pos, __n, __x); }
  333.   
  334.   void _M_fill_insert(iterator __pos, size_type __n, const _Tp& __x) {
  335.     for ( ; __n > 0; --__n)
  336.       insert(__pos, __x);
  337.   } 
  338.   void push_front(const _Tp& __x) { insert(begin(), __x); }
  339.   void push_back(const _Tp& __x) { insert(end(), __x); }
  340.  
  341. # ifndef _STLP_NO_ANACHRONISMS
  342.   iterator insert(iterator __position) { return insert(__position, _Tp()); }
  343.   void push_front() {insert(begin());}
  344.   void push_back() {insert(end());}
  345. # endif
  346.  
  347.   iterator erase(iterator __position) {
  348.     _List_node_base* __next_node = __position._M_node->_M_next;
  349.     _List_node_base* __prev_node = __position._M_node->_M_prev;
  350.     _Node* __n = (_Node*) __position._M_node;
  351.     __prev_node->_M_next = __next_node;
  352.     __next_node->_M_prev = __prev_node;
  353.     _Destroy(&__n->_M_data);
  354.     this->_M_node.deallocate(__n, 1);
  355.     return iterator((_Node*)__next_node);
  356.     }
  357.   
  358.   iterator erase(iterator __first, iterator __last) {
  359.     while (__first != __last)
  360.       erase(__first++);
  361.     return __last;
  362.   }
  363.  
  364.   void resize(size_type __new_size, const _Tp& __x);
  365.   void resize(size_type __new_size) { this->resize(__new_size, _Tp()); }
  366.  
  367.   void pop_front() { erase(begin()); }
  368.   void pop_back() { 
  369.     iterator __tmp = end();
  370.     erase(--__tmp);
  371.   }
  372.   list(size_type __n, const _Tp& __val,
  373.        const allocator_type& __a = allocator_type())
  374.     : _List_base<_Tp, _Alloc>(__a)
  375.     { this->insert(begin(), __n, __val); }
  376.   explicit list(size_type __n)
  377.     : _List_base<_Tp, _Alloc>(allocator_type())
  378.     { this->insert(begin(), __n, _Tp()); }
  379.  
  380. #ifdef _STLP_MEMBER_TEMPLATES
  381.   // We don't need any dispatching tricks here, because insert does all of
  382.   // that anyway.
  383. # ifdef _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
  384.   template <class _InputIterator>
  385.   list(_InputIterator __first, _InputIterator __last)
  386.     : _List_base<_Tp, _Alloc>(allocator_type())
  387.   { insert(begin(), __first, __last); }
  388. # endif  
  389.   template <class _InputIterator>
  390.   list(_InputIterator __first, _InputIterator __last,
  391.        const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
  392.     : _List_base<_Tp, _Alloc>(__a)
  393.   { insert(begin(), __first, __last); }
  394.   
  395. #else /* _STLP_MEMBER_TEMPLATES */
  396.  
  397.   list(const _Tp* __first, const _Tp* __last,
  398.        const allocator_type& __a = allocator_type())
  399.     : _List_base<_Tp, _Alloc>(__a)
  400.     { insert(begin(), __first, __last); }
  401.   list(const_iterator __first, const_iterator __last,
  402.        const allocator_type& __a = allocator_type())
  403.     : _List_base<_Tp, _Alloc>(__a)
  404.     { insert(begin(), __first, __last); }
  405.  
  406. #endif /* _STLP_MEMBER_TEMPLATES */
  407.   list(const list<_Tp, _Alloc>& __x) : _List_base<_Tp, _Alloc>(__x.get_allocator())
  408.     { insert(begin(), __x.begin(), __x.end()); }
  409.  
  410.   ~list() { }
  411.  
  412.   list<_Tp, _Alloc>& operator=(const list<_Tp, _Alloc>& __x);
  413.  
  414. public:
  415.   // assign(), a generalized assignment member function.  Two
  416.   // versions: one that takes a count, and one that takes a range.
  417.   // The range version is a member template, so we dispatch on whether
  418.   // or not the type is an integer.
  419.  
  420.   void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); }
  421.  
  422.   void _M_fill_assign(size_type __n, const _Tp& __val);
  423.  
  424. #ifdef _STLP_MEMBER_TEMPLATES
  425.  
  426.   template <class _InputIterator>
  427.   void assign(_InputIterator __first, _InputIterator __last) {
  428.     typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
  429.     _M_assign_dispatch(__first, __last, _Integral());
  430.   }
  431.  
  432.   template <class _Integer>
  433.   void _M_assign_dispatch(_Integer __n, _Integer __val, const __true_type&)
  434.     { assign((size_type) __n, (_Tp) __val); }
  435.  
  436.   template <class _InputIterator>
  437.   void _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
  438.                           const __false_type&) {
  439.     iterator __first1 = begin();
  440.     iterator __last1 = end();
  441.     for ( ; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
  442.       *__first1 = *__first2;
  443.     if (__first2 == __last2)
  444.       erase(__first1, __last1);
  445.     else
  446.       insert(__last1, __first2, __last2);
  447.   }
  448.  
  449. #endif /* _STLP_MEMBER_TEMPLATES */
  450.  
  451. public:
  452.   void splice(iterator __position, _Self& __x) {
  453.     if (!__x.empty()) 
  454.       _List_global_inst::_Transfer(__position._M_node, __x.begin()._M_node, __x.end()._M_node);
  455.   }
  456.   void splice(iterator __position, _Self&, iterator __i) {
  457.     iterator __j = __i;
  458.     ++__j;
  459.     if (__position == __i || __position == __j) return;
  460.     _List_global_inst::_Transfer(__position._M_node, __i._M_node, __j._M_node);
  461.   }
  462.   void splice(iterator __position, _Self&, iterator __first, iterator __last) {
  463.     if (__first != __last) 
  464.       _List_global_inst::_Transfer(__position._M_node, __first._M_node, __last._M_node);
  465.   }
  466.  
  467.   void remove(const _Tp& __val) {
  468.     iterator __first = begin();
  469.     iterator __last = end();
  470.     while (__first != __last) {
  471.       iterator __next = __first;
  472.       ++__next;
  473.       if (__val == *__first) erase(__first);
  474.       __first = __next;
  475.     }
  476.   }
  477.   
  478.   void unique() {
  479.     _S_unique(*this, equal_to<_Tp>());
  480.   }
  481.   
  482.   void merge(_Self& __x) {
  483.     _S_merge(*this, __x, less<_Tp>());
  484.   }
  485.  
  486.   void reverse() {
  487.     _List_node_base* __p = this->_M_node._M_data;
  488.     _List_node_base* __tmp = __p;
  489.     do {
  490.       _STLP_STD::swap(__tmp->_M_next, __tmp->_M_prev);
  491.       __tmp = __tmp->_M_prev;     // Old next node is now prev.
  492.     } while (__tmp != __p);
  493.   }    
  494.   
  495.   void sort() {
  496.     _S_sort(*this, less<_Tp>());
  497.   }
  498.  
  499. #ifdef _STLP_MEMBER_TEMPLATES
  500.   template <class _Predicate> void remove_if(_Predicate __pred)  {
  501.     _S_remove_if(*this, __pred);
  502.   }
  503.   template <class _BinaryPredicate>
  504.     void unique(_BinaryPredicate __binary_pred) {
  505.     _S_unique(*this, __binary_pred);
  506.   }
  507.  
  508.   template <class _StrictWeakOrdering>
  509.     void merge(list<_Tp, _Alloc>& __x,
  510.       _StrictWeakOrdering __comp) {
  511.     _S_merge(*this, __x, __comp);
  512.   }
  513.  
  514.   template <class _StrictWeakOrdering>
  515.     void sort(_StrictWeakOrdering __comp) {
  516.     _S_sort(*this, __comp);
  517.   }
  518. #endif /* _STLP_MEMBER_TEMPLATES */
  519.  
  520. };
  521.  
  522. template <class _Tp, class _Alloc>
  523. _STLP_INLINE_LOOP bool  _STLP_CALL
  524. operator==(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
  525. {
  526.   typedef typename list<_Tp,_Alloc>::const_iterator const_iterator;
  527.   const_iterator __end1 = __x.end();
  528.   const_iterator __end2 = __y.end();
  529.  
  530.   const_iterator __i1 = __x.begin();
  531.   const_iterator __i2 = __y.begin();
  532.   while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) {
  533.     ++__i1;
  534.     ++__i2;
  535.   }
  536.   return __i1 == __end1 && __i2 == __end2;
  537. }
  538.  
  539. template <class _Tp, class _Alloc>
  540. inline bool  _STLP_CALL operator<(const list<_Tp,_Alloc>& __x,
  541.                                   const list<_Tp,_Alloc>& __y)
  542. {
  543.   return lexicographical_compare(__x.begin(), __x.end(),
  544.                                  __y.begin(), __y.end());
  545. }
  546.  
  547. # define _STLP_TEMPLATE_CONTAINER list<_Tp, _Alloc>
  548. # define _STLP_TEMPLATE_HEADER    template <class _Tp, class _Alloc>
  549. _STLP_RELOPS_OPERATORS(_STLP_TEMPLATE_HEADER, _STLP_TEMPLATE_CONTAINER)
  550. # undef _STLP_TEMPLATE_CONTAINER
  551. # undef _STLP_TEMPLATE_HEADER
  552.  
  553. #ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
  554.  
  555. template <class _Tp, class _Alloc>
  556. inline void _STLP_CALL 
  557. swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
  558. {
  559.   __x.swap(__y);
  560. }
  561.  
  562. #endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
  563.  
  564. _STLP_END_NAMESPACE 
  565.  
  566. # if !defined (_STLP_LINK_TIME_INSTANTIATION)
  567. #  include <stl/_list.c>
  568. # endif
  569.  
  570. // do a cleanup
  571. # undef list
  572. # define __list__ __FULL_NAME(list)
  573.  
  574. #if defined (_STLP_DEBUG)
  575. # include <stl/debug/_list.h>
  576. #endif
  577.  
  578. #if defined (_STLP_USE_WRAPPER_FOR_ALLOC_PARAM)
  579. # include <stl/wrappers/_list.h>
  580. #endif
  581.  
  582. #endif /* _STLP_INTERNAL_LIST_H */
  583.  
  584. // Local Variables:
  585. // mode:C++
  586. // End:
  587.