#include <internal_concurrent_hash.h>

Inheritance diagram for Concurrency::details::_Concurrent_hash< _Traits >:

Public Types
typedef _Concurrent_hash< _Traits >	_Mytype

typedef _Split_ordered_list< typename _Traits::value_type, typename _Traits::allocator_type >	_Mylist

typedef _Traits::_Key_compare	_Key_compare

typedef _Traits::_Value_compare	_Value_compare

typedef _Traits::value_type	value_type

typedef _Traits::key_type	key_type

typedef _Traits::allocator_type	allocator_type

typedef allocator_type::pointer	pointer

typedef allocator_type::const_pointer	const_pointer

typedef allocator_type::reference	reference

typedef allocator_type::const_reference	const_reference

typedef allocator_type::size_type	size_type

typedef allocator_type::difference_type	difference_type

typedef std::tr1::conditional< std::tr1::is_same< key_type, value_type >::value, typename _Mylist::const_iterator, typename _Mylist::iterator >::type	iterator

typedef _Mylist::const_iterator	const_iterator

typedef iterator	local_iterator

typedef const_iterator	const_local_iterator

typedef _Mylist::_Nodeptr	_Nodeptr

typedef _Mylist::_Full_iterator	_Full_iterator

typedef _Mylist::_Full_const_iterator	_Full_const_iterator

Public Member Functions
	_Concurrent_hash (size_type _Number_of_buckets=_Initial_bucket_number, const _Key_compare &_Parg=_Key_compare(), const allocator_type &_Allocator=allocator_type())

	_Concurrent_hash (const _Concurrent_hash &_Right, const allocator_type &_Allocator)

	_Concurrent_hash (const _Concurrent_hash &_Right)

	_Concurrent_hash (_Concurrent_hash &&_Right)

_Concurrent_hash &	operator= (const _Concurrent_hash &_Right)

_Concurrent_hash &	operator= (_Concurrent_hash &&_Right)

	~_Concurrent_hash ()

allocator_type	get_allocator () const
	Returns the stored allocator object for this concurrent container. This method is concurrency safe. More...

bool	empty () const
	Tests whether no elements are present. This method is concurrency safe. More...

size_type	size () const
	Returns the number of elements in this concurrent container. This method is concurrency safe. More...

size_type	max_size () const
	Returns the maximum size of the concurrent container, determined by the allocator. This method is concurrency safe. More...

iterator	begin ()
	Returns an iterator pointing to the first element in the concurrent container. This method is concurrency safe. More...

const_iterator	begin () const
	Returns an iterator pointing to the first element in the concurrent container. This method is concurrency safe. More...

iterator	end ()
	Returns an iterator pointing to the location succeeding the last element in the concurrent container. This method is concurrency safe. More...

const_iterator	end () const
	Returns a const_iterator pointing to the location succeeding the last element in the concurrent container. This method is concurrency safe. More...

const_iterator	cbegin () const
	Returns a const iterator pointing to the first element in the concurrent container. This method is concurrency safe. More...

const_iterator	cend () const
	Returns a const iterator pointing to the location succeeding the last element in the concurrent container. This method is concurrency safe. More...

iterator	unsafe_erase (const_iterator _Where)
	Removes elements from the container at specified positions. This method is not concurrency-safe. More...

iterator	unsafe_erase (const_iterator _First, const_iterator _Last)
	Removes elements from the container at specified positions. This method is not concurrency-safe. More...

size_type	unsafe_erase (const key_type &_Keyval)
	Removes elements from the container at specified positions. This method is not concurrency-safe. More...

void	swap (_Concurrent_hash &_Right)
	Swaps the contents of two concurrent containers. This function is not concurrency safe. More...

void	clear ()
	Erases all the elements in the concurrent container. This function is not concurrency safe. More...

iterator	find (const key_type &_Keyval)
	Finds an element that matches a specified key. This function is concurrency safe. More...

const_iterator	find (const key_type &_Keyval) const
	Finds an element that matches a specified key. This function is concurrency safe. More...

size_type	count (const key_type &_Keyval) const
	Counts the number of elements matching a specified key. This function is concurrency safe. More...

std::pair< iterator, iterator >	equal_range (const key_type &_Keyval)
	Finds a range that matches a specified key. This function is concurrency safe. More...

std::pair< const_iterator, const_iterator >	equal_range (const key_type &_Keyval) const
	Finds a range that matches a specified key. This function is concurrency safe. More...

size_type	unsafe_bucket_count () const
	Returns the current number of buckets in this container. More...

size_type	unsafe_max_bucket_count () const
	Returns the maximum number of buckets in this container. More...

size_type	unsafe_bucket_size (size_type _Bucket)
	Returns the number of items in a specific bucket of this container. More...

size_type	unsafe_bucket (const key_type &_Keyval) const
	Returns the bucket index that a specific key maps to in this container. More...

local_iterator	unsafe_begin (size_type _Bucket)
	Returns an iterator to the first element in this container for a specific bucket. More...

const_local_iterator	unsafe_begin (size_type _Bucket) const
	Returns an iterator to the first element in this container for a specific bucket. More...

local_iterator	unsafe_end (size_type _Bucket)
	Returns an iterator to the last element in this container for a specific bucket. More...

const_local_iterator	unsafe_end (size_type _Bucket) const
	Returns an iterator to the last element in this container for a specific bucket. More...

const_local_iterator	unsafe_cbegin (size_type) const
	Returns an iterator to the first element in this container for a specific bucket. More...

const_local_iterator	unsafe_cend (size_type) const
	Returns an iterator to the first element in this container for a specific bucket. More...

float	load_factor () const
	Computes and returns the current load factor of the container. The load factor is the number of elements in the container divided by the number of buckets. More...

float	max_load_factor () const
	Gets or sets the maximum load factor of the container. The maximum load factor is the largest number of elements than can be in any bucket before the container grows its internal table. More...

void	max_load_factor (float _Newmax)
	Gets or sets the maximum load factor of the container. The maximum load factor is the largest number of elements than can be in any bucket before the container grows its internal table. More...

void	rehash (size_type _Buckets)
	Rebuilds the hash table. More...

Static Public Member Functions
static size_type __cdecl	_Segment_index_of (size_type _Index)

static size_type	_Segment_base (size_type _K)

static size_type	_Segment_size (size_type _K)

Static Public Attributes
static const size_type	_Initial_bucket_number = 8

static const size_type	_Initial_bucket_load = 4

static size_type const	_Pointers_per_table = sizeof(size_type) * 8

