2. Boost Unordered Translation (zh_Hans)
3. English
4. Zen

269 :1099
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Inserts an object, constructed with the arguments `args`, in the table if there is no element in the table with an equivalent key, and then invokes `f1` with a const reference to the newly created element. Otherwise, invokes `f2` with a const reference to the equivalent element. 279/10000 · 279
:1032 :1032
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
269 :1102
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Inserts an element constructed from `std::forward<K>(k)` in the container if and only if there is no element in the container with an equivalent key. Otherwise, invokes `f` with a const reference to the equivalent element. 222/10000 · 222
:1112 :1112
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — If there is no such element, it is added to the container as: ```c++ 68/10000 · 68
269 :1004
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — find 4/10000 · 4
269 :1025
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ void clear() noexcept; ``` 33/10000 · 33
269 :1114
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — swap 4/10000 · 4
270 :420
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Document that the equality and inequality operators are undefined for two objects if their equality predicates aren't equivalent. Thanks to Daniel Krügler. 155/10000 · 155
:1111 :1111
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<M>(obj))) 126/10000 · 126
:1068 :1068
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
270 :1032
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; A `node_type` object holding the extracted element, or empty if no element was extracted. Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type. 546/10000 · 546
:1180 :1180
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Equivalent to [listing,subs="+macros,+quotes"] 46/10000 · 46
270 :1190
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/MoveInsertable[MoveInsertable^]. Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + In a call of the form `insert_and_[c]visit(obj, f1, f2)`, the overloads accepting a `value_type&&` argument participate in overload resolution only if `std::remove_reference<decltype(obj)>::type` is `value_type`. 498/10000 · 498
270 :1104
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; Invalidates pointers and references to elements if a rehashing is issued. + + The interface is exposition only, as C++ does not allow to declare parameters `f1` and `f2` after a variadic parameter pack. 358/10000 · 358
270 :1034
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — erase_return_void 17/10000 · 17
:1106 :1106
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if an insert took place. Concurrency:;; Blocking on rehashing of `*this`. Notes:;; These overloads only participate in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type. 566/10000 · 566
:1115 :1115
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<M>(obj))) 126/10000 · 126
270 :1005
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ iterator find(const key_type& k); const_iterator find(const key_type& k) const; template<class K> iterator find(const K& k); 147/10000 · 147
270 :1029
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Erases all elements in the container. 37/10000 · 37
270 :1115
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ void swap(unordered_flat_map& other) noexcept(boost::allocator_traits<Allocator>::is_always_equal::value || boost::allocator_traits<Allocator>::propagate_on_container_swap::value); ``` 191/10000 · 191