ReactOS Development > Doxygen

00001 /*
00002  * Copyright (c) 2003
00003  * Francois Dumont
00004  *
00005  * This material is provided "as is", with absolutely no warranty expressed
00006  * or implied. Any use is at your own risk.
00007  *
00008  * Permission to use or copy this software for any purpose is hereby granted
00009  * without fee, provided the above notices are retained on all copies.
00010  * Permission to modify the code and to distribute modified code is granted,
00011  * provided the above notices are retained, and a notice that the code was
00012  * modified is included with the above copyright notice.
00013  *
00014  */
00015 
00016 /* NOTE: This is an internal header file, included by other STL headers.
00017  *   You should not attempt to use it directly.
00018  */
00019 
00020 #ifndef _STLP_SPECIALIZED_SLIST_H
00021 #define _STLP_SPECIALIZED_SLIST_H
00022 
00023 #ifndef _STLP_POINTERS_SPEC_TOOLS_H
00024 #  include <stl/pointers/_tools.h>
00025 #endif
00026 
00027 _STLP_BEGIN_NAMESPACE
00028 
00029 #define SLIST_IMPL _STLP_PTR_IMPL_NAME(slist)
00030 
00031 #if defined (__BORLANDC__) || defined (__DMC__)
00032 #  define typename
00033 #endif
00034 
00035 #if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
00036 _STLP_MOVE_TO_PRIV_NAMESPACE
00037 
00038 _STLP_EXPORT_TEMPLATE_CLASS _Slist_node<void*>;
00039 typedef _Slist_node<void*> _VoidPtrSNode;
00040 _STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_Slist_node_base, _VoidPtrSNode, allocator<_VoidPtrSNode> >;
00041 _STLP_EXPORT_TEMPLATE_CLASS _Slist_base<void*, allocator<void*> >;
00042 _STLP_EXPORT_TEMPLATE_CLASS SLIST_IMPL<void*, allocator<void*> >;
00043 
00044 _STLP_MOVE_TO_STD_NAMESPACE
00045 #endif
00046 
00047 #if defined (_STLP_DEBUG)
00048 #  define slist _STLP_NON_DBG_NAME(slist)
00049 _STLP_MOVE_TO_PRIV_NAMESPACE
00050 #endif
00051 
00052 template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
00053 class slist
00054 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (slist)
00055              : public __stlport_class<slist<_Tp, _Alloc> >
00056 #endif
00057 {
00058   typedef _STLP_TYPENAME _STLP_PRIV _StorageType<_Tp>::_Type _StorageType;
00059   typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc;
00060   typedef _STLP_PRIV SLIST_IMPL<_StorageType, _StorageTypeAlloc> _Base;
00061   typedef typename _Base::iterator _BaseIte;
00062   typedef typename _Base::const_iterator _BaseConstIte;
00063   typedef slist<_Tp, _Alloc> _Self;
00064   typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits;
00065   typedef _STLP_PRIV _Slist_node_base _Node_base;
00066 
00067 public:
00068   typedef _Tp               value_type;
00069   typedef value_type*       pointer;
00070   typedef const value_type* const_pointer;
00071   typedef value_type&       reference;
00072   typedef const value_type& const_reference;
00073   typedef size_t            size_type;
00074   typedef ptrdiff_t         difference_type;
00075   typedef forward_iterator_tag _Iterator_category;
00076 
00077   typedef _STLP_PRIV _Slist_iterator<value_type, _Nonconst_traits<value_type> >  iterator;
00078   typedef _STLP_PRIV _Slist_iterator<value_type, _Const_traits<value_type> >     const_iterator;
00079 
00080   _STLP_FORCE_ALLOCATORS(value_type, _Alloc)
00081   typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type;
00082 
00083 public:
00084   allocator_type get_allocator() const
00085   { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); }
00086 
00087   explicit slist(const allocator_type& __a = allocator_type())
00088     : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
00089 
00090 #if !defined(_STLP_DONT_SUP_DFLT_PARAM)
00091   explicit slist(size_type __n, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type),
00092 #else
00093   slist(size_type __n, const value_type& __x,
00094 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
00095         const allocator_type& __a =  allocator_type())
00096     : _M_impl(__n, cast_traits::to_storage_type_cref(__x), _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
00097 
00098 #if defined(_STLP_DONT_SUP_DFLT_PARAM)
00099   explicit slist(size_type __n) : _M_impl(__n) {}
00100 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
00101 
00102 #if defined (_STLP_MEMBER_TEMPLATES)
00103   // We don't need any dispatching tricks here, because _M_insert_after_range
00104   // already does them.
00105   template <class _InputIterator>
00106   slist(_InputIterator __first, _InputIterator __last,
00107         const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
00108 #  if !defined (_STLP_USE_ITERATOR_WRAPPER)
00109     : _M_impl(__first, __last, _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
00110 #  else
00111     : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {
00112     insert_after(before_begin(), __first, __last);
00113   }
00114 #  endif
00115 #  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
00116   // VC++ needs this crazyness
00117   template <class _InputIterator>
00118   slist(_InputIterator __first, _InputIterator __last)
00119 #    if !defined (_STLP_USE_WRAPPER_ITERATOR)
00120     : _M_impl(__first, __last) {}
00121 #    else
00122   { insert_after(before_begin(), __first, __last); }
00123 #    endif
00124 #  endif
00125 #else /* _STLP_MEMBER_TEMPLATES */
00126   slist(const_iterator __first, const_iterator __last,
00127         const allocator_type& __a =  allocator_type() )
00128     : _M_impl(_BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node),
00129               _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
00130   slist(const value_type* __first, const value_type* __last,
00131         const allocator_type& __a =  allocator_type())
00132     : _M_impl(cast_traits::to_storage_type_cptr(__first), cast_traits::to_storage_type_cptr(__last),
00133               _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
00134 #endif /* _STLP_MEMBER_TEMPLATES */
00135 
00136   slist(const _Self& __x) : _M_impl(__x._M_impl) {}
00137 
00138 #if !defined (_STLP_NO_MOVE_SEMANTIC)
00139   slist(__move_source<_Self> src)
00140     : _M_impl(__move_source<_Base>(src.get()._M_impl)) {}
00141 #endif
00142 
00143   _Self& operator= (const _Self& __x) { _M_impl = __x._M_impl; return *this; }
00144 
00145   void assign(size_type __n, const value_type& __val)
00146   { _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); }
00147 
00148 #if defined (_STLP_MEMBER_TEMPLATES)
00149 #  if defined (_STLP_USE_ITERATOR_WRAPPER)
00150 private:
00151   template <class _Integer>
00152   void _M_assign_dispatch(_Integer __n, _Integer __val,
00153                           const __true_type&)
00154   { _M_impl.assign(__n, __val); }
00155 
00156   template <class _InputIterator>
00157   void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
00158                           const __false_type&) {
00159     _M_impl.assign(_STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
00160                    _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
00161   }
00162 
00163 public:
00164 #  endif
00165 
00166   template <class _InputIterator>
00167   void assign(_InputIterator __first, _InputIterator __last) {
00168 #  if defined (_STLP_USE_ITERATOR_WRAPPER)
00169     typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
00170     _M_assign_dispatch(__first, __last, _Integral());
00171 #  else
00172     _M_impl.assign(__first, __last);
00173 #  endif
00174   }
00175 #else
00176   void assign(const value_type *__first, const value_type *__last) {
00177     _M_impl.assign(cast_traits::to_storage_type_cptr(__first),
00178                    cast_traits::to_storage_type_cptr(__last));
00179   }
00180   void assign(const_iterator __first, const_iterator __last) {
00181     _M_impl.assign(_BaseConstIte(__first._M_node),
00182                    _BaseConstIte(__last._M_node));
00183   }
00184 #endif /* _STLP_MEMBER_TEMPLATES */
00185 
00186   iterator before_begin()             { return iterator(_M_impl.before_begin()._M_node); }
00187   const_iterator before_begin() const { return const_iterator(const_cast<_Node_base*>(_M_impl.before_begin()._M_node)); }
00188 
00189   iterator begin()                    { return iterator(_M_impl.begin()._M_node); }
00190   const_iterator begin() const        { return const_iterator(const_cast<_Node_base*>(_M_impl.begin()._M_node));}
00191 
00192   iterator end()                      { return iterator(_M_impl.end()._M_node); }
00193   const_iterator end() const          { return iterator(_M_impl.end()._M_node); }
00194 
00195   size_type size() const      { return _M_impl.size(); }
00196   size_type max_size() const  { return _M_impl.max_size(); }
00197   bool empty() const          { return _M_impl.empty(); }
00198 
00199   void swap(_Self& __x) { _M_impl.swap(__x._M_impl); }
00200 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
00201   void _M_swap_workaround(_Self& __x) { swap(__x); }
00202 #endif
00203 
00204 public:
00205   reference front()             { return *begin(); }
00206   const_reference front() const { return *begin(); }
00207 #if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
00208   void push_front(const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
00209 #else
00210   void push_front(const value_type& __x)
00211 #endif 
00212   { _M_impl.push_front(cast_traits::to_storage_type_cref(__x)); }
00213 
00214 # if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
00215   void push_front() { _M_impl.push_front();}
00216 # endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
00217 
00218   void pop_front() { _M_impl.pop_front(); }
00219 
00220   iterator previous(const_iterator __pos)
00221   { return iterator(_M_impl.previous(_BaseConstIte(__pos._M_node))._M_node); }
00222   const_iterator previous(const_iterator __pos) const
00223   { return const_iterator(const_cast<_Node_base*>(_M_impl.previous(_BaseConstIte(__pos._M_node))._M_node)); }
00224 
00225 #if !defined(_STLP_DONT_SUP_DFLT_PARAM)
00226   iterator insert_after(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
00227 #else
00228   iterator insert_after(iterator __pos, const value_type& __x)
00229 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
00230   { return iterator(_M_impl.insert_after(_BaseIte(__pos._M_node),
00231                                          cast_traits::to_storage_type_cref(__x))._M_node); }
00232 
00233 #if defined(_STLP_DONT_SUP_DFLT_PARAM)
00234   iterator insert_after(iterator __pos)
00235   { return iterator(_M_impl.insert_after(_BaseIte(__pos._M_node))._M_node);}
00236 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
00237 
00238   void insert_after(iterator __pos, size_type __n, const value_type& __x)
00239   { _M_impl.insert_after(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); }
00240 
00241 #if defined (_STLP_MEMBER_TEMPLATES)
00242 #  if defined (_STLP_USE_ITERATOR_WRAPPER)
00243 private:
00244   template <class _Integer>
00245   void _M_insert_after_dispatch(iterator __pos, _Integer __n, _Integer __val,
00246                                 const __true_type&) {
00247     _M_impl.insert_after(_BaseIte(__pos._M_node), __n, __val);
00248   }
00249 
00250   template <class _InputIterator>
00251   void _M_insert_after_dispatch(iterator __pos,
00252                                 _InputIterator __first, _InputIterator __last,
00253                                 const __false_type&) {
00254     _M_impl.insert_after(_BaseIte(__pos._M_node),
00255                          _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
00256                          _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
00257   }
00258 
00259 public:
00260 #  endif
00261 
00262   template <class _InputIterator>
00263   void insert_after(iterator __pos, _InputIterator __first, _InputIterator __last) {
00264 #  if defined (_STLP_USE_ITERATOR_WRAPPER)
00265     // Check whether it's an integral type.  If so, it's not an iterator.
00266     typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
00267     _M_insert_after_dispatch(__pos, __first, __last, _Integral());
00268 #  else
00269     _M_impl.insert_after(_BaseIte(__pos._M_node), __first, __last);
00270 #  endif
00271   }
00272 
00273 #else /* _STLP_MEMBER_TEMPLATES */
00274   void insert_after(iterator __pos,
00275                     const_iterator __first, const_iterator __last)
00276   { _M_impl.insert_after(_BaseIte(__pos._M_node),
00277                          _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); }
00278   void insert_after(iterator __pos,
00279                     const value_type* __first, const value_type* __last) {
00280     _M_impl.insert_after(_BaseIte(__pos._M_node),
00281                          cast_traits::to_storage_type_cptr(__first),
00282                          cast_traits::to_storage_type_cptr(__last));
00283   }
00284 #endif /* _STLP_MEMBER_TEMPLATES */
00285 
00286 #if !defined(_STLP_DONT_SUP_DFLT_PARAM)
00287   iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
00288 #else
00289   iterator insert(iterator __pos, const value_type& __x)
00290 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
00291   { return iterator(_M_impl.insert(_BaseIte(__pos._M_node),
00292                                    cast_traits::to_storage_type_cref(__x))._M_node); }
00293 
00294 #if defined(_STLP_DONT_SUP_DFLT_PARAM)
00295   iterator insert(iterator __pos)
00296   { return iterator(_M_impl.insert(_BaseIte(__pos._M_node))._M_node); }
00297 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
00298 
00299   void insert(iterator __pos, size_type __n, const value_type& __x)
00300   { _M_impl.insert(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); }
00301 
00302 #if defined (_STLP_MEMBER_TEMPLATES)
00303 #  if defined (_STLP_USE_ITERATOR_WRAPPER)
00304 private:
00305   template <class _Integer>
00306   void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
00307                           const __true_type&) {
00308     _M_impl.insert(_BaseIte(__pos._M_node), __n, __val);
00309   }
00310 
00311   template <class _InputIterator>
00312   void _M_insert_dispatch(iterator __pos,
00313                           _InputIterator __first, _InputIterator __last,
00314                           const __false_type&) {
00315     _M_impl.insert(_BaseIte(__pos._M_node), _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
00316                                             _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
00317   }
00318 
00319 public:
00320 #  endif
00321 
00322   template <class _InputIterator>
00323   void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
00324 #  if defined (_STLP_USE_ITERATOR_WRAPPER)
00325     // Check whether it's an integral type.  If so, it's not an iterator.
00326     typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
00327     _M_insert_dispatch(__pos, __first, __last, _Integral());
00328 #  else
00329     _M_impl.insert(_BaseIte(__pos._M_node), __first, __last);
00330 #  endif
00331   }
00332 
00333 #else /* _STLP_MEMBER_TEMPLATES */
00334   void insert(iterator __pos, const_iterator __first, const_iterator __last)
00335   { _M_impl.insert(_BaseIte(__pos._M_node), _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); }
00336   void insert(iterator __pos, const value_type* __first, const value_type* __last)
00337   { _M_impl.insert(_BaseIte(__pos._M_node), cast_traits::to_storage_type_cptr(__first),
00338                                             cast_traits::to_storage_type_cptr(__last)); }
00339 #endif /* _STLP_MEMBER_TEMPLATES */
00340 
00341   iterator erase_after(iterator __pos)
00342   { return iterator(_M_impl.erase_after(_BaseIte(__pos._M_node))._M_node); }
00343   iterator erase_after(iterator __before_first, iterator __last)
00344   { return iterator(_M_impl.erase_after(_BaseIte(__before_first._M_node),
00345                                         _BaseIte(__last._M_node))._M_node); }
00346 
00347   iterator erase(iterator __pos)
00348   { return iterator(_M_impl.erase(_BaseIte(__pos._M_node))._M_node); }
00349   iterator erase(iterator __first, iterator __last)
00350   { return iterator(_M_impl.erase(_BaseIte(__first._M_node), _BaseIte(__last._M_node))._M_node); }
00351 
00352 #if !defined(_STLP_DONT_SUP_DFLT_PARAM)
00353   void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
00354 #else
00355   void resize(size_type __new_size, const value_type& __x)
00356 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
00357   { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x));}
00358 
00359 #if defined(_STLP_DONT_SUP_DFLT_PARAM)
00360   void resize(size_type __new_size) { _M_impl.resize(__new_size); }
00361 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
00362 
00363   void clear() { _M_impl.clear(); }
00364 
00365   void splice_after(iterator __pos, _Self& __x,
00366                     iterator __before_first, iterator __before_last)
00367   { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl,
00368                          _BaseIte(__before_first._M_node), _BaseIte(__before_last._M_node)); }
00369   void splice_after(iterator __pos, _Self& __x, iterator __prev)
00370   { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__prev._M_node)); }
00371   void splice_after(iterator __pos, _Self& __x)
00372   { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl); }
00373   void splice(iterator __pos, _Self& __x)
00374   { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl); }
00375   void splice(iterator __pos, _Self& __x, iterator __i)
00376   { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__i._M_node)); }
00377   void splice(iterator __pos, _Self& __x, iterator __first, iterator __last)
00378   { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl,
00379                    _BaseIte(__first._M_node), _BaseIte(__last._M_node)); }
00380 
00381   void reverse() { _M_impl.reverse(); }
00382 
00383   void remove(const value_type& __val) { _M_impl.remove(cast_traits::to_storage_type_cref(__val)); }
00384   void unique()                 { _M_impl.unique(); }
00385   void merge(_Self& __x)        { _M_impl.merge(__x._M_impl); }
00386   void sort()                   {_M_impl.sort(); }
00387 
00388 #ifdef _STLP_MEMBER_TEMPLATES
00389   template <class _Predicate>
00390   void remove_if(_Predicate __pred)
00391   { _M_impl.remove_if(_STLP_PRIV _UnaryPredWrapper<_StorageType, _Tp, _Predicate>(__pred)); }
00392 
00393   template <class _BinaryPredicate>
00394   void unique(_BinaryPredicate __pred)
00395   { _M_impl.unique(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _BinaryPredicate>(__pred)); }
00396 
00397   template <class _StrictWeakOrdering>
00398   void merge(_Self& __x, _StrictWeakOrdering __comp)
00399   { _M_impl.merge(__x._M_impl, _STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); }
00400 
00401   template <class _StrictWeakOrdering>
00402   void sort(_StrictWeakOrdering __comp)
00403   { _M_impl.sort(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); }
00404 #endif /* _STLP_MEMBER_TEMPLATES */
00405 
00406 private:
00407   _Base _M_impl;
00408 };
00409 
00410 #if defined (slist)
00411 #  undef slist
00412 _STLP_MOVE_TO_STD_NAMESPACE
00413 #endif
00414 
00415 #undef SLIST_IMPL
00416 
00417 #if defined (__BORLANDC__) || defined (__DMC__)
00418 #  undef typename
00419 #endif
00420 
00421 _STLP_END_NAMESPACE
00422 
00423 #endif /* _STLP_SPECIALIZED_SLIST_H */
00424 
00425 // Local Variables:
00426 // mode:C++
00427 // End:
Generated on Sun May 27 2012 04:29:31 for ReactOS by
1.7.6.1