The concurrent_unordered_set class is an concurrency-safe container that controls a varying-length sequence of elements of type _Key_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_set.h>

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

Public Types
typedef concurrent_unordered_set< _Key_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_set_traits< _Key_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 _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_set_traits< _Key_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false > >
typedef _Concurrent_hash< details::_Concurrent_unordered_set_traits< _Key_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false > >	_Mytype

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

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

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

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

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

typedef details::_Concurrent_unordered_set_traits< _Key_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_set_traits< _Key_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >
enum

typedef _Key_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

typedef _Key_compare	_Value_compare

Public Member Functions
	concurrent_unordered_set (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 set. More...

	concurrent_unordered_set (const allocator_type &_Allocator)
	Constructs a concurrent unordered set. More...

template<typename _Iterator >
	concurrent_unordered_set (_Iterator _First, _Iterator _Last, 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 set. More...

	concurrent_unordered_set (const concurrent_unordered_set &_Uset)
	Constructs a concurrent unordered set. More...

	concurrent_unordered_set (const concurrent_unordered_set &_Uset, const allocator_type &_Allocator)
	Constructs a concurrent unordered set. More...

	concurrent_unordered_set (concurrent_unordered_set &&_Uset)
	Constructs a concurrent unordered set. More...

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

concurrent_unordered_set &	operator= (concurrent_unordered_set &&_Uset)
	Assigns the contents of another `concurrent_unordered_set` 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_set` object. More...

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

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

template<class _Valty >
std::pair< iterator, bool >	insert (_Valty &&_Value)
	Adds elements to the `concurrent_unordered_set` 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_set` object. More...

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

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

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

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

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

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

Public Member Functions inherited from Concurrency::details::_Concurrent_hash< details::_Concurrent_unordered_set_traits< _Key_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_set_traits< _Key_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >
	_Concurrent_unordered_set_traits ()

	_Concurrent_unordered_set_traits (const details::_Hash_compare< _Key_type, _Hasher, _Key_equality > &_Traits)

Additional Inherited Members
Static Public Member Functions inherited from Concurrency::details::_Concurrent_hash< details::_Concurrent_unordered_set_traits< _Key_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_set_traits< _Key_type, details::_Hash_compare< _Key_type, _Hasher, _Key_equality >, _Allocator_type, false >
static const _Key_type &	_Key_function (const value_type &_Value)

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

Static Public Attributes inherited from Concurrency::details::_Concurrent_hash< details::_Concurrent_unordered_set_traits< _Key_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_set_traits< _Key_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 _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<_Key_type>>
class Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >

The concurrent_unordered_set class is an concurrency-safe container that controls a varying-length sequence of elements of type _Key_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.
_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 set. This argument is optional and the default value is `std::allocator<`_Key_type `>`.

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

See also: Parallel Containers and Objects

Member Typedef Documentation

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

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

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

typedef details::_Concurrent_hash< details::_Concurrent_unordered_set_traits<_Key_type, _Key_compare, _Allocator_type, false> > Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::_Mybase

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

typedef concurrent_unordered_set<_Key_type, _Hasher, _Key_equality, _Allocator_type> Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::_Mytype

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

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

The type of an allocator for managing storage.

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

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

The type of a constant iterator for the controlled sequence.

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

typedef _Mybase::const_iterator Concurrency::concurrent_unordered_set< _Key_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 _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<_Key_type>>

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

The type of a constant pointer to an element.

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

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

The type of a constant reference to an element.

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

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

The type of a signed distance between two elements.

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

typedef _Hasher Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::hasher

The type of the hash function.

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

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

The type of an iterator for the controlled sequence.

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

typedef _Key_equality Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::key_equal

The type of the comparison function.

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

typedef _Key_type Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::key_type

The type of an ordering key.

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

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

The type of a bucket iterator for the controlled sequence.

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

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

The type of a pointer to an element.

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

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

The type of a reference to an element.

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

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

The type of an unsigned distance between two elements.

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

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

The type of an element.

Constructor & Destructor Documentation

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

Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::concurrent_unordered_set	(	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 set.

Parameters

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

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

The first constructor specifies an empty initial set 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 set.

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

The fourth and fifth constructors specify a copy of the concurrent unordered set _Uset .

The last constructor specifies a move of the concurrent unordered set _Uset .

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

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

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

inline

Constructs a concurrent unordered set.

Parameters

_Allocator The allocator for this unordered set.

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

The first constructor specifies an empty initial set 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 set.

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

The fourth and fifth constructors specify a copy of the concurrent unordered set _Uset .

The last constructor specifies a move of the concurrent unordered set _Uset .

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

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

template<typename _Iterator >

Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::concurrent_unordered_set	(	_Iterator	_First,
		_Iterator	_Last,
		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 set.

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 set.
_Hasher	The hash function for this unordered set.
_Key_equality	The equality comparison function for this unordered set.
_Allocator	The allocator for this unordered set.

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

The first constructor specifies an empty initial set 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 set.

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

The fourth and fifth constructors specify a copy of the concurrent unordered set _Uset .

The last constructor specifies a move of the concurrent unordered set _Uset .

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

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

Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::concurrent_unordered_set ( const concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type > & _Uset )

inline

Constructs a concurrent unordered set.

Parameters

_Uset The source concurrent_unordered_set object to copy or move elements from.

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

The first constructor specifies an empty initial set 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 set.

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

The fourth and fifth constructors specify a copy of the concurrent unordered set _Uset .

The last constructor specifies a move of the concurrent unordered set _Uset .

                                                                     : _Mybase(_Uset)
     {
     }

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

Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::concurrent_unordered_set	(	const concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type > &	_Uset,
		const allocator_type &	_Allocator
	)

inline

Constructs a concurrent unordered set.

Parameters

_Uset	The source `concurrent_unordered_set` object to copy or move elements from.
_Allocator	The allocator for this unordered set.

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

The first constructor specifies an empty initial set 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 set.

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

The fourth and fifth constructors specify a copy of the concurrent unordered set _Uset .

The last constructor specifies a move of the concurrent unordered set _Uset .

                                                                                                       : _Mybase(_Uset, _Allocator)
     {
     }

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

Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::concurrent_unordered_set ( concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type > && _Uset )

inline

Constructs a concurrent unordered set.

Parameters

_Uset The source concurrent_unordered_set object to copy or move elements from.

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

The first constructor specifies an empty initial set 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 set.

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

The fourth and fifth constructors specify a copy of the concurrent unordered set _Uset .

The last constructor specifies a move of the concurrent unordered set _Uset .

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

Member Function Documentation

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

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

inline

Returns the stored hash function object.

Returns: The stored hash function object.

     {
         return this->_M_comparator._M_hash_object;
     }

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

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

inline

Adds elements to the concurrent_unordered_set 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 _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<_Key_type>>

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

inline

Adds elements to the concurrent_unordered_set 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 set 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_set.
         return this->_Insert(_Value).first;
     }

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

template<class _Iterator >

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

inline

Adds elements to the concurrent_unordered_set 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 _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<_Key_type>>

template<class _Valty >

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

inline

Adds elements to the concurrent_unordered_set object.

Template Parameters

_Valty The type of the value inserted into the set.

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 _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<_Key_type>>

template<class _Valty >

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

inline

Adds elements to the concurrent_unordered_set object.

Template Parameters

_Valty The type of the value inserted into the set.

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 set 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_set.
         return this->_Insert(std::forward<_Valty>(_Value)).first;
     }

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

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

inline

Returns 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 _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<_Key_type>>

concurrent_unordered_set& Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::operator= ( const concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type > & _Uset )

inline

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

Parameters

_Uset The source concurrent_unordered_set object.

Returns: A reference to this concurrent_unordered_set object.

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

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

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

concurrent_unordered_set& Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::operator= ( concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type > && _Uset )

inline

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

Parameters

_Uset The source concurrent_unordered_set object.

Returns: A reference to this concurrent_unordered_set object.

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

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

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

void Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::swap ( concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type > & _Uset )

inline

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

Parameters

_Uset The concurrent_unordered_set object to swap with.

     {
         _Mybase::swap(_Uset);
     }

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

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

inline

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

Parameters

_Where The iterator position to erase from.

The first member function removes the element 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_set::equal_range Method(_Keyval).

Returns: The first two member functions return an iterator that designates the first element remaining beyond any elements removed, or concurrent_unordered_set::end Method() 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 _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<_Key_type>>

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

inline

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

Parameters

_Keyval The key value to erase.

The first member function removes the element 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_set::equal_range Method(_Keyval).

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

     {
         return _Mybase::unsafe_erase(_Keyval);
     }

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

iterator Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >::unsafe_erase	(	const_iterator	_First,
		const_iterator	_Last
	)

inline

Removes elements from the concurrent_unordered_set 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 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_set::equal_range Method(_Keyval).

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

     {
         return _Mybase::unsafe_erase(_First, _Last);
     }

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

VS2017/inc/concurrent_unordered_set.h

Public Types

Public Member Functions

Additional Inherited Members

Detailed Description

template<typename _Key_type, typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<_Key_type>> class Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

template<typename _Key_type, typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<_Key_type>>
class Concurrency::concurrent_unordered_set< _Key_type, _Hasher, _Key_equality, _Allocator_type >