tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator > Class Template Reference

`#include <concurrent_unordered_set.h>`

Inheritance diagram for tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >:
Collaboration diagram for tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >:

## Public Types

typedef Key | key_type
typedef base_type::value_type | value_type
typedef Key | mapped_type
typedef Hasher | hasher
typedef Key_equality | key_equal
typedef hash_compare | key_compare
typedef base_type::allocator_type | allocator_type
typedef base_type::pointer | pointer
typedef base_type::const_pointer | const_pointer
typedef base_type::reference | reference
typedef base_type::const_reference | const_reference
typedef base_type::size_type | size_type
typedef base_type::difference_type | difference_type
typedef base_type::iterator | iterator
typedef base_type::const_iterator | const_iterator
typedef base_type::iterator | local_iterator
typedef base_type::const_iterator | const_local_iterator
typedef base_type::node_type | node_type

## Public Member Functions

| concurrent_unordered_set (size_type n_of_buckets=base_type::initial_bucket_number, const hasher &a_hasher=hasher(), const key_equal &a_keyeq=key_equal(), const allocator_type &a=allocator_type())
| concurrent_unordered_set (size_type n_of_buckets, const allocator_type &a)
| concurrent_unordered_set (size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
| concurrent_unordered_set (const Allocator &a)
template<typename Iterator >
| concurrent_unordered_set (Iterator first, Iterator last, size_type n_of_buckets=base_type::initial_bucket_number, const hasher &a_hasher=hasher(), const key_equal &a_keyeq=key_equal(), const allocator_type &a=allocator_type())
template<typename Iterator >
| concurrent_unordered_set (Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
template<typename Iterator >
| concurrent_unordered_set (Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
| concurrent_unordered_set (std::initializer_list< value_type > il, size_type n_of_buckets=base_type::initial_bucket_number, const hasher &a_hasher=hasher(), const key_equal &a_keyeq=key_equal(), const allocator_type &a=allocator_type())
| Constructor from initializer_list. More...
| concurrent_unordered_set (std::initializer_list< value_type > il, size_type n_of_buckets, const allocator_type &a)
| concurrent_unordered_set (std::initializer_list< value_type > il, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
| concurrent_unordered_set (concurrent_unordered_set &&table, const Allocator &a)
template<typename Hash , typename Equality >
void | merge (concurrent_unordered_set< Key, Hash, Equality, Allocator > &source)
template<typename Hash , typename Equality >
void | merge (concurrent_unordered_set< Key, Hash, Equality, Allocator > &&source)
template<typename Hash , typename Equality >
void | merge (concurrent_unordered_multiset< Key, Hash, Equality, Allocator > &source)
template<typename Hash , typename Equality >
void | merge (concurrent_unordered_multiset< Key, Hash, Equality, Allocator > &&source)
| concurrent_unordered_set (const concurrent_unordered_set &table, const Allocator &a)
std::pair< iterator, bool > | insert (const value_type &value)
iterator | insert (const_iterator, const value_type &value)
std::pair< iterator, bool > | insert (value_type &&value)
iterator | insert (const_iterator, value_type &&value)
std::pair< iterator, bool > | insert (node_type &&nh)
iterator | insert (const_iterator, node_type &&nh)
template<class Iterator >
void | insert (Iterator first, Iterator last)
void | insert (std::initializer_list< value_type > il)
| Insert initializer list. More...
Public Member Functions inherited from tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >
allocator_type | get_allocator () const
bool | empty () const
size_type | size () const
size_type | max_size () const
iterator | begin ()
const_iterator | begin () const
iterator | end ()
const_iterator | end () const
const_iterator | cbegin () const
const_iterator | cend () const
range_type | range ()
const_range_type | range () const
std::pair< iterator, bool > | insert (const value_type &value)
iterator | insert (const_iterator, const value_type &value)
std::pair< iterator, bool > | insert (value_type &&value)
iterator | insert (const_iterator, value_type &&value)
std::pair< iterator, bool > | insert (node_type &&nh)
iterator | insert (const_iterator, node_type &&nh)
void | insert (Iterator first, Iterator last)
void | insert (std::initializer_list< value_type > il)
| Insert initializer list. More...
std::pair< iterator, bool > | emplace (Args &&... args)
iterator | emplace_hint (const_iterator, Args &&... args)
iterator | unsafe_erase (const_iterator where)
iterator | unsafe_erase (const_iterator first, const_iterator last)
size_type | unsafe_erase (const key_type &key)
node_type | unsafe_extract (const_iterator where)
node_type | unsafe_extract (const key_type &key)
void | swap (concurrent_unordered_base &right)
hasher | hash_function () const
key_equal | key_eq () const
void | clear ()
iterator | find (const key_type &key)
const_iterator | find (const key_type &key) const
size_type | count (const key_type &key) const
std::pair< iterator, iterator > | equal_range (const key_type &key)
std::pair< const_iterator, const_iterator > | equal_range (const key_type &key) const
size_type | unsafe_bucket_count () const
size_type | unsafe_max_bucket_count () const
size_type | unsafe_bucket_size (size_type bucket)
size_type | unsafe_bucket (const key_type &key) const
local_iterator | unsafe_begin (size_type bucket)
const_local_iterator | unsafe_begin (size_type bucket) const
local_iterator | unsafe_end (size_type bucket)
const_local_iterator | unsafe_end (size_type bucket) const
const_local_iterator | unsafe_cbegin (size_type bucket) const
const_local_iterator | unsafe_cend (size_type bucket) const
float | load_factor () const
float | max_load_factor () const
void | max_load_factor (float newmax)
void | rehash (size_type buckets)

## Private Types

typedef internal::hash_compare< Key, Hasher, Key_equality > | hash_compare
typedef concurrent_unordered_set_traits< Key, hash_compare, Allocator, false > | traits_type
typedef internal::concurrent_unordered_base< traits_type > | base_type

## Additional Inherited Members

Protected Types inherited from tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >
typedef concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > > | self_type
typedef Traits::value_type | value_type
typedef Traits::key_type | key_type
typedef Traits::hash_compare | hash_compare
typedef Traits::allocator_type | allocator_type
typedef hash_compare::hasher | hasher
typedef hash_compare::key_equal | key_equal
typedef tbb::internal::allocator_traits< allocator_type >::size_type | size_type
typedef tbb::internal::allocator_traits< allocator_type >::difference_type | difference_type
typedef tbb::internal::allocator_traits< allocator_type >::pointer | pointer
typedef tbb::internal::allocator_traits< allocator_type >::const_pointer | const_pointer
typedef allocator_type::value_type & | reference
typedef const allocator_type::value_type & | const_reference
typedef split_ordered_list< value_type, typename Traits::allocator_type > | solist_t
typedef solist_t::nodeptr_t | nodeptr_t
typedef solist_t::raw_iterator | raw_iterator
typedef solist_t::raw_const_iterator | raw_const_iterator
typedef solist_t::iterator | iterator
typedef solist_t::const_iterator | const_iterator
typedef iterator | local_iterator
typedef const_iterator | const_local_iterator
typedef Traits::node_type | node_type
Protected Types inherited from tbb::interface5::concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false >
enum |
typedef Key | value_type
typedef Key | key_type
typedef internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > > | hash_compare
typedef tbb::internal::allocator_rebind< tbb::tbb_allocator< Key >, value_type >::type | allocator_type
typedef tbb::internal::node_handle< key_type, key_type, typename internal::split_ordered_list< key_type, allocator_type >::node, allocator_type > | node_type
Protected Member Functions inherited from tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >
| concurrent_unordered_base (size_type n_of_buckets=initial_bucket_number, const hash_compare &hc=hash_compare(), const allocator_type &a=allocator_type())
| concurrent_unordered_base (const concurrent_unordered_base &right, const allocator_type &a)
| concurrent_unordered_base (const concurrent_unordered_base &right)
| concurrent_unordered_base (concurrent_unordered_base &&right)
| concurrent_unordered_base (concurrent_unordered_base &&right, const allocator_type &a)
concurrent_unordered_base & | operator= (const concurrent_unordered_base &right)
concurrent_unordered_base & | operator= (concurrent_unordered_base &&other)
concurrent_unordered_base & | operator= (std::initializer_list< value_type > il)
| assignment operator from initializer_list More...
| ~concurrent_unordered_base ()
void | internal_merge (SourceType &source)
Protected Member Functions inherited from tbb::interface5::concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false >
| concurrent_unordered_set_traits ()
| concurrent_unordered_set_traits (const hash_compare &hc)
Static Protected Member Functions inherited from tbb::interface5::concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false >
static const Key & | get_key (const value_type &value)
Protected Attributes inherited from tbb::interface5::concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false >
hash_compare | my_hash_compare
Static Protected Attributes inherited from tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >
static const size_type | initial_bucket_number

## Detailed Description

### template<typename Key, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>
class tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >

Definition at line 64 of file concurrent_unordered_set.h.

## Member Typedef Documentation

## allocator_type

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::allocator_type tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::allocator_type

Definition at line 85 of file concurrent_unordered_set.h.

## base_type

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef internal::concurrent_unordered_base< traits_type > tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::base_type

private

Definition at line 69 of file concurrent_unordered_set.h.

## const_iterator

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::const_iterator tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::const_iterator

Definition at line 95 of file concurrent_unordered_set.h.

## const_local_iterator

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::const_iterator tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::const_local_iterator

Definition at line 97 of file concurrent_unordered_set.h.

## const_pointer

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::const_pointer tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::const_pointer

Definition at line 87 of file concurrent_unordered_set.h.

## const_reference

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::const_reference tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::const_reference

Definition at line 89 of file concurrent_unordered_set.h.

## difference_type

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::difference_type tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::difference_type

Definition at line 92 of file concurrent_unordered_set.h.

## hash_compare

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef internal::hash_compare<Key, Hasher, Key_equality> tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::hash_compare

private

Definition at line 67 of file concurrent_unordered_set.h.

## hasher

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef Hasher tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::hasher

Definition at line 81 of file concurrent_unordered_set.h.

## iterator

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::iterator tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::iterator

Definition at line 94 of file concurrent_unordered_set.h.

## key_compare

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef hash_compare tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::key_compare

Definition at line 83 of file concurrent_unordered_set.h.

## key_equal

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef Key_equality tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::key_equal

Definition at line 82 of file concurrent_unordered_set.h.

## key_type

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef Key tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::key_type

Definition at line 78 of file concurrent_unordered_set.h.

## local_iterator

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::iterator tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::local_iterator

Definition at line 96 of file concurrent_unordered_set.h.

## mapped_type

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef Key tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::mapped_type

Definition at line 80 of file concurrent_unordered_set.h.

## node_type

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::node_type tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::node_type

Definition at line 99 of file concurrent_unordered_set.h.

## pointer

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::pointer tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::pointer

Definition at line 86 of file concurrent_unordered_set.h.

## reference

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::reference tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::reference

Definition at line 88 of file concurrent_unordered_set.h.

## size_type

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::size_type tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::size_type

Definition at line 91 of file concurrent_unordered_set.h.

## traits_type

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef concurrent_unordered_set_traits<Key, hash_compare, Allocator, false> tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::traits_type

private

Definition at line 68 of file concurrent_unordered_set.h.

## value_type

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

typedef base_type::value_type tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::value_type

Definition at line 79 of file concurrent_unordered_set.h.

## Constructor & Destructor Documentation

## concurrent_unordered_set() [1/12]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set | ( | size_type | n_of_buckets = `base_type::initial_bucket_number`,
|  | const hasher & | a_hasher = `hasher()`,
|  | const key_equal & | a_keyeq = `key_equal()`,
|  | const allocator_type & | a = `allocator_type()`
| ) |  |

inline explicit

Definition at line 103 of file concurrent_unordered_set.h.

: base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
{}
tbb::interface5::concurrent_unordered_set::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_set.h:69
tbb::interface5::concurrent_unordered_set::key_compare
hash_compare key_compare
Definition: concurrent_unordered_set.h:83

## concurrent_unordered_set() [2/12]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set | ( | size_type | n_of_buckets,
|  | const allocator_type & | a
| ) |  |

inline

Definition at line 108 of file concurrent_unordered_set.h.

: base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
{}
tbb::interface5::concurrent_unordered_set::key_equal
Key_equality key_equal
Definition: concurrent_unordered_set.h:82
tbb::interface5::concurrent_unordered_set::hasher
Hasher hasher
Definition: concurrent_unordered_set.h:81

## concurrent_unordered_set() [3/12]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set | ( | size_type | n_of_buckets,
|  | const hasher & | a_hasher,
|  | const allocator_type & | a
| ) |  |

inline

Definition at line 112 of file concurrent_unordered_set.h.

: base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
{}

## concurrent_unordered_set() [4/12]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set | ( | const Allocator & | a | ) |

inline explicit

Definition at line 116 of file concurrent_unordered_set.h.

: base_type(base_type::initial_bucket_number, key_compare(), a)
{}
tbb::interface5::internal::concurrent_unordered_base::initial_bucket_number
static const size_type initial_bucket_number
Definition: _concurrent_unordered_impl.h:742

## concurrent_unordered_set() [5/12]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>
template<typename Iterator >

tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set | ( | Iterator | first,
|  | Iterator | last,
|  | size_type | n_of_buckets = `base_type::initial_bucket_number`,
|  | const hasher & | a_hasher = `hasher()`,
|  | const key_equal & | a_keyeq = `key_equal()`,
|  | const allocator_type & | a = `allocator_type()`
| ) |  |

inline

Definition at line 120 of file concurrent_unordered_set.h.

: base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
{
insert(first, last);
}
tbb::internal::last
auto last(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:40
tbb::internal::first
auto first(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:34
tbb::interface5::concurrent_unordered_set::insert
std::pair< iterator, bool > insert(const value_type &value)
Definition: _concurrent_unordered_impl.h:1068

References tbb::internal::first(), tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::insert(), and tbb::internal::last().

Here is the call graph for this function:

## concurrent_unordered_set() [6/12]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>
template<typename Iterator >

tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set | ( | Iterator | first,
|  | Iterator | last,
|  | size_type | n_of_buckets,
|  | const allocator_type & | a
| ) |  |

inline

Definition at line 128 of file concurrent_unordered_set.h.

: base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
{
insert(first, last);
}

References tbb::internal::first(), tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::insert(), and tbb::internal::last().

Here is the call graph for this function:

## concurrent_unordered_set() [7/12]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>
template<typename Iterator >

tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set | ( | Iterator | first,
|  | Iterator | last,
|  | size_type | n_of_buckets,
|  | const hasher & | a_hasher,
|  | const allocator_type & | a
| ) |  |

inline

Definition at line 135 of file concurrent_unordered_set.h.

: base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
{
insert(first, last);
}

References tbb::internal::first(), tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::insert(), and tbb::internal::last().

Here is the call graph for this function:

## concurrent_unordered_set() [8/12]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set | ( | std::initializer_list< value_type > | il,
|  | size_type | n_of_buckets = `base_type::initial_bucket_number`,
|  | const hasher & | a_hasher = `hasher()`,
|  | const key_equal & | a_keyeq = `key_equal()`,
|  | const allocator_type & | a = `allocator_type()`
| ) |  |

inline

Constructor from initializer_list.

Definition at line 143 of file concurrent_unordered_set.h.

: base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
{
insert(il.begin(),il.end());
}

References tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::insert().

Here is the call graph for this function:

## concurrent_unordered_set() [9/12]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set | ( | std::initializer_list< value_type > | il,
|  | size_type | n_of_buckets,
|  | const allocator_type & | a
| ) |  |

inline

Definition at line 150 of file concurrent_unordered_set.h.

: base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
{
insert(il.begin(), il.end());
}

References tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::insert().

Here is the call graph for this function:

## concurrent_unordered_set() [10/12]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set | ( | std::initializer_list< value_type > | il,
|  | size_type | n_of_buckets,
|  | const hasher & | a_hasher,
|  | const allocator_type & | a
| ) |  |

