Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
tbb::interface5::concurrent_unordered_multiset< Key, Hasher, Key_equality, Allocator > Class Template Reference

#include <concurrent_unordered_set.h>

Collaboration diagram for tbb::interface5::concurrent_unordered_multiset< 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_multiset (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_multiset (size_type n_of_buckets, const allocator_type &a)
 
 concurrent_unordered_multiset (size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
 
 concurrent_unordered_multiset (const Allocator &a)
 
template<typename Iterator >
 concurrent_unordered_multiset (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_multiset (Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
 
template<typename Iterator >
 concurrent_unordered_multiset (Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
 
 concurrent_unordered_multiset (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_multiset (std::initializer_list< value_type > il, size_type n_of_buckets, const allocator_type &a)
 
 concurrent_unordered_multiset (std::initializer_list< value_type > il, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
 
 concurrent_unordered_multiset (const concurrent_unordered_multiset &table)
 
concurrent_unordered_multisetoperator= (const concurrent_unordered_multiset &table)
 
 concurrent_unordered_multiset (concurrent_unordered_multiset &&table)
 
concurrent_unordered_multisetoperator= (concurrent_unordered_multiset &&table)
 
 concurrent_unordered_multiset (concurrent_unordered_multiset &&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_multiset (const concurrent_unordered_multiset &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...
 

Private Types

typedef internal::hash_compare< Key, Hasher, Key_equality > hash_compare
 
typedef concurrent_unordered_set_traits< Key, hash_compare, Allocator, true > traits_type
 
typedef internal::concurrent_unordered_base< traits_typebase_type
 

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_multiset< 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_multiset< Key, Hasher, Key_equality, Allocator >::allocator_type

Definition at line 279 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_multiset< Key, Hasher, Key_equality, Allocator >::base_type
private

Definition at line 263 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_multiset< Key, Hasher, Key_equality, Allocator >::const_iterator

Definition at line 289 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_multiset< Key, Hasher, Key_equality, Allocator >::const_local_iterator

Definition at line 291 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_multiset< Key, Hasher, Key_equality, Allocator >::const_pointer

Definition at line 281 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_multiset< Key, Hasher, Key_equality, Allocator >::const_reference

Definition at line 283 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_multiset< Key, Hasher, Key_equality, Allocator >::difference_type

Definition at line 286 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_multiset< Key, Hasher, Key_equality, Allocator >::hash_compare
private

Definition at line 261 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_multiset< Key, Hasher, Key_equality, Allocator >::hasher

Definition at line 275 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_multiset< Key, Hasher, Key_equality, Allocator >::iterator

Definition at line 288 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_multiset< Key, Hasher, Key_equality, Allocator >::key_compare

Definition at line 277 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_multiset< Key, Hasher, Key_equality, Allocator >::key_equal

Definition at line 276 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_multiset< Key, Hasher, Key_equality, Allocator >::key_type

Definition at line 272 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_multiset< Key, Hasher, Key_equality, Allocator >::local_iterator

Definition at line 290 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_multiset< Key, Hasher, Key_equality, Allocator >::mapped_type

Definition at line 274 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_multiset< Key, Hasher, Key_equality, Allocator >::node_type

Definition at line 293 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_multiset< Key, Hasher, Key_equality, Allocator >::pointer

Definition at line 280 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_multiset< Key, Hasher, Key_equality, Allocator >::reference

Definition at line 282 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_multiset< Key, Hasher, Key_equality, Allocator >::size_type

Definition at line 285 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, true> tbb::interface5::concurrent_unordered_multiset< Key, Hasher, Key_equality, Allocator >::traits_type
private

Definition at line 262 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_multiset< Key, Hasher, Key_equality, Allocator >::value_type

Definition at line 273 of file concurrent_unordered_set.h.

Constructor & Destructor Documentation

◆ concurrent_unordered_multiset() [1/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( 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 297 of file concurrent_unordered_set.h.

300  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
301  {}

◆ concurrent_unordered_multiset() [2/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( size_type  n_of_buckets,
const allocator_type a 
)
inline

Definition at line 303 of file concurrent_unordered_set.h.

304  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
305  {}

◆ concurrent_unordered_multiset() [3/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( size_type  n_of_buckets,
const hasher a_hasher,
const allocator_type a 
)
inline

Definition at line 307 of file concurrent_unordered_set.h.

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

◆ concurrent_unordered_multiset() [4/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( const Allocator &  a)
inlineexplicit

Definition at line 312 of file concurrent_unordered_set.h.

◆ concurrent_unordered_multiset() [5/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( 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 316 of file concurrent_unordered_set.h.

319  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
320  {
321  insert(first, last);
322  }

References tbb::internal::first(), and tbb::internal::last().

Here is the call graph for this function:

◆ concurrent_unordered_multiset() [6/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( Iterator  first,
Iterator  last,
size_type  n_of_buckets,
const allocator_type a 
)
inline

Definition at line 325 of file concurrent_unordered_set.h.

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

References tbb::internal::first(), and tbb::internal::last().

Here is the call graph for this function:

◆ concurrent_unordered_multiset() [7/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( Iterator  first,
Iterator  last,
size_type  n_of_buckets,
const hasher a_hasher,
const allocator_type a 
)
inline

Definition at line 332 of file concurrent_unordered_set.h.

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

References tbb::internal::first(), and tbb::internal::last().

Here is the call graph for this function:

◆ concurrent_unordered_multiset() [8/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( 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 341 of file concurrent_unordered_set.h.

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

◆ concurrent_unordered_multiset() [9/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( std::initializer_list< value_type il,
size_type  n_of_buckets,
const allocator_type a 
)
inline

Definition at line 348 of file concurrent_unordered_set.h.

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

◆ concurrent_unordered_multiset() [10/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( std::initializer_list< value_type il,
size_type  n_of_buckets,
const hasher a_hasher,
const allocator_type a 
)
inline

Definition at line 354 of file concurrent_unordered_set.h.

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

◆ concurrent_unordered_multiset() [11/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( const concurrent_unordered_multiset< Key, Hasher, Key_equality, Allocator > &  table)
inline

Definition at line 365 of file concurrent_unordered_set.h.

366  : base_type(table)
367  {}

◆ concurrent_unordered_multiset() [12/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( concurrent_unordered_multiset< Key, Hasher, Key_equality, Allocator > &&  table)
inline

Definition at line 374 of file concurrent_unordered_set.h.

375  : base_type(std::move(table))
376  {}

◆ concurrent_unordered_multiset() [13/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( concurrent_unordered_multiset< Key, Hasher, Key_equality, Allocator > &&  table,
const Allocator &  a 
)
inline

Definition at line 385 of file concurrent_unordered_set.h.

386  : base_type(std::move(table), a)
387  {
388  }

◆ concurrent_unordered_multiset() [14/14]

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_multiset< Key, Hasher, Key_equality, Allocator >::concurrent_unordered_multiset ( const concurrent_unordered_multiset< Key, Hasher, Key_equality, Allocator > &  table,
const Allocator &  a 
)
inline

Definition at line 410 of file concurrent_unordered_set.h.

411  : base_type(table, a)
412  {}

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.

1068  {
1069  return internal_insert</*AllowCreate=*/tbb::internal::true_type,
1070  /*AllowDestroy=*/tbb::internal::true_type>(value);
1071  }

◆ 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.

1073  {
1074  // Ignore hint
1075  return insert(value).first;
1076  }

◆ 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.

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

◆ 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.

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

◆ 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.

1128  {
1129  for (Iterator it = first; it != last; ++it)
1130  insert(*it);
1131  }

◆ 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.

1091  {
1092  if (!nh.empty()) {
1093  nodeptr_t handled_node = nh.my_node;
1094  std::pair<iterator, bool> insert_result =
1095  internal_insert</*AllowCreate=*/tbb::internal::false_type,
1096  /*AllowDestroy=*/tbb::internal::false_type>
1097  (handled_node->my_element, handled_node);
1098  if (insert_result.second)
1099  nh.deactivate();
1100  return insert_result;
1101  }
1102  return std::pair<iterator, bool>(end(), false);
1103  }

◆ 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.

1135  {
1136  insert(il.begin(), il.end());
1137  }

◆ 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.

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

◆ 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_multiset< Key, Hasher, Key_equality, Allocator >::merge ( concurrent_unordered_multiset< Key, Hash, Equality, Allocator > &&  source)
inline

Definition at line 405 of file concurrent_unordered_set.h.

406  { this->internal_merge(source); }

◆ 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_multiset< Key, Hasher, Key_equality, Allocator >::merge ( concurrent_unordered_multiset< Key, Hash, Equality, Allocator > &  source)
inline

Definition at line 401 of file concurrent_unordered_set.h.

402  { this->internal_merge(source); }

◆ 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_multiset< Key, Hasher, Key_equality, Allocator >::merge ( concurrent_unordered_set< Key, Hash, Equality, Allocator > &&  source)
inline

Definition at line 397 of file concurrent_unordered_set.h.

398  { this->internal_merge(source); }

◆ 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_multiset< Key, Hasher, Key_equality, Allocator >::merge ( concurrent_unordered_set< Key, Hash, Equality, Allocator > &  source)
inline

Definition at line 393 of file concurrent_unordered_set.h.

394  { this->internal_merge(source); }

◆ operator=() [1/2]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>
concurrent_unordered_multiset& tbb::interface5::concurrent_unordered_multiset< Key, Hasher, Key_equality, Allocator >::operator= ( concurrent_unordered_multiset< Key, Hasher, Key_equality, Allocator > &&  table)
inline

Definition at line 378 of file concurrent_unordered_set.h.

379  {
380  return static_cast<concurrent_unordered_multiset&>(base_type::operator=(std::move(table)));
381  }

References tbb::move().

Here is the call graph for this function:

◆ operator=() [2/2]

template<typename Key , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key>>
concurrent_unordered_multiset& tbb::interface5::concurrent_unordered_multiset< Key, Hasher, Key_equality, Allocator >::operator= ( const concurrent_unordered_multiset< Key, Hasher, Key_equality, Allocator > &  table)
inline

Definition at line 369 of file concurrent_unordered_set.h.

370  {
371  return static_cast<concurrent_unordered_multiset&>(base_type::operator=(table));
372  }

The documentation for this class was generated from the following file:
end
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 end
Definition: ittnotify_static.h:182
tbb::interface5::concurrent_unordered_multiset::key_compare
hash_compare key_compare
Definition: concurrent_unordered_set.h:277
tbb::internal::first
Container::iterator first(Container &c)
Definition: _range_iterator.h:46
tbb::internal::last
Container::iterator last(Container &c)
Definition: _range_iterator.h:52
tbb::interface5::concurrent_unordered_multiset::key_equal
Key_equality key_equal
Definition: concurrent_unordered_set.h:276
tbb::interface5::concurrent_unordered_multiset::hasher
Hasher hasher
Definition: concurrent_unordered_set.h:275
tbb::move
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
tbb::interface5::internal::concurrent_unordered_base::operator=
concurrent_unordered_base & operator=(const concurrent_unordered_base &right)
Definition: _concurrent_unordered_impl.h:844
tbb::interface5::concurrent_unordered_multiset::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_set.h:263
tbb::internal::bool_constant
Definition: tbb_stddef.h:486
tbb::internal::true_type
bool_constant< true > true_type
Definition: tbb_stddef.h:489
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::false_type
bool_constant< false > false_type
Definition: tbb_stddef.h:490
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(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())
Definition: concurrent_unordered_set.h:297
tbb::interface5::internal::concurrent_unordered_base::initial_bucket_number
static const size_type initial_bucket_number
Definition: _concurrent_unordered_impl.h:742
tbb::interface5::concurrent_unordered_multiset::insert
std::pair< iterator, bool > insert(const value_type &value)
Definition: _concurrent_unordered_impl.h:1068

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.