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

#include <concurrent_unordered_map.h>

Collaboration diagram for tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >:

Public Types

typedef Key key_type
 
typedef base_type::value_type value_type
 
typedef T 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_multimap (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_multimap (size_type n_of_buckets, const allocator_type &a)
 
 concurrent_unordered_multimap (size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
 
 concurrent_unordered_multimap (const Allocator &a)
 
template<typename Iterator >
 concurrent_unordered_multimap (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_multimap (Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
 
template<typename Iterator >
 concurrent_unordered_multimap (Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
 
 concurrent_unordered_multimap (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_multimap (std::initializer_list< value_type > il, size_type n_of_buckets, const allocator_type &a)
 
 concurrent_unordered_multimap (std::initializer_list< value_type > il, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
 
 concurrent_unordered_multimap (const concurrent_unordered_multimap &table)
 
concurrent_unordered_multimapoperator= (const concurrent_unordered_multimap &table)
 
 concurrent_unordered_multimap (concurrent_unordered_multimap &&table)
 
concurrent_unordered_multimapoperator= (concurrent_unordered_multimap &&table)
 
 concurrent_unordered_multimap (concurrent_unordered_multimap &&table, const Allocator &a)
 
template<typename Hash , typename Equality >
void merge (concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &source)
 
template<typename Hash , typename Equality >
void merge (concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &&source)
 
template<typename Hash , typename Equality >
void merge (concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &source)
 
template<typename Hash , typename Equality >
void merge (concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &&source)
 
 concurrent_unordered_multimap (const concurrent_unordered_multimap &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_map_traits< Key, T, hash_compare, Allocator, true > traits_type
 
typedef internal::concurrent_unordered_base< traits_typebase_type
 

Detailed Description

template<typename Key, typename T, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
class tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >

Definition at line 62 of file concurrent_unordered_map.h.

Member Typedef Documentation

◆ allocator_type

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::allocator_type tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::allocator_type

Definition at line 326 of file concurrent_unordered_map.h.

◆ base_type

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef internal::concurrent_unordered_base<traits_type> tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::base_type
private

Definition at line 310 of file concurrent_unordered_map.h.

◆ const_iterator

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::const_iterator tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::const_iterator

Definition at line 336 of file concurrent_unordered_map.h.

◆ const_local_iterator

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::const_iterator tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::const_local_iterator

Definition at line 338 of file concurrent_unordered_map.h.

◆ const_pointer

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::const_pointer tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::const_pointer

Definition at line 328 of file concurrent_unordered_map.h.

◆ const_reference

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::const_reference tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::const_reference

Definition at line 330 of file concurrent_unordered_map.h.

◆ difference_type

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::difference_type tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::difference_type

Definition at line 333 of file concurrent_unordered_map.h.

◆ hash_compare

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef internal::hash_compare<Key, Hasher, Key_equality> tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::hash_compare
private

Definition at line 308 of file concurrent_unordered_map.h.

◆ hasher

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef Hasher tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::hasher

Definition at line 322 of file concurrent_unordered_map.h.

◆ iterator

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::iterator tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::iterator

Definition at line 335 of file concurrent_unordered_map.h.

◆ key_compare

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef hash_compare tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::key_compare

Definition at line 324 of file concurrent_unordered_map.h.

◆ key_equal

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef Key_equality tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::key_equal

Definition at line 323 of file concurrent_unordered_map.h.

◆ key_type

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef Key tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::key_type

Definition at line 319 of file concurrent_unordered_map.h.

◆ local_iterator

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::iterator tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::local_iterator

Definition at line 337 of file concurrent_unordered_map.h.

◆ mapped_type

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef T tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::mapped_type

Definition at line 321 of file concurrent_unordered_map.h.

◆ node_type

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::node_type tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::node_type

Definition at line 340 of file concurrent_unordered_map.h.

◆ pointer

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::pointer tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::pointer

Definition at line 327 of file concurrent_unordered_map.h.

◆ reference

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::reference tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::reference

Definition at line 329 of file concurrent_unordered_map.h.

◆ size_type

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::size_type tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::size_type

Definition at line 332 of file concurrent_unordered_map.h.

◆ traits_type

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef concurrent_unordered_map_traits<Key, T, hash_compare, Allocator, true> tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::traits_type
private

Definition at line 309 of file concurrent_unordered_map.h.

◆ value_type

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
typedef base_type::value_type tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::value_type

Definition at line 320 of file concurrent_unordered_map.h.

Constructor & Destructor Documentation

◆ concurrent_unordered_multimap() [1/14]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( 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 344 of file concurrent_unordered_map.h.

347  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
348  {}

◆ concurrent_unordered_multimap() [2/14]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( size_type  n_of_buckets,
const allocator_type a 
)
inline

Definition at line 350 of file concurrent_unordered_map.h.

351  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
352  {}

◆ concurrent_unordered_multimap() [3/14]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( size_type  n_of_buckets,
const hasher a_hasher,
const allocator_type a 
)
inline

Definition at line 354 of file concurrent_unordered_map.h.

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

◆ concurrent_unordered_multimap() [4/14]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( const Allocator &  a)
inlineexplicit

Definition at line 358 of file concurrent_unordered_map.h.

◆ concurrent_unordered_multimap() [5/14]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
template<typename Iterator >
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( 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 362 of file concurrent_unordered_map.h.

365  : base_type(n_of_buckets,key_compare(a_hasher,a_keyeq), a)
366  {
367  insert(first, last);
368  }

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

Here is the call graph for this function:

◆ concurrent_unordered_multimap() [6/14]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
template<typename Iterator >
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( Iterator  first,
Iterator  last,
size_type  n_of_buckets,
const allocator_type a 
)
inline

Definition at line 371 of file concurrent_unordered_map.h.

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

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

Here is the call graph for this function:

◆ concurrent_unordered_multimap() [7/14]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
template<typename Iterator >
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( Iterator  first,
Iterator  last,
size_type  n_of_buckets,
const hasher a_hasher,
const allocator_type a 
)
inline

Definition at line 378 of file concurrent_unordered_map.h.

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

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

Here is the call graph for this function:

◆ concurrent_unordered_multimap() [8/14]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( 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 387 of file concurrent_unordered_map.h.

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

◆ concurrent_unordered_multimap() [9/14]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( std::initializer_list< value_type il,
size_type  n_of_buckets,
const allocator_type a 
)
inline

Definition at line 395 of file concurrent_unordered_map.h.

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

◆ concurrent_unordered_multimap() [10/14]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( std::initializer_list< value_type il,
size_type  n_of_buckets,
const hasher a_hasher,
const allocator_type a 
)
inline

Definition at line 401 of file concurrent_unordered_map.h.

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

◆ concurrent_unordered_multimap() [11/14]

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

Definition at line 411 of file concurrent_unordered_map.h.

412  : base_type(table)
413  {}

◆ concurrent_unordered_multimap() [12/14]

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

Definition at line 420 of file concurrent_unordered_map.h.

421  : base_type(std::move(table))
422  {}

◆ concurrent_unordered_multimap() [13/14]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator > &&  table,
const Allocator &  a 
)
inline

Definition at line 431 of file concurrent_unordered_map.h.

431  : base_type(std::move(table), a)
432  {}

◆ concurrent_unordered_multimap() [14/14]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( const concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator > &  table,
const Allocator &  a 
)
inline

Definition at line 454 of file concurrent_unordered_map.h.

455  : base_type(table, a)
456  {}

Member Function Documentation

◆ insert() [1/8]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
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 T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
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 T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
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 T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
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 T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
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 T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
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 T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
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 T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
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 T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
template<typename Hash , typename Equality >
void tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::merge ( concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &&  source)
inline

Definition at line 441 of file concurrent_unordered_map.h.

442  { this->internal_merge(source); }

◆ merge() [2/4]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
template<typename Hash , typename Equality >
void tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::merge ( concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &  source)
inline

Definition at line 437 of file concurrent_unordered_map.h.

438  { this->internal_merge(source); }

◆ merge() [3/4]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
template<typename Hash , typename Equality >
void tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::merge ( concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &&  source)
inline

Definition at line 449 of file concurrent_unordered_map.h.

450  { this->internal_merge(source); }

◆ merge() [4/4]

template<typename Key , typename T , typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> >>
template<typename Hash , typename Equality >
void tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::merge ( concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &  source)
inline

Definition at line 445 of file concurrent_unordered_map.h.

446  { this->internal_merge(source); }

◆ operator=() [1/2]

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

Definition at line 424 of file concurrent_unordered_map.h.

425  {
426  return static_cast<concurrent_unordered_multimap&>(base_type::operator=(std::move(table)));
427  }

References tbb::move().

Here is the call graph for this function:

◆ operator=() [2/2]

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

Definition at line 415 of file concurrent_unordered_map.h.

416  {
417  return static_cast<concurrent_unordered_multimap&>(base_type::operator=(table));
418  }

The documentation for this class was generated from the following file:
tbb::interface5::concurrent_unordered_multimap::insert
std::pair< iterator, bool > insert(const value_type &value)
Definition: _concurrent_unordered_impl.h:1068
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::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_multimap::key_compare
hash_compare key_compare
Definition: concurrent_unordered_map.h:324
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
concurrent_unordered_multimap(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_map.h:344
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_multimap::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:310
tbb::internal::bool_constant
Definition: tbb_stddef.h:486
tbb::interface5::concurrent_unordered_multimap::hasher
Hasher hasher
Definition: concurrent_unordered_map.h:322
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::internal::concurrent_unordered_base::initial_bucket_number
static const size_type initial_bucket_number
Definition: _concurrent_unordered_impl.h:742
tbb::interface5::concurrent_unordered_multimap::key_equal
Key_equality key_equal
Definition: concurrent_unordered_map.h:323

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.