libstdc++
tr1_impl/unordered_map
1 // TR1 unordered_map -*- 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_map
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 _Key, class _Tp,
37  class _Hash = hash<_Key>,
38  class _Pred = std::equal_to<_Key>,
39  class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
40  bool __cache_hash_code = false>
41  class __unordered_map
42  : public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
43  std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
44  _Hash, __detail::_Mod_range_hashing,
45  __detail::_Default_ranged_hash,
46  __detail::_Prime_rehash_policy,
47  __cache_hash_code, false, true>
48  {
49  typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
50  std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
51  _Hash, __detail::_Mod_range_hashing,
52  __detail::_Default_ranged_hash,
53  __detail::_Prime_rehash_policy,
54  __cache_hash_code, false, 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_map(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(),
70  __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
71  { }
72 
73  template<typename _InputIterator>
74  __unordered_map(_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(),
81  __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
82  { }
83 
84 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
85  __unordered_map(__unordered_map&& __x)
86  : _Base(std::forward<_Base>(__x)) { }
87 #endif
88  };
89 
90  template<class _Key, class _Tp,
91  class _Hash = hash<_Key>,
92  class _Pred = std::equal_to<_Key>,
93  class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
94  bool __cache_hash_code = false>
95  class __unordered_multimap
96  : public _Hashtable<_Key, std::pair<const _Key, _Tp>,
97  _Alloc,
98  std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
99  _Hash, __detail::_Mod_range_hashing,
100  __detail::_Default_ranged_hash,
101  __detail::_Prime_rehash_policy,
102  __cache_hash_code, false, false>
103  {
104  typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
105  _Alloc,
106  std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
107  _Hash, __detail::_Mod_range_hashing,
108  __detail::_Default_ranged_hash,
109  __detail::_Prime_rehash_policy,
110  __cache_hash_code, false, false>
111  _Base;
112 
113  public:
114  typedef typename _Base::size_type size_type;
115  typedef typename _Base::hasher hasher;
116  typedef typename _Base::key_equal key_equal;
117  typedef typename _Base::allocator_type allocator_type;
118 
119  explicit
120  __unordered_multimap(size_type __n = 10,
121  const hasher& __hf = hasher(),
122  const key_equal& __eql = key_equal(),
123  const allocator_type& __a = allocator_type())
124  : _Base(__n, __hf, __detail::_Mod_range_hashing(),
125  __detail::_Default_ranged_hash(),
126  __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
127  { }
128 
129 
130  template<typename _InputIterator>
131  __unordered_multimap(_InputIterator __f, _InputIterator __l,
132  typename _Base::size_type __n = 0,
133  const hasher& __hf = hasher(),
134  const key_equal& __eql = key_equal(),
135  const allocator_type& __a = allocator_type())
136  : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
137  __detail::_Default_ranged_hash(),
138  __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
139  { }
140 
141 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
142  __unordered_multimap(__unordered_multimap&& __x)
143  : _Base(std::forward<_Base>(__x)) { }
144 #endif
145  };
146 
147  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
148  bool __cache_hash_code>
149  inline void
150  swap(__unordered_map<_Key, _Tp, _Hash, _Pred,
151  _Alloc, __cache_hash_code>& __x,
152  __unordered_map<_Key, _Tp, _Hash, _Pred,
153  _Alloc, __cache_hash_code>& __y)
154  { __x.swap(__y); }
155 
156  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
157  bool __cache_hash_code>
158  inline void
159  swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred,
160  _Alloc, __cache_hash_code>& __x,
161  __unordered_multimap<_Key, _Tp, _Hash, _Pred,
162  _Alloc, __cache_hash_code>& __y)
163  { __x.swap(__y); }
164 
165 
166  /**
167  * @brief A standard container composed of unique keys (containing
168  * at most one of each key value) that associates values of another type
169  * with the keys.
170  *
171  * @ingroup unordered_associative_containers
172  *
173  * Meets the requirements of a <a href="tables.html#65">container</a>, and
174  * <a href="tables.html#xx">unordered associative container</a>
175  *
176  * @param Key Type of key objects.
177  * @param Tp Type of mapped objects.
178  * @param Hash Hashing function object type, defaults to hash<Value>.
179  * @param Pred Predicate function object type, defaults to equal_to<Value>.
180  * @param Alloc Allocator type, defaults to allocator<Key>.
181  *
182  * The resulting value type of the container is std::pair<const Key, Tp>.
183  */
184  template<class _Key, class _Tp,
185  class _Hash = hash<_Key>,
186  class _Pred = std::equal_to<_Key>,
187  class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
188  class unordered_map
189  : public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
190  {
191  typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc> _Base;
192 
193  public:
194  typedef typename _Base::value_type value_type;
195  typedef typename _Base::size_type size_type;
196  typedef typename _Base::hasher hasher;
197  typedef typename _Base::key_equal key_equal;
198  typedef typename _Base::allocator_type allocator_type;
199 
200  explicit
201  unordered_map(size_type __n = 10,
202  const hasher& __hf = hasher(),
203  const key_equal& __eql = key_equal(),
204  const allocator_type& __a = allocator_type())
205  : _Base(__n, __hf, __eql, __a)
206  { }
207 
208  template<typename _InputIterator>
209  unordered_map(_InputIterator __f, _InputIterator __l,
210  size_type __n = 10,
211  const hasher& __hf = hasher(),
212  const key_equal& __eql = key_equal(),
213  const allocator_type& __a = allocator_type())
214  : _Base(__f, __l, __n, __hf, __eql, __a)
215  { }
216 
217 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
218  unordered_map(unordered_map&& __x)
219  : _Base(std::forward<_Base>(__x)) { }
220 
221  unordered_map(initializer_list<value_type> __l,
222  size_type __n = 10,
223  const hasher& __hf = hasher(),
224  const key_equal& __eql = key_equal(),
225  const allocator_type& __a = allocator_type())
226  : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
227  { }
228 
229  unordered_map&
230  operator=(unordered_map&& __x)
231  {
232  // NB: DR 675.
233  this->clear();
234  this->swap(__x);
235  return *this;
236  }
237 
238  unordered_map&
239  operator=(initializer_list<value_type> __l)
240  {
241  this->clear();
242  this->insert(__l.begin(), __l.end());
243  return *this;
244  }
245 #endif
246  };
247 
248  /**
249  * @brief A standard container composed of equivalent keys
250  * (possibly containing multiple of each key value) that associates
251  * values of another type with the keys.
252  *
253  * @ingroup unordered_associative_containers
254  *
255  * Meets the requirements of a <a href="tables.html#65">container</a>, and
256  * <a href="tables.html#xx">unordered associative container</a>
257  *
258  * @param Key Type of key objects.
259  * @param Tp Type of mapped objects.
260  * @param Hash Hashing function object type, defaults to hash<Value>.
261  * @param Pred Predicate function object type, defaults to equal_to<Value>.
262  * @param Alloc Allocator type, defaults to allocator<Key>.
263  *
264  * The resulting value type of the container is std::pair<const Key, Tp>.
265  */
266  template<class _Key, class _Tp,
267  class _Hash = hash<_Key>,
268  class _Pred = std::equal_to<_Key>,
269  class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
270  class unordered_multimap
271  : public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
272  {
273  typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc> _Base;
274 
275  public:
276  typedef typename _Base::value_type value_type;
277  typedef typename _Base::size_type size_type;
278  typedef typename _Base::hasher hasher;
279  typedef typename _Base::key_equal key_equal;
280  typedef typename _Base::allocator_type allocator_type;
281 
282  explicit
283  unordered_multimap(size_type __n = 10,
284  const hasher& __hf = hasher(),
285  const key_equal& __eql = key_equal(),
286  const allocator_type& __a = allocator_type())
287  : _Base(__n, __hf, __eql, __a)
288  { }
289 
290 
291  template<typename _InputIterator>
292  unordered_multimap(_InputIterator __f, _InputIterator __l,
293  typename _Base::size_type __n = 0,
294  const hasher& __hf = hasher(),
295  const key_equal& __eql = key_equal(),
296  const allocator_type& __a = allocator_type())
297  : _Base(__f, __l, __n, __hf, __eql, __a)
298  { }
299 
300 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
301  unordered_multimap(unordered_multimap&& __x)
302  : _Base(std::forward<_Base>(__x)) { }
303 
304  unordered_multimap(initializer_list<value_type> __l,
305  size_type __n = 10,
306  const hasher& __hf = hasher(),
307  const key_equal& __eql = key_equal(),
308  const allocator_type& __a = allocator_type())
309  : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
310  { }
311 
312  unordered_multimap&
313  operator=(unordered_multimap&& __x)
314  {
315  // NB: DR 675.
316  this->clear();
317  this->swap(__x);
318  return *this;
319  }
320 
321  unordered_multimap&
322  operator=(initializer_list<value_type> __l)
323  {
324  this->clear();
325  this->insert(__l.begin(), __l.end());
326  return *this;
327  }
328 #endif
329  };
330 
331  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
332  inline void
333  swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
334  unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
335  { __x.swap(__y); }
336 
337  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
338  inline void
339  swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
340  unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
341  { __x.swap(__y); }
342 
343 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
344  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
345  inline void
346  swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __x,
347  unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
348  { __x.swap(__y); }
349 
350  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
351  inline void
352  swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
353  unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y)
354  { __x.swap(__y); }
355 
356  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
357  inline void
358  swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&& __x,
359  unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
360  { __x.swap(__y); }
361 
362  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
363  inline void
364  swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
365  unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y)
366  { __x.swap(__y); }
367 #endif
368 
369 _GLIBCXX_END_NAMESPACE_TR1
370 }