inline

Definition at line 156 of file concurrent_unordered_set.h.

: base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
{
insert(il.begin(), il.end());
}

References tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::insert().

Here is the call graph for this function:

## concurrent_unordered_set() [11/12]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set | ( | concurrent_unordered_set< Key, Hasher, Key_equality, Allocator > && | table,
|  | const Allocator & | a
| ) |  |

inline

Definition at line 185 of file concurrent_unordered_set.h.

: base_type(std::move(table), a)
{}
tbb::move
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319

## concurrent_unordered_set() [12/12]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set | ( | const concurrent_unordered_set< Key, Hasher, Key_equality, Allocator > & | table,
|  | const Allocator & | a
| ) |  |

inline

Definition at line 209 of file concurrent_unordered_set.h.

: base_type(table, a)
{}

## Member Function Documentation

## insert() [1/8]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

std::pair<iterator, bool> tbb::interface5::internal::concurrent_unordered_base< Traits >::insert

inline

Definition at line 1068 of file _concurrent_unordered_impl.h.

{
return internal_insert</*AllowCreate=*/tbb::internal::true_type,
/*AllowDestroy=*/tbb::internal::true_type>(value);
}
value
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long value
Definition: ittnotify_static.h:192
tbb::internal::true_type
bool_constant< true > true_type
Definition: tbb_stddef.h:489
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >::internal_insert
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)
Definition: _concurrent_unordered_impl.h:1404
tbb::internal::bool_constant
Definition: tbb_stddef.h:486

