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 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::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >
const typedef allocator_type::value_type & | const_reference
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()`
| ) |  |

inline explicit

Definition at line 109 of file concurrent_unordered_map.h.

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

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

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

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

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

## 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 | ) |

inline explicit

Definition at line 123 of file concurrent_unordered_map.h.

: base_type(base_type::initial_bucket_number, key_compare(), a)
{}

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

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

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.

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

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.

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

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.

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

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

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

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.

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

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.

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

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

: base_type(table, a)
{}

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

{
iterator where = find(key);
if (where == end())
{
tbb::internal::throw_exception(tbb::internal::eid_invalid_key);
}
return ((*where).second);
}

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.

{
const_iterator where = find(key);
if (where == end())
{
tbb::internal::throw_exception(tbb::internal::eid_invalid_key);
}
return ((*where).second);
}

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.

{
return my_solist.end();
}

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

{
return my_solist.end();
}

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

{
return internal_find(key);
}

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

{
return const_cast<self_type*>(this)->internal_find(key);
}

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

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

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

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

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

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

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

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

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

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

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

{
if (!nh.empty()) {
nodeptr_t handled_node = nh.my_node;
std::pair<iterator, bool> insert_result =
internal_insert</*AllowCreate=*/tbb::internal::false_type,
/*AllowDestroy=*/tbb::internal::false_type>
(handled_node->my_element, handled_node);
if (insert_result.second)
nh.deactivate();
return insert_result;
}
return std::pair<iterator, bool>(end(), false);
}

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

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

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

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

## 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 207 of file concurrent_unordered_map.h.

{ 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 203 of file concurrent_unordered_map.h.

{ 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 215 of file concurrent_unordered_map.h.

{ 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 211 of file concurrent_unordered_map.h.

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

{
iterator where = find(key);
if (where == end())
{
where = insert(std::pair<key_type, mapped_type>(key, mapped_type())).first;
}
return ((*where).second);
}

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:

- concurrent_unordered_map.h

tbb::interface5::concurrent_unordered_map::key_equal
Key_equality key_equal
Definition: concurrent_unordered_map.h:88
tbb::interface5::concurrent_unordered_map::hasher
Hasher hasher
Definition: concurrent_unordered_map.h:87
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::end
iterator end()
Definition: _concurrent_unordered_impl.h:960
tbb::interface5::concurrent_unordered_map::mapped_type
T mapped_type
Definition: concurrent_unordered_map.h:86
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::insert
std::pair< iterator, bool > insert(const value_type &value)
Definition: _concurrent_unordered_impl.h:1068
tbb::internal::throw_exception
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
Definition: tbb_exception.h:105
tbb::internal::bool_constant
Definition: tbb_stddef.h:486
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::nodeptr_t
solist_t::nodeptr_t nodeptr_t
Definition: _concurrent_unordered_impl.h:727
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73
tbb::interface5::internal::split_ordered_list::end
iterator end()
Definition: _concurrent_unordered_impl.h:390
tbb::internal::eid_invalid_key
Definition: tbb_exception.h:84
tbb::interface5::concurrent_unordered_map::iterator
base_type::iterator iterator
Definition: concurrent_unordered_map.h:100
tbb::interface5::internal::concurrent_unordered_base::initial_bucket_number
static const size_type initial_bucket_number
Definition: _concurrent_unordered_impl.h:742
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_find
iterator internal_find(const key_type &key)
Definition: _concurrent_unordered_impl.h:1467
tbb::move
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
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::first
auto first(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:34
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::my_solist
solist_t my_solist
Definition: _concurrent_unordered_impl.h:1671
tbb::internal::true_type
bool_constant< true > true_type
Definition: tbb_stddef.h:489
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::find
iterator find(const key_type &key)
Definition: _concurrent_unordered_impl.h:1202
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_insert
std::pair< iterator, bool > internal_insert(__TBB_FORWARDING_REF(ValueType) value, nodeptr_t pnode=NULL)
Definition: _concurrent_unordered_impl.h:1404
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_merge
void internal_merge(SourceType &source)
Definition: _concurrent_unordered_impl.h:892
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::interface5::concurrent_unordered_map::const_iterator
base_type::const_iterator const_iterator
Definition: concurrent_unordered_map.h:101
tbb::internal::last
auto last(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:40
tbb::internal::false_type
bool_constant< false > false_type
Definition: tbb_stddef.h:490
tbb::interface5::concurrent_unordered_map::key_compare
hash_compare key_compare
Definition: concurrent_unordered_map.h:89

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.