Line data Source code
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 0 : {
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 0 : __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 0 : std::_Identity<_Value>(), __a)
71 0 : { }
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 0 : {
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 0 : 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 0 : : _Base(__n, __hf, __eql, __a)
199 0 : { }
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 : }
|
