concurrent_unordered_map.h
Go to the documentation of this file.
/*
Copyright (c) 2005-2020 Intel Corporation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/* Container implementations in this header are based on PPL implementations
provided by Microsoft. */
#ifndef __TBB_concurrent_unordered_map_H
#define __TBB_concurrent_unordered_map_H
#define __TBB_concurrent_unordered_map_H_include_area
#include "internal/_warning_suppress_enable_notice.h"
#include "internal/_concurrent_unordered_impl.h"
namespace tbb
{
namespace interface5 {
// Template class for hash map traits
template<typename Key, typename T, typename Hash_compare, typename Allocator, bool Allow_multimapping>
class concurrent_unordered_map_traits
{
protected:
typedef std::pair<const Key, T> value_type;
typedef Key key_type;
typedef Hash_compare hash_compare;
typedef typename tbb::internal::allocator_rebind<Allocator, value_type>::type allocator_type;
#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
typedef tbb::internal::node_handle<key_type, value_type,
typename internal::split_ordered_list<value_type, allocator_type>::node,
allocator_type> node_type;
#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
enum { allow_multimapping = Allow_multimapping };
concurrent_unordered_map_traits() : my_hash_compare() {}
concurrent_unordered_map_traits(const hash_compare& hc) : my_hash_compare(hc) {}
template<class Type1, class Type2>
static const Key& get_key(const std::pair<Type1, Type2>& value) {
return (value.first);
}
hash_compare my_hash_compare; // the comparator predicate for keys
};
template<typename Key, typename T, typename Hasher, typename Key_equality, typename Allocator>
class concurrent_unordered_multimap;
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 concurrent_unordered_map :
public internal::concurrent_unordered_base< concurrent_unordered_map_traits<Key, T,
internal::hash_compare<Key, Hasher, Key_equality>, Allocator, false> >
{
// Base type definitions
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;
#if __TBB_EXTRA_DEBUG
public:
#endif
using traits_type::allow_multimapping;
public:
using base_type::end;
using base_type::find;
using base_type::insert;
// Type definitions
typedef Key key_type;
typedef typename base_type::value_type value_type;
typedef T mapped_type;
typedef Hasher hasher;
typedef Key_equality key_equal;
typedef hash_compare key_compare;
typedef typename base_type::allocator_type allocator_type;
typedef typename base_type::pointer pointer;
typedef typename base_type::const_pointer const_pointer;
typedef typename base_type::reference reference;
typedef typename base_type::const_reference const_reference;
typedef typename base_type::size_type size_type;
typedef typename base_type::difference_type difference_type;
typedef typename base_type::iterator iterator;
typedef typename base_type::const_iterator const_iterator;
typedef typename base_type::iterator local_iterator;
typedef typename base_type::const_iterator const_local_iterator;
#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
typedef typename base_type::node_type node_type;
#endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
// Construction/destruction/copying
explicit 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())
: base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
{}
concurrent_unordered_map(size_type n_of_buckets, const allocator_type& a)
: base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
{}
concurrent_unordered_map(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
: base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
{}
explicit concurrent_unordered_map(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), 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())
: base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
{
insert(first, last);
}
template <typename Iterator>
concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
: base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
{
insert(first, last);
}
template <typename Iterator>
concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
const allocator_type& a)
: base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
{
insert(first, last);
}
#if __TBB_INITIALIZER_LISTS_PRESENT
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())
: base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
{
insert(il.begin(),il.end());
}
concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
: base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
{
insert(il.begin(), il.end());
}
concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
const allocator_type& a)
: base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
{
insert(il.begin(), il.end());
}
#endif //# __TBB_INITIALIZER_LISTS_PRESENT
#if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
concurrent_unordered_map(const concurrent_unordered_map& table)
: base_type(table)
{}
concurrent_unordered_map& operator=(const concurrent_unordered_map& table)
{
return static_cast<concurrent_unordered_map&>(base_type::operator=(table));
}
concurrent_unordered_map(concurrent_unordered_map&& table)
: base_type(std::move(table))
{}
concurrent_unordered_map& operator=(concurrent_unordered_map&& table)
{
return static_cast<concurrent_unordered_map&>(base_type::operator=(std::move(table)));
}
#endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
#if __TBB_CPP11_RVALUE_REF_PRESENT
concurrent_unordered_map(concurrent_unordered_map&& table, const Allocator& a) : base_type(std::move(table), a)
{}
#endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
template<typename Hash, typename Equality>
void merge(concurrent_unordered_map<Key, T, Hash, Equality, Allocator>& source)
{ this->internal_merge(source); }
template<typename Hash, typename Equality>
void merge(concurrent_unordered_map<Key, T, Hash, Equality, Allocator>&& source)
{ this->internal_merge(source); }
template<typename Hash, typename Equality>
void merge(concurrent_unordered_multimap<Key, T, Hash, Equality, Allocator>& source)
{ this->internal_merge(source); }
template<typename Hash, typename Equality>
void merge(concurrent_unordered_multimap<Key, T, Hash, Equality, Allocator>&& source)
{ this->internal_merge(source); }
#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
concurrent_unordered_map(const concurrent_unordered_map& table, const Allocator& a)
: base_type(table, a)
{}
// Observers
mapped_type& operator[](const key_type& key)
{
iterator where = find(key);
if (where == end())
{
where = insert(std::pair<key_type, mapped_type>(key, mapped_type())).first;
}
return ((*where).second);
}
mapped_type& at(const key_type& key)
{
iterator where = find(key);
if (where == end())
{
tbb::internal::throw_exception(tbb::internal::eid_invalid_key);
}
return ((*where).second);
}
const mapped_type& at(const key_type& key) const
{
const_iterator where = find(key);
if (where == end())
{
tbb::internal::throw_exception(tbb::internal::eid_invalid_key);
}
return ((*where).second);
}
};
#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
namespace internal {
using namespace tbb::internal;
template<template<typename...> typename Map, typename Key, typename Element, typename... Args>
using cu_map_t = Map<
Key, Element,
std::conditional_t< (sizeof...(Args)>0) && !is_allocator_v< pack_element_t<0, Args...> >,
pack_element_t<0, Args...>, tbb_hash<Key> >,
std::conditional_t< (sizeof...(Args)>1) && !is_allocator_v< pack_element_t<1, Args...> >,
pack_element_t<1, Args...>, std::equal_to<Key> >,
std::conditional_t< (sizeof...(Args)>0) && is_allocator_v< pack_element_t<sizeof...(Args)-1, Args...> >,
pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<std::pair<const Key, Element> > >
>;
}
// Deduction guide for the constructor from two iterators
template<typename I>
concurrent_unordered_map (I, I)
-> internal::cu_map_t<concurrent_unordered_map, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>>;
// Deduction guide for the constructor from two iterators and hasher/equality/allocator
template<typename I, typename... Args>
concurrent_unordered_map(I, I, size_t, Args...)
-> internal::cu_map_t<concurrent_unordered_map, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>, Args...>;
// Deduction guide for the constructor from an initializer_list
template<typename Key, typename Element>
concurrent_unordered_map(std::initializer_list<std::pair<const Key, Element>>)
-> internal::cu_map_t<concurrent_unordered_map, Key, Element>;
// Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
template<typename Key, typename Element, typename... Args>
concurrent_unordered_map(std::initializer_list<std::pair<const Key, Element>>, size_t, Args...)
-> internal::cu_map_t<concurrent_unordered_map, Key, Element, Args...>;
#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
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 concurrent_unordered_multimap :
public internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T,
internal::hash_compare<Key, Hasher, Key_equality>, Allocator, true> >
{
// Base type definitions
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;
#if __TBB_EXTRA_DEBUG
public:
#endif
using traits_type::allow_multimapping;
public:
using base_type::insert;
// Type definitions
typedef Key key_type;
typedef typename base_type::value_type value_type;
typedef T mapped_type;
typedef Hasher hasher;
typedef Key_equality key_equal;
typedef hash_compare key_compare;
typedef typename base_type::allocator_type allocator_type;
typedef typename base_type::pointer pointer;
typedef typename base_type::const_pointer const_pointer;
typedef typename base_type::reference reference;
typedef typename base_type::const_reference const_reference;
typedef typename base_type::size_type size_type;
typedef typename base_type::difference_type difference_type;
typedef typename base_type::iterator iterator;
typedef typename base_type::const_iterator const_iterator;
typedef typename base_type::iterator local_iterator;
typedef typename base_type::const_iterator const_local_iterator;
#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
typedef typename base_type::node_type node_type;
#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
// Construction/destruction/copying
explicit 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())
: base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
{}
concurrent_unordered_multimap(size_type n_of_buckets, const allocator_type& a)
: base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
{}
concurrent_unordered_multimap(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
: base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
{}
explicit concurrent_unordered_multimap(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), 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())
: base_type(n_of_buckets,key_compare(a_hasher,a_keyeq), a)
{
insert(first, last);
}
template <typename Iterator>
concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
: base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
{
insert(first, last);
}
template <typename Iterator>
concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
const allocator_type& a)
: base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
{
insert(first, last);
}
#if __TBB_INITIALIZER_LISTS_PRESENT
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())
: base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
{
insert(il.begin(),il.end());
}
concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
: base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
{
insert(il.begin(), il.end());
}
concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
const allocator_type& a)
: base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
{
insert(il.begin(), il.end());
}
#endif //# __TBB_INITIALIZER_LISTS_PRESENT
#if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
concurrent_unordered_multimap(const concurrent_unordered_multimap& table)
: base_type(table)
{}
concurrent_unordered_multimap& operator=(const concurrent_unordered_multimap& table)
{
return static_cast<concurrent_unordered_multimap&>(base_type::operator=(table));
}
concurrent_unordered_multimap(concurrent_unordered_multimap&& table)
: base_type(std::move(table))
{}
concurrent_unordered_multimap& operator=(concurrent_unordered_multimap&& table)
{
return static_cast<concurrent_unordered_multimap&>(base_type::operator=(std::move(table)));
}
#endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
#if __TBB_CPP11_RVALUE_REF_PRESENT
concurrent_unordered_multimap(concurrent_unordered_multimap&& table, const Allocator& a) : base_type(std::move(table), a)
{}
#endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
#if __TBB_UNORDERED_NODE_HANDLE_PRESENT
template<typename Hash, typename Equality>
void merge(concurrent_unordered_map<Key, T, Hash, Equality, Allocator>& source)
{ this->internal_merge(source); }
template<typename Hash, typename Equality>
void merge(concurrent_unordered_map<Key, T, Hash, Equality, Allocator>&& source)
{ this->internal_merge(source); }
template<typename Hash, typename Equality>
void merge(concurrent_unordered_multimap<Key, T, Hash, Equality, Allocator>& source)
{ this->internal_merge(source); }
template<typename Hash, typename Equality>
void merge(concurrent_unordered_multimap<Key, T, Hash, Equality, Allocator>&& source)
{ this->internal_merge(source); }
#endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
concurrent_unordered_multimap(const concurrent_unordered_multimap& table, const Allocator& a)
: base_type(table, a)
{}
};
#if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
// Deduction guide for the constructor from two iterators
template<typename I>
concurrent_unordered_multimap (I, I)
-> internal::cu_map_t<concurrent_unordered_multimap, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>>;
// Deduction guide for the constructor from two iterators and hasher/equality/allocator
template<typename I, typename... Args>
concurrent_unordered_multimap(I, I, size_t, Args...)
-> internal::cu_map_t<concurrent_unordered_multimap, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>, Args...>;
// Deduction guide for the constructor from an initializer_list
template<typename Key, typename Element>
concurrent_unordered_multimap(std::initializer_list<std::pair<const Key, Element>>)
-> internal::cu_map_t<concurrent_unordered_multimap, Key, Element>;
// Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
template<typename Key, typename Element, typename... Args>
concurrent_unordered_multimap(std::initializer_list<std::pair<const Key, Element>>, size_t, Args...)
-> internal::cu_map_t<concurrent_unordered_multimap, Key, Element, Args...>;
#endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
} // namespace interface5
using interface5::concurrent_unordered_map;
using interface5::concurrent_unordered_multimap;
} // namespace tbb
#include "internal/_warning_suppress_disable_notice.h"
#undef __TBB_concurrent_unordered_map_H_include_area
#endif// __TBB_concurrent_unordered_map_H
_concurrent_unordered_impl.h
_warning_suppress_disable_notice.h
_warning_suppress_enable_notice.h
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
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
The graph class.
Definition: serial/tbb/parallel_for.h:46
tbb::move
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
tbb::internal
Identifiers declared inside namespace internal should never be used directly by client code.
Definition: atomic.h:65
tbb::internal::throw_exception
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
Definition: tbb_exception.h:105
tbb::internal::last
auto last(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:40
tbb::internal::eid_invalid_key
@ eid_invalid_key
Definition: tbb_exception.h:84
tbb::internal::first
auto first(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:34
internal
Definition: _flow_graph_async_msg_impl.h:24
tbb::interface5::concurrent_unordered_map_traits
Definition: concurrent_unordered_map.h:36
tbb::interface5::concurrent_unordered_map_traits::allocator_type
tbb::internal::allocator_rebind< Allocator, value_type >::type allocator_type
Definition: concurrent_unordered_map.h:41
tbb::interface5::concurrent_unordered_map_traits::value_type
std::pair< const Key, T > value_type
Definition: concurrent_unordered_map.h:38
tbb::interface5::concurrent_unordered_map_traits::key_type
Key key_type
Definition: concurrent_unordered_map.h:39
tbb::interface5::concurrent_unordered_map_traits::concurrent_unordered_map_traits
concurrent_unordered_map_traits()
Definition: concurrent_unordered_map.h:50
tbb::interface5::concurrent_unordered_map_traits::allow_multimapping
@ allow_multimapping
Definition: concurrent_unordered_map.h:48
tbb::interface5::concurrent_unordered_map_traits::get_key
static const Key & get_key(const std::pair< Type1, Type2 > &value)
Definition: concurrent_unordered_map.h:54
tbb::interface5::concurrent_unordered_map_traits::node_type
tbb::internal::node_handle< key_type, value_type, typename internal::split_ordered_list< value_type, allocator_type >::node, allocator_type > node_type
Definition: concurrent_unordered_map.h:45
tbb::interface5::concurrent_unordered_map_traits::my_hash_compare
hash_compare my_hash_compare
Definition: concurrent_unordered_map.h:58
tbb::interface5::concurrent_unordered_map_traits::concurrent_unordered_map_traits
concurrent_unordered_map_traits(const hash_compare &hc)
Definition: concurrent_unordered_map.h:51
tbb::interface5::concurrent_unordered_map_traits::hash_compare
Hash_compare hash_compare
Definition: concurrent_unordered_map.h:40
tbb::interface5::concurrent_unordered_multimap
Definition: concurrent_unordered_map.h:306
tbb::interface5::concurrent_unordered_multimap::pointer
base_type::pointer pointer
Definition: concurrent_unordered_map.h:327
tbb::interface5::concurrent_unordered_multimap::merge
void merge(concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &&source)
Definition: concurrent_unordered_map.h:449
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
concurrent_unordered_multimap(concurrent_unordered_multimap &&table, const Allocator &a)
Definition: concurrent_unordered_map.h:431
tbb::interface5::concurrent_unordered_multimap::const_reference
base_type::const_reference const_reference
Definition: concurrent_unordered_map.h:330
tbb::interface5::concurrent_unordered_multimap::key_type
Key key_type
Definition: concurrent_unordered_map.h:319
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
Definition: concurrent_unordered_map.h:378
tbb::interface5::concurrent_unordered_multimap::value_type
base_type::value_type value_type
Definition: concurrent_unordered_map.h:320
tbb::interface5::concurrent_unordered_multimap::const_iterator
base_type::const_iterator const_iterator
Definition: concurrent_unordered_map.h:336
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
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())
Definition: concurrent_unordered_map.h:362
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
concurrent_unordered_multimap(const concurrent_unordered_multimap &table, const Allocator &a)
Definition: concurrent_unordered_map.h:454
tbb::interface5::concurrent_unordered_multimap::merge
void merge(concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &source)
Definition: concurrent_unordered_map.h:445
tbb::interface5::concurrent_unordered_multimap::size_type
base_type::size_type size_type
Definition: concurrent_unordered_map.h:332
tbb::interface5::concurrent_unordered_multimap::iterator
base_type::iterator iterator
Definition: concurrent_unordered_map.h:335
tbb::interface5::concurrent_unordered_multimap::difference_type
base_type::difference_type difference_type
Definition: concurrent_unordered_map.h:333
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
concurrent_unordered_multimap(size_type n_of_buckets=base_type::initial_bucket_number, const hasher &a_hasher=hasher(), const key_equal &a_keyeq=key_equal(), const allocator_type &a=allocator_type())
Definition: concurrent_unordered_map.h:344
tbb::interface5::concurrent_unordered_multimap::const_pointer
base_type::const_pointer const_pointer
Definition: concurrent_unordered_map.h:328
tbb::interface5::concurrent_unordered_multimap::mapped_type
T mapped_type
Definition: concurrent_unordered_map.h:321
tbb::interface5::concurrent_unordered_multimap::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:310
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
concurrent_unordered_multimap(size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
Definition: concurrent_unordered_map.h:354
tbb::interface5::concurrent_unordered_multimap::key_compare
hash_compare key_compare
Definition: concurrent_unordered_map.h:324
tbb::interface5::concurrent_unordered_multimap::key_equal
Key_equality key_equal
Definition: concurrent_unordered_map.h:323
tbb::interface5::concurrent_unordered_multimap::local_iterator
base_type::iterator local_iterator
Definition: concurrent_unordered_map.h:337
tbb::interface5::concurrent_unordered_multimap::hash_compare
internal::hash_compare< Key, Hasher, Key_equality > hash_compare
Definition: concurrent_unordered_map.h:308
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
concurrent_unordered_multimap(size_type n_of_buckets, const allocator_type &a)
Definition: concurrent_unordered_map.h:350
tbb::interface5::concurrent_unordered_multimap::merge
void merge(concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &source)
Definition: concurrent_unordered_map.h:437
tbb::interface5::concurrent_unordered_multimap::hasher
Hasher hasher
Definition: concurrent_unordered_map.h:322
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
concurrent_unordered_multimap(std::initializer_list< value_type > il, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
Definition: concurrent_unordered_map.h:401
tbb::interface5::concurrent_unordered_multimap::allocator_type
base_type::allocator_type allocator_type
Definition: concurrent_unordered_map.h:326
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
concurrent_unordered_multimap(std::initializer_list< value_type > il, size_type n_of_buckets, const allocator_type &a)
Definition: concurrent_unordered_map.h:395
tbb::interface5::concurrent_unordered_multimap::const_local_iterator
base_type::const_iterator const_local_iterator
Definition: concurrent_unordered_map.h:338
tbb::interface5::concurrent_unordered_multimap::reference
base_type::reference reference
Definition: concurrent_unordered_map.h:329
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
Definition: concurrent_unordered_map.h:371
tbb::interface5::concurrent_unordered_multimap::node_type
base_type::node_type node_type
Definition: concurrent_unordered_map.h:340
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
concurrent_unordered_multimap(const Allocator &a)
Definition: concurrent_unordered_map.h:358
tbb::interface5::concurrent_unordered_multimap::traits_type
concurrent_unordered_map_traits< Key, T, hash_compare, Allocator, true > traits_type
Definition: concurrent_unordered_map.h:309
tbb::interface5::concurrent_unordered_multimap::merge
void merge(concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &&source)
Definition: concurrent_unordered_map.h:441
tbb::interface5::concurrent_unordered_multimap::concurrent_unordered_multimap
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.
Definition: concurrent_unordered_map.h:387
tbb::interface5::concurrent_unordered_map
Definition: concurrent_unordered_map.h:69
tbb::interface5::concurrent_unordered_map::reference
base_type::reference reference
Definition: concurrent_unordered_map.h:94
tbb::interface5::concurrent_unordered_map::concurrent_unordered_map
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())
Definition: concurrent_unordered_map.h:109
tbb::interface5::concurrent_unordered_map::difference_type
base_type::difference_type difference_type
Definition: concurrent_unordered_map.h:98
tbb::interface5::concurrent_unordered_map::allocator_type
base_type::allocator_type allocator_type
Definition: concurrent_unordered_map.h:91
tbb::interface5::concurrent_unordered_map::merge
void merge(concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &source)
Definition: concurrent_unordered_map.h:203
tbb::interface5::concurrent_unordered_map::key_equal
Key_equality key_equal
Definition: concurrent_unordered_map.h:88
tbb::interface5::concurrent_unordered_map::iterator
base_type::iterator iterator
Definition: concurrent_unordered_map.h:100
tbb::interface5::concurrent_unordered_map::end
iterator end()
Definition: _concurrent_unordered_impl.h:960
tbb::interface5::concurrent_unordered_map::concurrent_unordered_map
concurrent_unordered_map(const concurrent_unordered_map &table, const Allocator &a)
Definition: concurrent_unordered_map.h:220
tbb::interface5::concurrent_unordered_map::node_type
base_type::node_type node_type
Definition: concurrent_unordered_map.h:105
tbb::interface5::concurrent_unordered_map::key_type
Key key_type
Definition: concurrent_unordered_map.h:84
tbb::interface5::concurrent_unordered_map::concurrent_unordered_map
concurrent_unordered_map(std::initializer_list< value_type > il, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
Definition: concurrent_unordered_map.h:166
tbb::interface5::concurrent_unordered_map::concurrent_unordered_map
concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
Definition: concurrent_unordered_map.h:136
tbb::interface5::concurrent_unordered_map::merge
void merge(concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &&source)
Definition: concurrent_unordered_map.h:207
tbb::interface5::concurrent_unordered_map::find
iterator find(const key_type &key)
Definition: _concurrent_unordered_impl.h:1202
tbb::interface5::concurrent_unordered_map::const_iterator
base_type::const_iterator const_iterator
Definition: concurrent_unordered_map.h:101
tbb::interface5::concurrent_unordered_map::const_local_iterator
base_type::const_iterator const_local_iterator
Definition: concurrent_unordered_map.h:103
tbb::interface5::concurrent_unordered_map::traits_type
concurrent_unordered_map_traits< Key, T, hash_compare, Allocator, false > traits_type
Definition: concurrent_unordered_map.h:72
tbb::interface5::concurrent_unordered_map::local_iterator
base_type::iterator local_iterator
Definition: concurrent_unordered_map.h:102
tbb::interface5::concurrent_unordered_map::pointer
base_type::pointer pointer
Definition: concurrent_unordered_map.h:92
tbb::interface5::concurrent_unordered_map::mapped_type
T mapped_type
Definition: concurrent_unordered_map.h:86
tbb::interface5::concurrent_unordered_map::value_type
base_type::value_type value_type
Definition: concurrent_unordered_map.h:85
tbb::interface5::concurrent_unordered_map::concurrent_unordered_map
concurrent_unordered_map(std::initializer_list< value_type > il, size_type n_of_buckets, const allocator_type &a)
Definition: concurrent_unordered_map.h:160
tbb::interface5::concurrent_unordered_map::hash_compare
internal::hash_compare< Key, Hasher, Key_equality > hash_compare
Definition: concurrent_unordered_map.h:71
tbb::interface5::concurrent_unordered_map::concurrent_unordered_map
concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
Definition: concurrent_unordered_map.h:143
tbb::interface5::concurrent_unordered_map::concurrent_unordered_map
concurrent_unordered_map(size_type n_of_buckets, const allocator_type &a)
Definition: concurrent_unordered_map.h:115
tbb::interface5::concurrent_unordered_map::key_compare
hash_compare key_compare
Definition: concurrent_unordered_map.h:89
tbb::interface5::concurrent_unordered_map::concurrent_unordered_map
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.
Definition: concurrent_unordered_map.h:152
tbb::interface5::concurrent_unordered_map::concurrent_unordered_map
concurrent_unordered_map(concurrent_unordered_map &&table, const Allocator &a)
Definition: concurrent_unordered_map.h:197
tbb::interface5::concurrent_unordered_map::insert
std::pair< iterator, bool > insert(const value_type &value)
Definition: _concurrent_unordered_impl.h:1068
tbb::interface5::concurrent_unordered_map::const_pointer
base_type::const_pointer const_pointer
Definition: concurrent_unordered_map.h:93
tbb::interface5::concurrent_unordered_map::merge
void merge(concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &&source)
Definition: concurrent_unordered_map.h:215
tbb::interface5::concurrent_unordered_map::concurrent_unordered_map
concurrent_unordered_map(const Allocator &a)
Definition: concurrent_unordered_map.h:123
tbb::interface5::concurrent_unordered_map::const_reference
base_type::const_reference const_reference
Definition: concurrent_unordered_map.h:95
tbb::interface5::concurrent_unordered_map::at
const mapped_type & at(const key_type &key) const
Definition: concurrent_unordered_map.h:249
tbb::interface5::concurrent_unordered_map::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_map.h:73
tbb::interface5::concurrent_unordered_map::merge
void merge(concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &source)
Definition: concurrent_unordered_map.h:211
tbb::interface5::concurrent_unordered_map::size_type
base_type::size_type size_type
Definition: concurrent_unordered_map.h:97
tbb::interface5::concurrent_unordered_map::operator[]
mapped_type & operator[](const key_type &key)
Definition: concurrent_unordered_map.h:225
tbb::interface5::concurrent_unordered_map::concurrent_unordered_map
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())
Definition: concurrent_unordered_map.h:127
tbb::interface5::concurrent_unordered_map::at
mapped_type & at(const key_type &key)
Definition: concurrent_unordered_map.h:237
tbb::interface5::concurrent_unordered_map::concurrent_unordered_map
concurrent_unordered_map(size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
Definition: concurrent_unordered_map.h:119
tbb::interface5::concurrent_unordered_map::hasher
Hasher hasher
Definition: concurrent_unordered_map.h:87
tbb::internal::allocator_rebind::type
allocator_traits< Alloc >::template rebind_alloc< T >::other type
Definition: _allocator_traits.h:149
tbb::interface5::internal::concurrent_unordered_base
Definition: _concurrent_unordered_impl.h:707
tbb::interface5::internal::concurrent_unordered_base::reference
allocator_type::value_type & reference
Definition: _concurrent_unordered_impl.h:723
tbb::interface5::internal::concurrent_unordered_base::pointer
tbb::internal::allocator_traits< allocator_type >::pointer pointer
Definition: _concurrent_unordered_impl.h:720
tbb::interface5::internal::concurrent_unordered_base::end
iterator end()
Definition: _concurrent_unordered_impl.h:960
tbb::interface5::internal::concurrent_unordered_base::node_type
Traits::node_type node_type
Definition: _concurrent_unordered_impl.h:736
tbb::interface5::internal::concurrent_unordered_base::const_reference
const allocator_type::value_type & const_reference
Definition: _concurrent_unordered_impl.h:724
tbb::interface5::internal::concurrent_unordered_base::find
iterator find(const key_type &key)
Definition: _concurrent_unordered_impl.h:1202
tbb::interface5::internal::concurrent_unordered_base::difference_type
tbb::internal::allocator_traits< allocator_type >::difference_type difference_type
Definition: _concurrent_unordered_impl.h:719
tbb::interface5::internal::concurrent_unordered_base::const_pointer
tbb::internal::allocator_traits< allocator_type >::const_pointer const_pointer
Definition: _concurrent_unordered_impl.h:721
tbb::interface5::internal::concurrent_unordered_base::value_type
Traits::value_type value_type
Definition: _concurrent_unordered_impl.h:711
tbb::interface5::internal::concurrent_unordered_base::size_type
tbb::internal::allocator_traits< allocator_type >::size_type size_type
Definition: _concurrent_unordered_impl.h:718
tbb::interface5::internal::concurrent_unordered_base::insert
std::pair< iterator, bool > insert(const value_type &value)
Definition: _concurrent_unordered_impl.h:1068
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, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< std::pair< const Key, T > >, false > >::internal_merge
void internal_merge(SourceType &source)
Definition: _concurrent_unordered_impl.h:892
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< std::pair< const Key, T > >, false > >::operator=
concurrent_unordered_base & operator=(const concurrent_unordered_base &right)
Definition: _concurrent_unordered_impl.h:844
tbb::interface5::internal::concurrent_unordered_base::allocator_type
Traits::allocator_type allocator_type
Definition: _concurrent_unordered_impl.h:714
tbb::interface5::internal::solist_iterator
Definition: _concurrent_unordered_impl.h:130
tbb::interface5::internal::split_ordered_list::node
Definition: _concurrent_unordered_impl.h:229
tbb::internal::node_handle
Definition: _node_handle_impl.h:104
tbb::interface5::internal::hash_compare
Definition: _tbb_hash_compare_impl.h:30
tbb::tbb_allocator
Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5.
Definition: tbb_allocator.h:58

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.