/project/jni/stlport/stlport/stl/_unordered_map.h
C Header | 427 lines | 334 code | 67 blank | 26 comment | 1 complexity | 6757058ec720dfc908097215edc72682 MD5 | raw file
1/* 2 * Copyright (c) 2004 3 * Francois Dumont 4 * 5 * This material is provided "as is", with absolutely no warranty expressed 6 * or implied. Any use is at your own risk. 7 * 8 * Permission to use or copy this software for any purpose is hereby granted 9 * without fee, provided the above notices are retained on all copies. 10 * Permission to modify the code and to distribute modified code is granted, 11 * provided the above notices are retained, and a notice that the code was 12 * modified is included with the above copyright notice. 13 * 14 */ 15 16/* NOTE: This is an internal header file, included by other STL headers. 17 * You should not attempt to use it directly. 18 */ 19 20#ifndef _STLP_INTERNAL_UNORDERED_MAP_H 21#define _STLP_INTERNAL_UNORDERED_MAP_H 22 23#ifndef _STLP_INTERNAL_HASHTABLE_H 24# include <stl/_hashtable.h> 25#endif 26 27_STLP_BEGIN_NAMESPACE 28 29//Specific iterator traits creation 30_STLP_CREATE_HASH_ITERATOR_TRAITS(UnorderedMapTraitsT, traits) 31 32template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Key>), 33 _STLP_DFL_TMPL_PARAM(_EqualKey,equal_to<_Key>), 34 _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(const _Key, _Tp) > 35class unordered_map 36#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) 37 : public __stlport_class<unordered_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> > 38#endif 39{ 40private: 41 typedef unordered_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> _Self; 42public: 43 typedef _Key key_type; 44 typedef _Tp data_type; 45 typedef _Tp mapped_type; 46#if !defined (__DMC__) 47 typedef pair<const key_type, data_type> value_type; 48#else 49 typedef pair<key_type, data_type> value_type; 50#endif 51private: 52 //Specific iterator traits creation 53 typedef _STLP_PRIV _UnorderedMapTraitsT<value_type> _UnorderedMapTraits; 54 55public: 56 typedef hashtable<value_type, key_type, _HashFcn, _UnorderedMapTraits, 57 _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht; 58 59 typedef typename _Ht::hasher hasher; 60 typedef typename _Ht::key_equal key_equal; 61 62 typedef typename _Ht::size_type size_type; 63 typedef typename _Ht::difference_type difference_type; 64 typedef typename _Ht::pointer pointer; 65 typedef typename _Ht::const_pointer const_pointer; 66 typedef typename _Ht::reference reference; 67 typedef typename _Ht::const_reference const_reference; 68 69 typedef typename _Ht::iterator iterator; 70 typedef typename _Ht::const_iterator const_iterator; 71 typedef typename _Ht::local_iterator local_iterator; 72 typedef typename _Ht::const_local_iterator const_local_iterator; 73 74 typedef typename _Ht::allocator_type allocator_type; 75 76 hasher hash_function() const { return _M_ht.hash_funct(); } 77 key_equal key_eq() const { return _M_ht.key_eq(); } 78 allocator_type get_allocator() const { return _M_ht.get_allocator(); } 79 80private: 81 _Ht _M_ht; 82 _STLP_KEY_TYPE_FOR_CONT_EXT(key_type) 83 84public: 85 explicit unordered_map(size_type __n = 100, const hasher& __hf = hasher(), 86 const key_equal& __eql = key_equal(), 87 const allocator_type& __a = allocator_type()) 88 : _M_ht(__n, __hf, __eql, __a) {} 89 90 unordered_map(__move_source<_Self> src) 91 : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {} 92 93#if defined (_STLP_MEMBER_TEMPLATES) 94 template <class _InputIterator> 95 unordered_map(_InputIterator __f, _InputIterator __l, 96 size_type __n = 100, const hasher& __hf = hasher(), 97 const key_equal& __eql = key_equal(), 98 const allocator_type& __a = allocator_type()) 99 : _M_ht(__n, __hf, __eql, __a) 100 { _M_ht.insert_unique(__f, __l); } 101#else 102 unordered_map(const value_type* __f, const value_type* __l, 103 size_type __n = 100, const hasher& __hf = hasher(), 104 const key_equal& __eql = key_equal(), 105 const allocator_type& __a = allocator_type()) 106 : _M_ht(__n, __hf, __eql, __a) 107 { _M_ht.insert_unique(__f, __l); } 108 109 unordered_map(const_iterator __f, const_iterator __l, 110 size_type __n = 100, const hasher& __hf = hasher(), 111 const key_equal& __eql = key_equal(), 112 const allocator_type& __a = allocator_type()) 113 : _M_ht(__n, __hf, __eql, __a) 114 { _M_ht.insert_unique(__f, __l); } 115#endif /*_STLP_MEMBER_TEMPLATES */ 116 117 _Self& operator = (const _Self& __other) 118 { _M_ht = __other._M_ht; return *this; } 119 120 size_type size() const { return _M_ht.size(); } 121 size_type max_size() const { return _M_ht.max_size(); } 122 bool empty() const { return _M_ht.empty(); } 123 void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); } 124 125 iterator begin() { return _M_ht.begin(); } 126 iterator end() { return _M_ht.end(); } 127 const_iterator begin() const { return _M_ht.begin(); } 128 const_iterator end() const { return _M_ht.end(); } 129 130 pair<iterator,bool> insert(const value_type& __obj) 131 { return _M_ht.insert_unique(__obj); } 132 iterator insert(const_iterator /*__hint*/, const value_type& __obj) 133 { return _M_ht.insert_unique(__obj); } 134#if defined (_STLP_MEMBER_TEMPLATES) 135 template <class _InputIterator> 136 void insert(_InputIterator __f, _InputIterator __l) 137#else 138 void insert(const value_type* __f, const value_type* __l) 139 { _M_ht.insert_unique(__f,__l); } 140 void insert(const_iterator __f, const_iterator __l) 141#endif /*_STLP_MEMBER_TEMPLATES */ 142 { _M_ht.insert_unique(__f, __l); } 143 144 _STLP_TEMPLATE_FOR_CONT_EXT 145 iterator find(const _KT& __key) { return _M_ht.find(__key); } 146 _STLP_TEMPLATE_FOR_CONT_EXT 147 const_iterator find(const _KT& __key) const { return _M_ht.find(__key); } 148 149 _STLP_TEMPLATE_FOR_CONT_EXT 150 _Tp& operator[](const _KT& __key) { 151 iterator __it = _M_ht.find(__key); 152 return (__it == _M_ht.end() ? 153 _M_ht._M_insert(value_type(__key, _STLP_DEFAULT_CONSTRUCTED(_Tp))).second : 154 (*__it).second ); 155 } 156 157 _STLP_TEMPLATE_FOR_CONT_EXT 158 size_type count(const _KT& __key) const { return _M_ht.count(__key); } 159 160 _STLP_TEMPLATE_FOR_CONT_EXT 161 pair<iterator, iterator> equal_range(const _KT& __key) 162 { return _M_ht.equal_range(__key); } 163 _STLP_TEMPLATE_FOR_CONT_EXT 164 pair<const_iterator, const_iterator> equal_range(const _KT& __key) const 165 { return _M_ht.equal_range(__key); } 166 167 size_type erase(const key_type& __key) {return _M_ht.erase(__key); } 168 void erase(const_iterator __it) { _M_ht.erase(__it); } 169 void erase(const_iterator __f, const_iterator __l) { _M_ht.erase(__f, __l); } 170 void clear() { _M_ht.clear(); } 171 172 size_type bucket_count() const { return _M_ht.bucket_count(); } 173 size_type max_bucket_count() const { return _M_ht.max_bucket_count(); } 174 size_type bucket_size(size_type __n) const { return _M_ht.elems_in_bucket(__n); } 175 _STLP_TEMPLATE_FOR_CONT_EXT 176 size_type bucket(const _KT& __k) const { return _M_ht.bucket(__k); } 177 local_iterator begin(size_type __n) { return _M_ht.begin(__n); } 178 local_iterator end(size_type __n) { return _M_ht.end(__n); } 179 const_local_iterator begin(size_type __n) const { return _M_ht.begin(__n); } 180 const_local_iterator end(size_type __n) const { return _M_ht.end(__n); } 181 182 float load_factor() const { return _M_ht.load_factor(); } 183 float max_load_factor() const { return _M_ht.max_load_factor(); } 184 void max_load_factor(float __val) { _M_ht.max_load_factor(__val); } 185 void rehash(size_type __hint) { _M_ht.rehash(__hint); } 186}; 187 188//Specific iterator traits creation 189_STLP_CREATE_HASH_ITERATOR_TRAITS(UnorderedMultimapTraitsT, traits) 190 191template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Key>), 192 _STLP_DFL_TMPL_PARAM(_EqualKey,equal_to<_Key>), 193 _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(const _Key, _Tp) > 194class unordered_multimap 195#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) 196 : public __stlport_class<unordered_multimap<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> > 197#endif 198{ 199private: 200 typedef unordered_multimap<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> _Self; 201public: 202 typedef _Key key_type; 203 typedef _Tp data_type; 204 typedef _Tp mapped_type; 205#if !defined (__DMC__) 206 typedef pair<const key_type, data_type> value_type; 207#else 208 typedef pair<key_type, data_type> value_type; 209#endif 210private: 211 //Specific iterator traits creation 212 typedef _STLP_PRIV _UnorderedMultimapTraitsT<value_type> _UnorderedMultimapTraits; 213 214public: 215 typedef hashtable<value_type, key_type, _HashFcn, _UnorderedMultimapTraits, 216 _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht; 217 218 typedef typename _Ht::hasher hasher; 219 typedef typename _Ht::key_equal key_equal; 220 221 typedef typename _Ht::size_type size_type; 222 typedef typename _Ht::difference_type difference_type; 223 typedef typename _Ht::pointer pointer; 224 typedef typename _Ht::const_pointer const_pointer; 225 typedef typename _Ht::reference reference; 226 typedef typename _Ht::const_reference const_reference; 227 228 typedef typename _Ht::iterator iterator; 229 typedef typename _Ht::const_iterator const_iterator; 230 typedef typename _Ht::local_iterator local_iterator; 231 typedef typename _Ht::const_local_iterator const_local_iterator; 232 233 typedef typename _Ht::allocator_type allocator_type; 234 235 hasher hash_function() const { return _M_ht.hash_funct(); } 236 key_equal key_eq() const { return _M_ht.key_eq(); } 237 allocator_type get_allocator() const { return _M_ht.get_allocator(); } 238 239private: 240 _Ht _M_ht; 241 _STLP_KEY_TYPE_FOR_CONT_EXT(key_type) 242 243public: 244 explicit unordered_multimap(size_type __n = 100, const hasher& __hf = hasher(), 245 const key_equal& __eql = key_equal(), 246 const allocator_type& __a = allocator_type()) 247 : _M_ht(__n, __hf, __eql, __a) {} 248 249 unordered_multimap(__move_source<_Self> src) 250 : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {} 251 252#if defined (_STLP_MEMBER_TEMPLATES) 253 template <class _InputIterator> 254 unordered_multimap(_InputIterator __f, _InputIterator __l, 255 size_type __n = 100, const hasher& __hf = hasher(), 256 const key_equal& __eql = key_equal(), 257 const allocator_type& __a = allocator_type()) 258 : _M_ht(__n, __hf, __eql, __a) 259 { _M_ht.insert_equal(__f, __l); } 260#else 261 unordered_multimap(const value_type* __f, const value_type* __l, 262 size_type __n = 100, const hasher& __hf = hasher(), 263 const key_equal& __eql = key_equal(), 264 const allocator_type& __a = allocator_type()) 265 : _M_ht(__n, __hf, __eql, __a) 266 { _M_ht.insert_equal(__f, __l); } 267 268 unordered_multimap(const_iterator __f, const_iterator __l, 269 size_type __n = 100, const hasher& __hf = hasher(), 270 const key_equal& __eql = key_equal(), 271 const allocator_type& __a = allocator_type()) 272 : _M_ht(__n, __hf, __eql, __a) 273 { _M_ht.insert_equal(__f, __l); } 274#endif /*_STLP_MEMBER_TEMPLATES */ 275 276 _Self& operator = (const _Self& __other) 277 { _M_ht = __other._M_ht; return *this; } 278 279 size_type size() const { return _M_ht.size(); } 280 size_type max_size() const { return _M_ht.max_size(); } 281 bool empty() const { return _M_ht.empty(); } 282 void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); } 283 284 iterator begin() { return _M_ht.begin(); } 285 iterator end() { return _M_ht.end(); } 286 const_iterator begin() const { return _M_ht.begin(); } 287 const_iterator end() const { return _M_ht.end(); } 288 289 iterator insert(const value_type& __obj) 290 { return _M_ht.insert_equal(__obj); } 291 iterator insert(const_iterator /*__hint*/, const value_type& __obj) 292 { return _M_ht.insert_equal(__obj); } 293#if defined (_STLP_MEMBER_TEMPLATES) 294 template <class _InputIterator> 295 void insert(_InputIterator __f, _InputIterator __l) 296#else 297 void insert(const value_type* __f, const value_type* __l) 298 { _M_ht.insert_equal(__f,__l); } 299 void insert(const_iterator __f, const_iterator __l) 300#endif /*_STLP_MEMBER_TEMPLATES */ 301 { _M_ht.insert_equal(__f, __l); } 302 303 _STLP_TEMPLATE_FOR_CONT_EXT 304 iterator find(const _KT& __key) { return _M_ht.find(__key); } 305 _STLP_TEMPLATE_FOR_CONT_EXT 306 const_iterator find(const _KT& __key) const { return _M_ht.find(__key); } 307 308 _STLP_TEMPLATE_FOR_CONT_EXT 309 size_type count(const _KT& __key) const { return _M_ht.count(__key); } 310 311 _STLP_TEMPLATE_FOR_CONT_EXT 312 pair<iterator, iterator> equal_range(const _KT& __key) 313 { return _M_ht.equal_range(__key); } 314 _STLP_TEMPLATE_FOR_CONT_EXT 315 pair<const_iterator, const_iterator> equal_range(const _KT& __key) const 316 { return _M_ht.equal_range(__key); } 317 318 size_type erase(const key_type& __key) {return _M_ht.erase(__key); } 319 void erase(const_iterator __it) { _M_ht.erase(__it); } 320 void erase(const_iterator __f, const_iterator __l) { _M_ht.erase(__f, __l); } 321 void clear() { _M_ht.clear(); } 322 323 size_type bucket_count() const { return _M_ht.bucket_count(); } 324 size_type max_bucket_count() const { return _M_ht.max_bucket_count(); } 325 size_type bucket_size(size_type __n) const { return _M_ht.elems_in_bucket(__n); } 326 _STLP_TEMPLATE_FOR_CONT_EXT 327 size_type bucket(const _KT& __k) const { return _M_ht.bucket(__k); } 328 local_iterator begin(size_type __n) { return _M_ht.begin(__n); } 329 local_iterator end(size_type __n) { return _M_ht.end(__n); } 330 const_local_iterator begin(size_type __n) const { return _M_ht.begin(__n); } 331 const_local_iterator end(size_type __n) const { return _M_ht.end(__n); } 332 333 float load_factor() const { return _M_ht.load_factor(); } 334 float max_load_factor() const { return _M_ht.max_load_factor(); } 335 void max_load_factor(float __val) { _M_ht.max_load_factor(__val); } 336 void rehash(size_type __hint) { _M_ht.rehash(__hint); } 337}; 338 339#define _STLP_TEMPLATE_HEADER template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc> 340#define _STLP_TEMPLATE_CONTAINER unordered_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc> 341 342#include <stl/_relops_hash_cont.h> 343 344#undef _STLP_TEMPLATE_CONTAINER 345#define _STLP_TEMPLATE_CONTAINER unordered_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc> 346 347#include <stl/_relops_hash_cont.h> 348 349#undef _STLP_TEMPLATE_CONTAINER 350#undef _STLP_TEMPLATE_HEADER 351 352// Specialization of insert_iterator so that it will work for unordered_map 353// and unordered_multimap. 354 355#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) 356template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc> 357struct __move_traits<unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > : 358 _STLP_PRIV __move_traits_help<typename unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>::_Ht> 359{}; 360 361template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc> 362struct __move_traits<unordered_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > : 363 _STLP_PRIV __move_traits_help<typename unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>::_Ht> 364{}; 365 366template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc> 367class insert_iterator<unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > { 368protected: 369 typedef unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container; 370 _Container* container; 371public: 372 typedef _Container container_type; 373 typedef output_iterator_tag iterator_category; 374 typedef void value_type; 375 typedef void difference_type; 376 typedef void pointer; 377 typedef void reference; 378 379 insert_iterator(_Container& __x) : container(&__x) {} 380 insert_iterator(_Container& __x, typename _Container::iterator) 381 : container(&__x) {} 382 insert_iterator<_Container>& 383 operator=(const typename _Container::value_type& __val) { 384 container->insert(__val); 385 return *this; 386 } 387 insert_iterator<_Container>& operator*() { return *this; } 388 insert_iterator<_Container>& operator++() { return *this; } 389 insert_iterator<_Container>& operator++(int) { return *this; } 390}; 391 392template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc> 393class insert_iterator<unordered_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > { 394protected: 395 typedef unordered_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container; 396 _Container* container; 397 typename _Container::iterator iter; 398public: 399 typedef _Container container_type; 400 typedef output_iterator_tag iterator_category; 401 typedef void value_type; 402 typedef void difference_type; 403 typedef void pointer; 404 typedef void reference; 405 406 insert_iterator(_Container& __x) : container(&__x) {} 407 insert_iterator(_Container& __x, typename _Container::iterator) 408 : container(&__x) {} 409 insert_iterator<_Container>& 410 operator=(const typename _Container::value_type& __val) { 411 container->insert(__val); 412 return *this; 413 } 414 insert_iterator<_Container>& operator*() { return *this; } 415 insert_iterator<_Container>& operator++() { return *this; } 416 insert_iterator<_Container>& operator++(int) { return *this; } 417}; 418 419#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */ 420 421_STLP_END_NAMESPACE 422 423#endif /* _STLP_INTERNAL_UNORDERED_MAP_H */ 424 425// Local Variables: 426// mode:C++ 427// End: