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 #ifndef _GLIBCXX_DEBUG_HASH_MULTISET_H
00032 #define _GLIBCXX_DEBUG_HASH_MULTISET_H 1
00033
00034 #include <debug/safe_sequence.h>
00035 #include <debug/safe_iterator.h>
00036
00037 namespace __gnu_debug_def
00038 {
00039 template<typename _Value,
00040 typename _HashFcn = __gnu_cxx::hash<_Value>,
00041 typename _EqualKey = std::equal_to<_Value>,
00042 typename _Alloc = std::allocator<_Value> >
00043 class hash_multiset
00044 : public __gnu_cxx::hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>,
00045 public __gnu_debug::_Safe_sequence<hash_multiset<_Value, _HashFcn,
00046 _EqualKey, _Alloc> >
00047 {
00048 typedef __gnu_cxx:: hash_multiset<_Value,_HashFcn, _EqualKey,_Alloc>
00049 _Base;
00050 typedef __gnu_debug::_Safe_sequence<hash_multiset> _Safe_base;
00051
00052 public:
00053 typedef typename _Base::key_type key_type;
00054 typedef typename _Base::value_type value_type;
00055 typedef typename _Base::hasher hasher;
00056 typedef typename _Base::key_equal key_equal;
00057 typedef typename _Base::size_type size_type;
00058 typedef typename _Base::difference_type difference_type;
00059 typedef typename _Base::pointer pointer;
00060 typedef typename _Base::const_pointer const_pointer;
00061 typedef typename _Base::reference reference;
00062 typedef typename _Base::const_reference const_reference;
00063
00064 typedef __gnu_debug::_Safe_iterator<typename _Base::iterator,
00065 hash_multiset> iterator;
00066 typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator,
00067 hash_multiset> const_iterator;
00068
00069 typedef typename _Base::allocator_type allocator_type;
00070
00071 using _Base::hash_funct;
00072 using _Base::key_eq;
00073 using _Base::get_allocator;
00074
00075 hash_multiset() { }
00076
00077 explicit hash_multiset(size_type __n) : _Base(__n) { }
00078
00079 hash_multiset(size_type __n, const hasher& __hf) : _Base(__n, __hf) { }
00080
00081 hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
00082 const allocator_type& __a = allocator_type())
00083 : _Base(__n, __hf, __eql, __a)
00084 { }
00085
00086 template<typename _InputIterator>
00087 hash_multiset(_InputIterator __f, _InputIterator __l)
00088 : _Base(__gnu_debug::__check_valid_range(__f, __l), __l)
00089 { }
00090
00091 template<typename _InputIterator>
00092 hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n)
00093 : _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n)
00094 { }
00095
00096 template<typename _InputIterator>
00097 hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
00098 const hasher& __hf)
00099 : _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, __hf)
00100 { }
00101
00102 template<typename _InputIterator>
00103 hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
00104 const hasher& __hf, const key_equal& __eql,
00105 const allocator_type& __a = allocator_type())
00106 : _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n, __hf,
00107 __eql, __a)
00108 { }
00109
00110 hash_multiset(const _Base& __x) : _Base(__x), _Safe_base() { }
00111
00112 using _Base::size;
00113 using _Base::max_size;
00114 using _Base::empty;
00115
00116 void
00117 swap(hash_multiset& __x)
00118 {
00119 _Base::swap(__x);
00120 this->_M_swap(__x);
00121 }
00122
00123 iterator begin() const { return iterator(_Base::begin(), this); }
00124 iterator end() const { return iterator(_Base::end(), this); }
00125
00126 iterator
00127 insert(const value_type& __obj)
00128 { return iterator(_Base::insert(__obj), this); }
00129
00130 template <typename _InputIterator>
00131 void
00132 insert(_InputIterator __first, _InputIterator __last)
00133 {
00134 __glibcxx_check_valid_range(__first, __last);
00135 _Base::insert(__first.base(), __last.base());
00136 }
00137
00138
00139 iterator
00140 insert_noresize(const value_type& __obj)
00141 { return iterator(_Base::insert_noresize(__obj), this); }
00142
00143 iterator
00144 find(const key_type& __key) const
00145 { return iterator(_Base::find(__key), this); }
00146
00147 using _Base::count;
00148
00149 std::pair<iterator, iterator>
00150 equal_range(const key_type& __key) const
00151 {
00152 typedef typename _Base::iterator _Base_iterator;
00153 std::pair<_Base_iterator, _Base_iterator> __res =
00154 _Base::equal_range(__key);
00155 return std::make_pair(iterator(__res.first, this),
00156 iterator(__res.second, this));
00157 }
00158
00159 size_type
00160 erase(const key_type& __key)
00161 {
00162 size_type __count = 0;
00163 std::pair<iterator, iterator> __victims = this->equal_range(__key);
00164 while (__victims.first != __victims.second)
00165 {
00166 this->erase(__victims++);
00167 ++__count;
00168 }
00169 return __count;
00170 }
00171
00172 void
00173 erase(iterator __it)
00174 {
00175 __glibcxx_check_erase(__it);
00176 __it._M_invalidate();
00177 _Base::erase(__it.base());
00178 }
00179
00180 void
00181 erase(iterator __first, iterator __last)
00182 {
00183 __glibcxx_check_erase_range(__first, __last);
00184 for (iterator __tmp = __first; __tmp != __last;)
00185 {
00186 iterator __victim = __tmp++;
00187 __victim._M_invalidate();
00188 }
00189 _Base::erase(__first.base(), __last.base());
00190 }
00191
00192 void
00193 clear()
00194 {
00195 _Base::clear();
00196 this->_M_invalidate_all();
00197 }
00198
00199 using _Base::resize;
00200 using _Base::bucket_count;
00201 using _Base::max_bucket_count;
00202 using _Base::elems_in_bucket;
00203
00204 _Base& _M_base() { return *this; }
00205 const _Base& _M_base() const { return *this; }
00206
00207 private:
00208 void
00209 _M_invalidate_all()
00210 {
00211 typedef typename _Base::const_iterator _Base_const_iterator;
00212 typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
00213 this->_M_invalidate_if(_Not_equal(_M_base().end()));
00214 }
00215 };
00216
00217 template<typename _Value, typename _HashFcn, typename _EqualKey, typename _Alloc>
00218 inline bool
00219 operator==(const hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>& __x,
00220 const hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>& __y)
00221 { return __x._M_base() == __y._M_base(); }
00222
00223 template<typename _Value, typename _HashFcn, typename _EqualKey, typename _Alloc>
00224 inline bool
00225 operator!=(const hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>& __x,
00226 const hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>& __y)
00227 { return __x._M_base() != __y._M_base(); }
00228
00229 template<typename _Value, typename _HashFcn, typename _EqualKey, typename _Alloc>
00230 inline void
00231 swap(hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>& __x,
00232 hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>& __y)
00233 { __x.swap(__y); }
00234 }
00235
00236 #endif