1 // TR1 unordered_set -*- C++ -*- 2 3 // Copyright (C) 2007, 2009 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** @file tr1_impl/unordered_set 26 * This is an internal header file, included by other library headers. 27 * You should not attempt to use it directly. 28 */ 29 30 namespace std 31 { 32 _GLIBCXX_BEGIN_NAMESPACE_TR1 33 34 // XXX When we get typedef templates these class definitions 35 // will be unnecessary. 36 template<class _Value, 37 class _Hash = hash<_Value>, 38 class _Pred = std::equal_to<_Value>, 39 class _Alloc = std::allocator<_Value>, 40 bool __cache_hash_code = false> 41 class __unordered_set 42 : public _Hashtable<_Value, _Value, _Alloc, 43 std::_Identity<_Value>, _Pred, 44 _Hash, __detail::_Mod_range_hashing, 45 __detail::_Default_ranged_hash, 46 __detail::_Prime_rehash_policy, 47 __cache_hash_code, true, true> 48 { 49 typedef _Hashtable<_Value, _Value, _Alloc, 50 std::_Identity<_Value>, _Pred, 51 _Hash, __detail::_Mod_range_hashing, 52 __detail::_Default_ranged_hash, 53 __detail::_Prime_rehash_policy, 54 __cache_hash_code, true, true> 55 _Base; 56 57 public: 58 typedef typename _Base::size_type size_type; 59 typedef typename _Base::hasher hasher; 60 typedef typename _Base::key_equal key_equal; 61 typedef typename _Base::allocator_type allocator_type; 62 63 explicit 64 __unordered_set(size_type __n = 10, 65 const hasher& __hf = hasher(), 66 const key_equal& __eql = key_equal(), 67 const allocator_type& __a = allocator_type()) 68 : _Base(__n, __hf, __detail::_Mod_range_hashing(), 69 __detail::_Default_ranged_hash(), __eql, 70 std::_Identity<_Value>(), __a) 71 { } 72 73 template<typename _InputIterator> 74 __unordered_set(_InputIterator __f, _InputIterator __l, 75 size_type __n = 10, 76 const hasher& __hf = hasher(), 77 const key_equal& __eql = key_equal(), 78 const allocator_type& __a = allocator_type()) 79 : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(), 80 __detail::_Default_ranged_hash(), __eql, 81 std::_Identity<_Value>(), __a) 82 { } 83 84 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X 85 __unordered_set(__unordered_set&& __x) 86 : _Base(std::forward<_Base>(__x)) { } 87 #endif 88 }; 89 90 template<class _Value, 91 class _Hash = hash<_Value>, 92 class _Pred = std::equal_to<_Value>, 93 class _Alloc = std::allocator<_Value>, 94 bool __cache_hash_code = false> 95 class __unordered_multiset 96 : public _Hashtable<_Value, _Value, _Alloc, 97 std::_Identity<_Value>, _Pred, 98 _Hash, __detail::_Mod_range_hashing, 99 __detail::_Default_ranged_hash, 100 __detail::_Prime_rehash_policy, 101 __cache_hash_code, true, false> 102 { 103 typedef _Hashtable<_Value, _Value, _Alloc, 104 std::_Identity<_Value>, _Pred, 105 _Hash, __detail::_Mod_range_hashing, 106 __detail::_Default_ranged_hash, 107 __detail::_Prime_rehash_policy, 108 __cache_hash_code, true, false> 109 _Base; 110 111 public: 112 typedef typename _Base::size_type size_type; 113 typedef typename _Base::hasher hasher; 114 typedef typename _Base::key_equal key_equal; 115 typedef typename _Base::allocator_type allocator_type; 116 117 explicit 118 __unordered_multiset(size_type __n = 10, 119 const hasher& __hf = hasher(), 120 const key_equal& __eql = key_equal(), 121 const allocator_type& __a = allocator_type()) 122 : _Base(__n, __hf, __detail::_Mod_range_hashing(), 123 __detail::_Default_ranged_hash(), __eql, 124 std::_Identity<_Value>(), __a) 125 { } 126 127 128 template<typename _InputIterator> 129 __unordered_multiset(_InputIterator __f, _InputIterator __l, 130 typename _Base::size_type __n = 0, 131 const hasher& __hf = hasher(), 132 const key_equal& __eql = key_equal(), 133 const allocator_type& __a = allocator_type()) 134 : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(), 135 __detail::_Default_ranged_hash(), __eql, 136 std::_Identity<_Value>(), __a) 137 { } 138 139 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X 140 __unordered_multiset(__unordered_multiset&& __x) 141 : _Base(std::forward<_Base>(__x)) { } 142 #endif 143 }; 144 145 template<class _Value, class _Hash, class _Pred, class _Alloc, 146 bool __cache_hash_code> 147 inline void 148 swap(__unordered_set<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __x, 149 __unordered_set<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __y) 150 { __x.swap(__y); } 151 152 template<class _Value, class _Hash, class _Pred, class _Alloc, 153 bool __cache_hash_code> 154 inline void 155 swap(__unordered_multiset<_Value, _Hash, _Pred, 156 _Alloc, __cache_hash_code>& __x, 157 __unordered_multiset<_Value, _Hash, _Pred, 158 _Alloc, __cache_hash_code>& __y) 159 { __x.swap(__y); } 160 161 162 /** 163 * @brief A standard container composed of unique keys (containing 164 * at most one of each key value) in which the elements' keys are 165 * the elements themselves. 166 * 167 * @ingroup unordered_associative_containers 168 * 169 * Meets the requirements of a <a href="tables.html#65">container</a>, and 170 * <a href="tables.html#xx">unordered associative container</a> 171 * 172 * @param Value Type of key objects. 173 * @param Hash Hashing function object type, defaults to hash<Value>. 174 * @param Pred Predicate function object type, defaults to equal_to<Value>. 175 * @param Alloc Allocator type, defaults to allocator<Key>. 176 */ 177 template<class _Value, 178 class _Hash = hash<_Value>, 179 class _Pred = std::equal_to<_Value>, 180 class _Alloc = std::allocator<_Value> > 181 class unordered_set 182 : public __unordered_set<_Value, _Hash, _Pred, _Alloc> 183 { 184 typedef __unordered_set<_Value, _Hash, _Pred, _Alloc> _Base; 185 186 public: 187 typedef typename _Base::value_type value_type; 188 typedef typename _Base::size_type size_type; 189 typedef typename _Base::hasher hasher; 190 typedef typename _Base::key_equal key_equal; 191 typedef typename _Base::allocator_type allocator_type; 192 193 explicit 194 unordered_set(size_type __n = 10, 195 const hasher& __hf = hasher(), 196 const key_equal& __eql = key_equal(), 197 const allocator_type& __a = allocator_type()) 198 : _Base(__n, __hf, __eql, __a) 199 { } 200 201 template<typename _InputIterator> 202 unordered_set(_InputIterator __f, _InputIterator __l, 203 size_type __n = 10, 204 const hasher& __hf = hasher(), 205 const key_equal& __eql = key_equal(), 206 const allocator_type& __a = allocator_type()) 207 : _Base(__f, __l, __n, __hf, __eql, __a) 208 { } 209 210 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X 211 unordered_set(unordered_set&& __x) 212 : _Base(std::forward<_Base>(__x)) { } 213 214 unordered_set(initializer_list<value_type> __l, 215 size_type __n = 10, 216 const hasher& __hf = hasher(), 217 const key_equal& __eql = key_equal(), 218 const allocator_type& __a = allocator_type()) 219 : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a) 220 { } 221 222 unordered_set& 223 operator=(unordered_set&& __x) 224 { 225 // NB: DR 675. 226 this->clear(); 227 this->swap(__x); 228 return *this; 229 } 230 231 unordered_set& 232 operator=(initializer_list<value_type> __l) 233 { 234 this->clear(); 235 this->insert(__l.begin(), __l.end()); 236 return *this; 237 } 238 #endif 239 }; 240 241 /** 242 * @brief A standard container composed of equivalent keys 243 * (possibly containing multiple of each key value) in which the 244 * elements' keys are the elements themselves. 245 * 246 * @ingroup unordered_associative_containers 247 * 248 * Meets the requirements of a <a href="tables.html#65">container</a>, and 249 * <a href="tables.html#xx">unordered associative container</a> 250 * 251 * @param Value Type of key objects. 252 * @param Hash Hashing function object type, defaults to hash<Value>. 253 * @param Pred Predicate function object type, defaults to equal_to<Value>. 254 * @param Alloc Allocator type, defaults to allocator<Key>. 255 */ 256 template<class _Value, 257 class _Hash = hash<_Value>, 258 class _Pred = std::equal_to<_Value>, 259 class _Alloc = std::allocator<_Value> > 260 class unordered_multiset 261 : public __unordered_multiset<_Value, _Hash, _Pred, _Alloc> 262 { 263 typedef __unordered_multiset<_Value, _Hash, _Pred, _Alloc> _Base; 264 265 public: 266 typedef typename _Base::value_type value_type; 267 typedef typename _Base::size_type size_type; 268 typedef typename _Base::hasher hasher; 269 typedef typename _Base::key_equal key_equal; 270 typedef typename _Base::allocator_type allocator_type; 271 272 explicit 273 unordered_multiset(size_type __n = 10, 274 const hasher& __hf = hasher(), 275 const key_equal& __eql = key_equal(), 276 const allocator_type& __a = allocator_type()) 277 : _Base(__n, __hf, __eql, __a) 278 { } 279 280 281 template<typename _InputIterator> 282 unordered_multiset(_InputIterator __f, _InputIterator __l, 283 typename _Base::size_type __n = 0, 284 const hasher& __hf = hasher(), 285 const key_equal& __eql = key_equal(), 286 const allocator_type& __a = allocator_type()) 287 : _Base(__f, __l, __n, __hf, __eql, __a) 288 { } 289 290 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X 291 unordered_multiset(unordered_multiset&& __x) 292 : _Base(std::forward<_Base>(__x)) { } 293 294 unordered_multiset(initializer_list<value_type> __l, 295 size_type __n = 10, 296 const hasher& __hf = hasher(), 297 const key_equal& __eql = key_equal(), 298 const allocator_type& __a = allocator_type()) 299 : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a) 300 { } 301 302 unordered_multiset& 303 operator=(unordered_multiset&& __x) 304 { 305 // NB: DR 675. 306 this->clear(); 307 this->swap(__x); 308 return *this; 309 } 310 311 unordered_multiset& 312 operator=(initializer_list<value_type> __l) 313 { 314 this->clear(); 315 this->insert(__l.begin(), __l.end()); 316 return *this; 317 } 318 #endif 319 }; 320 321 template<class _Value, class _Hash, class _Pred, class _Alloc> 322 inline void 323 swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, 324 unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) 325 { __x.swap(__y); } 326 327 template<class _Value, class _Hash, class _Pred, class _Alloc> 328 inline void 329 swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, 330 unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) 331 { __x.swap(__y); } 332 333 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X 334 template<class _Value, class _Hash, class _Pred, class _Alloc> 335 inline void 336 swap(unordered_set<_Value, _Hash, _Pred, _Alloc>&& __x, 337 unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) 338 { __x.swap(__y); } 339 340 template<class _Value, class _Hash, class _Pred, class _Alloc> 341 inline void 342 swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, 343 unordered_set<_Value, _Hash, _Pred, _Alloc>&& __y) 344 { __x.swap(__y); } 345 346 template<class _Value, class _Hash, class _Pred, class _Alloc> 347 inline void 348 swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>&& __x, 349 unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) 350 { __x.swap(__y); } 351 352 template<class _Value, class _Hash, class _Pred, class _Alloc> 353 inline void 354 swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, 355 unordered_multiset<_Value, _Hash, _Pred, _Alloc>&& __y) 356 { __x.swap(__y); } 357 #endif 358 359 _GLIBCXX_END_NAMESPACE_TR1 360 } 361
