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
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00062 #ifndef __SGI_STL_INTERNAL_HASH_SET_H
00063 #define __SGI_STL_INTERNAL_HASH_SET_H
00064
00065 #include <ext/stl_hashtable.h>
00066 #include <bits/concept_check.h>
00067
00068 namespace __gnu_cxx
00069 {
00070 using std::equal_to;
00071 using std::allocator;
00072 using std::pair;
00073 using std::_Identity;
00074
00075
00076
00077 template <class _Value,
00078 class _HashFcn = hash<_Value>,
00079 class _EqualKey = equal_to<_Value>,
00080 class _Alloc = allocator<_Value> >
00081 class hash_set;
00082
00083 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
00084 inline bool
00085 operator==(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1,
00086 const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2);
00087
00088 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
00089 class hash_set
00090 {
00091
00092 __glibcpp_class_requires(_Value, _SGIAssignableConcept)
00093 __glibcpp_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept);
00094 __glibcpp_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept);
00095
00096 private:
00097 typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>,
00098 _EqualKey, _Alloc> _Ht;
00099 _Ht _M_ht;
00100
00101 public:
00102 typedef typename _Ht::key_type key_type;
00103 typedef typename _Ht::value_type value_type;
00104 typedef typename _Ht::hasher hasher;
00105 typedef typename _Ht::key_equal key_equal;
00106
00107 typedef typename _Ht::size_type size_type;
00108 typedef typename _Ht::difference_type difference_type;
00109 typedef typename _Ht::const_pointer pointer;
00110 typedef typename _Ht::const_pointer const_pointer;
00111 typedef typename _Ht::const_reference reference;
00112 typedef typename _Ht::const_reference const_reference;
00113
00114 typedef typename _Ht::const_iterator iterator;
00115 typedef typename _Ht::const_iterator const_iterator;
00116
00117 typedef typename _Ht::allocator_type allocator_type;
00118
00119 hasher hash_funct() const { return _M_ht.hash_funct(); }
00120 key_equal key_eq() const { return _M_ht.key_eq(); }
00121 allocator_type get_allocator() const { return _M_ht.get_allocator(); }
00122
00123 public:
00124 hash_set()
00125 : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
00126 explicit hash_set(size_type __n)
00127 : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
00128 hash_set(size_type __n, const hasher& __hf)
00129 : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
00130 hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
00131 const allocator_type& __a = allocator_type())
00132 : _M_ht(__n, __hf, __eql, __a) {}
00133
00134 template <class _InputIterator>
00135 hash_set(_InputIterator __f, _InputIterator __l)
00136 : _M_ht(100, hasher(), key_equal(), allocator_type())
00137 { _M_ht.insert_unique(__f, __l); }
00138 template <class _InputIterator>
00139 hash_set(_InputIterator __f, _InputIterator __l, size_type __n)
00140 : _M_ht(__n, hasher(), key_equal(), allocator_type())
00141 { _M_ht.insert_unique(__f, __l); }
00142 template <class _InputIterator>
00143 hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
00144 const hasher& __hf)
00145 : _M_ht(__n, __hf, key_equal(), allocator_type())
00146 { _M_ht.insert_unique(__f, __l); }
00147 template <class _InputIterator>
00148 hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
00149 const hasher& __hf, const key_equal& __eql,
00150 const allocator_type& __a = allocator_type())
00151 : _M_ht(__n, __hf, __eql, __a)
00152 { _M_ht.insert_unique(__f, __l); }
00153
00154 public:
00155 size_type size() const { return _M_ht.size(); }
00156 size_type max_size() const { return _M_ht.max_size(); }
00157 bool empty() const { return _M_ht.empty(); }
00158 void swap(hash_set& __hs) { _M_ht.swap(__hs._M_ht); }
00159
00160 template <class _Val, class _HF, class _EqK, class _Al>
00161 friend bool operator== (const hash_set<_Val, _HF, _EqK, _Al>&,
00162 const hash_set<_Val, _HF, _EqK, _Al>&);
00163
00164 iterator begin() const { return _M_ht.begin(); }
00165 iterator end() const { return _M_ht.end(); }
00166
00167 public:
00168 pair<iterator, bool> insert(const value_type& __obj)
00169 {
00170 pair<typename _Ht::iterator, bool> __p = _M_ht.insert_unique(__obj);
00171 return pair<iterator,bool>(__p.first, __p.second);
00172 }
00173 template <class _InputIterator>
00174 void insert(_InputIterator __f, _InputIterator __l)
00175 { _M_ht.insert_unique(__f,__l); }
00176 pair<iterator, bool> insert_noresize(const value_type& __obj)
00177 {
00178 pair<typename _Ht::iterator, bool> __p =
00179 _M_ht.insert_unique_noresize(__obj);
00180 return pair<iterator, bool>(__p.first, __p.second);
00181 }
00182
00183 iterator find(const key_type& __key) const { return _M_ht.find(__key); }
00184
00185 size_type count(const key_type& __key) const { return _M_ht.count(__key); }
00186
00187 pair<iterator, iterator> equal_range(const key_type& __key) const
00188 { return _M_ht.equal_range(__key); }
00189
00190 size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
00191 void erase(iterator __it) { _M_ht.erase(__it); }
00192 void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
00193 void clear() { _M_ht.clear(); }
00194
00195 public:
00196 void resize(size_type __hint) { _M_ht.resize(__hint); }
00197 size_type bucket_count() const { return _M_ht.bucket_count(); }
00198 size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
00199 size_type elems_in_bucket(size_type __n) const
00200 { return _M_ht.elems_in_bucket(__n); }
00201 };
00202
00203 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
00204 inline bool
00205 operator==(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1,
00206 const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2)
00207 {
00208 return __hs1._M_ht == __hs2._M_ht;
00209 }
00210
00211 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
00212 inline bool
00213 operator!=(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1,
00214 const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2) {
00215 return !(__hs1 == __hs2);
00216 }
00217
00218 template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
00219 inline void
00220 swap(hash_set<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
00221 hash_set<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2)
00222 {
00223 __hs1.swap(__hs2);
00224 }
00225
00226
00227 template <class _Value,
00228 class _HashFcn = hash<_Value>,
00229 class _EqualKey = equal_to<_Value>,
00230 class _Alloc = allocator<_Value> >
00231 class hash_multiset;
00232
00233 template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
00234 inline bool
00235 operator==(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
00236 const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2);
00237
00238
00239 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
00240 class hash_multiset
00241 {
00242
00243 __glibcpp_class_requires(_Value, _SGIAssignableConcept)
00244 __glibcpp_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept);
00245 __glibcpp_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept);
00246
00247 private:
00248 typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>,
00249 _EqualKey, _Alloc> _Ht;
00250 _Ht _M_ht;
00251
00252 public:
00253 typedef typename _Ht::key_type key_type;
00254 typedef typename _Ht::value_type value_type;
00255 typedef typename _Ht::hasher hasher;
00256 typedef typename _Ht::key_equal key_equal;
00257
00258 typedef typename _Ht::size_type size_type;
00259 typedef typename _Ht::difference_type difference_type;
00260 typedef typename _Ht::const_pointer pointer;
00261 typedef typename _Ht::const_pointer const_pointer;
00262 typedef typename _Ht::const_reference reference;
00263 typedef typename _Ht::const_reference const_reference;
00264
00265 typedef typename _Ht::const_iterator iterator;
00266 typedef typename _Ht::const_iterator const_iterator;
00267
00268 typedef typename _Ht::allocator_type allocator_type;
00269
00270 hasher hash_funct() const { return _M_ht.hash_funct(); }
00271 key_equal key_eq() const { return _M_ht.key_eq(); }
00272 allocator_type get_allocator() const { return _M_ht.get_allocator(); }
00273
00274 public:
00275 hash_multiset()
00276 : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
00277 explicit hash_multiset(size_type __n)
00278 : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
00279 hash_multiset(size_type __n, const hasher& __hf)
00280 : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
00281 hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
00282 const allocator_type& __a = allocator_type())
00283 : _M_ht(__n, __hf, __eql, __a) {}
00284
00285 template <class _InputIterator>
00286 hash_multiset(_InputIterator __f, _InputIterator __l)
00287 : _M_ht(100, hasher(), key_equal(), allocator_type())
00288 { _M_ht.insert_equal(__f, __l); }
00289 template <class _InputIterator>
00290 hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n)
00291 : _M_ht(__n, hasher(), key_equal(), allocator_type())
00292 { _M_ht.insert_equal(__f, __l); }
00293 template <class _InputIterator>
00294 hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
00295 const hasher& __hf)
00296 : _M_ht(__n, __hf, key_equal(), allocator_type())
00297 { _M_ht.insert_equal(__f, __l); }
00298 template <class _InputIterator>
00299 hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
00300 const hasher& __hf, const key_equal& __eql,
00301 const allocator_type& __a = allocator_type())
00302 : _M_ht(__n, __hf, __eql, __a)
00303 { _M_ht.insert_equal(__f, __l); }
00304
00305 public:
00306 size_type size() const { return _M_ht.size(); }
00307 size_type max_size() const { return _M_ht.max_size(); }
00308 bool empty() const { return _M_ht.empty(); }
00309 void swap(hash_multiset& hs) { _M_ht.swap(hs._M_ht); }
00310
00311 template <class _Val, class _HF, class _EqK, class _Al>
00312 friend bool operator== (const hash_multiset<_Val, _HF, _EqK, _Al>&,
00313 const hash_multiset<_Val, _HF, _EqK, _Al>&);
00314
00315 iterator begin() const { return _M_ht.begin(); }
00316 iterator end() const { return _M_ht.end(); }
00317
00318 public:
00319 iterator insert(const value_type& __obj)
00320 { return _M_ht.insert_equal(__obj); }
00321 template <class _InputIterator>
00322 void insert(_InputIterator __f, _InputIterator __l)
00323 { _M_ht.insert_equal(__f,__l); }
00324 iterator insert_noresize(const value_type& __obj)
00325 { return _M_ht.insert_equal_noresize(__obj); }
00326
00327 iterator find(const key_type& __key) const { return _M_ht.find(__key); }
00328
00329 size_type count(const key_type& __key) const { return _M_ht.count(__key); }
00330
00331 pair<iterator, iterator> equal_range(const key_type& __key) const
00332 { return _M_ht.equal_range(__key); }
00333
00334 size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
00335 void erase(iterator __it) { _M_ht.erase(__it); }
00336 void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
00337 void clear() { _M_ht.clear(); }
00338
00339 public:
00340 void resize(size_type __hint) { _M_ht.resize(__hint); }
00341 size_type bucket_count() const { return _M_ht.bucket_count(); }
00342 size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
00343 size_type elems_in_bucket(size_type __n) const
00344 { return _M_ht.elems_in_bucket(__n); }
00345 };
00346
00347 template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
00348 inline bool
00349 operator==(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
00350 const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2)
00351 {
00352 return __hs1._M_ht == __hs2._M_ht;
00353 }
00354
00355 template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
00356 inline bool
00357 operator!=(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
00358 const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2) {
00359 return !(__hs1 == __hs2);
00360 }
00361
00362 template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
00363 inline void
00364 swap(hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
00365 hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2) {
00366 __hs1.swap(__hs2);
00367 }
00368
00369 }
00370
00371 namespace std
00372 {
00373
00374
00375
00376 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
00377 class insert_iterator<__gnu_cxx::hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > {
00378 protected:
00379 typedef __gnu_cxx::hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
00380 _Container* container;
00381 public:
00382 typedef _Container container_type;
00383 typedef output_iterator_tag iterator_category;
00384 typedef void value_type;
00385 typedef void difference_type;
00386 typedef void pointer;
00387 typedef void reference;
00388
00389 insert_iterator(_Container& __x) : container(&__x) {}
00390 insert_iterator(_Container& __x, typename _Container::iterator)
00391 : container(&__x) {}
00392 insert_iterator<_Container>&
00393 operator=(const typename _Container::value_type& __value) {
00394 container->insert(__value);
00395 return *this;
00396 }
00397 insert_iterator<_Container>& operator*() { return *this; }
00398 insert_iterator<_Container>& operator++() { return *this; }
00399 insert_iterator<_Container>& operator++(int) { return *this; }
00400 };
00401
00402 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
00403 class insert_iterator<__gnu_cxx::hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > {
00404 protected:
00405 typedef __gnu_cxx::hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
00406 _Container* container;
00407 typename _Container::iterator iter;
00408 public:
00409 typedef _Container container_type;
00410 typedef output_iterator_tag iterator_category;
00411 typedef void value_type;
00412 typedef void difference_type;
00413 typedef void pointer;
00414 typedef void reference;
00415
00416 insert_iterator(_Container& __x) : container(&__x) {}
00417 insert_iterator(_Container& __x, typename _Container::iterator)
00418 : container(&__x) {}
00419 insert_iterator<_Container>&
00420 operator=(const typename _Container::value_type& __value) {
00421 container->insert(__value);
00422 return *this;
00423 }
00424 insert_iterator<_Container>& operator*() { return *this; }
00425 insert_iterator<_Container>& operator++() { return *this; }
00426 insert_iterator<_Container>& operator++(int) { return *this; }
00427 };
00428
00429 }
00430
00431 #endif
00432
00433
00434
00435