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 namespace std
00031 {
00032 _GLIBCXX_BEGIN_NAMESPACE_TR1
00033
00034
00035
00036 template<class _Key, class _Tp,
00037 class _Hash = hash<_Key>,
00038 class _Pred = std::equal_to<_Key>,
00039 class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
00040 bool __cache_hash_code = false>
00041 class __unordered_map
00042 : public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
00043 std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
00044 _Hash, __detail::_Mod_range_hashing,
00045 __detail::_Default_ranged_hash,
00046 __detail::_Prime_rehash_policy,
00047 __cache_hash_code, false, true>
00048 {
00049 typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
00050 std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
00051 _Hash, __detail::_Mod_range_hashing,
00052 __detail::_Default_ranged_hash,
00053 __detail::_Prime_rehash_policy,
00054 __cache_hash_code, false, true>
00055 _Base;
00056
00057 public:
00058 typedef typename _Base::size_type size_type;
00059 typedef typename _Base::hasher hasher;
00060 typedef typename _Base::key_equal key_equal;
00061 typedef typename _Base::allocator_type allocator_type;
00062
00063 explicit
00064 __unordered_map(size_type __n = 10,
00065 const hasher& __hf = hasher(),
00066 const key_equal& __eql = key_equal(),
00067 const allocator_type& __a = allocator_type())
00068 : _Base(__n, __hf, __detail::_Mod_range_hashing(),
00069 __detail::_Default_ranged_hash(),
00070 __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
00071 { }
00072
00073 template<typename _InputIterator>
00074 __unordered_map(_InputIterator __f, _InputIterator __l,
00075 size_type __n = 10,
00076 const hasher& __hf = hasher(),
00077 const key_equal& __eql = key_equal(),
00078 const allocator_type& __a = allocator_type())
00079 : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
00080 __detail::_Default_ranged_hash(),
00081 __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
00082 { }
00083
00084 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00085 __unordered_map(__unordered_map&& __x)
00086 : _Base(std::forward<_Base>(__x)) { }
00087 #endif
00088 };
00089
00090 template<class _Key, class _Tp,
00091 class _Hash = hash<_Key>,
00092 class _Pred = std::equal_to<_Key>,
00093 class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
00094 bool __cache_hash_code = false>
00095 class __unordered_multimap
00096 : public _Hashtable<_Key, std::pair<const _Key, _Tp>,
00097 _Alloc,
00098 std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
00099 _Hash, __detail::_Mod_range_hashing,
00100 __detail::_Default_ranged_hash,
00101 __detail::_Prime_rehash_policy,
00102 __cache_hash_code, false, false>
00103 {
00104 typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
00105 _Alloc,
00106 std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
00107 _Hash, __detail::_Mod_range_hashing,
00108 __detail::_Default_ranged_hash,
00109 __detail::_Prime_rehash_policy,
00110 __cache_hash_code, false, false>
00111 _Base;
00112
00113 public:
00114 typedef typename _Base::size_type size_type;
00115 typedef typename _Base::hasher hasher;
00116 typedef typename _Base::key_equal key_equal;
00117 typedef typename _Base::allocator_type allocator_type;
00118
00119 explicit
00120 __unordered_multimap(size_type __n = 10,
00121 const hasher& __hf = hasher(),
00122 const key_equal& __eql = key_equal(),
00123 const allocator_type& __a = allocator_type())
00124 : _Base(__n, __hf, __detail::_Mod_range_hashing(),
00125 __detail::_Default_ranged_hash(),
00126 __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
00127 { }
00128
00129
00130 template<typename _InputIterator>
00131 __unordered_multimap(_InputIterator __f, _InputIterator __l,
00132 typename _Base::size_type __n = 0,
00133 const hasher& __hf = hasher(),
00134 const key_equal& __eql = key_equal(),
00135 const allocator_type& __a = allocator_type())
00136 : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
00137 __detail::_Default_ranged_hash(),
00138 __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
00139 { }
00140
00141 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00142 __unordered_multimap(__unordered_multimap&& __x)
00143 : _Base(std::forward<_Base>(__x)) { }
00144 #endif
00145 };
00146
00147 template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
00148 bool __cache_hash_code>
00149 inline void
00150 swap(__unordered_map<_Key, _Tp, _Hash, _Pred,
00151 _Alloc, __cache_hash_code>& __x,
00152 __unordered_map<_Key, _Tp, _Hash, _Pred,
00153 _Alloc, __cache_hash_code>& __y)
00154 { __x.swap(__y); }
00155
00156 template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
00157 bool __cache_hash_code>
00158 inline void
00159 swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred,
00160 _Alloc, __cache_hash_code>& __x,
00161 __unordered_multimap<_Key, _Tp, _Hash, _Pred,
00162 _Alloc, __cache_hash_code>& __y)
00163 { __x.swap(__y); }
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184 template<class _Key, class _Tp,
00185 class _Hash = hash<_Key>,
00186 class _Pred = std::equal_to<_Key>,
00187 class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
00188 class unordered_map
00189 : public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
00190 {
00191 typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc> _Base;
00192
00193 public:
00194 typedef typename _Base::value_type value_type;
00195 typedef typename _Base::size_type size_type;
00196 typedef typename _Base::hasher hasher;
00197 typedef typename _Base::key_equal key_equal;
00198 typedef typename _Base::allocator_type allocator_type;
00199
00200 explicit
00201 unordered_map(size_type __n = 10,
00202 const hasher& __hf = hasher(),
00203 const key_equal& __eql = key_equal(),
00204 const allocator_type& __a = allocator_type())
00205 : _Base(__n, __hf, __eql, __a)
00206 { }
00207
00208 template<typename _InputIterator>
00209 unordered_map(_InputIterator __f, _InputIterator __l,
00210 size_type __n = 10,
00211 const hasher& __hf = hasher(),
00212 const key_equal& __eql = key_equal(),
00213 const allocator_type& __a = allocator_type())
00214 : _Base(__f, __l, __n, __hf, __eql, __a)
00215 { }
00216
00217 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00218 unordered_map(unordered_map&& __x)
00219 : _Base(std::forward<_Base>(__x)) { }
00220
00221 unordered_map(initializer_list<value_type> __l,
00222 size_type __n = 10,
00223 const hasher& __hf = hasher(),
00224 const key_equal& __eql = key_equal(),
00225 const allocator_type& __a = allocator_type())
00226 : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
00227 { }
00228
00229 unordered_map&
00230 operator=(unordered_map&& __x)
00231 {
00232
00233 this->clear();
00234 this->swap(__x);
00235 return *this;
00236 }
00237
00238 unordered_map&
00239 operator=(initializer_list<value_type> __l)
00240 {
00241 this->clear();
00242 this->insert(__l.begin(), __l.end());
00243 return *this;
00244 }
00245 #endif
00246 };
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266 template<class _Key, class _Tp,
00267 class _Hash = hash<_Key>,
00268 class _Pred = std::equal_to<_Key>,
00269 class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
00270 class unordered_multimap
00271 : public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
00272 {
00273 typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc> _Base;
00274
00275 public:
00276 typedef typename _Base::value_type value_type;
00277 typedef typename _Base::size_type size_type;
00278 typedef typename _Base::hasher hasher;
00279 typedef typename _Base::key_equal key_equal;
00280 typedef typename _Base::allocator_type allocator_type;
00281
00282 explicit
00283 unordered_multimap(size_type __n = 10,
00284 const hasher& __hf = hasher(),
00285 const key_equal& __eql = key_equal(),
00286 const allocator_type& __a = allocator_type())
00287 : _Base(__n, __hf, __eql, __a)
00288 { }
00289
00290
00291 template<typename _InputIterator>
00292 unordered_multimap(_InputIterator __f, _InputIterator __l,
00293 typename _Base::size_type __n = 0,
00294 const hasher& __hf = hasher(),
00295 const key_equal& __eql = key_equal(),
00296 const allocator_type& __a = allocator_type())
00297 : _Base(__f, __l, __n, __hf, __eql, __a)
00298 { }
00299
00300 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00301 unordered_multimap(unordered_multimap&& __x)
00302 : _Base(std::forward<_Base>(__x)) { }
00303
00304 unordered_multimap(initializer_list<value_type> __l,
00305 size_type __n = 10,
00306 const hasher& __hf = hasher(),
00307 const key_equal& __eql = key_equal(),
00308 const allocator_type& __a = allocator_type())
00309 : _Base(__l.begin(), __l.end(), __n, __hf, __eql, __a)
00310 { }
00311
00312 unordered_multimap&
00313 operator=(unordered_multimap&& __x)
00314 {
00315
00316 this->clear();
00317 this->swap(__x);
00318 return *this;
00319 }
00320
00321 unordered_multimap&
00322 operator=(initializer_list<value_type> __l)
00323 {
00324 this->clear();
00325 this->insert(__l.begin(), __l.end());
00326 return *this;
00327 }
00328 #endif
00329 };
00330
00331 template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
00332 inline void
00333 swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
00334 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
00335 { __x.swap(__y); }
00336
00337 template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
00338 inline void
00339 swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
00340 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
00341 { __x.swap(__y); }
00342
00343 #ifdef _GLIBCXX_INCLUDE_AS_CXX0X
00344 template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
00345 inline void
00346 swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __x,
00347 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
00348 { __x.swap(__y); }
00349
00350 template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
00351 inline void
00352 swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
00353 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y)
00354 { __x.swap(__y); }
00355
00356 template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
00357 inline void
00358 swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&& __x,
00359 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
00360 { __x.swap(__y); }
00361
00362 template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
00363 inline void
00364 swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
00365 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y)
00366 { __x.swap(__y); }
00367 #endif
00368
00369 _GLIBCXX_END_NAMESPACE_TR1
00370 }