Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
concurrent_unordered_map.h
Go to the documentation of this file.
1 /*
2  Copyright (c) 2005-2019 Intel Corporation
3 
4  Licensed under the Apache License, Version 2.0 (the "License");
5  you may not use this file except in compliance with the License.
6  You may obtain a copy of the License at
7 
8  http://www.apache.org/licenses/LICENSE-2.0
9 
10  Unless required by applicable law or agreed to in writing, software
11  distributed under the License is distributed on an "AS IS" BASIS,
12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  See the License for the specific language governing permissions and
14  limitations under the License.
15 
16 
17 
18 
19 */
20 
21 /* Container implementations in this header are based on PPL implementations
22  provided by Microsoft. */
23 
24 #ifndef __TBB_concurrent_unordered_map_H
25 #define __TBB_concurrent_unordered_map_H
26 
28 
29 namespace tbb
30 {
31 
32 namespace interface5 {
33 
34 // Template class for hash map traits
35 template<typename Key, typename T, typename Hash_compare, typename Allocator, bool Allow_multimapping>
37 {
38 protected:
39  typedef std::pair<const Key, T> value_type;
40  typedef Key key_type;
41  typedef Hash_compare hash_compare;
43 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
44  typedef internal::node_handle<Key, value_type, Allocator> node_type;
45 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
46 
47  enum { allow_multimapping = Allow_multimapping };
48 
51 
52  template<class Type1, class Type2>
53  static const Key& get_key(const std::pair<Type1, Type2>& value) {
54  return (value.first);
55  }
56 
57  hash_compare my_hash_compare; // the comparator predicate for keys
58 };
59 
60 template<typename Key, typename T, typename Hasher, typename Key_equality, typename Allocator>
62 
63 template <typename Key, typename T, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>,
64  typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> > >
66  public internal::concurrent_unordered_base< concurrent_unordered_map_traits<Key, T,
67  internal::hash_compare<Key, Hasher, Key_equality>, Allocator, false> >
68 {
69  // Base type definitions
70  typedef internal::hash_compare<Key, Hasher, Key_equality> hash_compare;
72  typedef internal::concurrent_unordered_base< traits_type > base_type;
73 #if __TBB_EXTRA_DEBUG
74 public:
75 #endif
77 public:
78  using base_type::end;
79  using base_type::find;
80  using base_type::insert;
81 
82  // Type definitions
83  typedef Key key_type;
84  typedef typename base_type::value_type value_type;
85  typedef T mapped_type;
86  typedef Hasher hasher;
87  typedef Key_equality key_equal;
89 
90  typedef typename base_type::allocator_type allocator_type;
91  typedef typename base_type::pointer pointer;
92  typedef typename base_type::const_pointer const_pointer;
93  typedef typename base_type::reference reference;
94  typedef typename base_type::const_reference const_reference;
95 
96  typedef typename base_type::size_type size_type;
97  typedef typename base_type::difference_type difference_type;
98 
99  typedef typename base_type::iterator iterator;
100  typedef typename base_type::const_iterator const_iterator;
101  typedef typename base_type::iterator local_iterator;
102  typedef typename base_type::const_iterator const_local_iterator;
103 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
104  typedef typename base_type::node_type node_type;
105 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
106 
107  // Construction/destruction/copying
108  explicit concurrent_unordered_map(size_type n_of_buckets = base_type::initial_bucket_number,
109  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
110  const allocator_type& a = allocator_type())
111  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
112  {}
113 
115  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
116  {}
117 
118  concurrent_unordered_map(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
119  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
120  {}
121 
123  {}
124 
125  template <typename Iterator>
126  concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
127  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
128  const allocator_type& a = allocator_type())
129  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
130  {
131  insert(first, last);
132  }
133 
134  template <typename Iterator>
135  concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
136  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
137  {
138  insert(first, last);
139  }
140 
141  template <typename Iterator>
142  concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
143  const allocator_type& a)
144  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
145  {
146  insert(first, last);
147  }
148 
149 #if __TBB_INITIALIZER_LISTS_PRESENT
150  concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number,
152  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
153  const allocator_type& a = allocator_type())
154  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
155  {
156  insert(il.begin(),il.end());
157  }
158 
159  concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
160  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
161  {
162  insert(il.begin(), il.end());
163  }
164 
165  concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
166  const allocator_type& a)
167  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
168  {
169  insert(il.begin(), il.end());
170  }
171 
172 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
173 
174 
175 #if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
177  : base_type(table)
178  {}
179 
181  {
182  return static_cast<concurrent_unordered_map&>(base_type::operator=(table));
183  }
184 
186  : base_type(std::move(table))
187  {}
188 
190  {
191  return static_cast<concurrent_unordered_map&>(base_type::operator=(std::move(table)));
192  }
193 #endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
194 
195 #if __TBB_CPP11_RVALUE_REF_PRESENT
196  concurrent_unordered_map(concurrent_unordered_map&& table, const Allocator& a) : base_type(std::move(table), a)
197  {}
198 #endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
199 
200 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
201  template<typename Hash, typename Equality>
203  { this->internal_merge(source); }
204 
205  template<typename Hash, typename Equality>
207  { this->internal_merge(source); }
208 
209  template<typename Hash, typename Equality>
211  { this->internal_merge(source); }
212 
213  template<typename Hash, typename Equality>
215  { this->internal_merge(source); }
216 
217 #endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
218 
219  concurrent_unordered_map(const concurrent_unordered_map& table, const Allocator& a)
220  : base_type(table, a)
221  {}
222 
223  // Observers
225  {
226  iterator where = find(key);
227 
228  if (where == end())
229  {
230  where = insert(std::pair<key_type, mapped_type>(key, mapped_type())).first;
231  }
232 
233  return ((*where).second);
234  }
235 
237  {
238  iterator where = find(key);
239 
240  if (where == end())
241  {
243  }
244 
245  return ((*where).second);
246  }
247 
248  const mapped_type& at(const key_type& key) const
249  {
250  const_iterator where = find(key);
251 
252  if (where == end())
253  {
255  }
256 
257  return ((*where).second);
258  }
259 };
260 
261 #if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
262 
263 namespace internal {
264 using namespace tbb::internal;
265 
266 template<template<typename...> typename Map, typename Key, typename Element, typename... Args>
267 using cu_map_t = Map<
268  Key, Element,
269  std::conditional_t< (sizeof...(Args)>0) && !is_allocator_v< pack_element_t<0, Args...> >,
270  pack_element_t<0, Args...>, tbb_hash<Key> >,
271  std::conditional_t< (sizeof...(Args)>1) && !is_allocator_v< pack_element_t<1, Args...> >,
272  pack_element_t<1, Args...>, std::equal_to<Key> >,
273  std::conditional_t< (sizeof...(Args)>0) && is_allocator_v< pack_element_t<sizeof...(Args)-1, Args...> >,
274  pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<std::pair<const Key, Element> > >
275 >;
276 }
277 
278 // Deduction guide for the constructor from two iterators
279 template<typename I>
280 concurrent_unordered_map (I, I)
281 -> internal::cu_map_t<concurrent_unordered_map, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>>;
282 
283 // Deduction guide for the constructor from two iterators and hasher/equality/allocator
284 template<typename I, typename... Args>
285 concurrent_unordered_map(I, I, size_t, Args...)
286 -> internal::cu_map_t<concurrent_unordered_map, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>, Args...>;
287 
288 // Deduction guide for the constructor from an initializer_list
289 template<typename Key, typename Element>
290 concurrent_unordered_map(std::initializer_list<std::pair<const Key, Element>>)
291 -> internal::cu_map_t<concurrent_unordered_map, Key, Element>;
292 
293 // Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
294 template<typename Key, typename Element, typename... Args>
295 concurrent_unordered_map(std::initializer_list<std::pair<const Key, Element>>, size_t, Args...)
296 -> internal::cu_map_t<concurrent_unordered_map, Key, Element, Args...>;
297 
298 #endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
299 
300 template < typename Key, typename T, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>,
301  typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> > >
302 class concurrent_unordered_multimap :
303  public internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T,
304  internal::hash_compare<Key, Hasher, Key_equality>, Allocator, true> >
305 {
306  // Base type definitions
307  typedef internal::hash_compare<Key, Hasher, Key_equality> hash_compare;
309  typedef internal::concurrent_unordered_base<traits_type> base_type;
310 #if __TBB_EXTRA_DEBUG
311 public:
312 #endif
313  using traits_type::allow_multimapping;
314 public:
315  using base_type::insert;
316 
317  // Type definitions
318  typedef Key key_type;
319  typedef typename base_type::value_type value_type;
320  typedef T mapped_type;
321  typedef Hasher hasher;
322  typedef Key_equality key_equal;
324 
325  typedef typename base_type::allocator_type allocator_type;
326  typedef typename base_type::pointer pointer;
327  typedef typename base_type::const_pointer const_pointer;
328  typedef typename base_type::reference reference;
329  typedef typename base_type::const_reference const_reference;
330 
331  typedef typename base_type::size_type size_type;
332  typedef typename base_type::difference_type difference_type;
333 
334  typedef typename base_type::iterator iterator;
335  typedef typename base_type::const_iterator const_iterator;
336  typedef typename base_type::iterator local_iterator;
337  typedef typename base_type::const_iterator const_local_iterator;
338 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
339  typedef typename base_type::node_type node_type;
340 #endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
341 
342  // Construction/destruction/copying
343  explicit concurrent_unordered_multimap(size_type n_of_buckets = base_type::initial_bucket_number,
344  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
345  const allocator_type& a = allocator_type())
346  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
347  {}
348 
350  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
351  {}
352 
353  concurrent_unordered_multimap(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
354  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
355  {}
356 
357  explicit concurrent_unordered_multimap(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), a)
358  {}
359 
360  template <typename Iterator>
361  concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
362  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
363  const allocator_type& a = allocator_type())
364  : base_type(n_of_buckets,key_compare(a_hasher,a_keyeq), a)
365  {
366  insert(first, last);
367  }
368 
369  template <typename Iterator>
370  concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
371  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
372  {
373  insert(first, last);
374  }
375 
376  template <typename Iterator>
377  concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
378  const allocator_type& a)
379  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
380  {
381  insert(first, last);
382  }
383 
384 #if __TBB_INITIALIZER_LISTS_PRESENT
385  concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number,
387  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
388  const allocator_type& a = allocator_type())
389  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
390  {
391  insert(il.begin(),il.end());
392  }
393 
394  concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
395  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
396  {
397  insert(il.begin(), il.end());
398  }
399 
400  concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
401  const allocator_type& a)
402  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
403  {
404  insert(il.begin(), il.end());
405  }
406 
407 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
408 
409 #if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
411  : base_type(table)
412  {}
413 
415  {
416  return static_cast<concurrent_unordered_multimap&>(base_type::operator=(table));
417  }
418 
419  concurrent_unordered_multimap(concurrent_unordered_multimap&& table)
420  : base_type(std::move(table))
421  {}
422 
423  concurrent_unordered_multimap& operator=(concurrent_unordered_multimap&& table)
424  {
425  return static_cast<concurrent_unordered_multimap&>(base_type::operator=(std::move(table)));
426  }
427 #endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
428 
429 #if __TBB_CPP11_RVALUE_REF_PRESENT
430  concurrent_unordered_multimap(concurrent_unordered_multimap&& table, const Allocator& a) : base_type(std::move(table), a)
431  {}
432 #endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
433 
434 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
435  template<typename Hash, typename Equality>
437  { this->internal_merge(source); }
438 
439  template<typename Hash, typename Equality>
441  { this->internal_merge(source); }
442 
443  template<typename Hash, typename Equality>
445  { this->internal_merge(source); }
446 
447  template<typename Hash, typename Equality>
449  { this->internal_merge(source); }
450 
451 #endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
452 
454  : base_type(table, a)
455  {}
456 };
457 
458 #if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
459 
460 // Deduction guide for the constructor from two iterators
461 template<typename I>
463 -> internal::cu_map_t<concurrent_unordered_multimap, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>>;
464 
465 // Deduction guide for the constructor from two iterators and hasher/equality/allocator
466 template<typename I, typename... Args>
467 concurrent_unordered_multimap(I, I, size_t, Args...)
468 -> internal::cu_map_t<concurrent_unordered_multimap, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>, Args...>;
469 
470 // Deduction guide for the constructor from an initializer_list
471 template<typename Key, typename Element>
472 concurrent_unordered_multimap(std::initializer_list<std::pair<const Key, Element>>)
473 -> internal::cu_map_t<concurrent_unordered_multimap, Key, Element>;
474 
475 // Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
476 template<typename Key, typename Element, typename... Args>
477 concurrent_unordered_multimap(std::initializer_list<std::pair<const Key, Element>>, size_t, Args...)
478 -> internal::cu_map_t<concurrent_unordered_multimap, Key, Element, Args...>;
479 
480 #endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
481 } // namespace interface5
482 
483 using interface5::concurrent_unordered_map;
484 using interface5::concurrent_unordered_multimap;
485 
486 } // namespace tbb
487 
488 #endif// __TBB_concurrent_unordered_map_H
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp end
concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
void merge(concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &&source)
void merge(concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &source)
concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
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_map(std::initializer_list< value_type > il, 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, const allocator_type &a)
void merge(concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &&source)
concurrent_unordered_multimap(concurrent_unordered_multimap &&table, const Allocator &a)
auto first(Container &c) -> decltype(begin(c))
Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5.
Definition: tbb_allocator.h:62
tbb::internal::allocator_rebind< Allocator, value_type >::type allocator_type
static const Key & get_key(const std::pair< Type1, Type2 > &value)
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())
allocator_traits< Alloc >::template rebind_alloc< T >::other type
concurrent_unordered_map(std::initializer_list< value_type > il, size_type n_of_buckets, const allocator_type &a)
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)
void merge(concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &source)
void merge(concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &source)
concurrent_unordered_map_traits< Key, T, hash_compare, Allocator, false > traits_type
mapped_type & operator[](const key_type &key)
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
concurrent_unordered_map_traits< Key, T, hash_compare, Allocator, true > traits_type
auto last(Container &c) -> decltype(begin(c))
concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
internal::concurrent_unordered_base< traits_type > base_type
The graph class.
concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
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
internal::node_handle< Key, value_type, Allocator > node_type
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_id __itt_string_handle * key
internal::concurrent_unordered_base< traits_type > base_type
const mapped_type & at(const key_type &key) const
void merge(concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &source)
internal::hash_compare< Key, Hasher, Key_equality > hash_compare
concurrent_unordered_multimap(const concurrent_unordered_multimap &table, const Allocator &a)
concurrent_unordered_map(concurrent_unordered_map &&table, const Allocator &a)
concurrent_unordered_map(size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:309
concurrent_unordered_multimap(std::initializer_list< value_type > il, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
internal::hash_compare< Key, Hasher, Key_equality > hash_compare
concurrent_unordered_map(const concurrent_unordered_map &table, const Allocator &a)
concurrent_unordered_map(size_type n_of_buckets, const allocator_type &a)
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())
Class for determining type of std::allocator<T>::value_type.
Definition: tbb_stddef.h:454
Identifiers declared inside namespace internal should never be used directly by client code.
Definition: atomic.h:55
void merge(concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &&source)
void merge(concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &&source)
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())

Copyright © 2005-2019 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.