Referenced by tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_set().

Here is the caller graph for this function:

## insert() [2/8]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::insert

inline

Definition at line 1073 of file _concurrent_unordered_impl.h.

{
// Ignore hint
return insert(value).first;
}

## insert() [3/8]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::insert

inline

Definition at line 1105 of file _concurrent_unordered_impl.h.

{
return insert(std::move(nh)).first;
}

## insert() [4/8]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::insert

inline

Definition at line 1084 of file _concurrent_unordered_impl.h.

{
// Ignore hint
return insert(std::move(value)).first;
}

## insert() [5/8]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>
template<class Iterator >

void tbb::interface5::internal::concurrent_unordered_base< Traits >::insert | ( | class Iterator |  | ) |

inline

Definition at line 1128 of file _concurrent_unordered_impl.h.

{
for (Iterator it = first; it != last; ++it)
insert(*it);
}

## insert() [6/8]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

std::pair<iterator, bool> tbb::interface5::internal::concurrent_unordered_base< Traits >::insert

inline

Definition at line 1091 of file _concurrent_unordered_impl.h.

{
if (!nh.empty()) {
nodeptr_t handled_node = nh.my_node;
std::pair<iterator, bool> insert_result =
internal_insert</*AllowCreate=*/tbb::internal::false_type,
/*AllowDestroy=*/tbb::internal::false_type>
(handled_node->my_element, handled_node);
if (insert_result.second)
nh.deactivate();
return insert_result;
}
return std::pair<iterator, bool>(end(), false);
}
tbb::internal::false_type
bool_constant< false > false_type
Definition: tbb_stddef.h:490
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >::nodeptr_t
solist_t::nodeptr_t nodeptr_t
Definition: _concurrent_unordered_impl.h:727
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >::end
iterator end()
Definition: _concurrent_unordered_impl.h:960