Protected Member Functions
template<typename _ValTy >
std::pair< iterator, bool >	_Insert (_ValTy &&_Value)

template<class _Iterator >
void	_Insert (_Iterator _First, _Iterator _Last)

Private Member Functions
void	_Init ()

void	_Copy (const _Mytype &_Right)

void	_Swap_buckets (_Concurrent_hash &_Right)

size_type	_Distance (const_iterator _First, const_iterator _Last) const

iterator	_Find (const key_type &_Keyval)

const_iterator	_Find (const key_type &_Keyval) const

iterator	_Erase (const_iterator _Iterator)

std::pair< iterator, iterator >	_Equal_range (const key_type &_Keyval)

std::pair< const_iterator, const_iterator >	_Equal_range (const key_type &_Keyval) const

void	_Initialize_bucket (size_type _Bucket)

void	_Adjust_table_size (size_type _Total_elements, size_type _Current_size)

size_type	_Get_parent (size_type _Bucket) const

_Full_iterator	_Get_bucket (size_type _Bucket) const

void	_Set_bucket (size_type _Bucket, _Full_iterator _Dummy_head)

bool	_Is_initialized (size_type _Bucket) const

_Split_order_key	_Reverse (_Map_key _Order_key) const

_Split_order_key	_Split_order_regular_key (_Map_key _Order_key) const

_Split_order_key	_Split_order_dummy_key (_Map_key _Order_key) const

Private Attributes
_Full_iterator *	_M_buckets [_Pointers_per_table]

_Mylist	_M_split_ordered_list

allocator_type::template rebind< _Full_iterator >::other	_M_allocator

size_type	_M_number_of_buckets

float	_M_maximum_bucket_size

Member Typedef Documentation

template<typename _Traits>

typedef _Mylist::_Full_const_iterator Concurrency::details::_Concurrent_hash< _Traits >::_Full_const_iterator

template<typename _Traits>

typedef _Mylist::_Full_iterator Concurrency::details::_Concurrent_hash< _Traits >::_Full_iterator

template<typename _Traits>

typedef _Traits::_Key_compare Concurrency::details::_Concurrent_hash< _Traits >::_Key_compare

template<typename _Traits>

typedef _Split_ordered_list<typename _Traits::value_type, typename _Traits::allocator_type> Concurrency::details::_Concurrent_hash< _Traits >::_Mylist

template<typename _Traits>

typedef _Concurrent_hash<_Traits> Concurrency::details::_Concurrent_hash< _Traits >::_Mytype

template<typename _Traits>

typedef _Mylist::_Nodeptr Concurrency::details::_Concurrent_hash< _Traits >::_Nodeptr

template<typename _Traits>

typedef _Traits::_Value_compare Concurrency::details::_Concurrent_hash< _Traits >::_Value_compare

template<typename _Traits>

typedef _Traits::allocator_type Concurrency::details::_Concurrent_hash< _Traits >::allocator_type

template<typename _Traits>

typedef _Mylist::const_iterator Concurrency::details::_Concurrent_hash< _Traits >::const_iterator

template<typename _Traits>

typedef const_iterator Concurrency::details::_Concurrent_hash< _Traits >::const_local_iterator

template<typename _Traits>

typedef allocator_type::const_pointer Concurrency::details::_Concurrent_hash< _Traits >::const_pointer

template<typename _Traits>

typedef allocator_type::const_reference Concurrency::details::_Concurrent_hash< _Traits >::const_reference

template<typename _Traits>

typedef allocator_type::difference_type Concurrency::details::_Concurrent_hash< _Traits >::difference_type

template<typename _Traits>

typedef std::tr1::conditional<std::tr1::is_same<key_type, value_type>::value, typename _Mylist::const_iterator, typename _Mylist::iterator>::type Concurrency::details::_Concurrent_hash< _Traits >::iterator

template<typename _Traits>

typedef _Traits::key_type Concurrency::details::_Concurrent_hash< _Traits >::key_type

template<typename _Traits>

typedef iterator Concurrency::details::_Concurrent_hash< _Traits >::local_iterator

template<typename _Traits>

typedef allocator_type::pointer Concurrency::details::_Concurrent_hash< _Traits >::pointer

template<typename _Traits>

typedef allocator_type::reference Concurrency::details::_Concurrent_hash< _Traits >::reference

template<typename _Traits>

typedef allocator_type::size_type Concurrency::details::_Concurrent_hash< _Traits >::size_type

template<typename _Traits>

typedef _Traits::value_type Concurrency::details::_Concurrent_hash< _Traits >::value_type

Constructor & Destructor Documentation

template<typename _Traits>

Concurrency::details::_Concurrent_hash< _Traits >::_Concurrent_hash	(	size_type	_Number_of_buckets = `_Initial_bucket_number`,
		const _Key_compare &	_Parg = `_Key_compare()`,
		const allocator_type &	_Allocator = `allocator_type()`
	)

inline

         : _Traits(_Parg), _M_number_of_buckets(_Number_of_buckets), _M_split_ordered_list(_Allocator), _M_allocator(_Allocator), _M_maximum_bucket_size((float) _Initial_bucket_load)
     {
         _Init();
     }

template<typename _Traits>

Concurrency::details::_Concurrent_hash< _Traits >::_Concurrent_hash	(	const _Concurrent_hash< _Traits > &	_Right,
		const allocator_type &	_Allocator
	)

inline

                                                                                        : _Traits(_Right._M_comparator), _M_split_ordered_list(_Allocator), _M_allocator(_Allocator)
     {
         _Copy(_Right);
     }

template<typename _Traits>

Concurrency::details::_Concurrent_hash< _Traits >::_Concurrent_hash ( const _Concurrent_hash< _Traits > & _Right )

inline

                                                      : _Traits(_Right._M_comparator), _M_split_ordered_list(_Right.get_allocator()), _M_allocator(_Right.get_allocator())
     {
         _Init();
         _Copy(_Right);
     }

template<typename _Traits>

Concurrency::details::_Concurrent_hash< _Traits >::_Concurrent_hash ( _Concurrent_hash< _Traits > && _Right )

inline

                                                 : _Traits(_Right._M_comparator), _M_split_ordered_list(_Right.get_allocator()), _M_allocator(_Right.get_allocator()),
         _M_number_of_buckets(_Initial_bucket_number), _M_maximum_bucket_size((float) _Initial_bucket_load)
     {
         _Init();
         swap(_Right);
     }

template<typename _Traits>

