Exit Zen
64
:459
English
```c++ unordered_node_map(unordered_node_map&& other); ```
66/580 · 58
81
:502
English
```c++ unordered_node_map(unordered_node_map&& other, Allocator const& a); ```
90/780 · 78
85
:517
English
```c++ unordered_node_map(concurrent_node_map<Key, T, Hash, Pred, Allocator>&& other); ```
117/900 · 90
137
:674
English
```c++ unordered_node_map& operator=(unordered_node_map&& other) noexcept((boost::allocator_traits<Allocator>::is_always_equal::value || boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value) && std::is_same<pointer, value_type*>::value); ``` The move assignment operator. Destroys previously existing elements, swaps the hash function and predicate from `other`, and move-assigns the allocator from `other` if `Alloc::propagate_on_container_move_assignment` exists and `Alloc::propagate_on_container_move_assignment::value` is `true`. If at this point the allocator is equal to `other.get_allocator()`, the internal bucket array of `other` is transferred directly to the new container; otherwise, inserts move-constructed copies of the elements of `other`. If statistics are xref:unordered_node_map_boost_unordered_enable_stats[enabled], transfers the internal statistical information from `other` iff the final allocator is equal to `other.get_allocator()`, and always calls `other.reset_stats()`.
784/10270 · 1027
191
:844
English
```c++ std::pair<iterator, bool> insert(value_type&& obj); std::pair<iterator, bool> insert(init_type&& obj); ```
159/1130 · 113
193
:852
English
Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^]. Returns:;; The `bool` component of the return type is `true` if an insert took place. + + If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; Can invalidate iterators, but only if the insert causes the load to be greater than the maximum load. + + A call of the form `insert(x)`, where `x` is equally convertible to both `value_type&&` and `init_type&&`, is not ambiguous and selects the `init_type` overload.
352/7190 · 719
201
:885
English
```c++ iterator insert(const_iterator hint, value_type&& obj); iterator insert(const_iterator hint, init_type&& obj); ```
137/1210 · 121
204
:895
English
Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^]. Returns:;; The `bool` component of the return type is `true` if an insert took place. + + If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; Can invalidate iterators, but only if the insert causes the load to be greater than the maximum load. + + A call of the form `insert(hint, x)`, where `x` is equally convertible to both `value_type&&` and `init_type&&`, is not ambiguous and selects the `init_type` overload.
358/7250 · 725
217
:935
English
```c++ insert_return_type insert(node_type&& nh); ```
61/530 · 53
226
:953
English
```c++ iterator insert(const_iterator hint, node_type&& nh); ```
72/640 · 64
232
:971
English
```c++ template<class... Args> std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); template<class... Args> std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); template<class K, class... Args> std::pair<iterator, bool> try_emplace(K&& k, Args&&... args); ```
430/2960 · 296
244
:1016
English
```c++ template<class... Args> iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); template<class... Args> iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); template<class K, class... Args> iterator try_emplace(const_iterator hint, K&& k, Args&&... args); ```
397/3080 · 308
257
:1061
English
```c++ template<class M> std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); template<class M> std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); template<class K, class M> std::pair<iterator, bool> insert_or_assign(K&& k, M&& obj); ```
400/2720 · 272
266
:1099
English
```c++ template<class M> iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); template<class M> iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); template<class K, class M> iterator insert_or_assign(const_iterator hint, K&& k, M&& obj); ```
367/2840 · 284
280
:1156
English
```c++ size_type erase(const key_type& k); template<class K> size_type erase(K&& k); ```
111/880 · 88
301
:1214
English
```c++ node_type extract(const key_type& k); template<class K> node_type extract(K&& k); ```
115/920 · 92
315
:1251
English
```c++ template<class H2, class P2> void merge(unordered_node_map<Key, T, H2, P2, Allocator>& source); template<class H2, class P2> void merge(unordered_node_map<Key, T, H2, P2, Allocator>&& source); ```
287/2030 · 203
351
:1360
English
```c++ mapped_type& operator[](const key_type& k); mapped_type& operator[](key_type&& k); template<class K> mapped_type& operator[](K&& k); ```
186/1430 · 143
413
:1554
English
```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator==(const unordered_node_map<Key, T, Hash, Pred, Alloc>& x, const unordered_node_map<Key, T, Hash, Pred, Alloc>& y); ```
259/2050 · 205
418
:1568
English
```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator!=(const unordered_node_map<Key, T, Hash, Pred, Alloc>& x, const unordered_node_map<Key, T, Hash, Pred, Alloc>& y); ```
259/2050 · 205