## insert() [7/8]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

void tbb::interface5::internal::concurrent_unordered_base< Traits >::insert

inline

Insert initializer list.

Definition at line 1135 of file _concurrent_unordered_impl.h.

{
insert(il.begin(), il.end());
}

## insert() [8/8]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>

std::pair<iterator, bool> tbb::interface5::internal::concurrent_unordered_base< Traits >::insert

inline

Definition at line 1079 of file _concurrent_unordered_impl.h.

{
return internal_insert</*AllowCreate=*/tbb::internal::true_type,
/*AllowDestroy=*/tbb::internal::true_type>(std::move(value));
}

## merge() [1/4]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>
template<typename Hash , typename Equality >

void tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::merge | ( | concurrent_unordered_multiset< Key, Hash, Equality, Allocator > && | source | ) |

inline

Definition at line 204 of file concurrent_unordered_set.h.

{ this->internal_merge(source); }
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >::internal_merge
void internal_merge(SourceType &source)
Definition: _concurrent_unordered_impl.h:892

References tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >::internal_merge().

Here is the call graph for this function:

## merge() [2/4]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>
template<typename Hash , typename Equality >

void tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::merge | ( | concurrent_unordered_multiset< Key, Hash, Equality, Allocator > & | source | ) |

inline

Definition at line 200 of file concurrent_unordered_set.h.

{ this->internal_merge(source); }

References tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >::internal_merge().

Here is the call graph for this function:

## merge() [3/4]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>
template<typename Hash , typename Equality >

void tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::merge | ( | concurrent_unordered_set< Key, Hash, Equality, Allocator > && | source | ) |

inline

Definition at line 196 of file concurrent_unordered_set.h.

{ this->internal_merge(source); }

References tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >::internal_merge().

Here is the call graph for this function:

## merge() [4/4]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>
template<typename Hash , typename Equality >

void tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator >::merge | ( | concurrent_unordered_set< Key, Hash, Equality, Allocator > & | source | ) |

inline

Definition at line 192 of file concurrent_unordered_set.h.

{ this->internal_merge(source); }

References tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >::internal_merge().

Here is the call graph for this function:

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

- concurrent_unordered_set.h

Copyright © 2005-2020 Intel Corporation. All Rights Reserved.

Intel, Pentium, Intel Xeon, Itanium, Intel XScale and VTune are registered trademarks or trademarks of Intel Corporation or its subsidiaries in the United States and other countries.

* Other names and brands may be claimed as the property of others.