Concurrency::details::_Concurrent_hash< _Traits >::~_Concurrent_hash ( )

inline

     {
         // Delete all node segments
         for (size_type _Index = 0; _Index < _Pointers_per_table; _Index++)
         {
             if (_M_buckets[_Index] != NULL)
             {
                 size_type _Seg_size = _Segment_size(_Index);
                 for (size_type _Index2 = 0; _Index2 < _Seg_size; _Index2++)
                 {
                     _M_allocator.destroy(&_M_buckets[_Index][_Index2]);
                 }
                 _M_allocator.deallocate(_M_buckets[_Index], _Seg_size);
             }
         }
     }

Member Function Documentation

template<typename _Traits>

void Concurrency::details::_Concurrent_hash< _Traits >::_Adjust_table_size	(	size_type	_Total_elements,
		size_type	_Current_size
	)

inlineprivate

     {
         // Grow the table by a factor of 2 if possible and needed
         if (((float) _Total_elements / (float) _Current_size) > _M_maximum_bucket_size)
         {
              // Double the size of the hash only if size has not changed inbetween loads
             _InterlockedCompareExchangeSizeT(&_M_number_of_buckets, 2 * _Current_size, _Current_size);
         }
     }

template<typename _Traits>

void Concurrency::details::_Concurrent_hash< _Traits >::_Copy ( const _Mytype & _Right )

inlineprivate

     {
         clear();
 
         _M_maximum_bucket_size = _Right._M_maximum_bucket_size;
         _M_number_of_buckets = _Right._M_number_of_buckets;
 
         try
         {
             _Insert(_Right.begin(), _Right.end());
             _M_comparator = _Right._M_comparator;
         }
         catch(...)
         {
             _M_split_ordered_list.clear();
             throw;
         }
     }

template<typename _Traits>

size_type Concurrency::details::_Concurrent_hash< _Traits >::_Distance	(	const_iterator	_First,
		const_iterator	_Last
	)		const

inlineprivate

     {
         size_type _Num = 0;
 
         for (const_iterator _Iterator = _First; _Iterator != _Last; _Iterator++)
         {
             _Num++;
         }
 
         return _Num;
     }

template<typename _Traits>

std::pair<iterator, iterator> Concurrency::details::_Concurrent_hash< _Traits >::_Equal_range ( const key_type & _Keyval )

inlineprivate

     {
         _Split_order_key _Order_key = (_Split_order_key) _M_comparator(_Keyval);
         size_type _Bucket = _Order_key % _M_number_of_buckets;
 
         // If _Bucket is empty, initialize it first
         if (!_Is_initialized(_Bucket))
         {
             _Initialize_bucket(_Bucket);
         }
 
         _Order_key = _Split_order_regular_key(_Order_key);
         _Full_iterator _Last = _M_split_ordered_list._End();
 
         for (_Full_iterator _Iterator = _Get_bucket(_Bucket); _Iterator != _Last; _Iterator++)
         {
             if (_Mylist::_Get_key(_Iterator) > _Order_key)
             {
                 // There is no element with the given key
                 return std::pair<iterator, iterator>(end(), end());
             }
             else if (_Mylist::_Get_key(_Iterator) == _Order_key && !_M_comparator(_Key_function(*_Iterator), _Keyval))
             {
                 iterator _Begin = _M_split_ordered_list._Get_iterator(_Iterator);
                 iterator _End= _Begin;
 
                 for (;_End != end() && !_M_comparator(_Key_function(*_End), _Keyval); _End++)
                 {
                 }
 
                 return std::pair<iterator, iterator>(_Begin, _End);
             }
         }
 
         return std::pair<iterator, iterator>(end(), end());
     }

template<typename _Traits>

std::pair<const_iterator, const_iterator> Concurrency::details::_Concurrent_hash< _Traits >::_Equal_range ( const key_type & _Keyval ) const

inlineprivate

     {
         _Split_order_key _Order_key = (_Split_order_key) _M_comparator(_Keyval);
         size_type _Bucket = _Order_key % _M_number_of_buckets;
 
         // If _Bucket has not been initialized, keep searching up for a parent bucket
         // that has been initialized.  Worst case is the entire map will be read.
         while (!_Is_initialized(_Bucket))
         {
             _Bucket = _Get_parent(_Bucket);
         }
 
         _Order_key = _Split_order_regular_key(_Order_key);
         _Full_const_iterator _Last = _M_split_ordered_list._End();
 
         for (_Full_const_iterator _Iterator = _Get_bucket(_Bucket); _Iterator != _Last; _Iterator++)
         {
             if (_Mylist::_Get_key(_Iterator) > _Order_key)
             {
                 // There is no element with the given key
                 return std::pair<const_iterator, const_iterator>(end(), end());
             }
             else if (_Mylist::_Get_key(_Iterator) == _Order_key && !_M_comparator(_Key_function(*_Iterator), _Keyval))
             {
                 const_iterator _Begin = _M_split_ordered_list._Get_iterator(_Iterator);
                 const_iterator _End = _Begin;
 
                 for (; _End != end() && !_M_comparator(_Key_function(*_End), _Keyval); _End++)
                 {
                 }
 
                 return std::pair<const_iterator, const_iterator>(_Begin, _End);
             }
         }
 
         return std::pair<const_iterator, const_iterator>(end(), end());
     }

template<typename _Traits>

iterator Concurrency::details::_Concurrent_hash< _Traits >::_Erase ( const_iterator _Iterator )

inlineprivate

     {
         _Split_order_key _Order_key = (_Split_order_key) _M_comparator(_Key_function(*_Iterator));
         size_type _Bucket = _Order_key % _M_number_of_buckets;
 
         // If bucket is empty, initialize it first
         if (!_Is_initialized(_Bucket))
         {
             _Initialize_bucket(_Bucket);
         }
 
         _Order_key = _Split_order_regular_key(_Order_key);
 
         _Full_iterator _Previous = _Get_bucket(_Bucket);
         _Full_iterator _Last = _M_split_ordered_list._End();
         _Full_iterator _Where = _Previous;
 
         _ASSERT_EXPR(_Where != _Last, L"Invalid head node");
 
         // First node is a dummy node
         _Where++;
 
         for (;;)
         {
             if (_Where == _Last)
             {
                 return end();
             }
             else if (_M_split_ordered_list._Get_iterator(_Where) == _Iterator)
             {
                 return _M_split_ordered_list._Erase(_Previous, _Iterator);
             }
 
             // Move the iterator forward
             _Previous = _Where;
             _Where++;
         }
     }

