STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
unordered_map.h
Go to the documentation of this file.
1 // TR1 unordered_map implementation -*- C++ -*-
2 
3 // Copyright (C) 2010-2013 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 
30 namespace std _GLIBCXX_VISIBILITY(default)
31 {
32 namespace tr1
33 {
34 _GLIBCXX_BEGIN_NAMESPACE_VERSION
35 
36  // NB: When we get typedef templates these class definitions
37  // will be unnecessary.
38  template<class _Key, class _Tp,
39  class _Hash = hash<_Key>,
40  class _Pred = std::equal_to<_Key>,
41  class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
42  bool __cache_hash_code = false>
43  class __unordered_map
44  : public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
45  std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
46  _Hash, __detail::_Mod_range_hashing,
47  __detail::_Default_ranged_hash,
48  __detail::_Prime_rehash_policy,
49  __cache_hash_code, false, true>
50  {
51  typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
52  std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
53  _Hash, __detail::_Mod_range_hashing,
54  __detail::_Default_ranged_hash,
55  __detail::_Prime_rehash_policy,
56  __cache_hash_code, false, true>
57  _Base;
58 
59  public:
60  typedef typename _Base::size_type size_type;
61  typedef typename _Base::hasher hasher;
62  typedef typename _Base::key_equal key_equal;
63  typedef typename _Base::allocator_type allocator_type;
64 
65  explicit
66  __unordered_map(size_type __n = 10,
67  const hasher& __hf = hasher(),
68  const key_equal& __eql = key_equal(),
69  const allocator_type& __a = allocator_type())
70  : _Base(__n, __hf, __detail::_Mod_range_hashing(),
71  __detail::_Default_ranged_hash(),
72  __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
73  { }
74 
75  template<typename _InputIterator>
76  __unordered_map(_InputIterator __f, _InputIterator __l,
77  size_type __n = 10,
78  const hasher& __hf = hasher(),
79  const key_equal& __eql = key_equal(),
80  const allocator_type& __a = allocator_type())
81  : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
82  __detail::_Default_ranged_hash(),
83  __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
84  { }
85  };
86 
87  template<class _Key, class _Tp,
88  class _Hash = hash<_Key>,
89  class _Pred = std::equal_to<_Key>,
90  class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
91  bool __cache_hash_code = false>
92  class __unordered_multimap
93  : public _Hashtable<_Key, std::pair<const _Key, _Tp>,
94  _Alloc,
95  std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
96  _Hash, __detail::_Mod_range_hashing,
97  __detail::_Default_ranged_hash,
98  __detail::_Prime_rehash_policy,
99  __cache_hash_code, false, false>
100  {
101  typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
102  _Alloc,
103  std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
104  _Hash, __detail::_Mod_range_hashing,
105  __detail::_Default_ranged_hash,
106  __detail::_Prime_rehash_policy,
107  __cache_hash_code, false, false>
108  _Base;
109 
110  public:
111  typedef typename _Base::size_type size_type;
112  typedef typename _Base::hasher hasher;
113  typedef typename _Base::key_equal key_equal;
114  typedef typename _Base::allocator_type allocator_type;
115 
116  explicit
117  __unordered_multimap(size_type __n = 10,
118  const hasher& __hf = hasher(),
119  const key_equal& __eql = key_equal(),
120  const allocator_type& __a = allocator_type())
121  : _Base(__n, __hf, __detail::_Mod_range_hashing(),
122  __detail::_Default_ranged_hash(),
123  __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
124  { }
125 
126 
127  template<typename _InputIterator>
128  __unordered_multimap(_InputIterator __f, _InputIterator __l,
129  typename _Base::size_type __n = 0,
130  const hasher& __hf = hasher(),
131  const key_equal& __eql = key_equal(),
132  const allocator_type& __a = allocator_type())
133  : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
134  __detail::_Default_ranged_hash(),
135  __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
136  { }
137  };
138 
139  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
140  bool __cache_hash_code>
141  inline void
142  swap(__unordered_map<_Key, _Tp, _Hash, _Pred,
143  _Alloc, __cache_hash_code>& __x,
144  __unordered_map<_Key, _Tp, _Hash, _Pred,
145  _Alloc, __cache_hash_code>& __y)
146  { __x.swap(__y); }
147 
148  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
149  bool __cache_hash_code>
150  inline void
151  swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred,
152  _Alloc, __cache_hash_code>& __x,
153  __unordered_multimap<_Key, _Tp, _Hash, _Pred,
154  _Alloc, __cache_hash_code>& __y)
155  { __x.swap(__y); }
156 
157 
176  template<class _Key, class _Tp,
177  class _Hash = hash<_Key>,
178  class _Pred = std::equal_to<_Key>,
179  class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
180  class unordered_map
181  : public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
182  {
183  typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc> _Base;
184 
185  public:
186  typedef typename _Base::value_type value_type;
187  typedef typename _Base::size_type size_type;
188  typedef typename _Base::hasher hasher;
189  typedef typename _Base::key_equal key_equal;
190  typedef typename _Base::allocator_type allocator_type;
191 
192  explicit
193  unordered_map(size_type __n = 10,
194  const hasher& __hf = hasher(),
195  const key_equal& __eql = key_equal(),
196  const allocator_type& __a = allocator_type())
197  : _Base(__n, __hf, __eql, __a)
198  { }
199 
200  template<typename _InputIterator>
201  unordered_map(_InputIterator __f, _InputIterator __l,
202  size_type __n = 10,
203  const hasher& __hf = hasher(),
204  const key_equal& __eql = key_equal(),
205  const allocator_type& __a = allocator_type())
206  : _Base(__f, __l, __n, __hf, __eql, __a)
207  { }
208  };
209 
228  template<class _Key, class _Tp,
229  class _Hash = hash<_Key>,
230  class _Pred = std::equal_to<_Key>,
231  class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
232  class unordered_multimap
233  : public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
234  {
235  typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc> _Base;
236 
237  public:
238  typedef typename _Base::value_type value_type;
239  typedef typename _Base::size_type size_type;
240  typedef typename _Base::hasher hasher;
241  typedef typename _Base::key_equal key_equal;
242  typedef typename _Base::allocator_type allocator_type;
243 
244  explicit
245  unordered_multimap(size_type __n = 10,
246  const hasher& __hf = hasher(),
247  const key_equal& __eql = key_equal(),
248  const allocator_type& __a = allocator_type())
249  : _Base(__n, __hf, __eql, __a)
250  { }
251 
252 
253  template<typename _InputIterator>
254  unordered_multimap(_InputIterator __f, _InputIterator __l,
255  typename _Base::size_type __n = 0,
256  const hasher& __hf = hasher(),
257  const key_equal& __eql = key_equal(),
258  const allocator_type& __a = allocator_type())
259  : _Base(__f, __l, __n, __hf, __eql, __a)
260  { }
261 
262  };
263 
264  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
265  inline void
266  swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
267  unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
268  { __x.swap(__y); }
269 
270  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
271  inline void
272  swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
273  unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
274  { __x.swap(__y); }
275 
276 _GLIBCXX_END_NAMESPACE_VERSION
277 }
278 }
_GLIBCXX_VISIBILITY
namespace std _GLIBCXX_VISIBILITY(default)
Definition: unordered_map.h:33
std::__exception_ptr::swap
void swap(exception_ptr &__lhs, exception_ptr &__rhs)
Definition: exception_ptr.h:160
Generated on Sat Jul 22 2017 14:40:12 for STLdoc by   doxygen 1.8.6