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