template<typename _Traits>

iterator Concurrency::details::_Concurrent_hash< _Traits >::_Find ( const key_type & _Keyval )

inlineprivate

     {
         _Split_order_key _Order_key = (_Split_order_key) _M_comparator(_Keyval);
         size_type _Bucket = _Order_key % _M_number_of_buckets;
 
         // If _Bucket is empty, initialize it first
         if (!_Is_initialized(_Bucket))
         {
             _Initialize_bucket(_Bucket);
         }
 
         _Order_key = _Split_order_regular_key(_Order_key);
         _Full_iterator _Last = _M_split_ordered_list._End();
 
         for (_Full_iterator _Iterator = _Get_bucket(_Bucket); _Iterator != _Last; _Iterator++)
         {
             if (_Mylist::_Get_key(_Iterator) > _Order_key)
             {
                 // If the order key is smaller than the current order key, the element
                 // is not in the hash.
                 return end();
             }
             else if (_Mylist::_Get_key(_Iterator) == _Order_key)
             {
                 // The fact that order keys match does not mean that the element is found.
                 // Key function comparison has to be performed to check whether this is the
                 // right element. If not, keep searching while order key is the same.
                 if (!_M_comparator(_Key_function(*_Iterator), _Keyval))
                 {
                     return _M_split_ordered_list._Get_iterator(_Iterator);
                 }
             }
         }
 
         return end();
     }

template<typename _Traits>

const_iterator Concurrency::details::_Concurrent_hash< _Traits >::_Find ( const key_type & _Keyval ) const

inlineprivate

     {
         _Split_order_key _Order_key = (_Split_order_key) _M_comparator(_Keyval);
         size_type _Bucket = _Order_key % _M_number_of_buckets;
 
         // If _Bucket has not been initialized, keep searching up for a parent bucket
         // that has been initialized.  Worst case is the entire map will be read.
         while (!_Is_initialized(_Bucket))
         {
             _Bucket = _Get_parent(_Bucket);
         }
 
         _Order_key = _Split_order_regular_key(_Order_key);
         _Full_const_iterator _Last = _M_split_ordered_list._End();
 
         for (_Full_const_iterator _Iterator = _Get_bucket(_Bucket); _Iterator != _Last; _Iterator++)
         {
             if (_Mylist::_Get_key(_Iterator) > _Order_key)
             {
                 // If the order key is smaller than the current order key, the element
                 // is not in the hash.
                 return end();
             }
             else if (_Mylist::_Get_key(_Iterator) == _Order_key)
             {
                 // The fact that order keys match does not mean that the element is found.
                 // Key function comparison has to be performed to check whether this is the
                 // right element. If not, keep searching while order key is the same.
                 if (!_M_comparator(_Key_function(*_Iterator), _Keyval))
                 {
                     return _M_split_ordered_list._Get_iterator(_Iterator);
                 }
             }
         }
 
         return end();
     }

template<typename _Traits>

_Full_iterator Concurrency::details::_Concurrent_hash< _Traits >::_Get_bucket ( size_type _Bucket ) const

inlineprivate

     {
         size_type _Segment = _Segment_index_of(_Bucket);
         _Bucket -= _Segment_base(_Segment);
         return _M_buckets[_Segment][_Bucket];
     }

template<typename _Traits>

size_type Concurrency::details::_Concurrent_hash< _Traits >::_Get_parent ( size_type _Bucket ) const

inlineprivate

     {
         // Unsets bucket's most significant turned-on bit
         unsigned char _Msb = _Get_msb(_Bucket);
         return _Bucket & ~(1 << _Msb);
     }

template<typename _Traits>

void Concurrency::details::_Concurrent_hash< _Traits >::_Init ( )

inlineprivate

     {
         // Allocate an array of segment pointers
         memset(_M_buckets, 0, _Pointers_per_table * sizeof(void *));
 
         // Insert the first element in the split-ordered list
         _Full_iterator _Dummy_node = _M_split_ordered_list._Begin();
         _Set_bucket(0, _Dummy_node);
     }

template<typename _Traits>

void Concurrency::details::_Concurrent_hash< _Traits >::_Initialize_bucket ( size_type _Bucket )

inlineprivate

     {
         // Bucket 0 has no parent. Initialize it and return.
         if (_Bucket == 0)
         {
             _Init();
             return;
         }
 
         size_type _Parent_bucket = _Get_parent(_Bucket);
 
         // All _Parent_bucket buckets have to be initialized before this bucket is
         if (!_Is_initialized(_Parent_bucket))
         {
             _Initialize_bucket(_Parent_bucket);
         }
 
         _Full_iterator _Parent = _Get_bucket(_Parent_bucket);
 
         // Create a dummy first node in this bucket
         _Full_iterator _Dummy_node = _M_split_ordered_list._Insert_dummy(_Parent, _Split_order_dummy_key(_Bucket));
         _Set_bucket(_Bucket, _Dummy_node);
     }

template<typename _Traits>

template<typename _ValTy >

std::pair<iterator, bool> Concurrency::details::_Concurrent_hash< _Traits >::_Insert ( _ValTy && _Value )

inlineprotected

     {
         _Split_order_key _Order_key = (_Split_order_key) _M_comparator(_Key_function(_Value));
         size_type _Bucket = _Order_key % _M_number_of_buckets;
 
         // If bucket is empty, initialize it first
         if (!_Is_initialized(_Bucket))
         {
             _Initialize_bucket(_Bucket);
         }
 
         long _New_count;
         _Order_key = _Split_order_regular_key(_Order_key);
         _Full_iterator _Iterator = _Get_bucket(_Bucket);
         _Full_iterator _Last = _M_split_ordered_list._End();
         _Full_iterator _Where = _Iterator;
         _Nodeptr _New_node = _M_split_ordered_list._Buynode(_Order_key, std::forward<_ValTy>(_Value));
 
         _ASSERT_EXPR(_Where != _Last, L"Invalid head node");
 
         // First node is a dummy node
         _Where++;
 
         for (;;)
         {
             if (_Where == _Last || _Mylist::_Get_key(_Where) > _Order_key)
             {
                 // Try to insert it in the right place
                 std::pair<iterator, bool> _Result = _M_split_ordered_list._Insert(_Iterator, _Where, _New_node, &_New_count);
 
                 if (_Result.second)
                 {
                     // Insertion succeeded, adjust the table size, if needed
                     _Adjust_table_size(_New_count, _M_number_of_buckets);
                     return _Result;
                 }
                 else
                 {
                     // Insertion failed: either the same node was inserted by another thread, or
                     // another element was inserted at exactly the same place as this node.
                     // Proceed with the search from the previous location where order key was
                     // known to be larger (note: this is legal only because there is no safe
                     // concurrent erase operation supported).
                     _Where = _Iterator;
                     _Where++;
                     continue;
                 }
             }
             else if (!_M_allow_multimapping && _Mylist::_Get_key(_Where) == _Order_key &&
                 _M_comparator(_Key_function(*_Where), _Key_function(_New_node->_M_element)) == 0)
             {
                 // If the insert failed (element already there), then delete the new one
                 _M_split_ordered_list._Erase(_New_node);
 
                 // Element already in the list, return it
                 return std::pair<iterator, bool>(_M_split_ordered_list._Get_iterator(_Where), false);
             }
 
             // Move the iterator forward
             _Iterator = _Where;
             _Where++;
         }
     }

