Home ⌂Doc Index ◂Up ▴
Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
Public Types | Public Member Functions | Private Types | List of all members
tbb::interface5::concurrent_unordered_map< Key, T, Hasher, Key_equality, Allocator > Class Template Reference

#include <concurrent_unordered_map.h>

Inheritance diagram for tbb::interface5::concurrent_unordered_map< Key, T, Hasher, Key_equality, Allocator >:
Collaboration diagram for tbb::interface5::concurrent_unordered_map< 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_map (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_map (size_type n_of_buckets, const allocator_type &a)
 
 concurrent_unordered_map (size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
 
 concurrent_unordered_map (const Allocator &a)
 
template<typename Iterator >
 concurrent_unordered_map (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_map (Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
 
template<typename Iterator >
 concurrent_unordered_map (Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
 
 concurrent_unordered_map (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_map (std::initializer_list< value_type > il, size_type n_of_buckets, const allocator_type &a)
 
 concurrent_unordered_map (std::initializer_list< value_type > il, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
 
 concurrent_unordered_map (concurrent_unordered_map &&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_map (const concurrent_unordered_map &table, const Allocator &a)
 
mapped_type & operator[] (const key_type &key)
 
mapped_type & at (const key_type &key)
 
const mapped_type & at (const key_type &key) const
 
iterator end ()
 
const_iterator end () const
 
iterator find (const key_type &key)
 
const_iterator find (const key_type &key) 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)
 
template<class Iterator >
void insert (Iterator first, Iterator last)
 
void insert (std::initializer_list< value_type > il)
 Insert initializer list. More...
 
- Public Member Functions inherited from tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, 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, iterator > equal_range (const key_type &key)
 
std::pair< const_iterator, const_iterator > equal_range (const key_type &key) const
 
size_type unsafe_bucket_count () const
 
size_type unsafe_max_bucket_count () const
 
size_type unsafe_bucket_size (size_type bucket)
 
size_type unsafe_bucket (const key_type &key) const
 
local_iterator unsafe_begin (size_type bucket)
 
const_local_iterator unsafe_begin (size_type bucket) const
 
local_iterator unsafe_end (size_type bucket)
 
const_local_iterator unsafe_end (size_type bucket) const
 
const_local_iterator unsafe_cbegin (size_type bucket) const
 
const_local_iterator unsafe_cend (size_type bucket) const
 
float load_factor () const
 
float max_load_factor () const
 
void max_load_factor (float newmax)
 
void rehash (size_type buckets)
 

Private Types

typedef internal::hash_compare< Key, Hasher, Key_equality > hash_compare
 
typedef concurrent_unordered_map_traits< Key, T, hash_compare, Allocator, false > traits_type
 
typedef internal::concurrent_unordered_base< traits_type > base_type
 

Additional Inherited Members

- Protected Types inherited from tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >
typedef concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > > self_type
 
typedef concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > ::value_type value_type
 
typedef concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > ::key_type key_type
 
typedef concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > ::hash_compare hash_compare
 
typedef concurrent_unordered_map_traits< Key, T, 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_type & reference
 
typedef const allocator_type::value_type & const_reference
 
typedef split_ordered_list< value_type, typename concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > ::allocator_type > solist_t
 
typedef solist_t::nodeptr_t nodeptr_t
 
typedef solist_t::raw_iterator raw_iterator
 
typedef solist_t::raw_const_iterator raw_const_iterator
 
typedef solist_t::iterator iterator
 
typedef solist_t::const_iterator const_iterator
 
typedef iterator local_iterator
 
typedef const_iterator const_local_iterator
 
typedef concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > ::node_type node_type
 
- Protected Types inherited from tbb::interface5::concurrent_unordered_map_traits< Key, T, Hash_compare, Allocator, Allow_multimapping >
enum  { allow_multimapping = Allow_multimapping }
 
typedef std::pair< const Key, T > 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, value_type, typename internal::split_ordered_list< value_type, allocator_type >::node, allocator_type > node_type
 
- Protected Member Functions inherited from tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, 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_base & operator= (const concurrent_unordered_base &right)
 
concurrent_unordered_base & operator= (concurrent_unordered_base &&other)
 
concurrent_unordered_base & operator= (std::initializer_list< value_type > il)
 assignment operator from initializer_list More...
 
 ~concurrent_unordered_base ()
 
void internal_merge (SourceType &source)
 
- Protected Member Functions inherited from tbb::interface5::concurrent_unordered_map_traits< Key, T, Hash_compare, Allocator, Allow_multimapping >
 concurrent_unordered_map_traits ()
 
 concurrent_unordered_map_traits (const hash_compare &hc)
 
- Static Protected Member Functions inherited from tbb::interface5::concurrent_unordered_map_traits< Key, T, Hash_compare, Allocator, Allow_multimapping >
template<class Type1 , class Type2 >
static const Key & get_key (const std::pair< Type1, Type2 > &value)
 
- Protected Attributes inherited from tbb::interface5::concurrent_unordered_map_traits< Key, T, Hash_compare, Allocator, Allow_multimapping >
hash_compare my_hash_compare
 
- Static Protected Attributes inherited from tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >
static const size_type initial_bucket_number
 

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_map< Key, T, Hasher, Key_equality, Allocator >

Definition at line 66 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_map< Key, T, Hasher, Key_equality, Allocator >::allocator_type

Definition at line 91 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_map< Key, T, Hasher, Key_equality, Allocator >::base_type
private

Definition at line 73 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_map< Key, T, Hasher, Key_equality, Allocator >::const_iterator

Definition at line 101 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_map< Key, T, Hasher, Key_equality, Allocator >::const_local_iterator

Definition at line 103 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_map< Key, T, Hasher, Key_equality, Allocator >::const_pointer

Definition at line 93 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_map< Key, T, Hasher, Key_equality, Allocator >::const_reference

Definition at line 95 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_map< Key, T, Hasher, Key_equality, Allocator >::difference_type

Definition at line 98 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_map< Key, T, Hasher, Key_equality, Allocator >::hash_compare
private

Definition at line 71 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_map< Key, T, Hasher, Key_equality, Allocator >::hasher

Definition at line 87 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_map< Key, T, Hasher, Key_equality, Allocator >::iterator

Definition at line 100 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_map< Key, T, Hasher, Key_equality, Allocator >::key_compare

Definition at line 89 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_map< Key, T, Hasher, Key_equality, Allocator >::key_equal

Definition at line 88 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_map< Key, T, Hasher, Key_equality, Allocator >::key_type

Definition at line 84 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_map< Key, T, Hasher, Key_equality, Allocator >::local_iterator

Definition at line 102 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_map< Key, T, Hasher, Key_equality, Allocator >::mapped_type

Definition at line 86 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_map< Key, T, Hasher, Key_equality, Allocator >::node_type

Definition at line 105 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_map< Key, T, Hasher, Key_equality, Allocator >::pointer

Definition at line 92 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_map< Key, T, Hasher, Key_equality, Allocator >::reference

Definition at line 94 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_map< Key, T, Hasher, Key_equality, Allocator >::size_type

Definition at line 97 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, false> tbb::interface5::concurrent_unordered_map< Key, T, Hasher, Key_equality, Allocator >::traits_type
private

Definition at line 72 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_map< Key, T, Hasher, Key_equality, Allocator >::value_type

Definition at line 85 of file concurrent_unordered_map.h.

Constructor & Destructor Documentation

◆ concurrent_unordered_map() [1/12]

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_map< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_map ( 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 109 of file concurrent_unordered_map.h.

112  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
113  {}
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73

◆ concurrent_unordered_map() [2/12]

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_map< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_map ( size_type  n_of_buckets,
const allocator_type &  a 
)
inline

Definition at line 115 of file concurrent_unordered_map.h.

116  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
117  {}
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73

◆ concurrent_unordered_map() [3/12]

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

Definition at line 119 of file concurrent_unordered_map.h.

120  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
121  {}
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73

◆ concurrent_unordered_map() [4/12]

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

Definition at line 123 of file concurrent_unordered_map.h.

123  : base_type(base_type::initial_bucket_number, key_compare(), a)
124  {}
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73

◆ concurrent_unordered_map() [5/12]

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_map< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_map ( 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 127 of file concurrent_unordered_map.h.

130  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
131  {
132  insert(first, last);
133  }
tbb::internal::last
auto last(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:40
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73
tbb::internal::first
auto first(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:34

References tbb::internal::first(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::insert(), and tbb::internal::last().

Here is the call graph for this function:

◆ concurrent_unordered_map() [6/12]

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

Definition at line 136 of file concurrent_unordered_map.h.

137  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
138  {
139  insert(first, last);
140  }
tbb::internal::last
auto last(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:40
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73
tbb::internal::first
auto first(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:34

References tbb::internal::first(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::insert(), and tbb::internal::last().

Here is the call graph for this function:

◆ concurrent_unordered_map() [7/12]

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

Definition at line 143 of file concurrent_unordered_map.h.

145  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
146  {
147  insert(first, last);
148  }
tbb::internal::last
auto last(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:40
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73
tbb::internal::first
auto first(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:34

References tbb::internal::first(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::insert(), and tbb::internal::last().

Here is the call graph for this function:

◆ concurrent_unordered_map() [8/12]

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_map< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_map ( 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 152 of file concurrent_unordered_map.h.

155  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
156  {
157  insert(il.begin(),il.end());
158  }
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73

◆ concurrent_unordered_map() [9/12]

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

Definition at line 160 of file concurrent_unordered_map.h.

161  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
162  {
163  insert(il.begin(), il.end());
164  }
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73

References tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::insert().

Here is the call graph for this function:

◆ concurrent_unordered_map() [10/12]

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

Definition at line 166 of file concurrent_unordered_map.h.

168  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
169  {
170  insert(il.begin(), il.end());
171  }
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73

References tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::insert().

Here is the call graph for this function:

◆ concurrent_unordered_map() [11/12]

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

Definition at line 197 of file concurrent_unordered_map.h.

197  : base_type(std::move(table), a)
198  {}
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73
tbb::move
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319

◆ concurrent_unordered_map() [12/12]

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

Definition at line 220 of file concurrent_unordered_map.h.

221  : base_type(table, a)
222  {}
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73

Member Function Documentation

◆ at() [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> >>
mapped_type& tbb::interface5::concurrent_unordered_map< Key, T, Hasher, Key_equality, Allocator >::at ( const key_type &  key)
inline

Definition at line 237 of file concurrent_unordered_map.h.

238  {
239  iterator where = find(key);
240 
241  if (where == end())
242  {
243  tbb::internal::throw_exception(tbb::internal::eid_invalid_key);
244  }
245 
246  return ((*where).second);
247  }
key
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 ITT_FORMAT lu const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle * key
Definition: ittnotify_static.h:198
tbb::internal::throw_exception
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
Definition: tbb_exception.h:105

References tbb::internal::eid_invalid_key, tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::end(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::find(), key, and tbb::internal::throw_exception().

Here is the call graph for this function:

◆ at() [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> >>
const mapped_type& tbb::interface5::concurrent_unordered_map< Key, T, Hasher, Key_equality, Allocator >::at ( const key_type &  key) const
inline

Definition at line 249 of file concurrent_unordered_map.h.

250  {
251  const_iterator where = find(key);
252 
253  if (where == end())
254  {
255  tbb::internal::throw_exception(tbb::internal::eid_invalid_key);
256  }
257 
258  return ((*where).second);
259  }
key
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 ITT_FORMAT lu const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle * key
Definition: ittnotify_static.h:198
tbb::internal::throw_exception
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
Definition: tbb_exception.h:105

References tbb::internal::eid_invalid_key, tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::end(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::find(), key, and tbb::internal::throw_exception().

Here is the call graph for this function:

◆ end() [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> >>
iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::end
inline

Definition at line 960 of file _concurrent_unordered_impl.h.

960  {
961  return my_solist.end();
962  }

◆ end() [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> >>
const_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::end
inline

Definition at line 964 of file _concurrent_unordered_impl.h.

964  {
965  return my_solist.end();
966  }

◆ find() [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> >>
iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::find
inline

Definition at line 1202 of file _concurrent_unordered_impl.h.

1202  {
1203  return internal_find(key);
1204  }
key
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 ITT_FORMAT lu const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle * key
Definition: ittnotify_static.h:198

◆ find() [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> >>
const_iterator tbb::interface5::internal::concurrent_unordered_base< Traits >::find
inline

Definition at line 1206 of file _concurrent_unordered_impl.h.

1206  {
1207  return const_cast<self_type*>(this)->internal_find(key);
1208  }
key
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 ITT_FORMAT lu const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle * key
Definition: ittnotify_static.h:198

◆ 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> >>
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  }
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::move
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319

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

◆ 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> >>
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  }
tbb::internal::false_type
bool_constant< false > false_type
Definition: tbb_stddef.h:490

◆ 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 1105 of file _concurrent_unordered_impl.h.

1105  {
1106  return insert(std::move(nh)).first;
1107  }
tbb::move
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319

◆ 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  }
tbb::internal::last
auto last(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:40
tbb::internal::first
auto first(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:34

◆ 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> >>
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() [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> >>
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  }
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

◆ 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  }
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::move
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319

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

Definition at line 203 of file concurrent_unordered_map.h.

204  { this->internal_merge(source); }

References tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_merge().

Here is the call graph for this function:

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

Definition at line 207 of file concurrent_unordered_map.h.

208  { this->internal_merge(source); }

References tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_merge().

Here is the call graph for this function:

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

Definition at line 211 of file concurrent_unordered_map.h.

212  { this->internal_merge(source); }

References tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_merge().

Here is the call graph for this function:

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

Definition at line 215 of file concurrent_unordered_map.h.

216  { this->internal_merge(source); }

References tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_merge().

Here is the call graph for this function:

◆ operator[]()

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> >>
mapped_type& tbb::interface5::concurrent_unordered_map< Key, T, Hasher, Key_equality, Allocator >::operator[] ( const key_type &  key)
inline

Definition at line 225 of file concurrent_unordered_map.h.

226  {
227  iterator where = find(key);
228 
229  if (where == end())
230  {
231  where = insert(std::pair<key_type, mapped_type>(key, mapped_type())).first;
232  }
233 
234  return ((*where).second);
235  }
key
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 ITT_FORMAT lu const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle * key
Definition: ittnotify_static.h:198

References tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::end(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::find(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::insert(), and key.

Here is the call graph for this function:
The documentation for this class was generated from the following file:

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.