Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
concurrent_unordered_set.h
Go to the documentation of this file.
1 /*
2  Copyright (c) 2005-2020 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_set_H
21 #define __TBB_concurrent_unordered_set_H
22 
23 #define __TBB_concurrent_unordered_set_H_include_area
25 
27 
28 namespace tbb
29 {
30 
31 namespace interface5 {
32 
33 // Template class for hash set traits
34 template<typename Key, typename Hash_compare, typename Allocator, bool Allow_multimapping>
36 {
37 protected:
38  typedef Key value_type;
39  typedef Key key_type;
40  typedef Hash_compare hash_compare;
42 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
46 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
47 
48  enum { allow_multimapping = Allow_multimapping };
49 
52 
53  static const Key& get_key(const value_type& value) {
54  return value;
55  }
56 
57  hash_compare my_hash_compare; // the comparator predicate for keys
58 };
59 
60 template<typename Key, typename Hasher, typename Key_equality, typename Allocator>
62 
63 template <typename Key, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>, typename Allocator = tbb::tbb_allocator<Key> >
64 class concurrent_unordered_set : public internal::concurrent_unordered_base< concurrent_unordered_set_traits<Key, internal::hash_compare<Key, Hasher, Key_equality>, Allocator, false> >
65 {
66  // Base type definitions
70 #if __TBB_EXTRA_DEBUG
71 public:
72 #endif
74 public:
75  using base_type::insert;
76 
77  // Type definitions
78  typedef Key key_type;
80  typedef Key mapped_type;
81  typedef Hasher hasher;
82  typedef Key_equality key_equal;
84 
86  typedef typename base_type::pointer pointer;
88  typedef typename base_type::reference reference;
90 
91  typedef typename base_type::size_type size_type;
93 
94  typedef typename base_type::iterator iterator;
98 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
99  typedef typename base_type::node_type node_type;
100 #endif /*__TBB_UNORDERED_NODE_HANDLE_PRESENT*/
101 
102  // Construction/destruction/copying
104  const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
105  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
106  {}
107 
109  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
110  {}
111 
112  concurrent_unordered_set(size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
113  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
114  {}
115 
117  {}
118 
119  template <typename Iterator>
121  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
122  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
123  {
124  insert(first, last);
125  }
126 
127  template <typename Iterator>
128  concurrent_unordered_set(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
129  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
130  {
131  insert(first, last);
132  }
133 
134  template <typename Iterator>
135  concurrent_unordered_set(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
136  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
137  {
138  insert(first, last);
139  }
140 
141 #if __TBB_INITIALIZER_LISTS_PRESENT
142  concurrent_unordered_set(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number, const hasher& a_hasher = hasher(),
144  const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
145  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
146  {
147  insert(il.begin(),il.end());
148  }
149 
150  concurrent_unordered_set(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
151  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
152  {
153  insert(il.begin(), il.end());
154  }
155 
156  concurrent_unordered_set(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher, const allocator_type& a)
157  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
158  {
159  insert(il.begin(), il.end());
160  }
161 
162 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
163 
164 #if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
166  : base_type(table)
167  {}
168 
170  {
171  return static_cast<concurrent_unordered_set&>(base_type::operator=(table));
172  }
173 
175  : base_type(std::move(table))
176  {}
177 
179  {
180  return static_cast<concurrent_unordered_set&>(base_type::operator=(std::move(table)));
181  }
182 #endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
183 
184 #if __TBB_CPP11_RVALUE_REF_PRESENT
186  : base_type(std::move(table), a)
187  {}
188 #endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
189 
190 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
191  template<typename Hash, typename Equality>
193  { this->internal_merge(source); }
194 
195  template<typename Hash, typename Equality>
197  { this->internal_merge(source); }
198 
199  template<typename Hash, typename Equality>
201  { this->internal_merge(source); }
202 
203  template<typename Hash, typename Equality>
205  { this->internal_merge(source); }
206 
207 #endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
208 
209  concurrent_unordered_set(const concurrent_unordered_set& table, const Allocator& a)
210  : base_type(table, a)
211  {}
212 
213 };
214 
215 #if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
216 
217 namespace internal {
218 using namespace tbb::internal;
219 
220 template <template<typename...> typename Set, typename T, typename... Args>
221 using cu_set_t = Set <
222  T,
223  std::conditional_t< (sizeof...(Args)>0) && !is_allocator_v< pack_element_t<0, Args...> >,
224  pack_element_t<0, Args...>, tbb_hash<T> >,
225  std::conditional_t< (sizeof...(Args)>1) && !is_allocator_v< pack_element_t<1, Args...> >,
226  pack_element_t<1, Args...>, std::equal_to<T> >,
227  std::conditional_t< (sizeof...(Args)>0) && is_allocator_v< pack_element_t<sizeof...(Args)-1, Args...> >,
228  pack_element_t<sizeof...(Args)-1, Args...>, tbb_allocator<T> >
229 >;
230 }
231 
232 // Deduction guide for the constructor from two iterators
233 template<typename I>
234 concurrent_unordered_set(I, I)
235 -> internal::cu_set_t<concurrent_unordered_set, internal::iterator_value_t<I>>;
236 
237 // Deduction guide for the constructor from two iterators and hasher/equality/allocator
238 template<typename I, typename... Args>
239 concurrent_unordered_set(I, I, size_t, Args...)
240 -> internal::cu_set_t<concurrent_unordered_set, internal::iterator_value_t<I>, Args...>;
241 
242 // Deduction guide for the constructor from an initializer_list
243 template<typename T>
244 concurrent_unordered_set(std::initializer_list<T>)
245 -> internal::cu_set_t<concurrent_unordered_set, T>;
246 
247 // Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
248 template<typename T, typename... Args>
249 concurrent_unordered_set(std::initializer_list<T>, size_t, Args...)
250 -> internal::cu_set_t<concurrent_unordered_set, T, Args...>;
251 
252 #endif /*__TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
253 
254 template <typename Key, typename Hasher = tbb::tbb_hash<Key>, typename Key_equality = std::equal_to<Key>,
255  typename Allocator = tbb::tbb_allocator<Key> >
256 class concurrent_unordered_multiset :
257  public internal::concurrent_unordered_base< concurrent_unordered_set_traits<Key,
258  internal::hash_compare<Key, Hasher, Key_equality>, Allocator, true> >
259 {
260  // Base type definitions
264 #if __TBB_EXTRA_DEBUG
265 public:
266 #endif
267  using traits_type::allow_multimapping;
268 public:
269  using base_type::insert;
270 
271  // Type definitions
272  typedef Key key_type;
274  typedef Key mapped_type;
275  typedef Hasher hasher;
276  typedef Key_equality key_equal;
278 
280  typedef typename base_type::pointer pointer;
282  typedef typename base_type::reference reference;
283  typedef typename base_type::const_reference const_reference;
284 
285  typedef typename base_type::size_type size_type;
287 
288  typedef typename base_type::iterator iterator;
292 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
293  typedef typename base_type::node_type node_type;
294 #endif // __TBB_UNORDERED_NODE_HANDLE_PRESENT
295 
296  // Construction/destruction/copying
297  explicit concurrent_unordered_multiset(size_type n_of_buckets = base_type::initial_bucket_number,
298  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
299  const allocator_type& a = allocator_type())
300  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
301  {}
302 
304  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
305  {}
306 
307  concurrent_unordered_multiset(size_type n_of_buckets, const hasher& a_hasher,
308  const allocator_type& a)
309  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
310  {}
311 
312  explicit concurrent_unordered_multiset(const Allocator& a) : base_type(base_type::initial_bucket_number, key_compare(), a)
313  {}
314 
315  template <typename Iterator>
316  concurrent_unordered_multiset(Iterator first, Iterator last, size_type n_of_buckets = base_type::initial_bucket_number,
317  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(),
318  const allocator_type& a = allocator_type())
319  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
320  {
321  insert(first, last);
322  }
323 
324  template <typename Iterator>
325  concurrent_unordered_multiset(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type& a)
326  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
327  {
328  insert(first, last);
329  }
330 
331  template <typename Iterator>
332  concurrent_unordered_multiset(Iterator first, Iterator last, size_type n_of_buckets, const hasher& a_hasher,
333  const allocator_type& a)
334  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
335  {
336  insert(first, last);
337  }
338 
339 #if __TBB_INITIALIZER_LISTS_PRESENT
340  concurrent_unordered_multiset(std::initializer_list<value_type> il, size_type n_of_buckets = base_type::initial_bucket_number,
342  const hasher& a_hasher = hasher(), const key_equal& a_keyeq = key_equal(), const allocator_type& a = allocator_type())
343  : base_type(n_of_buckets, key_compare(a_hasher, a_keyeq), a)
344  {
345  insert(il.begin(),il.end());
346  }
347 
348  concurrent_unordered_multiset(std::initializer_list<value_type> il, size_type n_of_buckets, const allocator_type& a)
349  : base_type(n_of_buckets, key_compare(hasher(), key_equal()), a)
350  {
351  insert(il.begin(), il.end());
352  }
353 
354  concurrent_unordered_multiset(std::initializer_list<value_type> il, size_type n_of_buckets, const hasher& a_hasher,
355  const allocator_type& a)
356  : base_type(n_of_buckets, key_compare(a_hasher, key_equal()), a)
357  {
358  insert(il.begin(), il.end());
359  }
360 
361 #endif //# __TBB_INITIALIZER_LISTS_PRESENT
362 
363 
364 #if __TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
366  : base_type(table)
367  {}
368 
370  {
371  return static_cast<concurrent_unordered_multiset&>(base_type::operator=(table));
372  }
373 
375  : base_type(std::move(table))
376  {}
377 
379  {
380  return static_cast<concurrent_unordered_multiset&>(base_type::operator=(std::move(table)));
381  }
382 #endif //__TBB_CPP11_RVALUE_REF_PRESENT && !__TBB_IMPLICIT_MOVE_PRESENT
383 
384 #if __TBB_CPP11_RVALUE_REF_PRESENT
386  : base_type(std::move(table), a)
387  {
388  }
389 #endif /*__TBB_CPP11_RVALUE_REF_PRESENT*/
390 
391 #if __TBB_UNORDERED_NODE_HANDLE_PRESENT
392  template<typename Hash, typename Equality>
394  { this->internal_merge(source); }
395 
396  template<typename Hash, typename Equality>
398  { this->internal_merge(source); }
399 
400  template<typename Hash, typename Equality>
402  { this->internal_merge(source); }
403 
404  template<typename Hash, typename Equality>
406  { this->internal_merge(source); }
407 
408 #endif //__TBB_UNORDERED_NODE_HANDLE_PRESENT
409 
411  : base_type(table, a)
412  {}
413 };
414 
415 #if __TBB_CPP17_DEDUCTION_GUIDES_PRESENT
416 
417 // Deduction guide for the constructor from two iterators
418 template<typename I>
420 -> internal::cu_set_t<concurrent_unordered_multiset, internal::iterator_value_t<I>>;
421 
422 // Deduction guide for the constructor from two iterators and hasher/equality/allocator
423 template<typename I, typename... Args>
424 concurrent_unordered_multiset(I, I, size_t, Args...)
425 -> internal::cu_set_t<concurrent_unordered_multiset, internal::iterator_value_t<I>, Args...>;
426 
427 // Deduction guide for the constructor from an initializer_list
428 template<typename T>
429 concurrent_unordered_multiset(std::initializer_list<T>)
430 -> internal::cu_set_t<concurrent_unordered_multiset, T>;
431 
432 // Deduction guide for the constructor from an initializer_list and hasher/equality/allocator
433 template<typename T, typename... Args>
434 concurrent_unordered_multiset(std::initializer_list<T>, size_t, Args...)
435 -> internal::cu_set_t<concurrent_unordered_multiset, T, Args...>;
436 
437 #endif /* __TBB_CPP17_DEDUCTION_GUIDES_PRESENT */
438 } // namespace interface5
439 
440 using interface5::concurrent_unordered_set;
441 using interface5::concurrent_unordered_multiset;
442 
443 } // namespace tbb
444 
446 #undef __TBB_concurrent_unordered_set_H_include_area
447 
448 #endif// __TBB_concurrent_unordered_set_H
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(const Allocator &a)
Definition: concurrent_unordered_set.h:312
tbb::interface5::concurrent_unordered_set_traits::concurrent_unordered_set_traits
concurrent_unordered_set_traits()
Definition: concurrent_unordered_set.h:50
tbb::interface5::concurrent_unordered_multiset::const_pointer
base_type::const_pointer const_pointer
Definition: concurrent_unordered_set.h:281
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(const concurrent_unordered_set &table)
Definition: concurrent_unordered_set.h:165
tbb::interface5::concurrent_unordered_set::merge
void merge(concurrent_unordered_set< Key, Hash, Equality, Allocator > &&source)
Definition: concurrent_unordered_set.h:196
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
Definition: concurrent_unordered_set.h:307
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(const Allocator &a)
Definition: concurrent_unordered_set.h:116
internal
Definition: _flow_graph_async_msg_impl.h:24
tbb::interface5::concurrent_unordered_multiset
Definition: concurrent_unordered_set.h:61
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::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
Definition: concurrent_unordered_set.h:325
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(const concurrent_unordered_set &table, const Allocator &a)
Definition: concurrent_unordered_set.h:209
tbb::interface5::concurrent_unordered_set::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_set.h:69
tbb::interface5::concurrent_unordered_set::operator=
concurrent_unordered_set & operator=(const concurrent_unordered_set &table)
Definition: concurrent_unordered_set.h:169
tbb::interface5::concurrent_unordered_set_traits::allow_multimapping
@ allow_multimapping
Definition: concurrent_unordered_set.h:48
tbb::interface5::concurrent_unordered_set::node_type
base_type::node_type node_type
Definition: concurrent_unordered_set.h:99
tbb::interface5::concurrent_unordered_multiset::merge
void merge(concurrent_unordered_multiset< Key, Hash, Equality, Allocator > &source)
Definition: concurrent_unordered_set.h:401
tbb::interface5::concurrent_unordered_set::key_equal
Key_equality key_equal
Definition: concurrent_unordered_set.h:82
tbb::interface5::concurrent_unordered_set::local_iterator
base_type::iterator local_iterator
Definition: concurrent_unordered_set.h:96
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(size_type n_of_buckets, const allocator_type &a)
Definition: concurrent_unordered_set.h:108
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(std::initializer_list< value_type > il, size_type n_of_buckets, const allocator_type &a)
Definition: concurrent_unordered_set.h:150
tbb::interface5::concurrent_unordered_multiset::const_reference
base_type::const_reference const_reference
Definition: concurrent_unordered_set.h:283
tbb::interface5::concurrent_unordered_multiset::key_compare
hash_compare key_compare
Definition: concurrent_unordered_set.h:277
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(concurrent_unordered_multiset &&table, const Allocator &a)
Definition: concurrent_unordered_set.h:385
tbb::interface5::concurrent_unordered_multiset::traits_type
concurrent_unordered_set_traits< Key, hash_compare, Allocator, true > traits_type
Definition: concurrent_unordered_set.h:262
tbb::interface5::concurrent_unordered_set::iterator
base_type::iterator iterator
Definition: concurrent_unordered_set.h:94
tbb::interface5::concurrent_unordered_set_traits::get_key
static const Key & get_key(const value_type &value)
Definition: concurrent_unordered_set.h:53
tbb::interface5::concurrent_unordered_multiset::operator=
concurrent_unordered_multiset & operator=(const concurrent_unordered_multiset &table)
Definition: concurrent_unordered_set.h:369
tbb::interface5::internal::concurrent_unordered_base::value_type
Traits::value_type value_type
Definition: _concurrent_unordered_impl.h:711
tbb::interface5::concurrent_unordered_set_traits
Definition: concurrent_unordered_set.h:35
tbb
The graph class.
Definition: serial/tbb/parallel_for.h:46
tbb::internal::first
Container::iterator first(Container &c)
Definition: _range_iterator.h:46
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(const concurrent_unordered_multiset &table)
Definition: concurrent_unordered_set.h:365
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(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_set.h:120
tbb::interface5::internal::solist_iterator
Definition: _concurrent_unordered_impl.h:129
tbb::internal::last
Container::iterator last(Container &c)
Definition: _range_iterator.h:52
tbb::interface5::internal::concurrent_unordered_base::const_reference
const typedef allocator_type::value_type & const_reference
Definition: _concurrent_unordered_impl.h:724
tbb::interface5::concurrent_unordered_multiset::hash_compare
internal::hash_compare< Key, Hasher, Key_equality > hash_compare
Definition: concurrent_unordered_set.h:261
tbb::interface5::concurrent_unordered_multiset::iterator
base_type::iterator iterator
Definition: concurrent_unordered_set.h:288
tbb::interface5::concurrent_unordered_set::operator=
concurrent_unordered_set & operator=(concurrent_unordered_set &&table)
Definition: concurrent_unordered_set.h:178
tbb::internal::allocator_type
Class for determining type of std::allocator<T>::value_type.
Definition: tbb_stddef.h:471
tbb::interface5::concurrent_unordered_multiset::key_equal
Key_equality key_equal
Definition: concurrent_unordered_set.h:276
tbb::interface5::concurrent_unordered_set::hash_compare
internal::hash_compare< Key, Hasher, Key_equality > hash_compare
Definition: concurrent_unordered_set.h:67
tbb::interface5::internal::concurrent_unordered_base
Definition: _concurrent_unordered_impl.h:63
tbb::interface5::internal::concurrent_unordered_base::reference
allocator_type::value_type & reference
Definition: _concurrent_unordered_impl.h:723
tbb::interface5::concurrent_unordered_set::const_pointer
base_type::const_pointer const_pointer
Definition: concurrent_unordered_set.h:87
tbb::interface5::internal::concurrent_unordered_base::insert
std::pair< iterator, bool > insert(const value_type &value)
Definition: _concurrent_unordered_impl.h:1068
tbb::interface5::concurrent_unordered_multiset::operator=
concurrent_unordered_multiset & operator=(concurrent_unordered_multiset &&table)
Definition: concurrent_unordered_set.h:378
tbb::interface5::concurrent_unordered_set::key_compare
hash_compare key_compare
Definition: concurrent_unordered_set.h:83
tbb::interface5::concurrent_unordered_multiset::size_type
base_type::size_type size_type
Definition: concurrent_unordered_set.h:285
tbb::interface5::concurrent_unordered_set::key_type
Key key_type
Definition: concurrent_unordered_set.h:78
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(std::initializer_list< value_type > il, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
Definition: concurrent_unordered_set.h:156
tbb::interface5::concurrent_unordered_multiset::hasher
Hasher hasher
Definition: concurrent_unordered_set.h:275
tbb::interface5::concurrent_unordered_set::mapped_type
Key mapped_type
Definition: concurrent_unordered_set.h:80
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
Definition: concurrent_unordered_set.h:112
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(size_type n_of_buckets, const allocator_type &a)
Definition: concurrent_unordered_set.h:303
tbb::interface5::concurrent_unordered_set::hasher
Hasher hasher
Definition: concurrent_unordered_set.h:81
tbb::interface5::concurrent_unordered_set_traits::node_type
tbb::internal::node_handle< key_type, key_type, typename internal::split_ordered_list< key_type, allocator_type >::node, allocator_type > node_type
Definition: concurrent_unordered_set.h:45
tbb::interface5::concurrent_unordered_set_traits::value_type
Key value_type
Definition: concurrent_unordered_set.h:38
tbb::interface5::concurrent_unordered_multiset::allocator_type
base_type::allocator_type allocator_type
Definition: concurrent_unordered_set.h:279
tbb::interface5::concurrent_unordered_set::allocator_type
base_type::allocator_type allocator_type
Definition: concurrent_unordered_set.h:85
tbb::move
void move(tbb_thread &t1, tbb_thread &t2)
Definition: tbb_thread.h:319
tbb::interface5::concurrent_unordered_set::size_type
base_type::size_type size_type
Definition: concurrent_unordered_set.h:91
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::node_type
Traits::node_type node_type
Definition: _concurrent_unordered_impl.h:736
tbb::interface5::internal::concurrent_unordered_base::operator=
concurrent_unordered_base & operator=(const concurrent_unordered_base &right)
Definition: _concurrent_unordered_impl.h:844
tbb::tbb_allocator
Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5.
Definition: tbb_allocator.h:58
tbb::interface5::concurrent_unordered_set::reference
base_type::reference reference
Definition: concurrent_unordered_set.h:88
tbb::interface5::concurrent_unordered_multiset::base_type
internal::concurrent_unordered_base< traits_type > base_type
Definition: concurrent_unordered_set.h:263
tbb::interface5::concurrent_unordered_set::merge
void merge(concurrent_unordered_multiset< Key, Hash, Equality, Allocator > &source)
Definition: concurrent_unordered_set.h:200
tbb::interface5::concurrent_unordered_set::merge
void merge(concurrent_unordered_multiset< Key, Hash, Equality, Allocator > &&source)
Definition: concurrent_unordered_set.h:204
tbb::interface5::concurrent_unordered_set::merge
void merge(concurrent_unordered_set< Key, Hash, Equality, Allocator > &source)
Definition: concurrent_unordered_set.h:192
tbb::interface5::internal::concurrent_unordered_base::pointer
tbb::internal::allocator_traits< allocator_type >::pointer pointer
Definition: _concurrent_unordered_impl.h:720
tbb::interface5::concurrent_unordered_set::value_type
base_type::value_type value_type
Definition: concurrent_unordered_set.h:79
tbb::interface5::concurrent_unordered_set_traits::concurrent_unordered_set_traits
concurrent_unordered_set_traits(const hash_compare &hc)
Definition: concurrent_unordered_set.h:51
tbb::interface5::concurrent_unordered_set::const_local_iterator
base_type::const_iterator const_local_iterator
Definition: concurrent_unordered_set.h:97
tbb::interface5::internal::split_ordered_list::node
Definition: _concurrent_unordered_impl.h:228
tbb::interface5::concurrent_unordered_set::const_reference
base_type::const_reference const_reference
Definition: concurrent_unordered_set.h:89
_warning_suppress_disable_notice.h
tbb::interface5::internal::concurrent_unordered_base::allocator_type
Traits::allocator_type allocator_type
Definition: _concurrent_unordered_impl.h:714
tbb::interface5::concurrent_unordered_set_traits::my_hash_compare
hash_compare my_hash_compare
Definition: concurrent_unordered_set.h:57
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(std::initializer_list< value_type > il, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
Definition: concurrent_unordered_set.h:354
tbb::interface5::concurrent_unordered_multiset::value_type
base_type::value_type value_type
Definition: concurrent_unordered_set.h:273
tbb::interface5::concurrent_unordered_multiset::const_local_iterator
base_type::const_iterator const_local_iterator
Definition: concurrent_unordered_set.h:291
tbb::internal::node_handle
Definition: _node_handle_impl.h:104
tbb::interface5::concurrent_unordered_set::difference_type
base_type::difference_type difference_type
Definition: concurrent_unordered_set.h:92
tbb::interface5::concurrent_unordered_set
Definition: concurrent_unordered_set.h:64
tbb::interface5::concurrent_unordered_multiset::mapped_type
Key mapped_type
Definition: concurrent_unordered_set.h:274
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
Definition: concurrent_unordered_set.h:135
tbb::interface5::concurrent_unordered_set_traits::key_type
Key key_type
Definition: concurrent_unordered_set.h:39
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > >::internal_merge
void internal_merge(SourceType &source)
Definition: _concurrent_unordered_impl.h:892
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(Iterator first, Iterator last, size_type n_of_buckets, const hasher &a_hasher, const allocator_type &a)
Definition: concurrent_unordered_set.h:332
value
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long value
Definition: ittnotify_static.h:192
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(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_set.h:103
_concurrent_unordered_impl.h
tbb::interface5::concurrent_unordered_multiset::pointer
base_type::pointer pointer
Definition: concurrent_unordered_set.h:280
tbb::internal
Identifiers declared inside namespace internal should never be used directly by client code.
Definition: atomic.h:65
tbb::interface5::concurrent_unordered_multiset::merge
void merge(concurrent_unordered_set< Key, Hash, Equality, Allocator > &&source)
Definition: concurrent_unordered_set.h:397
tbb::interface5::concurrent_unordered_multiset::local_iterator
base_type::iterator local_iterator
Definition: concurrent_unordered_set.h:290
_warning_suppress_enable_notice.h
tbb::interface5::concurrent_unordered_multiset::difference_type
base_type::difference_type difference_type
Definition: concurrent_unordered_set.h:286
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(concurrent_unordered_multiset &&table)
Definition: concurrent_unordered_set.h:374
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(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_set.h:297
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(concurrent_unordered_set &&table, const Allocator &a)
Definition: concurrent_unordered_set.h:185
tbb::interface5::concurrent_unordered_set::const_iterator
base_type::const_iterator const_iterator
Definition: concurrent_unordered_set.h:95
tbb::interface5::concurrent_unordered_set_traits::hash_compare
Hash_compare hash_compare
Definition: concurrent_unordered_set.h:40
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(std::initializer_list< value_type > il, size_type n_of_buckets, const allocator_type &a)
Definition: concurrent_unordered_set.h:348
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(concurrent_unordered_set &&table)
Definition: concurrent_unordered_set.h:174
tbb::interface5::concurrent_unordered_multiset::key_type
Key key_type
Definition: concurrent_unordered_set.h:272
tbb::interface5::concurrent_unordered_multiset::merge
void merge(concurrent_unordered_set< Key, Hash, Equality, Allocator > &source)
Definition: concurrent_unordered_set.h:393
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(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_set.h:316
tbb::interface5::concurrent_unordered_multiset::const_iterator
base_type::const_iterator const_iterator
Definition: concurrent_unordered_set.h:289
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::concurrent_unordered_multiset::merge
void merge(concurrent_unordered_multiset< Key, Hash, Equality, Allocator > &&source)
Definition: concurrent_unordered_set.h:405
tbb::interface5::concurrent_unordered_set::pointer
base_type::pointer pointer
Definition: concurrent_unordered_set.h:86
tbb::interface5::concurrent_unordered_set_traits::allocator_type
tbb::internal::allocator_rebind< Allocator, value_type >::type allocator_type
Definition: concurrent_unordered_set.h:41
tbb::interface5::internal::concurrent_unordered_base::initial_bucket_number
static const size_type initial_bucket_number
Definition: _concurrent_unordered_impl.h:742
tbb::internal::allocator_rebind::type
allocator_traits< Alloc >::template rebind_alloc< T >::other type
Definition: _allocator_traits.h:149
tbb::interface5::concurrent_unordered_set::concurrent_unordered_set
concurrent_unordered_set(Iterator first, Iterator last, size_type n_of_buckets, const allocator_type &a)
Definition: concurrent_unordered_set.h:128
tbb::interface5::concurrent_unordered_set::traits_type
concurrent_unordered_set_traits< Key, hash_compare, Allocator, false > traits_type
Definition: concurrent_unordered_set.h:68
tbb::interface5::concurrent_unordered_multiset::concurrent_unordered_multiset
concurrent_unordered_multiset(const concurrent_unordered_multiset &table, const Allocator &a)
Definition: concurrent_unordered_set.h:410
tbb::interface5::concurrent_unordered_multiset::node_type
base_type::node_type node_type
Definition: concurrent_unordered_set.h:293
tbb::interface5::concurrent_unordered_multiset::reference
base_type::reference reference
Definition: concurrent_unordered_set.h:282
tbb::interface5::internal::hash_compare
Definition: _tbb_hash_compare_impl.h:29

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.