2. Boost Unordered Translation (zh_Hans)
3. Doc / Modules / Root / Pages / Reference / Concurrent Flat Map (adoc)
4. English
5. Zen

:1215 :1215
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; The number of elements inserted. 43/10000 · 43
:1217 :1217
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
277 :1219
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Insert Initializer List and Visit 33/10000 · 33
278 :1220
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class F1, class F2> size_type insert_and_visit(std::initializer_list<value_type> il, F1 f1, F2 f2); template<class F1, class F2> size_type insert_and_cvisit(std::initializer_list<value_type> il, F1 f1, F2 f2); ``` 229/10000 · 229
:1227 :1227
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Equivalent to [listing,subs="+macros,+quotes"] 46/10000 · 46
:1234 :1234
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; The number of elements inserted. 43/10000 · 43
:1236 :1236
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
282 :1238
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — try_emplace 11/10000 · 11
283 :1239
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class... Args> bool try_emplace(const key_type& k, Args&&... args); template<class... Args> bool try_emplace(key_type&& k, Args&&... args); template<class K, class... Args> bool try_emplace(K&& k, Args&&... args); ``` 233/10000 · 233
284 :1245
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Inserts an element constructed from `k` and `args` into the table if there is no existing element with key `k` contained within it. 131/10000 · 131
285 :1248
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; This function is similiar to xref:#concurrent_flat_map_emplace[emplace], with the difference that no `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++ 336/10000 · 336
:1256 :1256
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) 133/10000 · 133
:1261 :1261
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ``` 135/10000 · 135
288 :1266
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — unlike xref:#concurrent_flat_map_emplace[emplace], which simply forwards all arguments to ``value_type``'s constructor. 119/10000 · 119
:1268 :1268
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Invalidates pointers and references to elements if a rehashing is issued. 73/10000 · 73
290 :1270
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The `template<class K, class\... Args>` 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. 373/10000 · 373
:1272 :1272
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — -- 2/10000 · 2
:1274 :1274
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
293 :1276
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — try_emplace_or_[c]visit 23/10000 · 23
294 :1277
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class... Args, class F> bool try_emplace_or_visit(const key_type& k, Args&&... args, F&& f); template<class... Args, class F> bool try_emplace_or_cvisit(const key_type& k, Args&&... args, F&& f); template<class... Args, class F> bool try_emplace_or_visit(key_type&& k, Args&&... args, F&& f); template<class... Args, class F> bool try_emplace_or_cvisit(key_type&& k, Args&&... args, F&& f); template<class K, class... Args, class F> bool try_emplace_or_visit(K&& k, Args&&... args, F&& f); template<class K, class... Args, class F> bool try_emplace_or_cvisit(K&& k, Args&&... args, F&& f); ``` 609/10000 · 609