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