tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator > Class Template Reference

#include <concurrent_unordered_map.h>

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

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

Public Types
typedef Key	key_type
typedef base_type::value_type	value_type
typedef T	mapped_type
typedef Hasher	hasher
typedef Key_equality	key_equal
typedef hash_compare	key_compare
typedef base_type::allocator_type	allocator_type
typedef base_type::pointer	pointer
typedef base_type::const_pointer	const_pointer
typedef base_type::reference	reference
typedef base_type::const_reference	const_reference
typedef base_type::size_type	size_type
typedef base_type::difference_type	difference_type
typedef base_type::iterator	iterator
typedef base_type::const_iterator	const_iterator
typedef base_type::iterator	local_iterator
typedef base_type::const_iterator	const_local_iterator
typedef base_type::node_type	node_type

Public Member Functions
	concurrent_unordered_multimap (size_type n_of_buckets=base_type::initial_bucket_number, const hasher &a_hasher=hasher(), const key_equal &a_keyeq=key_equal(), const allocator_type &a=allocator_type())
	concurrent_unordered_multimap (size_type n_of_buckets, const allocator_type &a)
	concurrent_unordered_multimap (size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
	concurrent_unordered_multimap (const Allocator &a)
template<typename Iterator >
	concurrent_unordered_multimap (Iterator first, Iterator last, size_type n_of_buckets=base_type::initial_bucket_number, const hasher &a_hasher=hasher(), const key_equal &a_keyeq=key_equal(), const allocator_type &a=allocator_type())
template<typename Iterator >
	concurrent_unordered_multimap (Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
template<typename Iterator >
	concurrent_unordered_multimap (Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
	concurrent_unordered_multimap (std::initializer_list< value_type > il, size_type n_of_buckets=base_type::initial_bucket_number, const hasher &a_hasher=hasher(), const key_equal &a_keyeq=key_equal(), const allocator_type &a=allocator_type())
	Constructor from initializer_list. More...
	concurrent_unordered_multimap (std::initializer_list< value_type > il, size_type n_of_buckets, const allocator_type &a)
	concurrent_unordered_multimap (std::initializer_list< value_type > il, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
	concurrent_unordered_multimap (concurrent_unordered_multimap &&table, const Allocator &a)
template<typename Hash , typename Equality >
void	merge (concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &source)
template<typename Hash , typename Equality >
void	merge (concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &&source)
template<typename Hash , typename Equality >
void	merge (concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &source)
template<typename Hash , typename Equality >
void	merge (concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &&source)
	concurrent_unordered_multimap (const concurrent_unordered_multimap &table, const Allocator &a)
std::pair< iterator, bool >	insert (const value_type &value)
iterator	insert (const_iterator, const value_type &value)
std::pair< iterator, bool >	insert (value_type &&value)
iterator	insert (const_iterator, value_type &&value)
std::pair< iterator, bool >	insert (node_type &&nh)
iterator	insert (const_iterator, node_type &&nh)
template<class Iterator >
void	insert (Iterator first, Iterator last)
void	insert (std::initializer_list< value_type > il)
	Insert initializer list. More...
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, true > >
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, true >	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, true > >
typedef concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, true > >	self_type
typedef concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, true > ::value_type	value_type
typedef concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, true > ::key_type	key_type
typedef concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, true > ::hash_compare	hash_compare
typedef concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, true > ::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, true > ::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, true > ::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, true > >
	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, true > >
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_multimap< Key, T, Hasher, Key_equality, Allocator >

Definition at line 62 of file concurrent_unordered_map.h.

Member Typedef Documentation

allocator_type

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

typedef base_type::allocator_type tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::allocator_type

Definition at line 326 of file concurrent_unordered_map.h.

base_type

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

typedef internal::concurrent_unordered_base<traits_type> tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::base_type

private

Definition at line 310 of file concurrent_unordered_map.h.

const_iterator

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

typedef base_type::const_iterator tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::const_iterator

Definition at line 336 of file concurrent_unordered_map.h.

const_local_iterator

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

typedef base_type::const_iterator tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::const_local_iterator

Definition at line 338 of file concurrent_unordered_map.h.

const_pointer

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

typedef base_type::const_pointer tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::const_pointer

Definition at line 328 of file concurrent_unordered_map.h.

const_reference

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

typedef base_type::const_reference tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::const_reference

Definition at line 330 of file concurrent_unordered_map.h.

difference_type

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

typedef base_type::difference_type tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::difference_type

Definition at line 333 of file concurrent_unordered_map.h.

hash_compare

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

typedef internal::hash_compare<Key, Hasher, Key_equality> tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::hash_compare

private

Definition at line 308 of file concurrent_unordered_map.h.

hasher

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

typedef Hasher tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::hasher

Definition at line 322 of file concurrent_unordered_map.h.

iterator

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

typedef base_type::iterator tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::iterator

Definition at line 335 of file concurrent_unordered_map.h.

key_compare

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

typedef hash_compare tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::key_compare

Definition at line 324 of file concurrent_unordered_map.h.

key_equal

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

typedef Key_equality tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::key_equal

Definition at line 323 of file concurrent_unordered_map.h.

key_type

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

typedef Key tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::key_type

Definition at line 319 of file concurrent_unordered_map.h.

local_iterator

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

typedef base_type::iterator tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::local_iterator

Definition at line 337 of file concurrent_unordered_map.h.

mapped_type

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

typedef T tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::mapped_type

Definition at line 321 of file concurrent_unordered_map.h.

node_type

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

typedef base_type::node_type tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::node_type

Definition at line 340 of file concurrent_unordered_map.h.

pointer

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

typedef base_type::pointer tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::pointer

Definition at line 327 of file concurrent_unordered_map.h.

reference

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

typedef base_type::reference tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::reference

Definition at line 329 of file concurrent_unordered_map.h.

size_type

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

typedef base_type::size_type tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::size_type

Definition at line 332 of file concurrent_unordered_map.h.

traits_type

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

typedef concurrent_unordered_map_traits<Key, T, hash_compare, Allocator, true> tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::traits_type

private

Definition at line 309 of file concurrent_unordered_map.h.

value_type

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

typedef base_type::value_type tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::value_type

Definition at line 320 of file concurrent_unordered_map.h.

Constructor & Destructor Documentation

concurrent_unordered_multimap() [1/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_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( size_type  n_of_buckets = base_type::initial_bucket_number, const hasher &  a_hasher = hasher(), const key_equal &  a_keyeq = key_equal(), const allocator_type &  a = allocator_type()  )

inlineexplicit

Definition at line 344 of file concurrent_unordered_map.h.

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

concurrent_unordered_multimap() [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_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( size_type  n_of_buckets, const allocator_type &  a  )

inline

Definition at line 350 of file concurrent_unordered_map.h.

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

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

inline

Definition at line 354 of file concurrent_unordered_map.h.

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

concurrent_unordered_multimap() [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_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( const Allocator &  a )

inlineexplicit

Definition at line 358 of file concurrent_unordered_map.h.

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

concurrent_unordered_multimap() [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_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( Iterator  first, Iterator  last, size_type  n_of_buckets = base_type::initial_bucket_number, const hasher &  a_hasher = hasher(), const key_equal &  a_keyeq = key_equal(), const allocator_type &  a = allocator_type()  )

inline

Definition at line 362 of file concurrent_unordered_map.h.

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

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

Here is the call graph for this function:

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

inline

Definition at line 371 of file concurrent_unordered_map.h.

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

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

Here is the call graph for this function:

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

inline

Definition at line 378 of file concurrent_unordered_map.h.

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

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

Here is the call graph for this function:

concurrent_unordered_multimap() [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_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( std::initializer_list< value_type >  il, size_type  n_of_buckets = base_type::initial_bucket_number, const hasher &  a_hasher = hasher(), const key_equal &  a_keyeq = key_equal(), const allocator_type &  a = allocator_type()  )

inline

Constructor from initializer_list.

Definition at line 387 of file concurrent_unordered_map.h.

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

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

inline

Definition at line 395 of file concurrent_unordered_map.h.

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

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

inline

Definition at line 401 of file concurrent_unordered_map.h.

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

concurrent_unordered_multimap() [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_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator > &&  table, const Allocator &  a  )

inline

Definition at line 431 of file concurrent_unordered_map.h.

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

concurrent_unordered_multimap() [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_multimap< Key, T, Hasher, Key_equality, Allocator >::concurrent_unordered_multimap ( const concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator > &  table, const Allocator &  a  )

inline

Definition at line 454 of file concurrent_unordered_map.h.

        : base_type(table, a)
    {}

Member Function Documentation

insert() [1/8]

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

std::pair<iterator, bool> tbb::interface5::internal::concurrent_unordered_base< Traits >::insert

inline

Definition at line 1068 of file _concurrent_unordered_impl.h.

                                                            {
        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 1084 of file _concurrent_unordered_impl.h.

                                                        {
        // Ignore hint
        return insert(std::move(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> >>

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

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

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

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() [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 1079 of file _concurrent_unordered_impl.h.

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

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

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());
    }

merge() [1/4]

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

template<typename Hash , typename Equality >

void tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::merge ( concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &  source )

inline

Definition at line 437 of file concurrent_unordered_map.h.

              { this->internal_merge(source); }

merge() [2/4]

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

template<typename Hash , typename Equality >

void tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::merge ( concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &&  source )

inline

Definition at line 441 of file concurrent_unordered_map.h.

              { this->internal_merge(source); }

merge() [3/4]

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

template<typename Hash , typename Equality >

void tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::merge ( concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &  source )

inline

Definition at line 445 of file concurrent_unordered_map.h.

              { this->internal_merge(source); }

merge() [4/4]

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

template<typename Hash , typename Equality >

void tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator >::merge ( concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &&  source )

inline

Definition at line 449 of file concurrent_unordered_map.h.

              { this->internal_merge(source); }

---

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

• concurrent_unordered_map.h