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 /* Container implementations in this header are based on PPL implementations
18  provided by Microsoft. */
19 
20 #ifndef __TBB_concurrent_unordered_map_H
21 #define __TBB_concurrent_unordered_map_H
22 
24 
25 namespace tbb
26 {
27 
28 namespace interface5 {
29 
30 // Template class for hash map traits
31 template<typename Key, typename T, typename Hash_compare, typename Allocator, bool Allow_multimapping>
33 {
34 protected:
35  typedef std::pair<const Key, T> value_type;
36  typedef Key key_type;
37  typedef Hash_compare hash_compare;
39 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
40  typedef internal::node_handle<Key, value_type, Allocator> node_type;
41 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
42 
43  enum { allow_multimapping = Allow_multimapping };
44 
47 
48  template<class Type1, class Type2>
49  static const Key& get_key(const std::pair<Type1, Type2>& value) {
50  return (value.first);
51  }
52 
53  hash_compare my_hash_compare; // the comparator predicate for keys
54 };
55 
56 template<typename Key, typename T, typename Hasher, typename Key_equality, typename Allocator>
58 
59 template <typename Key, typename T, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>,
60  typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> > >
62  public internal::concurrent_unordered_base< concurrent_unordered_map_traits<Key, T,
63  internal::hash_compare<Key, Hasher, Key_equality>, Allocator, false> >
64 {
65  // Base type definitions
66  typedef internal::hash_compare<Key, Hasher, Key_equality> hash_compare;
68  typedef internal::concurrent_unordered_base< traits_type > base_type;
69 #if __TBB_EXTRA_DEBUG
70 public:
71 #endif
73 public:
74  using base_type::end;
75  using base_type::find;
76  using base_type::insert;
77 
78  // Type definitions
79  typedef Key key_type;
80  typedef typename base_type::value_type value_type;
81  typedef T mapped_type;
82  typedef Hasher hasher;
83  typedef Key_equality key_equal;
85 
86  typedef typename base_type::allocator_type allocator_type;
87  typedef typename base_type::pointer pointer;
88  typedef typename base_type::const_pointer const_pointer;
89  typedef typename base_type::reference reference;
90  typedef typename base_type::const_reference const_reference;
91 
92  typedef typename base_type::size_type size_type;
93  typedef typename base_type::difference_type difference_type;
94 
95  typedef typename base_type::iterator iterator;
96  typedef typename base_type::const_iterator const_iterator;
97  typedef typename base_type::iterator local_iterator;
98  typedef typename base_type::const_iterator const_local_iterator;
99 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
100  typedef typename base_type::node_type node_type;
101 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
102 
103  // Construction/destruction/copying
104  explicit concurrent_unordered_map(size_type n_of_buckets = base_type::initial_bucket_number,
105  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
106  const allocator_type& a = allocator_type())
107  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
108  {}
109 
111  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
112  {}
113 
114  concurrent_unordered_map(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
115  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
116  {}
117 
119  {}
120 
121  template <typename Iterator>
122  concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
123  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
124  const allocator_type& a = allocator_type())
125  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
126  {
127  insert(first, last);
128  }
129 
130  template <typename Iterator>
131  concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
132  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
133  {
134  insert(first, last);
135  }
136 
137  template <typename Iterator>
138  concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
139  const allocator_type& a)
140  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
141  {
142  insert(first, last);
143  }
144 
145 #if __TBB_INITIALIZER_LISTS_PRESENT
146  concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number,
148  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
149  const allocator_type& a = allocator_type())
150  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
151  {
152  insert(il.begin(),il.end());
153  }
154 
155  concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
156  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
157  {
158  insert(il.begin(), il.end());
159  }
160 
161  concurrent_unordered_map(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
162  const allocator_type& a)
163  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
164  {
165  insert(il.begin(), il.end());
166  }
167 
168 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
169 
170 
171 #if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
173  : base_type(table)
174  {}
175 
177  {
178  return static_cast<concurrent_unordered_map&>(base_type::operator=(table));
179  }
180 
182  : base_type(std::move(table))
183  {}
184 
186  {
187  return static_cast<concurrent_unordered_map&>(base_type::operator=(std::move(table)));
188  }
189 #endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
190 
191 #if __TBB_CPP11_RVALUE_REF_PRESENT
192  concurrent_unordered_map(concurrent_unordered_map&& table, const Allocator& a) : base_type(std::move(table), a)
193  {}
194 #endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
195 
196 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
197  template<typename Hash, typename Equality>
199  { this->internal_merge(source); }
200 
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 #endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
214 
215  concurrent_unordered_map(const concurrent_unordered_map& table, const Allocator& a)
216  : base_type(table, a)
217  {}
218 
219  // Observers
221  {
222  iterator where = find(key);
223 
224  if (where == end())
225  {
226  where = insert(std::pair<key_type, mapped_type>(key, mapped_type())).first;
227  }
228 
229  return ((*where).second);
230  }
231 
233  {
234  iterator where = find(key);
235 
236  if (where == end())
237  {
239  }
240 
241  return ((*where).second);
242  }
243 
244  const mapped_type& at(const key_type& key) const
245  {
246  const_iterator where = find(key);
247 
248  if (where == end())
249  {
251  }
252 
253  return ((*where).second);
254  }
255 };
256 
257 #if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
258 
259 namespace internal {
260 using namespace tbb::internal;
261 
262 template<template<typename...> typename Map, typename Key, typename Element, typename... Args>
263 using cu_map_t = Map<
264  Key, Element,
265  std::conditional_t< (sizeof...(Args)>0) && !is_allocator_v< pack_element_t<0, Args...> >,
266  pack_element_t<0, Args...>, tbb_hash<Key> >,
267  std::conditional_t< (sizeof...(Args)>1) && !is_allocator_v< pack_element_t<1, Args...> >,
268  pack_element_t<1, Args...>, std::equal_to<Key> >,
269  std::conditional_t< (sizeof...(Args)>0) && is_allocator_v< pack_element_t<sizeof...(Args)-1, Args...> >,
270  pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<std::pair<const Key, Element> > >
271 >;
272 }
273 
274 // Deduction guide for the constructor from two iterators
275 template<typename I>
276 concurrent_unordered_map (I, I)
277 -> internal::cu_map_t<concurrent_unordered_map, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>>;
278 
279 // Deduction guide for the constructor from two iterators and hasher/equality/allocator
280 template<typename I, typename... Args>
281 concurrent_unordered_map(I, I, size_t, Args...)
282 -> internal::cu_map_t<concurrent_unordered_map, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>, Args...>;
283 
284 // Deduction guide for the constructor from an initializer_list
285 template<typename Key, typename Element>
286 concurrent_unordered_map(std::initializer_list<std::pair<const Key, Element>>)
287 -> internal::cu_map_t<concurrent_unordered_map, Key, Element>;
288 
289 // Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
290 template<typename Key, typename Element, typename... Args>
291 concurrent_unordered_map(std::initializer_list<std::pair<const Key, Element>>, size_t, Args...)
292 -> internal::cu_map_t<concurrent_unordered_map, Key, Element, Args...>;
293 
294 #endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
295 
296 template < typename Key, typename T, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>,
297  typename Allocator = tbb::tbb_allocator<std::pair<const Key, T> > >
298 class concurrent_unordered_multimap :
299  public internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T,
300  internal::hash_compare<Key, Hasher, Key_equality>, Allocator, true> >
301 {
302  // Base type definitions
303  typedef internal::hash_compare<Key, Hasher, Key_equality> hash_compare;
305  typedef internal::concurrent_unordered_base<traits_type> base_type;
306 #if __TBB_EXTRA_DEBUG
307 public:
308 #endif
309  using traits_type::allow_multimapping;
310 public:
311  using base_type::insert;
312 
313  // Type definitions
314  typedef Key key_type;
315  typedef typename base_type::value_type value_type;
316  typedef T mapped_type;
317  typedef Hasher hasher;
318  typedef Key_equality key_equal;
320 
321  typedef typename base_type::allocator_type allocator_type;
322  typedef typename base_type::pointer pointer;
323  typedef typename base_type::const_pointer const_pointer;
324  typedef typename base_type::reference reference;
325  typedef typename base_type::const_reference const_reference;
326 
327  typedef typename base_type::size_type size_type;
328  typedef typename base_type::difference_type difference_type;
329 
330  typedef typename base_type::iterator iterator;
331  typedef typename base_type::const_iterator const_iterator;
332  typedef typename base_type::iterator local_iterator;
333  typedef typename base_type::const_iterator const_local_iterator;
334 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
335  typedef typename base_type::node_type node_type;
336 #endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
337 
338  // Construction/destruction/copying
339  explicit concurrent_unordered_multimap(size_type n_of_buckets = base_type::initial_bucket_number,
340  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
341  const allocator_type& a = allocator_type())
342  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
343  {}
344 
346  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
347  {}
348 
349  concurrent_unordered_multimap(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
350  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
351  {}
352 
353  explicit concurrent_unordered_multimap(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), a)
354  {}
355 
356  template <typename Iterator>
357  concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
358  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
359  const allocator_type& a = allocator_type())
360  : base_type(n_of_buckets,key_compare(a_hasher,a_keyeq), a)
361  {
362  insert(first, last);
363  }
364 
365  template <typename Iterator>
366  concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
367  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
368  {
369  insert(first, last);
370  }
371 
372  template <typename Iterator>
373  concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
374  const allocator_type& a)
375  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
376  {
377  insert(first, last);
378  }
379 
380 #if __TBB_INITIALIZER_LISTS_PRESENT
381  concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number,
383  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
384  const allocator_type& a = allocator_type())
385  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
386  {
387  insert(il.begin(),il.end());
388  }
389 
390  concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
391  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
392  {
393  insert(il.begin(), il.end());
394  }
395 
396  concurrent_unordered_multimap(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
397  const allocator_type& a)
398  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
399  {
400  insert(il.begin(), il.end());
401  }
402 
403 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
404 
405 #if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
407  : base_type(table)
408  {}
409 
411  {
412  return static_cast<concurrent_unordered_multimap&>(base_type::operator=(table));
413  }
414 
415  concurrent_unordered_multimap(concurrent_unordered_multimap&& table)
416  : base_type(std::move(table))
417  {}
418 
419  concurrent_unordered_multimap& operator=(concurrent_unordered_multimap&& table)
420  {
421  return static_cast<concurrent_unordered_multimap&>(base_type::operator=(std::move(table)));
422  }
423 #endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
424 
425 #if __TBB_CPP11_RVALUE_REF_PRESENT
426  concurrent_unordered_multimap(concurrent_unordered_multimap&& table, const Allocator& a) : base_type(std::move(table), a)
427  {}
428 #endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
429 
430 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
431  template<typename Hash, typename Equality>
433  { this->internal_merge(source); }
434 
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 #endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
448 
450  : base_type(table, a)
451  {}
452 };
453 
454 #if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
455 
456 // Deduction guide for the constructor from two iterators
457 template<typename I>
459 -> internal::cu_map_t<concurrent_unordered_multimap, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>>;
460 
461 // Deduction guide for the constructor from two iterators and hasher/equality/allocator
462 template<typename I, typename... Args>
463 concurrent_unordered_multimap(I, I, size_t, Args...)
464 -> internal::cu_map_t<concurrent_unordered_multimap, internal::iterator_key_t<I>, internal::iterator_mapped_t<I>, Args...>;
465 
466 // Deduction guide for the constructor from an initializer_list
467 template<typename Key, typename Element>
468 concurrent_unordered_multimap(std::initializer_list<std::pair<const Key, Element>>)
469 -> internal::cu_map_t<concurrent_unordered_multimap, Key, Element>;
470 
471 // Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
472 template<typename Key, typename Element, typename... Args>
473 concurrent_unordered_multimap(std::initializer_list<std::pair<const Key, Element>>, size_t, Args...)
474 -> internal::cu_map_t<concurrent_unordered_multimap, Key, Element, Args...>;
475 
476 #endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
477 } // namespace interface5
478 
479 using interface5::concurrent_unordered_map;
480 using interface5::concurrent_unordered_multimap;
481 
482 } // namespace tbb
483 
484 #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 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
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
concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
void merge(concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &source)
concurrent_unordered_multimap(const concurrent_unordered_multimap &table, const Allocator &a)
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:305
concurrent_unordered_multimap(size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
void merge(concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &&source)
concurrent_unordered_map_traits< Key, T, hash_compare, Allocator, true > traits_type
concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5.
Definition: tbb_allocator.h:58
const mapped_type & at(const key_type &key) const
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_map(size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
concurrent_unordered_map(Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
The graph class.
Class for determining type of std::allocator<T>::value_type.
Definition: tbb_stddef.h:450
concurrent_unordered_multimap(concurrent_unordered_multimap &&table, const Allocator &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 end
internal::concurrent_unordered_base< traits_type > base_type
concurrent_unordered_multimap(Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
internal::hash_compare< Key, Hasher, Key_equality > hash_compare
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())
concurrent_unordered_map(std::initializer_list< value_type > il, size_type n_of_buckets, const allocator_type &a)
void merge(concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &source)
concurrent_unordered_multimap(std::initializer_list< value_type > il, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
concurrent_unordered_map(std::initializer_list< value_type > il, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
auto first(Container &c) -> decltype(begin(c))
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())
concurrent_unordered_multimap(size_type n_of_buckets, const allocator_type &a)
allocator_traits< Alloc >::template rebind_alloc< T >::other type
void merge(concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &&source)
static const Key & get_key(const std::pair< Type1, Type2 > &value)
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(std::initializer_list< value_type > il, size_type n_of_buckets, const allocator_type &a)
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
void merge(concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &&source)
internal::concurrent_unordered_base< traits_type > base_type
void merge(concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &&source)
auto last(Container &c) -> decltype(begin(c))
concurrent_unordered_map_traits< Key, T, hash_compare, Allocator, false > traits_type
concurrent_unordered_map(size_type n_of_buckets=base_type::initial_bucket_number, const hasher &a_hasher=hasher(), const key_equal &a_keyeq=key_equal(), const allocator_type &a=allocator_type())
concurrent_unordered_map(concurrent_unordered_map &&table, const Allocator &a)
tbb::internal::allocator_rebind< Allocator, value_type >::type allocator_type
void merge(concurrent_unordered_multimap< Key, T, Hash, Equality, Allocator > &source)
internal::node_handle< Key, value_type, Allocator > node_type
void merge(concurrent_unordered_map< Key, T, Hash, Equality, Allocator > &source)
internal::hash_compare< Key, Hasher, Key_equality > hash_compare
mapped_type & operator[](const key_type &key)
Identifiers declared inside namespace internal should never be used directly by client code.
Definition: atomic.h:51

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.