template<typename _Traits>

template<class _Iterator >

void Concurrency::details::_Concurrent_hash< _Traits >::_Insert	(	_Iterator	_First,
		_Iterator	_Last
	)

inlineprotected

     {
         for (_Iterator _I = _First; _I != _Last; _I++)
         {
             _Insert(*_I);
         }
     }

template<typename _Traits>

bool Concurrency::details::_Concurrent_hash< _Traits >::_Is_initialized ( size_type _Bucket ) const

inlineprivate

     {
         size_type _Segment = _Segment_index_of(_Bucket);
         _Bucket -= _Segment_base(_Segment);
 
         if (_M_buckets[_Segment] == NULL)
         {
             return false;
         }
 
         _Full_iterator _Iterator = _M_buckets[_Segment][_Bucket];
         return (_Iterator._Mynode() != NULL);
     }

template<typename _Traits>

_Split_order_key Concurrency::details::_Concurrent_hash< _Traits >::_Reverse ( _Map_key _Order_key ) const

inlineprivate

     {
         _Split_order_key _Reversed_order_key;
 
         unsigned char * _Original = (unsigned char *) &_Order_key;
         unsigned char * _Reversed = (unsigned char *) &_Reversed_order_key;
 
         int _Size = sizeof(_Map_key);
         for (int _Index = 0; _Index < _Size; _Index++)
         {
             _Reversed[_Size - _Index - 1] = _Reverse_byte(_Original[_Index]);
         }
 
         return _Reversed_order_key;
     }

template<typename _Traits>

static size_type Concurrency::details::_Concurrent_hash< _Traits >::_Segment_base ( size_type _K )

inlinestatic

     {
         return (size_type(1)<<_K & ~size_type(1));
     }

template<typename _Traits>

static size_type __cdecl Concurrency::details::_Concurrent_hash< _Traits >::_Segment_index_of ( size_type _Index )

inlinestatic

     {
         return size_type( _Get_msb( _Index|1 ) );
     }

template<typename _Traits>

static size_type Concurrency::details::_Concurrent_hash< _Traits >::_Segment_size ( size_type _K )

inlinestatic

     {
         return _K ? size_type(1)<<_K : 2;
     }

template<typename _Traits>

void Concurrency::details::_Concurrent_hash< _Traits >::_Set_bucket	(	size_type	_Bucket,
		_Full_iterator	_Dummy_head
	)

inlineprivate

     {
         size_type _Segment = _Segment_index_of(_Bucket);
         _Bucket -= _Segment_base(_Segment);
 
         if (_M_buckets[_Segment] == NULL)
         {
             size_type _Seg_size = _Segment_size(_Segment);
             _Full_iterator * _New_segment = _M_allocator.allocate(_Seg_size);
             std::_Wrap_alloc<decltype(_M_allocator)> _Wrapped_allocator(_M_allocator);
             std::_Uninitialized_default_fill_n(_New_segment, _Seg_size, _Wrapped_allocator);
             if (_InterlockedCompareExchangePointer((void * volatile *) &_M_buckets[_Segment], _New_segment, NULL) != NULL)
             {
                 _M_allocator.deallocate(_New_segment, _Seg_size);
             }
         }
         _M_buckets[_Segment][_Bucket] = _Dummy_head;
     }

template<typename _Traits>

_Split_order_key Concurrency::details::_Concurrent_hash< _Traits >::_Split_order_dummy_key ( _Map_key _Order_key ) const

inlineprivate

     {
         return _Reverse(_Order_key) & ~(0x1);
     }

template<typename _Traits>

_Split_order_key Concurrency::details::_Concurrent_hash< _Traits >::_Split_order_regular_key ( _Map_key _Order_key ) const

inlineprivate

     {
         return _Reverse(_Order_key) | 0x1;
     }

template<typename _Traits>

void Concurrency::details::_Concurrent_hash< _Traits >::_Swap_buckets ( _Concurrent_hash< _Traits > & _Right )

inlineprivate

     {
         if (_M_allocator == _Right._M_allocator)
         {
             // Swap all node segments
             for (size_type _Index = 0; _Index < _Pointers_per_table; _Index++)
             {
                 _Full_iterator * _Iterator_pointer = _M_buckets[_Index];
                 _M_buckets[_Index] = _Right._M_buckets[_Index];
                 _Right._M_buckets[_Index] = _Iterator_pointer;
             }
         }
         else
         {
             throw std::invalid_argument("swap is invalid on non-equal allocators");
         }
     }

template<typename _Traits>

iterator Concurrency::details::_Concurrent_hash< _Traits >::begin ( )

inline

Returns an iterator pointing to the first element in the concurrent container. This method is concurrency safe.

Returns: An iterator to the first element in the concurrent container.

     {
         return _M_split_ordered_list.begin();
     }

template<typename _Traits>

const_iterator Concurrency::details::_Concurrent_hash< _Traits >::begin ( ) const

inline

Returns an iterator pointing to the first element in the concurrent container. This method is concurrency safe.

Returns: An iterator to the first element in the concurrent container.

     {
         return _M_split_ordered_list.begin();
     }

template<typename _Traits>

const_iterator Concurrency::details::_Concurrent_hash< _Traits >::cbegin ( ) const

inline

Returns a const iterator pointing to the first element in the concurrent container. This method is concurrency safe.

Returns: A const iterator to the first element in the concurrent container.

     {
         return _M_split_ordered_list.cbegin();
     }

template<typename _Traits>

const_iterator Concurrency::details::_Concurrent_hash< _Traits >::cend ( ) const

inline

