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_MAP_H
00032 #define _GLIBCXX_DEBUG_MAP_H 1
00033
00034 #include <debug/safe_sequence.h>
00035 #include <debug/safe_iterator.h>
00036 #include <utility>
00037
00038 namespace __gnu_debug_def
00039 {
00040 template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
00041 typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
00042 class map
00043 : public _GLIBCXX_STD::map<_Key, _Tp, _Compare, _Allocator>,
00044 public __gnu_debug::_Safe_sequence<map<_Key, _Tp, _Compare, _Allocator> >
00045 {
00046 typedef _GLIBCXX_STD::map<_Key, _Tp, _Compare, _Allocator> _Base;
00047 typedef __gnu_debug::_Safe_sequence<map> _Safe_base;
00048
00049 public:
00050
00051 typedef _Key key_type;
00052 typedef _Tp mapped_type;
00053 typedef std::pair<const _Key, _Tp> value_type;
00054 typedef _Compare key_compare;
00055 typedef _Allocator allocator_type;
00056 typedef typename _Allocator::reference reference;
00057 typedef typename _Allocator::const_reference const_reference;
00058
00059 typedef __gnu_debug::_Safe_iterator<typename _Base::iterator, map>
00060 iterator;
00061 typedef __gnu_debug::_Safe_iterator<typename _Base::const_iterator, map>
00062 const_iterator;
00063
00064 typedef typename _Base::size_type size_type;
00065 typedef typename _Base::difference_type difference_type;
00066 typedef typename _Allocator::pointer pointer;
00067 typedef typename _Allocator::const_pointer const_pointer;
00068 typedef std::reverse_iterator<iterator> reverse_iterator;
00069 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00070
00071 using _Base::value_compare;
00072
00073
00074 explicit map(const _Compare& __comp = _Compare(),
00075 const _Allocator& __a = _Allocator())
00076 : _Base(__comp, __a) { }
00077
00078 template<typename _InputIterator>
00079 map(_InputIterator __first, _InputIterator __last,
00080 const _Compare& __comp = _Compare(),
00081 const _Allocator& __a = _Allocator())
00082 : _Base(__gnu_debug::__check_valid_range(__first, __last), __last,
00083 __comp, __a), _Safe_base() { }
00084
00085 map(const map<_Key,_Tp,_Compare,_Allocator>& __x)
00086 : _Base(__x), _Safe_base() { }
00087
00088 map(const _Base& __x) : _Base(__x), _Safe_base() { }
00089
00090 ~map() { }
00091
00092 map<_Key,_Tp,_Compare,_Allocator>&
00093 operator=(const map<_Key,_Tp,_Compare,_Allocator>& __x)
00094 {
00095 *static_cast<_Base*>(this) = __x;
00096 this->_M_invalidate_all();
00097 return *this;
00098 }
00099
00100
00101
00102 using _Base::get_allocator;
00103
00104
00105 iterator
00106 begin()
00107 { return iterator(_Base::begin(), this); }
00108
00109 const_iterator
00110 begin() const
00111 { return const_iterator(_Base::begin(), this); }
00112
00113 iterator
00114 end()
00115 { return iterator(_Base::end(), this); }
00116
00117 const_iterator
00118 end() const
00119 { return const_iterator(_Base::end(), this); }
00120
00121 reverse_iterator
00122 rbegin()
00123 { return reverse_iterator(end()); }
00124
00125 const_reverse_iterator
00126 rbegin() const
00127 { return const_reverse_iterator(end()); }
00128
00129 reverse_iterator
00130 rend()
00131 { return reverse_iterator(begin()); }
00132
00133 const_reverse_iterator
00134 rend() const
00135 { return const_reverse_iterator(begin()); }
00136
00137
00138 using _Base::empty;
00139 using _Base::size;
00140 using _Base::max_size;
00141
00142
00143 using _Base::operator[];
00144
00145
00146 std::pair<iterator, bool>
00147 insert(const value_type& __x)
00148 {
00149 typedef typename _Base::iterator _Base_iterator;
00150 std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
00151 return std::pair<iterator, bool>(iterator(__res.first, this),
00152 __res.second);
00153 }
00154
00155 iterator
00156 insert(iterator __position, const value_type& __x)
00157 {
00158 __glibcxx_check_insert(__position);
00159 return iterator(_Base::insert(__position.base(), __x), this);
00160 }
00161
00162 template<typename _InputIterator>
00163 void
00164 insert(_InputIterator __first, _InputIterator __last)
00165 {
00166 __glibcxx_check_valid_range(__first, __last);
00167 _Base::insert(__first, __last);
00168 }
00169
00170 void
00171 erase(iterator __position)
00172 {
00173 __glibcxx_check_erase(__position);
00174 __position._M_invalidate();
00175 _Base::erase(__position.base());
00176 }
00177
00178 size_type
00179 erase(const key_type& __x)
00180 {
00181 iterator __victim = find(__x);
00182 if (__victim == end())
00183 return 0;
00184 else
00185 {
00186 __victim._M_invalidate();
00187 _Base::erase(__victim.base());
00188 return 1;
00189 }
00190 }
00191
00192 void
00193 erase(iterator __first, iterator __last)
00194 {
00195
00196
00197 __glibcxx_check_erase_range(__first, __last);
00198 while (__first != __last)
00199 this->erase(__first++);
00200 }
00201
00202 void
00203 swap(map<_Key,_Tp,_Compare,_Allocator>& __x)
00204 {
00205 _Base::swap(__x);
00206 this->_M_swap(__x);
00207 }
00208
00209 void
00210 clear()
00211 { this->erase(begin(), end()); }
00212
00213
00214 using _Base::key_comp;
00215 using _Base::value_comp;
00216
00217
00218 iterator
00219 find(const key_type& __x)
00220 { return iterator(_Base::find(__x), this); }
00221
00222 const_iterator
00223 find(const key_type& __x) const
00224 { return const_iterator(_Base::find(__x), this); }
00225
00226 using _Base::count;
00227
00228 iterator
00229 lower_bound(const key_type& __x)
00230 { return iterator(_Base::lower_bound(__x), this); }
00231
00232 const_iterator
00233 lower_bound(const key_type& __x) const
00234 { return const_iterator(_Base::lower_bound(__x), this); }
00235
00236 iterator
00237 upper_bound(const key_type& __x)
00238 { return iterator(_Base::upper_bound(__x), this); }
00239
00240 const_iterator
00241 upper_bound(const key_type& __x) const
00242 { return const_iterator(_Base::upper_bound(__x), this); }
00243
00244 std::pair<iterator,iterator>
00245 equal_range(const key_type& __x)
00246 {
00247 typedef typename _Base::iterator _Base_iterator;
00248 std::pair<_Base_iterator, _Base_iterator> __res =
00249 _Base::equal_range(__x);
00250 return std::make_pair(iterator(__res.first, this),
00251 iterator(__res.second, this));
00252 }
00253
00254 std::pair<const_iterator,const_iterator>
00255 equal_range(const key_type& __x) const
00256 {
00257 typedef typename _Base::const_iterator _Base_const_iterator;
00258 std::pair<_Base_const_iterator, _Base_const_iterator> __res =
00259 _Base::equal_range(__x);
00260 return std::make_pair(const_iterator(__res.first, this),
00261 const_iterator(__res.second, this));
00262 }
00263
00264 _Base&
00265 _M_base() { return *this; }
00266
00267 const _Base&
00268 _M_base() const { return *this; }
00269
00270 private:
00271 void
00272 _M_invalidate_all()
00273 {
00274 typedef typename _Base::const_iterator _Base_const_iterator;
00275 typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
00276 this->_M_invalidate_if(_Not_equal(_M_base().end()));
00277 }
00278 };
00279
00280 template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
00281 inline bool
00282 operator==(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
00283 const map<_Key,_Tp,_Compare,_Allocator>& __rhs)
00284 { return __lhs._M_base() == __rhs._M_base(); }
00285
00286 template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
00287 inline bool
00288 operator!=(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
00289 const map<_Key,_Tp,_Compare,_Allocator>& __rhs)
00290 { return __lhs._M_base() != __rhs._M_base(); }
00291
00292 template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
00293 inline bool
00294 operator<(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
00295 const map<_Key,_Tp,_Compare,_Allocator>& __rhs)
00296 { return __lhs._M_base() < __rhs._M_base(); }
00297
00298 template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
00299 inline bool
00300 operator<=(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
00301 const map<_Key,_Tp,_Compare,_Allocator>& __rhs)
00302 { return __lhs._M_base() <= __rhs._M_base(); }
00303
00304 template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
00305 inline bool
00306 operator>=(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
00307 const map<_Key,_Tp,_Compare,_Allocator>& __rhs)
00308 { return __lhs._M_base() >= __rhs._M_base(); }
00309
00310 template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
00311 inline bool
00312 operator>(const map<_Key,_Tp,_Compare,_Allocator>& __lhs,
00313 const map<_Key,_Tp,_Compare,_Allocator>& __rhs)
00314 { return __lhs._M_base() > __rhs._M_base(); }
00315
00316 template<typename _Key,typename _Tp,typename _Compare,typename _Allocator>
00317 inline void
00318 swap(map<_Key,_Tp,_Compare,_Allocator>& __lhs,
00319 map<_Key,_Tp,_Compare,_Allocator>& __rhs)
00320 { __lhs.swap(__rhs); }
00321 }
00322
00323 #endif