The concurrent_unordered_map class is a concurrency-safe container that controls a varying-length sequence of elements of type std::pair<const _Key_type, _Element_type>. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access, and iterator traversal operations. More...

#include <concurrent_unordered_map.h>

Inheritance diagram for Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >:

Public Types
typedef concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >	_Mytype

typedef details::_Hash_compare< _Key_type, _Hasher, _Key_equality >	_Key_compare

typedef details::_Concurrent_hash< details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, _Key_compare, _Allocator_type, false > >	_Mybase

typedef _Key_type	key_type
	The type of an ordering key. More...

typedef _Mybase::value_type	value_type
	The type of an element. More...

typedef _Element_type	mapped_type
	The type of a mapped value associated with each key. More...

typedef _Hasher	hasher
	The type of the hash function. More...

typedef _Key_equality	key_equal
	The type of the comparison function. More...

typedef _Mybase::allocator_type	allocator_type
	The type of an allocator for managing storage. More...

typedef _Mybase::pointer	pointer
	The type of a pointer to an element. More...

typedef _Mybase::const_pointer	const_pointer
	The type of a constant pointer to an element. More...

typedef _Mybase::reference	reference
	The type of a reference to an element. More...

typedef _Mybase::const_reference	const_reference
	The type of a constant reference to an element. More...

typedef _Mybase::size_type	size_type
	The type of an unsigned distance between two elements. More...

typedef _Mybase::difference_type	difference_type
	The type of a signed distance between two elements. More...

typedef _Mybase::iterator	iterator
	The type of an iterator for the controlled sequence. More...

typedef _Mybase::const_iterator	const_iterator
	The type of a constant iterator for the controlled sequence. More...

typedef _Mybase::iterator	local_iterator
	The type of a bucket iterator for the controlled sequence. More...

typedef _Mybase::const_iterator	const_local_iterator
	The type of a constant bucket iterator for the controlled sequence. More...

Public Types inherited from Concurrency::details::_Concurrent_hash< details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false > >
typedef _Concurrent_hash< details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false > >	_Mytype

typedef _Split_ordered_list< typename details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >::value_type, typename details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >::allocator_type >	_Mylist

typedef details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >::_Key_compare	_Key_compare

typedef details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >::_Value_compare	_Value_compare

typedef details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >::value_type	value_type

typedef details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >::key_type	key_type

typedef details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >::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::conditional< std::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 Types inherited from Concurrency::details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >
enum

typedef std::pair< const _Key_type, _Element_type >	value_type

typedef _Key_type	key_type

typedef details::_Hash_compare< _Key_type, _Hasher, _Key_equality >	_Key_compare

typedef _Allocator_type::template rebind< value_type >::other	allocator_type

Public Member Functions
	concurrent_unordered_map (size_type _Number_of_buckets=8, const hasher &_Hasher=hasher(), const key_equal &_Key_equality=key_equal(), const allocator_type &_Allocator=allocator_type())
	Constructs a concurrent unordered map. More...

	concurrent_unordered_map (const allocator_type &_Allocator)
	Constructs a concurrent unordered map. More...

template<typename _Iterator >
	concurrent_unordered_map (_Iterator _Begin, _Iterator _End, size_type _Number_of_buckets=8, const hasher &_Hasher=hasher(), const key_equal &_Key_equality=key_equal(), const allocator_type &_Allocator=allocator_type())
	Constructs a concurrent unordered map. More...

	concurrent_unordered_map (const concurrent_unordered_map &_Umap)
	Constructs a concurrent unordered map. More...

	concurrent_unordered_map (const concurrent_unordered_map &_Umap, const allocator_type &_Allocator)
	Constructs a concurrent unordered map. More...

	concurrent_unordered_map (concurrent_unordered_map &&_Umap)
	Constructs a concurrent unordered map. More...

concurrent_unordered_map &	operator= (const concurrent_unordered_map &_Umap)
	Assigns the contents of another `concurrent_unordered_map` object to this one. This method is not concurrency-safe. More...

concurrent_unordered_map &	operator= (concurrent_unordered_map &&_Umap)
	Assigns the contents of another `concurrent_unordered_map` object to this one. This method is not concurrency-safe. More...

std::pair< iterator, bool >	insert (const value_type &_Value)
	Adds elements to the `concurrent_unordered_map` object. More...