Returns a const iterator pointing to the location succeeding the last element in the concurrent container. This method is concurrency safe.

Returns: A const iterator to the location succeeding the last element in the concurrent container.

     {
         return _M_split_ordered_list.cend();
     }

template<typename _Traits>

void Concurrency::details::_Concurrent_hash< _Traits >::clear ( )

inline

Erases all the elements in the concurrent container. This function is not concurrency safe.

     {
         // Clear list
         _M_split_ordered_list.clear();
 
         // Clear buckets
         for (size_type _Index = 0; _Index < _Pointers_per_table; _Index++)
         {
             if (_M_buckets[_Index] != NULL)
             {
                 size_type _Seg_size = _Segment_size(_Index);
                 for (size_type _Index2 = 0; _Index2 < _Seg_size; _Index2++)
                 {
                     _M_allocator.destroy(&_M_buckets[_Index][_Index2]);
                 }
                 _M_allocator.deallocate(_M_buckets[_Index], _Seg_size);
             }
         }
 
         // memset all the buckets to zero and initialize the dummy node 0
         _Init();
     }

template<typename _Traits>

size_type Concurrency::details::_Concurrent_hash< _Traits >::count ( const key_type & _Keyval ) const

inline

Counts the number of elements matching a specified key. This function is concurrency safe.

Parameters

_Keyval The key to search for.

Returns: The number of times number of times the key appears in the container.

     {
         size_type _Count = 0;
         const_iterator _It = _Find(_Keyval);
         for (;_It != end() && !_M_comparator(_Key_function(*_It), _Keyval); _It++)
         {
             _Count++;
         }
         return _Count;
     }

template<typename _Traits>

bool Concurrency::details::_Concurrent_hash< _Traits >::empty ( ) const

inline

Tests whether no elements are present. This method is concurrency safe.

In the presence of concurrent inserts, whether or not the concurrent container is empty may change immediately after calling this function, before the return value is even read.

Returns: true if the concurrent container is empty, false otherwise.

     {
         return _M_split_ordered_list.empty();
     }

template<typename _Traits>

iterator Concurrency::details::_Concurrent_hash< _Traits >::end ( )

inline

Returns an iterator pointing to the location succeeding the last element in the concurrent container. This method is concurrency safe.

Returns: An iterator to the location succeeding the last element in the concurrent container.

     {
         return _M_split_ordered_list.end();
     }

template<typename _Traits>

const_iterator Concurrency::details::_Concurrent_hash< _Traits >::end ( ) const

inline

Returns a const_iterator pointing to the location succeeding the last element in the concurrent container. This method is concurrency safe.

Returns: A const_iterator to the location succeeding the last element in the concurrent container.

     {
         return _M_split_ordered_list.end();
     }

template<typename _Traits>

std::pair<iterator, iterator> Concurrency::details::_Concurrent_hash< _Traits >::equal_range ( const key_type & _Keyval )

inline

Finds a range that matches a specified key. This function is concurrency safe.

Parameters

_Keyval The key value to search for.

Returns: A pair where the first element is an iterator to the beginning and the second element is an iterator to the end of the range.

It is possible for concurrent inserts to cause additional keys to be inserted after the begin iterator and before the end iterator.

     {
         return _Equal_range(_Keyval);
     }

template<typename _Traits>

std::pair<const_iterator, const_iterator> Concurrency::details::_Concurrent_hash< _Traits >::equal_range ( const key_type & _Keyval ) const

inline

Finds a range that matches a specified key. This function is concurrency safe.

Parameters

_Keyval The key value to search for.

Returns: A pair where the first element is an iterator to the beginning and the second element is an iterator to the end of the range.

It is possible for concurrent inserts to cause additional keys to be inserted after the begin iterator and before the end iterator.

     {
         return _Equal_range(_Keyval);
     }

template<typename _Traits>

iterator Concurrency::details::_Concurrent_hash< _Traits >::find ( const key_type & _Keyval )

inline

Finds an element that matches a specified key. This function is concurrency safe.

Parameters

_Keyval The key value to search for.

Returns: An iterator pointing to the location of the the first element that matched the key provided, or the iterator end() if no such element exists.

     {
         return _Find(_Keyval);
     }

template<typename _Traits>

const_iterator Concurrency::details::_Concurrent_hash< _Traits >::find ( const key_type & _Keyval ) const

inline

Finds an element that matches a specified key. This function is concurrency safe.

Parameters

_Keyval The key value to search for.

Returns: An iterator pointing to the location of the the first element that matched the key provided, or the iterator end() if no such element exists.

     {
         return _Find(_Keyval);
     }

template<typename _Traits>

allocator_type Concurrency::details::_Concurrent_hash< _Traits >::get_allocator ( ) const

inline

Returns the stored allocator object for this concurrent container. This method is concurrency safe.

Returns: The stored allocator object for this concurrent container.

     {
         return _M_split_ordered_list.get_allocator();
     }

template<typename _Traits>

float Concurrency::details::_Concurrent_hash< _Traits >::load_factor ( ) const

inline

Computes and returns the current load factor of the container. The load factor is the number of elements in the container divided by the number of buckets.

Returns: The load factor for the container.

     {
         return (float) size() / (float) unsafe_bucket_count();
     }

template<typename _Traits>

float Concurrency::details::_Concurrent_hash< _Traits >::max_load_factor ( ) const

inline

Gets or sets the maximum load factor of the container. The maximum load factor is the largest number of elements than can be in any bucket before the container grows its internal table.

Returns: The first member function returns the stored maximum load factor. The second member function does not return a value but throws an out_of_range exception if the supplied load factor is invalid..

     {
         return _M_maximum_bucket_size;
     }

template<typename _Traits>

void Concurrency::details::_Concurrent_hash< _Traits >::max_load_factor ( float _Newmax )

inline

Gets or sets the maximum load factor of the container. The maximum load factor is the largest number of elements than can be in any bucket before the container grows its internal table.

Returns: The first member function returns the stored maximum load factor. The second member function does not return a value but throws an out_of_range exception if the supplied load factor is invalid..

     {
         // The _Newmax != _Newmax is a check for NaN, because NaN is != to itself
         if (_Newmax != _Newmax || _Newmax < 0)
         {
             throw std::out_of_range("invalid hash load factor");
         }
 
         _M_maximum_bucket_size = _Newmax;
     }

template<typename _Traits>

size_type Concurrency::details::_Concurrent_hash< _Traits >::max_size ( ) const

inline

Returns the maximum size of the concurrent container, determined by the allocator. This method is concurrency safe.

