Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
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)
 
- Public Member Functions inherited from tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, 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, iteratorequal_range (const key_type &key)
 
std::pair< const_iterator, const_iteratorequal_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_typebase_type
 

Additional Inherited Members

- Protected Types inherited from tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >
typedef concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > > self_type
 
typedef concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > ::value_type value_type
 
typedef concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > ::key_type key_type
 
typedef concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > ::hash_compare hash_compare
 
typedef concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > ::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_typereference
 
typedef const allocator_type::value_typeconst_reference
 
typedef split_ordered_list< value_type, typename concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > ::allocator_typesolist_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 concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > ::node_type node_type
 
- Protected Types inherited from tbb::interface5::concurrent_unordered_set_traits< Key, Hash_compare, Allocator, Allow_multimapping >
enum  { allow_multimapping = Allow_multimapping }
 
typedef Key value_type
 
typedef Key key_type
 
typedef Hash_compare hash_compare
 
typedef tbb::internal::allocator_rebind< Allocator, 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_typenode_type
 
- Protected Member Functions inherited from tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, 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_baseoperator= (const concurrent_unordered_base &right)
 
concurrent_unordered_baseoperator= (concurrent_unordered_base &&other)
 
concurrent_unordered_baseoperator= (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, Hash_compare, Allocator, Allow_multimapping >
 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, Hash_compare, Allocator, Allow_multimapping >
static const Key & get_key (const value_type &value)
 
- Protected Attributes inherited from tbb::interface5::concurrent_unordered_set_traits< Key, Hash_compare, Allocator, Allow_multimapping >
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, Hasher, Key_equality >, Allocator, 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 61 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 82 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 66 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 92 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 94 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 84 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 86 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 89 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 64 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 78 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 91 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 80 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 79 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 75 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 93 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 77 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 96 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 83 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 85 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 88 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 65 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 76 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() 
)
inlineexplicit

Definition at line 100 of file concurrent_unordered_set.h.

102  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
103  {}
internal::concurrent_unordered_base< traits_type > base_type

◆ 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

◆ 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 109 of file concurrent_unordered_set.h.

110  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
111  {}
internal::concurrent_unordered_base< traits_type > base_type

◆ 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)
inlineexplicit

Definition at line 113 of file concurrent_unordered_set.h.

113  : base_type(base_type::initial_bucket_number, key_compare(), a)
114  {}
internal::concurrent_unordered_base< traits_type > base_type

◆ 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 117 of file concurrent_unordered_set.h.

119  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
120  {
121  insert(first, last);
122  }
internal::concurrent_unordered_base< traits_type > base_type
auto last(Container &c) -> decltype(begin(c))
auto first(Container &c) -> decltype(begin(c))

References tbb::internal::first(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::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 125 of file concurrent_unordered_set.h.

References tbb::internal::first(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::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 132 of file concurrent_unordered_set.h.

133  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
134  {
135  insert(first, last);
136  }
internal::concurrent_unordered_base< traits_type > base_type
auto last(Container &c) -> decltype(begin(c))
auto first(Container &c) -> decltype(begin(c))

References tbb::internal::first(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::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 140 of file concurrent_unordered_set.h.

142  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
143  {
144  insert(il.begin(),il.end());
145  }
internal::concurrent_unordered_base< traits_type > base_type

◆ 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

◆ 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 153 of file concurrent_unordered_set.h.

References tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::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 182 of file concurrent_unordered_set.h.

183  : base_type(std::move(table), a)
184  {}
internal::concurrent_unordered_base< traits_type > base_type
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:305

◆ 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 206 of file concurrent_unordered_set.h.

207  : base_type(table, a)
208  {}
internal::concurrent_unordered_base< traits_type > base_type

Member Function Documentation

◆ 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_set< Key, Hash, Equality, Allocator > &  source)
inline

◆ 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_set< Key, Hash, Equality, Allocator > &&  source)
inline

◆ 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_multiset< Key, Hash, Equality, Allocator > &  source)
inline

◆ 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_multiset< Key, Hash, Equality, Allocator > &&  source)
inline

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

Copyright © 2005-2019 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.