iterator	insert (const_iterator _Where, const value_type &_Value)
	Adds elements to the `concurrent_unordered_map` object. More...

template<class _Iterator >
void	insert (_Iterator _First, _Iterator _Last)
	Adds elements to the `concurrent_unordered_map` object. More...

template<class _Valty >
std::pair< iterator, bool >	insert (_Valty &&_Value)
	Adds elements to the `concurrent_unordered_map` object. More...

template<class _Valty >
std::enable_if<!std::is_same< const_iterator, typename std::remove_reference< _Valty >::type >::value, iterator >::type	insert (const_iterator _Where, _Valty &&_Value)
	Adds elements to the `concurrent_unordered_map` object. More...

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

iterator	unsafe_erase (const_iterator _Begin, const_iterator _End)
	Removes elements from the `concurrent_unordered_map` at specified positions. This method is not concurrency-safe. More...

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

void	swap (concurrent_unordered_map &_Umap)
	Swaps the contents of two `concurrent_unordered_map` objects. This method is not concurrency-safe. More...

hasher	hash_function () const
	Gets the stored hash function object. More...

key_equal	key_eq () const
	Gets the stored equality comparison function object. More...

mapped_type &	operator[] (const key_type &_Keyval)
	Finds or inserts an element with the specified key. This method is concurrency-safe. More...

mapped_type &	operator[] (key_type &&_Keyval)
	Finds or inserts an element with the specified key. This method is concurrency-safe. More...

mapped_type &	at (const key_type &_Keyval)
	Finds an element in a `concurrent_unordered_map` with a specified key value.. This method is concurrency-safe. More...

const mapped_type &	at (const key_type &_Keyval) const
	Finds an element in a `concurrent_unordered_map` with a specified key value.. This method is concurrency-safe. More...

Public Member Functions inherited from Concurrency::details::_Concurrent_hash< details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false > >
	_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...

Public Member Functions inherited from Concurrency::details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >
	_Concurrent_unordered_map_traits ()

	_Concurrent_unordered_map_traits (const _Key_compare &_Traits)

Additional Inherited Members
Static Public Member Functions inherited from Concurrency::details::_Concurrent_hash< details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false > >
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 Member Functions inherited from Concurrency::details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >
static const _Type1 &	_Key_function (const std::pair< _Type1, _Type2 > &_Value)

Public Attributes inherited from Concurrency::details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >
_Key_compare	_M_comparator

Static Public Attributes inherited from Concurrency::details::_Concurrent_hash< details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false > >
static const size_type	_Initial_bucket_number

static const size_type	_Initial_bucket_load

static size_type const	_Pointers_per_table

Protected Member Functions inherited from Concurrency::details::_Concurrent_hash< details::_Concurrent_unordered_map_traits< _Key_type, _Element_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false > >
std::pair< iterator, bool >	_Insert (_ValTy &&_Value)

void	_Insert (_Iterator _First, _Iterator _Last)

Detailed Description

template<typename _Key_type, typename _Element_type, typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>
class Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >

The concurrent_unordered_map class is a concurrency-safe container that controls a varying-length sequence of elements of type std::pair<const _Key_type, _Element_type>. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access, and iterator traversal operations.

Template Parameters

_Key_type	The key type.
_Element_type	The mapped type.
_Hasher	The hash function object type. This argument is optional and the default value is `std::hash<`_Key_type `>`.
_Key_equality	The equality comparison function object type. This argument is optional and the default value is `std::equal_to<`_Key_type `>`.
_Allocator_type	The type that represents the stored allocator object that encapsulates details about the allocation and deallocation of memory for the concurrent unordered map. This argument is optional and the default value is `std::allocator<std::pair<`_Key_type , _Element_type `>>`.

For detailed information on the concurrent_unordered_map class, see Parallel Containers and Objects.

See also: Parallel Containers and Objects

Member Typedef Documentation

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef details::_Hash_compare<_Key_type, _Hasher, _Key_equality> Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::_Key_compare

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef details::_Concurrent_hash< details::_Concurrent_unordered_map_traits<_Key_type, _Element_type, _Key_compare, _Allocator_type, false> > Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::_Mybase

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef concurrent_unordered_map<_Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type> Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::_Mytype

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Mybase::allocator_type Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::allocator_type