This upper bound value may actually be higher than what the container can actually hold.

Returns: The maximum number of elements that can be inserted into this concurrent container.

     {
         return _M_split_ordered_list.max_size();
     }

template<typename _Traits>

_Concurrent_hash& Concurrency::details::_Concurrent_hash< _Traits >::operator= ( const _Concurrent_hash< _Traits > & _Right )

inline

     {
         if (this != &_Right)
         {
             _Copy(_Right);
         }
 
         return (*this);
     }

template<typename _Traits>

_Concurrent_hash& Concurrency::details::_Concurrent_hash< _Traits >::operator= ( _Concurrent_hash< _Traits > && _Right )

inline

     {
         if (this != &_Right)
         {
             clear();
             swap(_Right);
         }
 
         return (*this);
     }

template<typename _Traits>

void Concurrency::details::_Concurrent_hash< _Traits >::rehash ( size_type _Buckets )

inline

Rebuilds the hash table.

Parameters

_Buckets The desired number of buckets.

The member function alters the number of buckets to be at least _Buckets and rebuilds the hash table as needed. The number of buckets must be a power of 2. If not a power of 2, it will be rounded up to the next largest power of 2.

It throws an out_of_range exception if the number of buckets is invalid (either 0 or greater than the maximum number of buckets).

     {
         size_type _Current_buckets = _M_number_of_buckets;
 
         if (_Current_buckets > _Buckets)
         {
             return;
         }
         else if (_Buckets <= 0 || _Buckets > unsafe_max_bucket_count())
         {
             throw std::out_of_range("invalid number of buckets");
         }
         // Round up the number of buckets to the next largest power of 2
         _M_number_of_buckets = ((size_type) 1) << _Get_msb(_Buckets*2-1);
     }

template<typename _Traits>

size_type Concurrency::details::_Concurrent_hash< _Traits >::size ( ) const

inline

Returns the number of elements in this concurrent container. This method is concurrency safe.

In the presence of concurrent inserts, the number of elements in the concurrent container may change immediately after calling this function, before the return value is even read.

Returns: The number of items in the container.

     {
         return _M_split_ordered_list.size();
     }

template<typename _Traits>

void Concurrency::details::_Concurrent_hash< _Traits >::swap ( _Concurrent_hash< _Traits > & _Right )

inline

Swaps the contents of two concurrent containers. This function is not concurrency safe.

Parameters

_Right The container to swap elements from.

The member function throws an invalid_argument exception if the swap is being performed on unequal allocators.

     {
         if (this != &_Right)
         {
             std::_Swap_adl(_M_comparator, _Right._M_comparator);
             _M_split_ordered_list.swap(_Right._M_split_ordered_list);
             _Swap_buckets(_Right);
             std::swap(_M_number_of_buckets, _Right._M_number_of_buckets);
             std::swap(_M_maximum_bucket_size, _Right._M_maximum_bucket_size);
         }
     }

template<typename _Traits>

local_iterator Concurrency::details::_Concurrent_hash< _Traits >::unsafe_begin ( size_type _Bucket )

inline

Returns an iterator to the first element in this container for a specific bucket.

Parameters

_Bucket The bucket index.

Returns: An iterator pointing to the beginning of the bucket.

     {
         // It is possible the bucket being searched for has not yet been initialized
         if (!_Is_initialized(_Bucket))
         {
             _Initialize_bucket(_Bucket);
         }
 
         _Full_iterator _Iterator = _Get_bucket(_Bucket);
         return _M_split_ordered_list._Get_first_real_iterator(_Iterator);
     }

template<typename _Traits>

const_local_iterator Concurrency::details::_Concurrent_hash< _Traits >::unsafe_begin ( size_type _Bucket ) const

inline

Returns an iterator to the first element in this container for a specific bucket.

Parameters

_Bucket The bucket index.

Returns: An iterator pointing to the beginning of the bucket.

     {
         // It is possible the bucket being searched for has not yet been initialized
         if (!_Is_initialized(_Bucket))
         {
             _Initialize_bucket(_Bucket);
         }
 
 
         _Full_const_iterator _Iterator = _Get_bucket(_Bucket);
         return _M_split_ordered_list._Get_first_real_iterator(_Iterator);
     }

template<typename _Traits>

size_type Concurrency::details::_Concurrent_hash< _Traits >::unsafe_bucket ( const key_type & _Keyval ) const

inline

Returns the bucket index that a specific key maps to in this container.

Parameters

_Keyval The element key being searched for.

Returns: The bucket index for the key in this container.

     {
         _Split_order_key _Order_key = (_Split_order_key) _M_comparator(_Keyval);
         size_type _Bucket = _Order_key % _M_number_of_buckets;
         return _Bucket;
     }

template<typename _Traits>

size_type Concurrency::details::_Concurrent_hash< _Traits >::unsafe_bucket_count ( ) const

inline

Returns the current number of buckets in this container.

Returns: The current number of buckets in this container.

     {
         return _M_number_of_buckets;
     }

template<typename _Traits>

size_type Concurrency::details::_Concurrent_hash< _Traits >::unsafe_bucket_size ( size_type _Bucket )

inline

Returns the number of items in a specific bucket of this container.

Parameters

_Bucket The bucket to search for.

Returns: The current number of buckets in this container.

     {
         size_type _Count = 0;
 
         if (!_Is_initialized(_Bucket))
         {
             return _Count;
         }
 
         _Full_iterator _Iterator = _Get_bucket(_Bucket);
         _Iterator++;
 
         for (; _Iterator != _M_split_ordered_list._End() && !_Iterator._Mynode()->_Is_dummy(); _Iterator++)
         {
             _Count++;
         }
 
         return _Count;
     }

template<typename _Traits>

const_local_iterator Concurrency::details::_Concurrent_hash< _Traits >::unsafe_cbegin ( size_type ) const

inline

Returns an iterator to the first element in this container for a specific bucket.

Parameters

_Bucket The bucket index.

Returns: An iterator pointing to the beginning of the bucket.

     {
         return ((const _Mytype *) this)->begin();
     }

template<typename _Traits>

const_local_iterator Concurrency::details::_Concurrent_hash< _Traits >::unsafe_cend ( size_type ) const

inline

Returns an iterator to the first element in this container for a specific bucket.

Parameters

_Bucket The bucket index.

Returns: An iterator pointing to the beginning of the bucket.

     {
         return ((const _Mytype *) this)->end();
     }

template<typename _Traits>

