|
|
|
| 1 |
|
// unordered_map standard header |
| 2 |
|
#pragma once |
| 3 |
|
#ifndef _UNORDERED_MAP_ |
| 4 |
|
#define _UNORDERED_MAP_ |
| 5 |
|
#ifndef RC_INVOKED |
| 6 |
|
#include <xhash> |
| 7 |
|
|
| 8 |
|
#pragma pack(push,_CRT_PACKING) |
| 9 |
|
#pragma warning(push,3) |
| 10 |
|
|
| 11 |
|
_STD_BEGIN |
| 12 |
|
namespace tr1 { // TR1 additions |
| 13 |
|
|
| 14 |
|
// TEMPLATE CLASS _Umap_traits |
| 15 |
|
template<class _Kty, // key type |
| 16 |
|
class _Ty, // mapped type |
| 17 |
|
class _Tr, // comparator predicate type |
| 18 |
|
class _Alloc, // actual allocator type (should be value allocator) |
| 19 |
|
bool _Mfl> // true if multiple equivalent keys are permitted |
| 20 |
|
class _Umap_traits |
| 21 |
|
: public _Container_base |
| 22 |
|
{ // traits required to make _Hash behave like a map |
| 23 |
|
public: |
| 24 |
|
typedef _Kty key_type; |
| 25 |
|
typedef pair<const _Kty, _Ty> value_type; |
| 26 |
|
typedef _Tr key_compare; |
| 27 |
|
|
| 28 |
|
typedef typename _Alloc::template rebind<value_type>::other |
| 29 |
|
allocator_type; |
| 30 |
|
|
| 31 |
|
typedef typename allocator_type::pointer _ITptr; |
| 32 |
|
typedef typename allocator_type::reference _IReft; |
| 33 |
|
|
| 34 |
|
enum |
| 35 |
|
{ // make multi parameter visible as an enum constant |
| 36 |
|
_Multi = _Mfl}; |
| 37 |
|
|
| 38 |
|
_Umap_traits() |
| 39 |
|
: comp() |
| 40 |
|
{ // construct with default comparator |
| 41 |
|
} |
| 42 |
|
|
| 43 |
|
_Umap_traits(const _Tr& _Traits) |
| 44 |
|
: comp(_Traits) |
| 45 |
|
{ // construct with specified comparator |
| 46 |
|
} |
| 47 |
|
|
| 48 |
|
class value_compare |
| 49 |
|
: public binary_function<value_type, value_type, bool> |
| 50 |
|
{ // functor for comparing two element values |
| 51 |
|
friend class _Umap_traits<_Kty, _Ty, _Tr, _Alloc, _Mfl>; |
| 52 |
|
|
| 53 |
|
public: |
| 54 |
|
bool operator()(const value_type& _Left, |
| 55 |
|
const value_type& _Right) const |
| 323 |
|
_Mybase::insert(*_First); |
| 324 |
|
} |
| 325 |
|
|
| 326 |
|
template<class _Iter> |
| 327 |
|
unordered_multimap(_Iter _First, _Iter _Last, |
| 328 |
|
size_type _Buckets, const hasher& _Hasharg, |
| 329 |
|
const _Keyeq& _Keyeqarg) |
| 330 |
|
: _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type()) |
| 331 |
|
{ // construct map from sequence, comparator, and allocator |
| 332 |
|
this->rehash(_Buckets); |
| 333 |
|
for (; _First != _Last; ++_First) |
| 334 |
|
_Mybase::insert(*_First); |
| 335 |
|
} |
| 336 |
|
|
| 337 |
|
template<class _Iter> |
| 338 |
|
unordered_multimap(_Iter _First, _Iter _Last, |
| 339 |
|
size_type _Buckets, const hasher& _Hasharg, |
| 340 |
|
const _Keyeq& _Keyeqarg, const allocator_type _Al) |
| 341 |
|
: _Mybase(key_compare(_Hasharg, _Keyeqarg), _Al) |
| 342 |
|
{ // construct map from sequence, comparator, and allocator |
| 343 |
|
this->rehash(_Buckets); |
| 344 |
|
for (; _First != _Last; ++_First) |
| 345 |
|
_Mybase::insert(*_First); |
| 346 |
|
} |
| 347 |
|
|
| 348 |
|
hasher hash_function() const |
| 349 |
|
{ // return hasher object |
| 350 |
|
return (this->comp._Hashobj); |
| 351 |
|
} |
| 352 |
|
|
| 353 |
|
key_equal key_eq() const |
| 354 |
|
{ // return equality comparator object |
| 355 |
|
return (this->comp._Keyeqobj); |
| 356 |
|
} |
| 357 |
|
|
| 358 |
|
iterator insert(const value_type& _Val) |
| 359 |
|
{ // insert a {key, mapped} value |
| 360 |
|
return (_Mybase::insert(_Val).first); |
| 361 |
|
} |
| 362 |
|
|
| 363 |
|
iterator insert(const_iterator _Where, const value_type& _Val) |
| 364 |
|
{ // insert a {key, mapped} value, with hint |
| 365 |
|
return (_Mybase::insert(_Where, _Val)); |
| 366 |
|
} |
| 367 |
|
|
| 368 |
|
template<class _Iter> |
| 369 |
|
void insert(_Iter _First, _Iter _Last) |
| 370 |
|
{ // insert [_First, _Last), arbitrary iterators |
| 371 |
|
|
| 372 |
|
#if _HAS_ITERATOR_DEBUGGING |
| 373 |
|
_DEBUG_RANGE(_First, _Last); |
| 374 |
|
#endif /* _HAS_ITERATOR_DEBUGGING */ |
| 375 |
|
|
| 376 |
|
_Mybase::insert(_First, _Last); |
| 377 |
|
} |
| 378 |
|
}; |
| 379 |
|
|
| 380 |
|
template<class _Kty, |
| 381 |
|
class _Ty, |
| 382 |
|
class _Hasher, |
| 383 |
|
class _Keyeq, |
| 384 |
|
class _Alloc> |
| 385 |
|
void swap(unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left, |
| 386 |
|
unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) |
| 387 |
|
{ // swap _Left and _Right unordered_multimaps |
| 388 |
|
_Left.swap(_Right); |
| 389 |
|
} |
| 390 |
|
|
| 391 |
|
} // namespace tr1 |
| 392 |
|
|
| 393 |
|
// unordered_map implements a performant swap |
| 394 |
|
template<class _Kty, |
| 395 |
|
class _Ty, |
| 396 |
|
class _Hasher, |
| 397 |
|
class _Keyeq, |
| 398 |
|
class _Alloc> |
| 399 |
|
class _Move_operation_category<tr1::unordered_map<_Kty, _Ty, _Hasher, |
| 400 |
|
_Keyeq, _Alloc> > |
| 401 |
|
{ |
| 402 |
|
public: |
| 403 |
|
typedef _Swap_move_tag _Move_cat; |
| 404 |
|
}; |
| 405 |
|
|
| 406 |
|
// unordered_multimap implements a performant swap |
| 407 |
|
template<class _Kty, |
| 408 |
|
class _Ty, |
| 409 |
|
class _Hasher, |
| 410 |
|
class _Keyeq, |
| 411 |
|
class _Alloc> |
| 412 |
|
class _Move_operation_category<tr1::unordered_multimap<_Kty, _Ty, _Hasher, |
| 413 |
|
_Keyeq, _Alloc> > |
| 414 |
|
{ |
| 415 |
|
public: |
| 416 |
|
typedef _Swap_move_tag _Move_cat; |
| 417 |
|
}; |
| 418 |
|
_STD_END |
| 419 |
|
#pragma warning(pop) |
| 420 |
|
#pragma pack(pop) |
| 421 |
|
|
| 422 |
|
#endif /* RC_INVOKED */ |
| 423 |
|
#endif /* _UNORDERED_MAP_ */ |
| 424 |
|
|
| 425 |
|
/* |
| 426 |
|
* Copyright (c) 1992-2008 by P.J. Plauger. ALL RIGHTS RESERVED. |
| 427 |
|
* Consult your license regarding permissions and restrictions. |
| 428 |
|
V5.05:0009 */ |
| 429 |
|
|
|
|
|