The type of an allocator for managing storage.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Mybase::const_iterator Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::const_iterator

The type of a constant iterator for the controlled sequence.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Mybase::const_iterator Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::const_local_iterator

The type of a constant bucket iterator for the controlled sequence.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Mybase::const_pointer Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::const_pointer

The type of a constant pointer to an element.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Mybase::const_reference Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::const_reference

The type of a constant reference to an element.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Mybase::difference_type Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::difference_type

The type of a signed distance between two elements.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Hasher Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::hasher

The type of the hash function.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Mybase::iterator Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::iterator

The type of an iterator for the controlled sequence.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Key_equality Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::key_equal

The type of the comparison function.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Key_type Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::key_type

The type of an ordering key.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Mybase::iterator Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::local_iterator

The type of a bucket iterator for the controlled sequence.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Element_type Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::mapped_type

The type of a mapped value associated with each key.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Mybase::pointer Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::pointer

The type of a pointer to an element.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Mybase::reference Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::reference

The type of a reference to an element.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Mybase::size_type Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::size_type

The type of an unsigned distance between two elements.

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

typedef _Mybase::value_type Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::value_type

The type of an element.

Constructor & Destructor Documentation

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::concurrent_unordered_map	(	size_type	_Number_of_buckets = `8`,
		const hasher &	_Hasher = `hasher()`,
		const key_equal &	_Key_equality = `key_equal()`,
		const allocator_type &	_Allocator = `allocator_type()`
	)

inlineexplicit

Constructs a concurrent unordered map.

Parameters

_Number_of_buckets	The initial number of buckets for this unordered map.
_Hasher	The hash function for this unordered map.
_Key_equality	The equality comparison function for this unordered map.
_Allocator	The allocator for this unordered map.

All constructors store an allocator object _Allocator and initialize the unordered map.

The first constructor specifies an empty initial map and explicitly specifies the number of buckets, hash function, equality function and allocator type to be used.

The second constructor specifies an allocator for the unordered map.

The third constructor specifies values supplied by the iterator range [_Begin , _End ).

The fourth and fifth constructors specify a copy of the concurrent unordered map _Umap .