local_iterator Concurrency::details::_Concurrent_hash< _Traits >::unsafe_end ( size_type _Bucket )

inline

Returns an iterator to the last element in this container for a specific bucket.

Parameters

_Bucket The bucket index.

Returns: An iterator pointing to the end of the bucket.

     {
         // If we've increased the number of buckets, there's a chance the intermediate dummy
         // node marking the end of this bucket has not yet been lazily initialized.
         // Inserting from _M_number_of_buckets/2 to _M_number_of_buckets will recursively
         // initialize all the dummy nodes in the map.
         for(size_type _Bucket_index = _M_number_of_buckets >> 1; _Bucket_index < _M_number_of_buckets; _Bucket_index++)
         {
             if (!_Is_initialized(_Bucket_index))
             {
                 _Initialize_bucket(_Bucket_index);
             }
         }
 
         _Full_iterator _Iterator = _Get_bucket(_Bucket);
 
         // Find the end of the bucket, denoted by the dummy element
         do
         {
             _Iterator++;
         }
         while(_Iterator != _M_split_ordered_list._End() && !_Iterator._Mynode()->_Is_dummy());
 
         // Return the first real element past the end of the bucket
         return _M_split_ordered_list._Get_first_real_iterator(_Iterator);
     }

template<typename _Traits>

const_local_iterator Concurrency::details::_Concurrent_hash< _Traits >::unsafe_end ( size_type _Bucket ) const

inline

Returns an iterator to the last element in this container for a specific bucket.

Parameters

_Bucket The bucket index.

Returns: An iterator pointing to the end of the bucket.

     {
         // If we've increased the number of buckets, there's a chance the intermediate dummy
         // node marking the end of this bucket has not yet been lazily initialized.
         // Inserting from _M_number_of_buckets/2 to _M_number_of_buckets will recursively
         // initialize all the dummy nodes in the map.
         for(size_type _Bucket_index = _M_number_of_buckets >> 1; _Bucket_index < _M_number_of_buckets; _Bucket_index++)
         {
             if (!_Is_initialized(_Bucket_index))
             {
                 _Initialize_bucket(_Bucket_index);
             }
         }
 
         _Full_const_iterator _Iterator = _Get_bucket(_Bucket);
 
         // Find the end of the bucket, denoted by the dummy element
         do
         {
             _Iterator++;
         }
         while(_Iterator != _M_split_ordered_list._End() && !_Iterator._Mynode()->_Is_dummy());
 
         // Return the first real element past the end of the bucket
         return _M_split_ordered_list._Get_first_real_iterator(_Iterator);
     }

template<typename _Traits>

iterator Concurrency::details::_Concurrent_hash< _Traits >::unsafe_erase ( const_iterator _Where )

inline

Removes elements from the container at specified positions. This method is not concurrency-safe.

Parameters

_Where The iterator position to erase from.

The first member function removes the element of the controlled sequence pointed to by _Where . The second member function removes the elements in the range [_First , _Last ).

The third member function removes the elements in the range delimited by equal_range(_Keyval )

.

Returns: The first two member functions return an iterator that designates the first element remaining beyond any elements removed, or end() if no such element exists. The third member function returns the number of elements it removes.

     {
         if (_Where == end())
         {
             return end();
         }
 
         return _Erase(_Where);
     }

template<typename _Traits>

iterator Concurrency::details::_Concurrent_hash< _Traits >::unsafe_erase	(	const_iterator	_First,
		const_iterator	_Last
	)

inline

Removes elements from the container at specified positions. This method is not concurrency-safe.

Parameters

_First	The position of the first element in the range of elements to be erased.
_Last	The position of the first element beyond the range of elements to be erased.

The first member function removes the element of the controlled sequence pointed to by _Where . The second member function removes the elements in the range [_First , _Last ).

The third member function removes the elements in the range delimited by equal_range(_Keyval )

.

Returns: The first two member functions return an iterator that designates the first element remaining beyond any elements removed, or end() if no such element exists. The third member function returns the number of elements it removes.

     {
         while (_First != _Last)
         {
             unsafe_erase(_First++);
         }
 
         return _M_split_ordered_list._Get_iterator(_First);
     }

template<typename _Traits>

size_type Concurrency::details::_Concurrent_hash< _Traits >::unsafe_erase ( const key_type & _Keyval )

inline

Removes elements from the container at specified positions. This method is not concurrency-safe.

Parameters

_Keyval The key value to erase.

The first member function removes the element of the controlled sequence pointed to by _Where . The second member function removes the elements in the range [_First , _Last ).

The third member function removes the elements in the range delimited by equal_range(_Keyval )

.

Returns: The first two member functions return an iterator that designates the first element remaining beyond any elements removed, or end() if no such element exists. The third member function returns the number of elements it removes.

     {
         std::pair<iterator, iterator> _Where = equal_range(_Keyval);
         size_type _Count = _Distance(_Where.first, _Where.second);
         unsafe_erase(_Where.first, _Where.second);
         return _Count;
     }

template<typename _Traits>

size_type Concurrency::details::_Concurrent_hash< _Traits >::unsafe_max_bucket_count ( ) const

inline

Returns the maximum number of buckets in this container.

Returns: The maximum number of buckets in this container.

     {
         return _Segment_size(_Pointers_per_table-1);
     }

Member Data Documentation

template<typename _Traits>

const size_type Concurrency::details::_Concurrent_hash< _Traits >::_Initial_bucket_load = 4

static

template<typename _Traits>

const size_type Concurrency::details::_Concurrent_hash< _Traits >::_Initial_bucket_number = 8

static

template<typename _Traits>

allocator_type::template rebind<_Full_iterator>::other Concurrency::details::_Concurrent_hash< _Traits >::_M_allocator

private

template<typename _Traits>

_Full_iterator* Concurrency::details::_Concurrent_hash< _Traits >::_M_buckets[_Pointers_per_table]

private

template<typename _Traits>

float Concurrency::details::_Concurrent_hash< _Traits >::_M_maximum_bucket_size

private

template<typename _Traits>

size_type Concurrency::details::_Concurrent_hash< _Traits >::_M_number_of_buckets

private

template<typename _Traits>

_Mylist Concurrency::details::_Concurrent_hash< _Traits >::_M_split_ordered_list

private

template<typename _Traits>

size_type const Concurrency::details::_Concurrent_hash< _Traits >::_Pointers_per_table = sizeof(size_type) * 8

static

The documentation for this class was generated from the following file:

VS2013/inc/internal_concurrent_hash.h

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation