epoc32/include/tools/stlport/stl/pointers/_set.h
branchSymbian3
changeset 4 837f303aceeb
     1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/epoc32/include/tools/stlport/stl/pointers/_set.h	Wed Mar 31 12:33:34 2010 +0100
     1.3 @@ -0,0 +1,536 @@
     1.4 +/*
     1.5 + * Copyright (c) 2005
     1.6 + * Francois Dumont
     1.7 + *
     1.8 + * This material is provided "as is", with absolutely no warranty expressed
     1.9 + * or implied. Any use is at your own risk.
    1.10 + *
    1.11 + * Permission to use or copy this software for any purpose is hereby granted
    1.12 + * without fee, provided the above notices are retained on all copies.
    1.13 + * Permission to modify the code and to distribute modified code is granted,
    1.14 + * provided the above notices are retained, and a notice that the code was
    1.15 + * modified is included with the above copyright notice.
    1.16 + */
    1.17 +
    1.18 +/* NOTE: This is an internal header file, included by other STL headers.
    1.19 + *   You should not attempt to use it directly.
    1.20 + */
    1.21 +
    1.22 +#ifndef _STLP_PTR_SPECIALIZED_SET_H
    1.23 +#define _STLP_PTR_SPECIALIZED_SET_H
    1.24 +
    1.25 +#ifndef _STLP_POINTERS_SPEC_TOOLS_H
    1.26 +#  include <stl/pointers/_tools.h>
    1.27 +#endif
    1.28 +
    1.29 +_STLP_BEGIN_NAMESPACE
    1.30 +
    1.31 +//Specific iterator traits creation
    1.32 +_STLP_CREATE_ITERATOR_TRAITS(SetTraitsT, Const_traits)
    1.33 +
    1.34 +#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
    1.35 +_STLP_EXPORT template struct _STLP_CLASS_DECLSPEC less<void*>;
    1.36 +
    1.37 +_STLP_MOVE_TO_PRIV_NAMESPACE
    1.38 +
    1.39 +typedef _Rb_tree_node<void*> _Node;
    1.40 +_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_Rb_tree_node_base, _Node,  allocator<_Node> >;
    1.41 +_STLP_EXPORT_TEMPLATE_CLASS _Rb_tree_base<void*, allocator<void*> >;
    1.42 +#  if defined (_STLP_DEBUG)
    1.43 +_STLP_EXPORT_TEMPLATE_CLASS _DbgCompare<void*, less<void*> >;
    1.44 +#    define _Rb_tree _STLP_NON_DBG_NAME(Rb_tree)
    1.45 +_STLP_EXPORT_TEMPLATE_CLASS _Rb_tree<void*, _DbgCompare<void*, less<void*> >, void*, _Identity<void*>,
    1.46 +                                     _SetTraitsT<void*>, allocator<void*> >;
    1.47 +#    undef _Rb_tree
    1.48 +#  endif
    1.49 +_STLP_EXPORT_TEMPLATE_CLASS _Rb_tree<void*, less<void*>, void*, _Identity<void*>,
    1.50 +                                     _SetTraitsT<void*>, allocator<void*> >;
    1.51 +_STLP_MOVE_TO_STD_NAMESPACE
    1.52 +#endif
    1.53 +
    1.54 +template <class _Key, _STLP_DFL_TMPL_PARAM(_Compare, less<_Key>),
    1.55 +                      _STLP_DEFAULT_ALLOCATOR_SELECT(_Key) >
    1.56 +class set
    1.57 +#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
    1.58 +          : public __stlport_class<set<_Key, _Compare, _Alloc> >
    1.59 +#endif
    1.60 +{
    1.61 +  typedef _STLP_PRIV _AssocStorageTypes<_Key, _Compare> _AssocStorageTypes;
    1.62 +  typedef typename _AssocStorageTypes::_KeyStorageType _KeyStorageType;
    1.63 +  typedef typename _AssocStorageTypes::_CompareStorageType _CompareStorageType;
    1.64 +  typedef typename _Alloc_traits<_KeyStorageType, _Alloc>::allocator_type _StorageTypeAlloc;
    1.65 +  typedef _STLP_PRIV _CastTraits<_KeyStorageType, _Key> cast_traits;
    1.66 +
    1.67 +  typedef set<_Key, _Compare, _Alloc> _Self;
    1.68 +public:
    1.69 +  typedef _Key     key_type;
    1.70 +  typedef _Key     value_type;
    1.71 +  typedef _Compare key_compare;
    1.72 +  typedef _Compare value_compare;
    1.73 +
    1.74 +protected:
    1.75 +  //Specific iterator traits creation
    1.76 +  typedef _STLP_PRIV _SetTraitsT<value_type> _SetTraits;
    1.77 +  typedef _STLP_PRIV _Rb_tree<key_type, key_compare,
    1.78 +                              value_type, _STLP_PRIV _Identity<value_type>,
    1.79 +                              _SetTraits, _Alloc> _Priv_Rep_type;
    1.80 +
    1.81 +  typedef _STLP_PRIV _SetTraitsT<_KeyStorageType> _SetStorageTraits;
    1.82 +
    1.83 +public:
    1.84 +  //dums: need the following public for the __move_traits framework
    1.85 +  typedef _STLP_PRIV _Rb_tree<_KeyStorageType, _CompareStorageType,
    1.86 +                              _KeyStorageType, _STLP_PRIV _Identity<_KeyStorageType>,
    1.87 +                              _SetStorageTraits, _StorageTypeAlloc> _Rep_type;
    1.88 +
    1.89 +private:
    1.90 +  typedef typename _Rep_type::iterator base_iterator;
    1.91 +  typedef typename _Rep_type::const_iterator const_base_iterator;
    1.92 +
    1.93 +public:
    1.94 +  typedef typename _Priv_Rep_type::pointer pointer;
    1.95 +  typedef typename _Priv_Rep_type::const_pointer const_pointer;
    1.96 +  typedef typename _Priv_Rep_type::reference reference;
    1.97 +  typedef typename _Priv_Rep_type::const_reference const_reference;
    1.98 +  typedef typename _Priv_Rep_type::iterator iterator;
    1.99 +  typedef typename _Priv_Rep_type::const_iterator const_iterator;
   1.100 +  typedef typename _Priv_Rep_type::reverse_iterator reverse_iterator;
   1.101 +  typedef typename _Priv_Rep_type::const_reverse_iterator const_reverse_iterator;
   1.102 +  typedef typename _Priv_Rep_type::size_type size_type;
   1.103 +  typedef typename _Priv_Rep_type::difference_type difference_type;
   1.104 +  typedef typename _Priv_Rep_type::allocator_type allocator_type;
   1.105 +
   1.106 +private:
   1.107 +  _Rep_type _M_t;  // red-black tree representing set
   1.108 +  _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
   1.109 +
   1.110 +#if defined (_STLP_DEBUG)
   1.111 +  static iterator _S_to_value_ite(const_base_iterator __ite)
   1.112 +  { return iterator(__ite._Owner(), __ite._M_iterator._M_node); }
   1.113 +  static base_iterator _S_to_storage_ite(const_iterator __ite)
   1.114 +  { return base_iterator(__ite._Owner(), __ite._M_iterator._M_node); }
   1.115 +#else
   1.116 +  static iterator _S_to_value_ite(const_base_iterator __ite)
   1.117 +  { return iterator(__ite._M_node); }
   1.118 +  static base_iterator _S_to_storage_ite(const_iterator __ite)
   1.119 +  { return base_iterator(__ite._M_node); }
   1.120 +#endif
   1.121 +
   1.122 +public:
   1.123 +  set() : _M_t(_CompareStorageType(), _StorageTypeAlloc()) {}
   1.124 +  explicit set(const _Compare& __comp,
   1.125 +               const allocator_type& __a = allocator_type())
   1.126 +    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {}
   1.127 +
   1.128 +#if defined (_STLP_MEMBER_TEMPLATES)
   1.129 +  template <class _InputIterator>
   1.130 +  set(_InputIterator __first, _InputIterator __last)
   1.131 +    : _M_t(_Compare(), _StorageTypeAlloc()) {
   1.132 +#  if defined (_STLP_USE_ITERATOR_WRAPPER)
   1.133 +    _M_t.insert_unique(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
   1.134 +                       typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
   1.135 +#  else
   1.136 +    _M_t.insert_unique(__first, __last);
   1.137 +#  endif
   1.138 +  }
   1.139 +
   1.140 +#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
   1.141 +  template <class _InputIterator>
   1.142 +  set(_InputIterator __first, _InputIterator __last, const _Compare& __comp)
   1.143 +    : _M_t(__comp, _StorageTypeAlloc()) {
   1.144 +#    if defined (_STLP_USE_ITERATOR_WRAPPER)
   1.145 +    _M_t.insert_unique(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
   1.146 +                       typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
   1.147 +#    else
   1.148 +    _M_t.insert_unique(__first, __last);
   1.149 +#    endif
   1.150 +  }
   1.151 +#  endif
   1.152 +  template <class _InputIterator>
   1.153 +  set(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
   1.154 +      const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
   1.155 +    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {
   1.156 +#  if defined (_STLP_USE_ITERATOR_WRAPPER)
   1.157 +    _M_t.insert_unique(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
   1.158 +                       typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
   1.159 +#  else
   1.160 +    _M_t.insert_unique(__first, __last);
   1.161 +#  endif
   1.162 +  }
   1.163 +#else
   1.164 +  set(const value_type* __first, const value_type* __last)
   1.165 +    : _M_t(_Compare(), _StorageTypeAlloc()) {
   1.166 +    _M_t.insert_unique(cast_traits::to_storage_type_cptr(__first),
   1.167 +                       cast_traits::to_storage_type_cptr(__last));
   1.168 +  }
   1.169 +
   1.170 +  set(const value_type* __first, const value_type* __last,
   1.171 +      const _Compare& __comp, const allocator_type& __a = allocator_type())
   1.172 +    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {
   1.173 +    _M_t.insert_unique(cast_traits::to_storage_type_cptr(__first),
   1.174 +                       cast_traits::to_storage_type_cptr(__last));
   1.175 +  }
   1.176 +
   1.177 +  set(const_iterator __first, const_iterator __last)
   1.178 +    : _M_t(_Compare(), _StorageTypeAlloc())
   1.179 +  { _M_t.insert_unique(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
   1.180 +
   1.181 +  set(const_iterator __first, const_iterator __last,
   1.182 +      const _Compare& __comp, const allocator_type& __a = allocator_type())
   1.183 +    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType))
   1.184 +  { _M_t.insert_unique(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
   1.185 +#endif /* _STLP_MEMBER_TEMPLATES */
   1.186 +
   1.187 +  set(const _Self& __x) : _M_t(__x._M_t) {}
   1.188 +
   1.189 +  set(__move_source<_Self> src)
   1.190 +    : _M_t(__move_source<_Rep_type>(src.get()._M_t)) {}
   1.191 +
   1.192 +  _Self& operator=(const _Self& __x) {
   1.193 +    _M_t = __x._M_t;
   1.194 +    return *this;
   1.195 +  }
   1.196 +
   1.197 +  // accessors:
   1.198 +  key_compare key_comp() const { return _M_t.key_comp(); }
   1.199 +  value_compare value_comp() const { return _M_t.key_comp(); }
   1.200 +  allocator_type get_allocator() const
   1.201 +  { return _STLP_CONVERT_ALLOCATOR(_M_t.get_allocator(), value_type); }
   1.202 +
   1.203 +  iterator begin() { return _S_to_value_ite(_M_t.begin()); }
   1.204 +  iterator end() { return _S_to_value_ite(_M_t.end()); }
   1.205 +  const_iterator begin() const { return _S_to_value_ite(_M_t.begin()); }
   1.206 +  const_iterator end() const { return _S_to_value_ite(_M_t.end()); }
   1.207 +  reverse_iterator rbegin() { return reverse_iterator(end()); }
   1.208 +  reverse_iterator rend() { return reverse_iterator(begin()); }
   1.209 +  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
   1.210 +  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
   1.211 +  bool empty() const { return _M_t.empty(); }
   1.212 +  size_type size() const { return _M_t.size(); }
   1.213 +  size_type max_size() const { return _M_t.max_size(); }
   1.214 +  void swap(_Self& __x) { _M_t.swap(__x._M_t); }
   1.215 +
   1.216 +  // insert/erase
   1.217 +  pair<iterator,bool> insert(const value_type& __x) {
   1.218 +    pair<base_iterator, bool> ret = _M_t.insert_unique(cast_traits::to_storage_type_cref(__x));
   1.219 +    return pair<iterator, bool>(_S_to_value_ite(ret.first), ret.second);
   1.220 +  }
   1.221 +  iterator insert(iterator __pos, const value_type& __x)
   1.222 +  { return _S_to_value_ite(_M_t.insert_unique(_S_to_storage_ite(__pos), cast_traits::to_storage_type_cref(__x))); }
   1.223 +
   1.224 +#if defined (_STLP_MEMBER_TEMPLATES)
   1.225 +  template <class _InputIterator>
   1.226 +  void insert(_InputIterator __first, _InputIterator __last) {
   1.227 +#  if defined (_STLP_USE_ITERATOR_WRAPPER)
   1.228 +    _M_t.insert_unique(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
   1.229 +                       typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
   1.230 +#  else
   1.231 +    _M_t.insert_unique(__first, __last);
   1.232 +#  endif
   1.233 +  }
   1.234 +#else
   1.235 +  void insert(const_iterator __first, const_iterator __last)
   1.236 +  { _M_t.insert_unique(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
   1.237 +  void insert(const value_type* __first, const value_type* __last) {
   1.238 +    _M_t.insert_unique(cast_traits::to_storage_type_cptr(__first),
   1.239 +                       cast_traits::to_storage_type_cptr(__last));
   1.240 +  }
   1.241 +#endif
   1.242 +  void erase(iterator __pos)
   1.243 +  { _M_t.erase(_S_to_storage_ite(__pos)); }
   1.244 +  size_type erase(const key_type& __x)
   1.245 +  { return _M_t.erase_unique(cast_traits::to_storage_type_cref(__x)); }
   1.246 +  void erase(iterator __first, iterator __last)
   1.247 +  { _M_t.erase(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
   1.248 +  void clear() { _M_t.clear(); }
   1.249 +
   1.250 +  // set operations:
   1.251 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.252 +  const_iterator find(const _KT& __x) const
   1.253 +  { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); }
   1.254 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.255 +  iterator find(const _KT& __x)
   1.256 +  { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); }
   1.257 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.258 +  size_type count(const _KT& __x) const
   1.259 +  { return _M_t.find(cast_traits::to_storage_type_crefT(__x)) == _M_t.end() ? 0 : 1; }
   1.260 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.261 +  iterator lower_bound(const _KT& __x)
   1.262 +  { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); }
   1.263 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.264 +  const_iterator lower_bound(const _KT& __x) const
   1.265 +  { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); }
   1.266 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.267 +  iterator upper_bound(const _KT& __x)
   1.268 +  { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); }
   1.269 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.270 +  const_iterator upper_bound(const _KT& __x) const
   1.271 +  { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); }
   1.272 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.273 +  pair<iterator, iterator> equal_range(const _KT& __x) {
   1.274 +    pair<base_iterator, base_iterator> __ret;
   1.275 +    __ret = _M_t.equal_range(cast_traits::to_storage_type_crefT(__x));
   1.276 +    return pair<iterator, iterator>(_S_to_value_ite(__ret.first),
   1.277 +                                    _S_to_value_ite(__ret.second));
   1.278 +  }
   1.279 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.280 +  pair<const_iterator, const_iterator> equal_range(const _KT& __x) const {
   1.281 +    pair<const_base_iterator, const_base_iterator> __ret;
   1.282 +    __ret = _M_t.equal_range_unique(cast_traits::to_storage_type_crefT(__x));
   1.283 +    return pair<const_iterator, const_iterator>(_S_to_value_ite(__ret.first),
   1.284 +                                                _S_to_value_ite(__ret.second));
   1.285 +  }
   1.286 +};
   1.287 +
   1.288 +//Specific iterator traits creation
   1.289 +_STLP_CREATE_ITERATOR_TRAITS(MultisetTraitsT, Const_traits)
   1.290 +
   1.291 +template <class _Key, _STLP_DFL_TMPL_PARAM(_Compare, less<_Key>),
   1.292 +                     _STLP_DEFAULT_ALLOCATOR_SELECT(_Key) >
   1.293 +class multiset
   1.294 +#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
   1.295 +               : public __stlport_class<multiset<_Key, _Compare, _Alloc> >
   1.296 +#endif
   1.297 +{
   1.298 +  typedef _STLP_PRIV _AssocStorageTypes<_Key, _Compare> _AssocStorageTypes;
   1.299 +  typedef typename _AssocStorageTypes::_KeyStorageType _KeyStorageType;
   1.300 +  typedef typename _AssocStorageTypes::_CompareStorageType _CompareStorageType;
   1.301 +  typedef typename _Alloc_traits<_KeyStorageType, _Alloc>::allocator_type _StorageTypeAlloc;
   1.302 +  typedef _STLP_PRIV _CastTraits<_KeyStorageType, _Key> cast_traits;
   1.303 +
   1.304 +  typedef multiset<_Key, _Compare, _Alloc> _Self;
   1.305 +public:
   1.306 +  // typedefs:
   1.307 +  typedef _Key     key_type;
   1.308 +  typedef _Key     value_type;
   1.309 +  typedef _Compare key_compare;
   1.310 +  typedef _Compare value_compare;
   1.311 +
   1.312 +protected:
   1.313 +  //Specific iterator traits creation
   1.314 +  typedef _STLP_PRIV _MultisetTraitsT<value_type> _MultisetTraits;
   1.315 +  typedef _STLP_PRIV _Rb_tree<key_type, key_compare,
   1.316 +                              value_type, _STLP_PRIV _Identity<value_type>,
   1.317 +                              _MultisetTraits, _Alloc> _Priv_Rep_type;
   1.318 +
   1.319 +  typedef _STLP_PRIV _MultisetTraitsT<_KeyStorageType> _MultisetStorageTraits;
   1.320 +public:
   1.321 +  //dums: need the following public for the __move_traits framework
   1.322 +  typedef _STLP_PRIV _Rb_tree<_KeyStorageType, _CompareStorageType,
   1.323 +                              _KeyStorageType, _STLP_PRIV _Identity<_KeyStorageType>,
   1.324 +                              _MultisetStorageTraits, _StorageTypeAlloc> _Rep_type;
   1.325 +
   1.326 +private:
   1.327 +  typedef typename _Rep_type::iterator base_iterator;
   1.328 +  typedef typename _Rep_type::const_iterator const_base_iterator;
   1.329 +
   1.330 +public:
   1.331 +  typedef typename _Priv_Rep_type::pointer pointer;
   1.332 +  typedef typename _Priv_Rep_type::const_pointer const_pointer;
   1.333 +  typedef typename _Priv_Rep_type::reference reference;
   1.334 +  typedef typename _Priv_Rep_type::const_reference const_reference;
   1.335 +  typedef typename _Priv_Rep_type::iterator iterator;
   1.336 +  typedef typename _Priv_Rep_type::const_iterator const_iterator;
   1.337 +  typedef typename _Priv_Rep_type::reverse_iterator reverse_iterator;
   1.338 +  typedef typename _Priv_Rep_type::const_reverse_iterator const_reverse_iterator;
   1.339 +  typedef typename _Priv_Rep_type::size_type size_type;
   1.340 +  typedef typename _Priv_Rep_type::difference_type difference_type;
   1.341 +  typedef typename _Priv_Rep_type::allocator_type allocator_type;
   1.342 +
   1.343 +private:
   1.344 +  _Rep_type _M_t;  // red-black tree representing multiset
   1.345 +  _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
   1.346 +
   1.347 +#if defined (_STLP_DEBUG)
   1.348 +  static iterator _S_to_value_ite(const_base_iterator __ite)
   1.349 +  { return iterator(__ite._Owner(), __ite._M_iterator._M_node); }
   1.350 +  static base_iterator _S_to_storage_ite(const_iterator __ite)
   1.351 +  { return base_iterator(__ite._Owner(), __ite._M_iterator._M_node); }
   1.352 +#else
   1.353 +  static iterator _S_to_value_ite(const_base_iterator __ite)
   1.354 +  { return iterator(__ite._M_node); }
   1.355 +  static base_iterator _S_to_storage_ite(const_iterator __ite)
   1.356 +  { return base_iterator(__ite._M_node); }
   1.357 +#endif
   1.358 +
   1.359 +public:
   1.360 +  multiset() : _M_t(_Compare(), _StorageTypeAlloc()) {}
   1.361 +  explicit multiset(const _Compare& __comp,
   1.362 +                    const allocator_type& __a = allocator_type())
   1.363 +    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {}
   1.364 +
   1.365 +#if defined (_STLP_MEMBER_TEMPLATES)
   1.366 +  template <class _InputIterator>
   1.367 +  multiset(_InputIterator __first, _InputIterator __last)
   1.368 +    : _M_t(_Compare(), _StorageTypeAlloc()) {
   1.369 +#  if defined (_STLP_USE_ITERATOR_WRAPPER)
   1.370 +    _M_t.insert_equal(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
   1.371 +                      typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
   1.372 +#  else
   1.373 +    _M_t.insert_equal(__first, __last);
   1.374 +#  endif
   1.375 +  }
   1.376 +
   1.377 +#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
   1.378 +  template <class _InputIterator>
   1.379 +  multiset(_InputIterator __first, _InputIterator __last,
   1.380 +           const _Compare& __comp)
   1.381 +    : _M_t(__comp, _StorageTypeAlloc()) {
   1.382 +#    if defined (_STLP_USE_ITERATOR_WRAPPER)
   1.383 +    _M_t.insert_equal(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
   1.384 +                      typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
   1.385 +#    else
   1.386 +    _M_t.insert_equal(__first, __last);
   1.387 +#    endif
   1.388 +  }
   1.389 +#  endif
   1.390 +  template <class _InputIterator>
   1.391 +  multiset(_InputIterator __first, _InputIterator __last,
   1.392 +           const _Compare& __comp,
   1.393 +           const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
   1.394 +    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {
   1.395 +#  if defined (_STLP_USE_ITERATOR_WRAPPER)
   1.396 +    _M_t.insert_equal(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
   1.397 +                      typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
   1.398 +#  else
   1.399 +    _M_t.insert_equal(__first, __last);
   1.400 +#  endif
   1.401 +  }
   1.402 +
   1.403 +#else
   1.404 +  multiset(const value_type* __first, const value_type* __last)
   1.405 +    : _M_t(_Compare(), _StorageTypeAlloc()) {
   1.406 +    _M_t.insert_equal(cast_traits::to_storage_type_cptr(__first),
   1.407 +                      cast_traits::to_storage_type_cptr(__last));
   1.408 +  }
   1.409 +
   1.410 +  multiset(const value_type* __first, const value_type* __last,
   1.411 +           const _Compare& __comp,
   1.412 +           const allocator_type& __a = allocator_type())
   1.413 +    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {
   1.414 +    _M_t.insert_equal(cast_traits::to_storage_type_cptr(__first),
   1.415 +                      cast_traits::to_storage_type_cptr(__last));
   1.416 +  }
   1.417 +
   1.418 +  multiset(const_iterator __first, const_iterator __last)
   1.419 +    : _M_t(_Compare(), _StorageTypeAlloc())
   1.420 +  { _M_t.insert_equal(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
   1.421 +
   1.422 +  multiset(const_iterator __first, const_iterator __last,
   1.423 +           const _Compare& __comp,
   1.424 +           const allocator_type& __a = allocator_type())
   1.425 +    : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType))
   1.426 +  { _M_t.insert_equal(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
   1.427 +#endif /* _STLP_MEMBER_TEMPLATES */
   1.428 +
   1.429 +  multiset(const _Self& __x)
   1.430 +    : _M_t(__x._M_t) {}
   1.431 +
   1.432 +  _Self& operator=(const _Self& __x) {
   1.433 +    _M_t = __x._M_t;
   1.434 +    return *this;
   1.435 +  }
   1.436 +
   1.437 +  multiset(__move_source<_Self> src)
   1.438 +    : _M_t(__move_source<_Rep_type>(src.get()._M_t)) {}
   1.439 +
   1.440 +  // accessors:
   1.441 +  key_compare key_comp() const { return _M_t.key_comp(); }
   1.442 +  value_compare value_comp() const { return _M_t.key_comp(); }
   1.443 +  allocator_type get_allocator() const
   1.444 +  { return _STLP_CONVERT_ALLOCATOR(_M_t.get_allocator(), value_type); }
   1.445 +
   1.446 +  iterator begin() { return _S_to_value_ite(_M_t.begin()); }
   1.447 +  iterator end() { return _S_to_value_ite(_M_t.end()); }
   1.448 +  const_iterator begin() const { return _S_to_value_ite(_M_t.begin()); }
   1.449 +  const_iterator end() const { return _S_to_value_ite(_M_t.end()); }
   1.450 +  reverse_iterator rbegin() { return reverse_iterator(end()); }
   1.451 +  reverse_iterator rend() { return reverse_iterator(begin()); }
   1.452 +  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
   1.453 +  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
   1.454 +  bool empty() const { return _M_t.empty(); }
   1.455 +  size_type size() const { return _M_t.size(); }
   1.456 +  size_type max_size() const { return _M_t.max_size(); }
   1.457 +  void swap(_Self& __x) { _M_t.swap(__x._M_t); }
   1.458 +
   1.459 +  // insert/erase
   1.460 +  iterator insert(const value_type& __x)
   1.461 +  { return _S_to_value_ite(_M_t.insert_equal(cast_traits::to_storage_type_cref(__x))); }
   1.462 +  iterator insert(iterator __pos, const value_type& __x) {
   1.463 +    return _S_to_value_ite(_M_t.insert_equal(_S_to_storage_ite(__pos),
   1.464 +                                             cast_traits::to_storage_type_cref(__x)));
   1.465 +  }
   1.466 +
   1.467 +#if defined (_STLP_MEMBER_TEMPLATES)
   1.468 +  template <class _InputIterator>
   1.469 +  void insert(_InputIterator __first, _InputIterator __last) {
   1.470 +#  if defined (_STLP_USE_ITERATOR_WRAPPER)
   1.471 +    _M_t.insert_equal(typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
   1.472 +                      typename _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
   1.473 +#  else
   1.474 +    _M_t.insert_equal(__first, __last);
   1.475 +#  endif
   1.476 +  }
   1.477 +#else
   1.478 +  void insert(const value_type* __first, const value_type* __last) {
   1.479 +    _M_t.insert_equal(cast_traits::to_storage_type_cptr(__first),
   1.480 +                      cast_traits::to_storage_type_cptr(__last));
   1.481 +  }
   1.482 +  void insert(const_iterator __first, const_iterator __last)
   1.483 +  { _M_t.insert_equal(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
   1.484 +#endif /* _STLP_MEMBER_TEMPLATES */
   1.485 +
   1.486 +  void erase(iterator __pos)
   1.487 +  { _M_t.erase(_S_to_storage_ite(__pos)); }
   1.488 +  size_type erase(const key_type& __x)
   1.489 +  { return _M_t.erase(cast_traits::to_storage_type_cref(__x)); }
   1.490 +  void erase(iterator __first, iterator __last)
   1.491 +  { _M_t.erase(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
   1.492 +  void clear() { _M_t.clear(); }
   1.493 +
   1.494 +  // multiset operations:
   1.495 +
   1.496 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.497 +  iterator find(const _KT& __x)
   1.498 +  { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); }
   1.499 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.500 +  const_iterator find(const _KT& __x) const
   1.501 +  { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); }
   1.502 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.503 +  size_type count(const _KT& __x) const
   1.504 +  { return _M_t.count(cast_traits::to_storage_type_crefT(__x)); }
   1.505 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.506 +  iterator lower_bound(const _KT& __x)
   1.507 +  { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); }
   1.508 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.509 +  const_iterator lower_bound(const _KT& __x) const
   1.510 +  { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); }
   1.511 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.512 +  iterator upper_bound(const _KT& __x)
   1.513 +  { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); }
   1.514 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.515 +  const_iterator upper_bound(const _KT& __x) const
   1.516 +  { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); }
   1.517 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.518 +  pair<iterator, iterator> equal_range(const _KT& __x) {
   1.519 +    pair<base_iterator, base_iterator> __ret;
   1.520 +    __ret = _M_t.equal_range(cast_traits::to_storage_type_crefT(__x));
   1.521 +    return pair<iterator, iterator>(_S_to_value_ite(__ret.first),
   1.522 +                                    _S_to_value_ite(__ret.second));
   1.523 +  }
   1.524 +  _STLP_TEMPLATE_FOR_CONT_EXT
   1.525 +  pair<const_iterator, const_iterator> equal_range(const _KT& __x) const {
   1.526 +    pair<const_base_iterator, const_base_iterator> __ret;
   1.527 +    __ret = _M_t.equal_range(cast_traits::to_storage_type_crefT(__x));
   1.528 +    return pair<const_iterator, const_iterator>(_S_to_value_ite(__ret.first),
   1.529 +                                                _S_to_value_ite(__ret.second));
   1.530 +  }
   1.531 +};
   1.532 +
   1.533 +_STLP_END_NAMESPACE
   1.534 +
   1.535 +#endif /* _STLP_PTR_SPECIALIZED_SET_H */
   1.536 +
   1.537 +// Local Variables:
   1.538 +// mode:C++
   1.539 +// End: