include/c++/stl/stl/pointers/_slist.h

   1 /*
   2  * Copyright (c) 2003
   3  * Francois Dumont
   4  *
   5  * This material is provided "as is", with absolutely no warranty expressed
   6  * or implied. Any use is at your own risk.
   7  *
   8  * Permission to use or copy this software for any purpose is hereby granted
   9  * without fee, provided the above notices are retained on all copies.
  10  * Permission to modify the code and to distribute modified code is granted,
  11  * provided the above notices are retained, and a notice that the code was
  12  * modified is included with the above copyright notice.
  13  *
  14  */
  15
  16 /* NOTE: This is an internal header file, included by other STL headers.
  17  *   You should not attempt to use it directly.
  18  */
  19
  20 #ifndef _STLP_SPECIALIZED_SLIST_H
  21 #define _STLP_SPECIALIZED_SLIST_H
  22
  23 #ifndef _STLP_POINTERS_SPEC_TOOLS_H
  24 #  include <stl/pointers/_tools.h>
  25 #endif
  26
  27 _STLP_BEGIN_NAMESPACE
  28
  29 #define SLIST_IMPL _STLP_PTR_IMPL_NAME(slist)
  30
  31 #if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
  32 _STLP_MOVE_TO_PRIV_NAMESPACE
  33
  34 _STLP_EXPORT_TEMPLATE_CLASS _Slist_node<void*>;
  35 typedef _Slist_node<void*> _VoidPtrSNode;
  36 _STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_Slist_node_base, _VoidPtrSNode, allocator<_VoidPtrSNode> >;
  37 _STLP_EXPORT_TEMPLATE_CLASS _Slist_base<void*, allocator<void*> >;
  38 _STLP_EXPORT_TEMPLATE_CLASS SLIST_IMPL<void*, allocator<void*> >;
  39
  40 _STLP_MOVE_TO_STD_NAMESPACE
  41 #endif
  42
  43 #if defined (_STLP_DEBUG)
  44 #  define slist _STLP_NON_DBG_NAME(slist)
  45 _STLP_MOVE_TO_PRIV_NAMESPACE
  46 #endif
  47
  48 template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) >
  49 class slist
  50 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (slist)
  51              : public __stlport_class<slist<_Tp, _Alloc> >
  52 #endif
  53 {
  54   typedef typename _STLP_PRIV _StorageType<_Tp>::_Type _StorageType;
  55   typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc;
  56   typedef _STLP_PRIV SLIST_IMPL<_StorageType, _StorageTypeAlloc> _Base;
  57   typedef typename _Base::iterator _BaseIte;
  58   typedef typename _Base::const_iterator _BaseConstIte;
  59   typedef slist<_Tp, _Alloc> _Self;
  60   typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits;
  61   typedef _STLP_PRIV _Slist_node_base _Node_base;
  62
  63 public:
  64   typedef _Tp               value_type;
  65   typedef value_type*       pointer;
  66   typedef const value_type* const_pointer;
  67   typedef value_type&       reference;
  68   typedef const value_type& const_reference;
  69   typedef size_t            size_type;
  70   typedef ptrdiff_t         difference_type;
  71   typedef forward_iterator_tag _Iterator_category;
  72
  73   typedef _STLP_PRIV _Slist_iterator<value_type, _Nonconst_traits<value_type> >  iterator;
  74   typedef _STLP_PRIV _Slist_iterator<value_type, _Const_traits<value_type> >     const_iterator;
  75
  76   _STLP_FORCE_ALLOCATORS(value_type, _Alloc)
  77   typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type;
  78
  79 public:
  80   allocator_type get_allocator() const
  81   { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); }
  82
  83   explicit slist(const allocator_type& __a = allocator_type())
  84     : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
  85
  86 #if !defined(_STLP_DONT_SUP_DFLT_PARAM)
  87   explicit slist(size_type __n, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type),
  88 #else
  89   slist(size_type __n, const value_type& __x,
  90 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
  91         const allocator_type& __a =  allocator_type())
  92     : _M_impl(__n, cast_traits::to_storage_type_cref(__x), _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
  93
  94 #if defined(_STLP_DONT_SUP_DFLT_PARAM)
  95   explicit slist(size_type __n) : _M_impl(__n) {}
  96 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
  97
  98 #if defined (_STLP_MEMBER_TEMPLATES)
  99   // We don't need any dispatching tricks here, because _M_insert_after_range
 100   // already does them.
 101   template <class _InputIterator>
 102   slist(_InputIterator __first, _InputIterator __last,
 103         const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
 104 #  if !defined (_STLP_USE_ITERATOR_WRAPPER)
 105     : _M_impl(__first, __last, _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
 106 #  else
 107     : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {
 108     insert_after(before_begin(), __first, __last);
 109   }
 110 #  endif
 111 #  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
 112   // VC++ needs this crazyness
 113   template <class _InputIterator>
 114   slist(_InputIterator __first, _InputIterator __last)
 115 #    if !defined (_STLP_USE_WRAPPER_ITERATOR)
 116     : _M_impl(__first, __last) {}
 117 #    else
 118   { insert_after(before_begin(), __first, __last); }
 119 #    endif
 120 #  endif
 121 #else /* _STLP_MEMBER_TEMPLATES */
 122   slist(const_iterator __first, const_iterator __last,
 123         const allocator_type& __a =  allocator_type() )
 124     : _M_impl(_BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node),
 125               _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
 126   slist(const value_type* __first, const value_type* __last,
 127         const allocator_type& __a =  allocator_type())
 128     : _M_impl(cast_traits::to_storage_type_cptr(__first), cast_traits::to_storage_type_cptr(__last),
 129               _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
 130 #endif /* _STLP_MEMBER_TEMPLATES */
 131
 132   slist(const _Self& __x) : _M_impl(__x._M_impl) {}
 133   slist(__move_source<_Self> src)
 134     : _M_impl(__move_source<_Base>(src.get()._M_impl)) {}
 135
 136   _Self& operator= (const _Self& __x) { _M_impl = __x._M_impl; return *this; }
 137
 138   void assign(size_type __n, const value_type& __val)
 139   { _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); }
 140
 141 #if defined (_STLP_MEMBER_TEMPLATES)
 142 #  if defined (_STLP_USE_ITERATOR_WRAPPER)
 143 private:
 144   template <class _Integer>
 145   void _M_assign_dispatch(_Integer __n, _Integer __val,
 146                           const __true_type&)
 147   { _M_impl.assign(__n, __val); }
 148
 149   template <class _InputIterator>
 150   void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
 151                           const __false_type&) {
 152     _M_impl.assign(typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
 153                    typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
 154   }
 155
 156 public:
 157 #  endif
 158
 159   template <class _InputIterator>
 160   void assign(_InputIterator __first, _InputIterator __last) {
 161 #  if defined (_STLP_USE_ITERATOR_WRAPPER)
 162     typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
 163     _M_assign_dispatch(__first, __last, _Integral());
 164 #  else
 165     _M_impl.assign(__first, __last);
 166 #  endif
 167   }
 168 #else
 169   void assign(const value_type *__first, const value_type *__last) {
 170     _M_impl.assign(cast_traits::to_storage_type_cptr(__first),
 171                    cast_traits::to_storage_type_cptr(__last));
 172   }
 173   void assign(const_iterator __first, const_iterator __last) {
 174     _M_impl.assign(_BaseConstIte(__first._M_node),
 175                    _BaseConstIte(__last._M_node));
 176   }
 177 #endif /* _STLP_MEMBER_TEMPLATES */
 178
 179   iterator before_begin()             { return iterator(_M_impl.before_begin()._M_node); }
 180   const_iterator before_begin() const { return const_iterator(const_cast<_Node_base*>(_M_impl.before_begin()._M_node)); }
 181
 182   iterator begin()                    { return iterator(_M_impl.begin()._M_node); }
 183   const_iterator begin() const        { return const_iterator(const_cast<_Node_base*>(_M_impl.begin()._M_node));}
 184
 185   iterator end()                      { return iterator(_M_impl.end()._M_node); }
 186   const_iterator end() const          { return iterator(_M_impl.end()._M_node); }
 187
 188   size_type size() const      { return _M_impl.size(); }
 189   size_type max_size() const  { return _M_impl.max_size(); }
 190   bool empty() const          { return _M_impl.empty(); }
 191
 192   void swap(_Self& __x) { _M_impl.swap(__x._M_impl); }
 193
 194 public:
 195   reference front()             { return *begin(); }
 196   const_reference front() const { return *begin(); }
 197 #if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
 198   void push_front(const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
 199 #else
 200   void push_front(const value_type& __x)
 201 #endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
 202   { _M_impl.push_front(cast_traits::to_storage_type_cref(__x)); }
 203
 204 # if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
 205   void push_front() { _M_impl.push_front();}
 206 # endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
 207
 208   void pop_front() { _M_impl.pop_front(); }
 209
 210   iterator previous(const_iterator __pos)
 211   { return iterator(_M_impl.previous(_BaseConstIte(__pos._M_node))._M_node); }
 212   const_iterator previous(const_iterator __pos) const
 213   { return const_iterator(const_cast<_Node_base*>(_M_impl.previous(_BaseConstIte(__pos._M_node))._M_node)); }
 214
 215 #if !defined(_STLP_DONT_SUP_DFLT_PARAM)
 216   iterator insert_after(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
 217 #else
 218   iterator insert_after(iterator __pos, const value_type& __x)
 219 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
 220   { return iterator(_M_impl.insert_after(_BaseIte(__pos._M_node),
 221                                          cast_traits::to_storage_type_cref(__x))._M_node); }
 222
 223 #if defined(_STLP_DONT_SUP_DFLT_PARAM)
 224   iterator insert_after(iterator __pos)
 225   { return iterator(_M_impl.insert_after(_BaseIte(__pos._M_node))._M_node);}
 226 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
 227
 228   void insert_after(iterator __pos, size_type __n, const value_type& __x)
 229   { _M_impl.insert_after(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); }
 230
 231 #if defined (_STLP_MEMBER_TEMPLATES)
 232 #  if defined (_STLP_USE_ITERATOR_WRAPPER)
 233 private:
 234   template <class _Integer>
 235   void _M_insert_after_dispatch(iterator __pos, _Integer __n, _Integer __val,
 236                                 const __true_type&) {
 237     _M_impl.insert_after(_BaseIte(__pos._M_node), __n, __val);
 238   }
 239
 240   template <class _InputIterator>
 241   void _M_insert_after_dispatch(iterator __pos,
 242                                 _InputIterator __first, _InputIterator __last,
 243                                 const __false_type&) {
 244     _M_impl.insert_after(_BaseIte(__pos._M_node),
 245                          typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
 246                          typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
 247   }
 248
 249 public:
 250 #  endif
 251
 252   template <class _InputIterator>
 253   void insert_after(iterator __pos, _InputIterator __first, _InputIterator __last) {
 254 #  if defined (_STLP_USE_ITERATOR_WRAPPER)
 255     // Check whether it's an integral type.  If so, it's not an iterator.
 256     typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
 257     _M_insert_after_dispatch(__pos, __first, __last, _Integral());
 258 #  else
 259     _M_impl.insert_after(_BaseIte(__pos._M_node), __first, __last);
 260 #  endif
 261   }
 262
 263 #else /* _STLP_MEMBER_TEMPLATES */
 264   void insert_after(iterator __pos,
 265                     const_iterator __first, const_iterator __last)
 266   { _M_impl.insert_after(_BaseIte(__pos._M_node),
 267                          _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); }
 268   void insert_after(iterator __pos,
 269                     const value_type* __first, const value_type* __last) {
 270     _M_impl.insert_after(_BaseIte(__pos._M_node),
 271                          cast_traits::to_storage_type_cptr(__first),
 272                          cast_traits::to_storage_type_cptr(__last));
 273   }
 274 #endif /* _STLP_MEMBER_TEMPLATES */
 275
 276 #if !defined(_STLP_DONT_SUP_DFLT_PARAM)
 277   iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
 278 #else
 279   iterator insert(iterator __pos, const value_type& __x)
 280 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
 281   { return iterator(_M_impl.insert(_BaseIte(__pos._M_node),
 282                                    cast_traits::to_storage_type_cref(__x))._M_node); }
 283
 284 #if defined(_STLP_DONT_SUP_DFLT_PARAM)
 285   iterator insert(iterator __pos)
 286   { return iterator(_M_impl.insert(_BaseIte(__pos._M_node))._M_node); }
 287 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
 288
 289   void insert(iterator __pos, size_type __n, const value_type& __x)
 290   { _M_impl.insert(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); }
 291
 292 #if defined (_STLP_MEMBER_TEMPLATES)
 293 #  if defined (_STLP_USE_ITERATOR_WRAPPER)
 294 private:
 295   template <class _Integer>
 296   void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
 297                           const __true_type&) {
 298     _M_impl.insert(_BaseIte(__pos._M_node), __n, __val);
 299   }
 300
 301   template <class _InputIterator>
 302   void _M_insert_dispatch(iterator __pos,
 303                           _InputIterator __first, _InputIterator __last,
 304                           const __false_type&) {
 305     _M_impl.insert(_BaseIte(__pos._M_node), typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
 306                                             typename _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
 307   }
 308
 309 public:
 310 #  endif
 311
 312   template <class _InputIterator>
 313   void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
 314 #  if defined (_STLP_USE_ITERATOR_WRAPPER)
 315     // Check whether it's an integral type.  If so, it's not an iterator.
 316     typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
 317     _M_insert_dispatch(__pos, __first, __last, _Integral());
 318 #  else
 319     _M_impl.insert(_BaseIte(__pos._M_node), __first, __last);
 320 #  endif
 321   }
 322
 323 #else /* _STLP_MEMBER_TEMPLATES */
 324   void insert(iterator __pos, const_iterator __first, const_iterator __last)
 325   { _M_impl.insert(_BaseIte(__pos._M_node), _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); }
 326   void insert(iterator __pos, const value_type* __first, const value_type* __last)
 327   { _M_impl.insert(_BaseIte(__pos._M_node), cast_traits::to_storage_type_cptr(__first),
 328                                             cast_traits::to_storage_type_cptr(__last)); }
 329 #endif /* _STLP_MEMBER_TEMPLATES */
 330
 331   iterator erase_after(iterator __pos)
 332   { return iterator(_M_impl.erase_after(_BaseIte(__pos._M_node))._M_node); }
 333   iterator erase_after(iterator __before_first, iterator __last)
 334   { return iterator(_M_impl.erase_after(_BaseIte(__before_first._M_node),
 335                                         _BaseIte(__last._M_node))._M_node); }
 336
 337   iterator erase(iterator __pos)
 338   { return iterator(_M_impl.erase(_BaseIte(__pos._M_node))._M_node); }
 339   iterator erase(iterator __first, iterator __last)
 340   { return iterator(_M_impl.erase(_BaseIte(__first._M_node), _BaseIte(__last._M_node))._M_node); }
 341
 342 #if !defined(_STLP_DONT_SUP_DFLT_PARAM)
 343   void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
 344 #else
 345   void resize(size_type __new_size, const value_type& __x)
 346 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
 347   { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x));}
 348
 349 #if defined(_STLP_DONT_SUP_DFLT_PARAM)
 350   void resize(size_type __new_size) { _M_impl.resize(__new_size); }
 351 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
 352
 353   void clear() { _M_impl.clear(); }
 354
 355   void splice_after(iterator __pos, _Self& __x,
 356                     iterator __before_first, iterator __before_last)
 357   { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl,
 358                          _BaseIte(__before_first._M_node), _BaseIte(__before_last._M_node)); }
 359   void splice_after(iterator __pos, _Self& __x, iterator __prev)
 360   { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__prev._M_node)); }
 361   void splice_after(iterator __pos, _Self& __x)
 362   { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl); }
 363   void splice(iterator __pos, _Self& __x)
 364   { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl); }
 365   void splice(iterator __pos, _Self& __x, iterator __i)
 366   { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__i._M_node)); }
 367   void splice(iterator __pos, _Self& __x, iterator __first, iterator __last)
 368   { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl,
 369                    _BaseIte(__first._M_node), _BaseIte(__last._M_node)); }
 370
 371   void reverse() { _M_impl.reverse(); }
 372
 373   void remove(const value_type& __val) { _M_impl.remove(cast_traits::to_storage_type_cref(__val)); }
 374   void unique()                 { _M_impl.unique(); }
 375   void merge(_Self& __x)        { _M_impl.merge(__x._M_impl); }
 376   void sort()                   {_M_impl.sort(); }
 377
 378 #ifdef _STLP_MEMBER_TEMPLATES
 379   template <class _Predicate>
 380   void remove_if(_Predicate __pred)
 381   { _M_impl.remove_if(_STLP_PRIV _UnaryPredWrapper<_StorageType, _Tp, _Predicate>(__pred)); }
 382
 383   template <class _BinaryPredicate>
 384   void unique(_BinaryPredicate __pred)
 385   { _M_impl.unique(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _BinaryPredicate>(__pred)); }
 386
 387   template <class _StrictWeakOrdering>
 388   void merge(_Self& __x, _StrictWeakOrdering __comp)
 389   { _M_impl.merge(__x._M_impl, _STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); }
 390
 391   template <class _StrictWeakOrdering>
 392   void sort(_StrictWeakOrdering __comp)
 393   { _M_impl.sort(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); }
 394 #endif /* _STLP_MEMBER_TEMPLATES */
 395
 396 private:
 397   _Base _M_impl;
 398 };
 399
 400 #if defined (slist)
 401 #  undef slist
 402 _STLP_MOVE_TO_STD_NAMESPACE
 403 #endif
 404
 405 #undef SLIST_IMPL
 406
 407 _STLP_END_NAMESPACE
 408
 409 #endif /* _STLP_SPECIALIZED_SLIST_H */
 410
 411 // Local Variables:
 412 // mode:C++
 413 // End: