76     solist_iterator( const solist_iterator<Container, typename Container::value_type>& other )  in solist_iterator()  argument
77         : my_node_ptr(other.my_node_ptr) {}  in solist_iterator()
79 …st_iterator& operator=( const solist_iterator<Container, typename Container::value_type>& other ) {
80         my_node_ptr = other.my_node_ptr;
281     concurrent_unordered_base( const concurrent_unordered_base& other )  in concurrent_unordered_base()  argument
282         : my_size(other.my_size.load(std::memory_order_relaxed)),  in concurrent_unordered_base()
283           my_bucket_count(other.my_bucket_count.load(std::memory_order_relaxed)),  in concurrent_unordered_base()
284           my_max_load_factor(other.my_max_load_factor),  in concurrent_unordered_base()
285           my_hash_compare(other.my_hash_compare),  in concurrent_unordered_base()
286           my_head(other.my_head.order_key()),  in concurrent_unordered_base()
287           my_segments(other.my_segments)  in concurrent_unordered_base()
290             internal_copy(other);  in concurrent_unordered_base()
296     concurrent_unordered_base( const concurrent_unordered_base& other, const allocator_type& alloc )  in concurrent_unordered_base()  argument
297         : my_size(other.my_size.load(std::memory_order_relaxed)),  in concurrent_unordered_base()
298           my_bucket_count(other.my_bucket_count.load(std::memory_order_relaxed)),  in concurrent_unordered_base()
299           my_max_load_factor(other.my_max_load_factor),  in concurrent_unordered_base()
300           my_hash_compare(other.my_hash_compare),  in concurrent_unordered_base()
301           my_head(other.my_head.order_key()),  in concurrent_unordered_base()
302           my_segments(other.my_segments, alloc)  in concurrent_unordered_base()
305             internal_copy(other);  in concurrent_unordered_base()
311     concurrent_unordered_base( concurrent_unordered_base&& other )  in concurrent_unordered_base()  argument
312         : my_size(other.my_size.load(std::memory_order_relaxed)),  in concurrent_unordered_base()
313           my_bucket_count(other.my_bucket_count.load(std::memory_order_relaxed)),  in concurrent_unordered_base()
314           my_max_load_factor(std::move(other.my_max_load_factor)),  in concurrent_unordered_base()
315           my_hash_compare(std::move(other.my_hash_compare)),  in concurrent_unordered_base()
316           my_head(other.my_head.order_key()),  in concurrent_unordered_base()
317           my_segments(std::move(other.my_segments))  in concurrent_unordered_base()
319         move_content(std::move(other));  in concurrent_unordered_base()
322     concurrent_unordered_base( concurrent_unordered_base&& other, const allocator_type& alloc )  in concurrent_unordered_base()  argument
323         : my_size(other.my_size.load(std::memory_order_relaxed)),  in concurrent_unordered_base()
324           my_bucket_count(other.my_bucket_count.load(std::memory_order_relaxed)),  in concurrent_unordered_base()
325           my_max_load_factor(std::move(other.my_max_load_factor)),  in concurrent_unordered_base()
326           my_hash_compare(std::move(other.my_hash_compare)),  in concurrent_unordered_base()
327           my_head(other.my_head.order_key()),  in concurrent_unordered_base()
328           my_segments(std::move(other.my_segments), alloc)  in concurrent_unordered_base()
331         internal_move_construct_with_allocator(std::move(other), alloc, is_always_equal());  in concurrent_unordered_base()
352     concurrent_unordered_base& operator=( const concurrent_unordered_base& other ) {
353         if (this != &other) {
355             my_size.store(other.my_size.load(std::memory_order_relaxed), std::memory_order_relaxed);
356 …my_bucket_count.store(other.my_bucket_count.load(std::memory_order_relaxed), std::memory_order_rel…
357             my_max_load_factor = other.my_max_load_factor;
358             my_hash_compare = other.my_hash_compare;
359             my_segments = other.my_segments;
360             internal_copy(other); // TODO: guards for exceptions?
365 …concurrent_unordered_base& operator=( concurrent_unordered_base&& other ) noexcept(unordered_segme…  in noexcept()
366         if (this != &other) {  in noexcept()
368             my_size.store(other.my_size.load(std::memory_order_relaxed), std::memory_order_relaxed);  in noexcept()
369 …my_bucket_count.store(other.my_bucket_count.load(std::memory_order_relaxed), std::memory_order_rel…  in noexcept()
370             my_max_load_factor = std::move(other.my_max_load_factor);  in noexcept()
371             my_hash_compare = std::move(other.my_hash_compare);  in noexcept()
372             my_segments = std::move(other.my_segments);  in noexcept()
376 …   internal_move_assign(std::move(other), tbb::detail::disjunction<pocma_type, is_always_equal>());  in noexcept()
387 …void swap( concurrent_unordered_base& other ) noexcept(unordered_segment_table::is_noexcept_swap) {  in swap()  argument
388         if (this != &other) {  in swap()
391             internal_swap(other, tbb::detail::disjunction<pocs_type, is_always_equal>());  in swap()
816 …  unordered_segment_table( const unordered_segment_table& other, const base_allocator_type& alloc )  in unordered_segment_table()  argument
817             : base_type(other, alloc) {}  in unordered_segment_table()
821         unordered_segment_table( unordered_segment_table&& other, const base_allocator_type& alloc )  in unordered_segment_table()  argument
822             : base_type(std::move(other), alloc) {}  in unordered_segment_table()
1319     void internal_copy( const concurrent_unordered_base& other ) {  in internal_copy()  argument
1323         for (node_ptr node = other.my_head.next(); node != nullptr; node = node->next()) {  in internal_copy()
1339     void internal_move( concurrent_unordered_base&& other ) {  in internal_move()  argument
1343         for (node_ptr node = other.my_head.next(); node != nullptr; node = node->next()) {  in internal_move()
1360     void move_content( concurrent_unordered_base&& other ) {  in move_content()  argument
1362         my_head.set_next(other.my_head.next());  in move_content()
1363         other.my_head.set_next(nullptr);  in move_content()
1366         other.my_bucket_count.store(initial_bucket_count, std::memory_order_relaxed);  in move_content()
1367         other.my_max_load_factor = initial_max_load_factor;  in move_content()
1368         other.my_size.store(0, std::memory_order_relaxed);  in move_content()
1371 …void internal_move_construct_with_allocator( concurrent_unordered_base&& other, const allocator_ty…  in internal_move_construct_with_allocator()  argument
1374         move_content(std::move(other));  in internal_move_construct_with_allocator()
1377 …void internal_move_construct_with_allocator( concurrent_unordered_base&& other, const allocator_ty…  in internal_move_construct_with_allocator()  argument
1380         if (alloc == other.my_segments.get_allocator()) {  in internal_move_construct_with_allocator()
1381             move_content(std::move(other));  in internal_move_construct_with_allocator()
1384                 internal_move(std::move(other));  in internal_move_construct_with_allocator()
1393 …void internal_move_assign( concurrent_unordered_base&& other, /*is_always_equal || POCMA = */std::…  in internal_move_assign()  argument
1394         move_content(std::move(other));  in internal_move_assign()
1399 …void internal_move_assign( concurrent_unordered_base&& other, /*is_always_equal || POCMA = */std::…  in internal_move_assign()  argument
1400         if (my_segments.get_allocator() == other.my_segments.get_allocator()) {  in internal_move_assign()
1401             move_content(std::move(other));  in internal_move_assign()
1404             internal_move(std::move(other));  in internal_move_assign()
1408 …void internal_swap( concurrent_unordered_base& other, /*is_always_equal || POCS = */std::true_type…  in internal_swap()  argument
1409         internal_swap_fields(other);  in internal_swap()
1412 …void internal_swap( concurrent_unordered_base& other, /*is_always_equal || POCS = */std::false_typ…  in internal_swap()  argument
1413         __TBB_ASSERT(my_segments.get_allocator() == other.my_segments.get_allocator(),  in internal_swap()
1415         internal_swap_fields(other);  in internal_swap()
1418     void internal_swap_fields( concurrent_unordered_base& other ) {  in internal_swap_fields()  argument
1420         my_head.set_next(other.my_head.next());  in internal_swap_fields()
1421         other.my_head.set_next(first_node);  in internal_swap_fields()
1424         my_size.store(other.my_size.load(std::memory_order_relaxed), std::memory_order_relaxed);  in internal_swap_fields()
1425         other.my_size.store(current_size, std::memory_order_relaxed);  in internal_swap_fields()
1428 …my_bucket_count.store(other.my_bucket_count.load(std::memory_order_relaxed), std::memory_order_rel…  in internal_swap_fields()
1429         other.my_bucket_count.store(bucket_count, std::memory_order_relaxed);  in internal_swap_fields()
1432         swap(my_max_load_factor, other.my_max_load_factor);  in internal_swap_fields()
1433         swap(my_hash_compare, other.my_hash_compare);  in internal_swap_fields()
1434         my_segments.swap(other.my_segments);  in internal_swap_fields()
1440         other.my_segments[0].store(&other.my_head, std::memory_order_relaxed);  in internal_swap_fields()