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