The last constructor specifies a move of the concurrent unordered map _Umap .

         : _Mybase(_Number_of_buckets, _Key_compare(_Hasher, _Key_equality), _Allocator)
     {
         this->rehash(_Number_of_buckets);
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::concurrent_unordered_map ( const allocator_type & _Allocator )

inline

Constructs a concurrent unordered map.

Parameters

_Allocator The allocator for this unordered map.

All constructors store an allocator object _Allocator and initialize the unordered map.

The first constructor specifies an empty initial map and explicitly specifies the number of buckets, hash function, equality function and allocator type to be used.

The second constructor specifies an allocator for the unordered map.

The third constructor specifies values supplied by the iterator range [_Begin , _End ).

The fourth and fifth constructors specify a copy of the concurrent unordered map _Umap .

The last constructor specifies a move of the concurrent unordered map _Umap .

                                                                : _Mybase(8, _Key_compare(), _Allocator)
     {
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

template<typename _Iterator >

Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::concurrent_unordered_map	(	_Iterator	_Begin,
		_Iterator	_End,
		size_type	_Number_of_buckets = `8`,
		const hasher &	_Hasher = `hasher()`,
		const key_equal &	_Key_equality = `key_equal()`,
		const allocator_type &	_Allocator = `allocator_type()`
	)

inline

Constructs a concurrent unordered map.

Template Parameters

_Iterator The type of the input iterator.

Parameters

_Begin	The position of the first element in the range of elements to be copied.
_End	The position of the first element beyond the range of elements to be copied.
_Number_of_buckets	The initial number of buckets for this unordered map.
_Hasher	The hash function for this unordered map.
_Key_equality	The equality comparison function for this unordered map.
_Allocator	The allocator for this unordered map.

All constructors store an allocator object _Allocator and initialize the unordered map.

The first constructor specifies an empty initial map and explicitly specifies the number of buckets, hash function, equality function and allocator type to be used.

The second constructor specifies an allocator for the unordered map.

The third constructor specifies values supplied by the iterator range [_Begin , _End ).

The fourth and fifth constructors specify a copy of the concurrent unordered map _Umap .

The last constructor specifies a move of the concurrent unordered map _Umap .

         : _Mybase(_Number_of_buckets, _Key_compare(), allocator_type())
     {
         this->rehash(_Number_of_buckets);
         for (; _Begin != _End; ++_Begin)
         {
             this->_Insert(*_Begin);
         }
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::concurrent_unordered_map ( const concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type > & _Umap )

inline

Constructs a concurrent unordered map.

Parameters

_Umap The source concurrent_unordered_map object to copy or move elements from.

All constructors store an allocator object _Allocator and initialize the unordered map.

The first constructor specifies an empty initial map and explicitly specifies the number of buckets, hash function, equality function and allocator type to be used.

The second constructor specifies an allocator for the unordered map.

The third constructor specifies values supplied by the iterator range [_Begin , _End ).

The fourth and fifth constructors specify a copy of the concurrent unordered map _Umap .

The last constructor specifies a move of the concurrent unordered map _Umap .

                                                                     : _Mybase(_Umap)
     {
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::concurrent_unordered_map	(	const concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type > &	_Umap,
		const allocator_type &	_Allocator
	)

inline

Constructs a concurrent unordered map.

Parameters

_Umap	The source `concurrent_unordered_map` object to copy or move elements from.
_Allocator	The allocator for this unordered map.

All constructors store an allocator object _Allocator and initialize the unordered map.

The first constructor specifies an empty initial map and explicitly specifies the number of buckets, hash function, equality function and allocator type to be used.

The second constructor specifies an allocator for the unordered map.

The third constructor specifies values supplied by the iterator range [_Begin , _End ).

The fourth and fifth constructors specify a copy of the concurrent unordered map _Umap .

The last constructor specifies a move of the concurrent unordered map _Umap .

                                                                                                       : _Mybase(_Umap, _Allocator)
     {
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::concurrent_unordered_map ( concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type > && _Umap )

inline

Constructs a concurrent unordered map.

Parameters

_Umap The source concurrent_unordered_map object to copy or move elements from.

All constructors store an allocator object _Allocator and initialize the unordered map.

The first constructor specifies an empty initial map and explicitly specifies the number of buckets, hash function, equality function and allocator type to be used.

The second constructor specifies an allocator for the unordered map.

The third constructor specifies values supplied by the iterator range [_Begin , _End ).

The fourth and fifth constructors specify a copy of the concurrent unordered map _Umap .

The last constructor specifies a move of the concurrent unordered map _Umap .

                                                                : _Mybase(std::move(_Umap))
     {
     }

Member Function Documentation

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

mapped_type& Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::at ( const key_type & _Keyval )

inline

Finds an element in a concurrent_unordered_map with a specified key value.. This method is concurrency-safe.

Parameters

_Keyval The key value to find.

Returns: A reference to the data value of the element found.

If the argument key value is not found, the function throws an object of class out_of_range.

     {
         iterator _Where = this->find(_Keyval);
 
         if (_Where == this->end())
         {
             throw std::out_of_range("invalid concurrent_unordered_map<K, T> key");
         }
 
         return ((*_Where).second);
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

const mapped_type& Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::at ( const key_type & _Keyval ) const

inline

Finds an element in a concurrent_unordered_map with a specified key value.. This method is concurrency-safe.

Parameters

_Keyval The key value to find.

Returns: A reference to the data value of the element found.

If the argument key value is not found, the function throws an object of class out_of_range.

     {
         const_iterator _Where = this->find(_Keyval);
 
         if (_Where == this->end())
         {
             throw std::out_of_range("invalid concurrent_unordered_map<K, T> key");
         }
 
         return ((*_Where).second);
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

hasher Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::hash_function ( ) const

inline

Gets the stored hash function object.

Returns: The stored hash function object.

     {
         return this->_M_comparator._M_hash_object;
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

std::pair<iterator, bool> Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::insert ( const value_type & _Value )

inline

Adds elements to the concurrent_unordered_map object.

Parameters

_Value The value to be inserted.

Returns: A pair that contains an iterator and a boolean value. See the Remarks section for more details.

The first member function determines whether an element X exists in the sequence whose key has equivalent ordering to that of _Value . If not, it creates such an element X and initializes it with _Value . The function then determines the iterator where that designates X. If an insertion occurred, the function returns std::pair(where, true). Otherwise, it returns std::pair(where, false).

The second member function returns insert(_Value ), using _Where as a starting place within the controlled sequence to search for the insertion point.

The third member function inserts the sequence of element values from the range [_First , _Last ).

The last two member functions behave the same as the first two, except that _Value is used to construct the inserted value.

     {
         return this->_Insert(_Value);
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

iterator Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::insert	(	const_iterator	_Where,
		const value_type &	_Value
	)

inline

Adds elements to the concurrent_unordered_map object.

Parameters

_Where	The starting location to search for an insertion point.
_Value	The value to be inserted.

Returns: An iterator pointing to the insertion location of the object. If the key already exists in the container an iterator pointing to the duplicate key location in the map is returned.

The first member function determines whether an element X exists in the sequence whose key has equivalent ordering to that of _Value . If not, it creates such an element X and initializes it with _Value . The function then determines the iterator where that designates X. If an insertion occurred, the function returns std::pair(where, true). Otherwise, it returns std::pair(where, false).

The second member function returns insert(_Value ), using _Where as a starting place within the controlled sequence to search for the insertion point.

The third member function inserts the sequence of element values from the range [_First , _Last ).

The last two member functions behave the same as the first two, except that _Value is used to construct the inserted value.

     {
         // Current implementation ignores the hint. The method is provided for compatibility with unordered_map.
         return this->_Insert(_Value).first;
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

template<class _Iterator >

void Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::insert	(	_Iterator	_First,
		_Iterator	_Last
	)

inline

Adds elements to the concurrent_unordered_map object.

Template Parameters

_Iterator The iterator type used for insertion.

Parameters

_First	The beginning of the range to insert.
_Last	The end of the range to insert.

The first member function determines whether an element X exists in the sequence whose key has equivalent ordering to that of _Value . If not, it creates such an element X and initializes it with _Value . The function then determines the iterator where that designates X. If an insertion occurred, the function returns std::pair(where, true). Otherwise, it returns std::pair(where, false).

The second member function returns insert(_Value ), using _Where as a starting place within the controlled sequence to search for the insertion point.

The third member function inserts the sequence of element values from the range [_First , _Last ).

The last two member functions behave the same as the first two, except that _Value is used to construct the inserted value.

     {
         this->_Insert(_First, _Last);
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

template<class _Valty >

std::pair<iterator, bool> Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::insert ( _Valty && _Value )

inline

Adds elements to the concurrent_unordered_map object.

Template Parameters

_Valty The type of the value inserted into the map.

Parameters

_Value The value to be inserted.

Returns: A pair that contains an iterator and a boolean value. See the Remarks section for more details.

The first member function determines whether an element X exists in the sequence whose key has equivalent ordering to that of _Value . If not, it creates such an element X and initializes it with _Value . The function then determines the iterator where that designates X. If an insertion occurred, the function returns std::pair(where, true). Otherwise, it returns std::pair(where, false).

The second member function returns insert(_Value ), using _Where as a starting place within the controlled sequence to search for the insertion point.

The third member function inserts the sequence of element values from the range [_First , _Last ).

The last two member functions behave the same as the first two, except that _Value is used to construct the inserted value.

     {
         return this->_Insert(std::forward<_Valty>(_Value));
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

template<class _Valty >

std::enable_if<!std::is_same<const_iterator, typename std::remove_reference<_Valty>::type>::value, iterator>::type Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::insert	(	const_iterator	_Where,
		_Valty &&	_Value
	)

inline

Adds elements to the concurrent_unordered_map object.

Template Parameters

_Valty The type of the value inserted into the map.

Parameters

_Where	The starting location to search for an insertion point.
_Value	The value to be inserted.

Returns: An iterator pointing to the insertion location of the object. If the key already exists in the container an iterator pointing to the duplicate key location in the map is returned.

The first member function determines whether an element X exists in the sequence whose key has equivalent ordering to that of _Value . If not, it creates such an element X and initializes it with _Value . The function then determines the iterator where that designates X. If an insertion occurred, the function returns std::pair(where, true). Otherwise, it returns std::pair(where, false).

The second member function returns insert(_Value ), using _Where as a starting place within the controlled sequence to search for the insertion point.

The third member function inserts the sequence of element values from the range [_First , _Last ).

The last two member functions behave the same as the first two, except that _Value is used to construct the inserted value.

     {
         // Current implementation ignores the hint. The method is provided for compatibility with unordered_map.
         return this->_Insert(std::forward<_Valty>(_Value)).first;
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

key_equal Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::key_eq ( ) const

inline

Gets the stored equality comparison function object.

Returns: The stored equality comparison function object.

     {
         return this->_M_comparator._M_key_compare_object;
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

concurrent_unordered_map& Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::operator= ( const concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type > & _Umap )

inline

Assigns the contents of another concurrent_unordered_map object to this one. This method is not concurrency-safe.

Parameters

_Umap The source concurrent_unordered_map object.

Returns: A reference to this concurrent_unordered_map object.

After erasing any existing elements a concurrent vector, operator= either copies or moves the contents of _Umap into the concurrent vector.

     {
         _Mybase::operator=(_Umap);
         return (*this);
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

concurrent_unordered_map& Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::operator= ( concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type > && _Umap )

inline

Assigns the contents of another concurrent_unordered_map object to this one. This method is not concurrency-safe.

Parameters

_Umap The source concurrent_unordered_map object.

Returns: A reference to this concurrent_unordered_map object.

After erasing any existing elements in a concurrent vector, operator= either copies or moves the contents of _Umap into the concurrent vector.

     {
         _Mybase::operator=(std::move(_Umap));
         return (*this);
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

mapped_type& Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::operator[] ( const key_type & _Keyval )

inline

Finds or inserts an element with the specified key. This method is concurrency-safe.

Parameters

_Keyval The key value to find or insert.

Returns: A reference to the data value of the found or inserted element.

If the argument key value is not found, then it is inserted along with the default value of the data type.

operator[] may be used to insert elements into a map m using m[_Key] = DataValue;, where DataValue is the value of the mapped_type of the element with a key value of _Key.

When using operator[] to insert elements, the returned reference does not indicate whether an insertion is changing a pre-existing element or creating a new one. The member functions find and insert can be used to determine whether an element with a specified key is already present before an insertion.

     {
         iterator _Where = this->find(_Keyval);
 
         if (_Where == this->end())
         {
             _Where = this->_Insert(std::make_pair(_Keyval, mapped_type())).first;
         }
 
         return ((*_Where).second);
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

mapped_type& Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::operator[] ( key_type && _Keyval )

inline

Finds or inserts an element with the specified key. This method is concurrency-safe.

Parameters

_Keyval The key value to find or insert.

Returns: A reference to the data value of the found or inserted element.

If the argument key value is not found, then it is inserted along with the default value of the data type.

operator[] may be used to insert elements into a map m using m[_Key] = DataValue;, where DataValue is the value of the mapped_type of the element with a key value of _Key.

When using operator[] to insert elements, the returned reference does not indicate whether an insertion is changing a pre-existing element or creating a new one. The member functions find and insert can be used to determine whether an element with a specified key is already present before an insertion.

     {
         iterator _Where = this->find(_Keyval);
 
         if (_Where == this->end())
         {
             _Where = this->_Insert(std::make_pair(std::forward<key_type>(_Keyval), mapped_type())).first;
         }
 
         return ((*_Where).second);
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

void Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::swap ( concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type > & _Umap )

inline

Swaps the contents of two concurrent_unordered_map objects. This method is not concurrency-safe.

Parameters

_Umap The concurrent_unordered_map object to swap with.

     {
         _Mybase::swap(_Umap);
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

iterator Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::unsafe_erase ( const_iterator _Where )

inline

Removes elements from the concurrent_unordered_map 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 [_Begin , _End ).

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

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

     {
         return _Mybase::unsafe_erase(_Where);
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

iterator Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::unsafe_erase	(	const_iterator	_Begin,
		const_iterator	_End
	)

inline

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

Parameters

_Begin	The position of the first element in the range of elements to be erased.
_End	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 [_Begin , _End ).

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

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

     {
         return _Mybase::unsafe_erase(_Begin, _End);
     }

template<typename _Key_type , typename _Element_type , typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> >>

size_type Concurrency::concurrent_unordered_map< _Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type >::unsafe_erase ( const key_type & _Keyval )

inline

Removes elements from the concurrent_unordered_map 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 [_Begin , _End ).

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

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

     {
         return _Mybase::unsafe_erase(_Keyval);
     }

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

VS2015/inc/concurrent_unordered_map.h

Public Types

Public Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation