msgid ""
msgstr ""
"Project-Id-Version: English (Boost Unordered Translation (zh_Hans))\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-06-07 19:36+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: English <https://insights.cppalliance.org/weblate/projects/"
"boost-unordered-documentation-zh_Hans/doc-modules-root-pages-reference-"
"concurrent-node-map-adoc/en/>\n"
"Language: en\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n != 1;\n"
"X-Generator: Weblate 2026.5\n"

#: :1
#, read-only, safe-html, strict-same
msgid "﻿[#concurrent_node_map]"
msgstr "﻿[#concurrent_node_map]"

#: :2
#, read-only, safe-html, strict-same
msgid "Class Template concurrent_node_map"
msgstr "Class Template concurrent_node_map"

#: :4
#, read-only, safe-html, strict-same
msgid ":idprefix: concurrent_node_map_"
msgstr ":idprefix: concurrent_node_map_"

#: :6
#, read-only, safe-html, strict-same
msgid ""
"`boost::concurrent_node_map` — A node-based hash table that associates "
"unique keys with another value and allows for concurrent element insertion, "
"erasure, lookup and access without external synchronization mechanisms."
msgstr ""
"`boost::concurrent_node_map` — A node-based hash table that associates "
"unique keys with another value and allows for concurrent element insertion, "
"erasure, lookup and access without external synchronization mechanisms."

#: :10
#, read-only, safe-html, strict-same
msgid ""
"Even though it acts as a container, `boost::concurrent_node_map` does not "
"model the standard C++ https://en.cppreference.com/w/cpp/named_req/"
"Container[Container^] concept. In particular, iterators and associated "
"operations (`begin`, `end`, etc.) are not provided. Element access and "
"modification are done through user-provided _visitation functions_ that are "
"passed to `concurrent_node_map` operations where they are executed "
"internally in a controlled fashion. Such visitation-based API allows for low-"
"contention concurrent usage scenarios."
msgstr ""
"Even though it acts as a container, `boost::concurrent_node_map` does not "
"model the standard C++ https://en.cppreference.com/w/cpp/named_req/"
"Container[Container^] concept. In particular, iterators and associated "
"operations (`begin`, `end`, etc.) are not provided. Element access and "
"modification are done through user-provided _visitation functions_ that are "
"passed to `concurrent_node_map` operations where they are executed "
"internally in a controlled fashion. Such visitation-based API allows for low-"
"contention concurrent usage scenarios."

#: :17
#, read-only, safe-html, strict-same
msgid ""
"The internal data structure of `boost::concurrent_node_map` is similar to "
"that of `boost::unordered_node_map`. Unlike `boost::concurrent_flat_map`, "
"pointer stability and node handling functionalities are provided, at the "
"expense of potentially lower performance."
msgstr ""
"The internal data structure of `boost::concurrent_node_map` is similar to "
"that of `boost::unordered_node_map`. Unlike `boost::concurrent_flat_map`, "
"pointer stability and node handling functionalities are provided, at the "
"expense of potentially lower performance."

#: :21
#, read-only, safe-html, strict-same
msgid "Synopsis"
msgstr "Synopsis"

#: :347
#, read-only, safe-html, strict-same
msgctxt ":347"
msgid "---"
msgstr "---"

#: :349
#, read-only, safe-html, strict-same
msgid "Description"
msgstr "Description"

#: :351
#, read-only, safe-html, strict-same
msgid "*Template Parameters*"
msgstr "*Template Parameters*"

#: :354
#, read-only, safe-html, strict-same
msgid "_Key_"
msgstr "_Key_"

#: :358
#, read-only, safe-html, strict-same
msgid ""
"into the table from any `std::pair` object convertible to it, and it also "
"must be https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] from "
"the table."
msgstr ""
"into the table from any `std::pair` object convertible to it, and it also "
"must be https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] from "
"the table."

#: :361
#, read-only, safe-html, strict-same
msgid "_T_"
msgstr "_T_"

#: :361
#, read-only, safe-html, strict-same
msgid "_Hash_"
msgstr "_Hash_"

#: :361
#, read-only, safe-html, strict-same
msgid ""
"A unary function object type that acts a hash function for a `Key`. It takes "
"a single argument of type `Key` and returns a value of type `std::size_t`."
msgstr ""
"A unary function object type that acts a hash function for a `Key`. It takes "
"a single argument of type `Key` and returns a value of type `std::size_t`."

#: :361
#, read-only, safe-html, strict-same
msgid "_Pred_"
msgstr "_Pred_"

#: :361
#, read-only, safe-html, strict-same
msgid ""
"A binary function object that induces an equivalence relation on values of "
"type `Key`. It takes two arguments of type `Key` and returns a value of type "
"`bool`."
msgstr ""
"A binary function object that induces an equivalence relation on values of "
"type `Key`. It takes two arguments of type `Key` and returns a value of type "
"`bool`."

#: :361
#, read-only, safe-html, strict-same
msgid "_Allocator_"
msgstr "_Allocator_"

#: :361
#, read-only, safe-html, strict-same
msgid "An allocator whose value type is the same as the table's value type."
msgstr "An allocator whose value type is the same as the table's value type."

#: :371
#, read-only, safe-html, strict-same
msgid ""
"Allocators using https://en.cppreference.com/w/cpp/named_req/"
"Allocator#Fancy_pointers[fancy pointers] are supported."
msgstr ""
"Allocators using https://en.cppreference.com/w/cpp/named_req/"
"Allocator#Fancy_pointers[fancy pointers] are supported."

#: :375
#, read-only, safe-html, strict-same
msgid ""
"The element nodes of the table are held into an internal _bucket array_. An "
"node is inserted into a bucket determined by the hash code of its element, "
"but if the bucket is already occupied (a _collision_), an available one in "
"the vicinity of the original position is used."
msgstr ""
"The element nodes of the table are held into an internal _bucket array_. An "
"node is inserted into a bucket determined by the hash code of its element, "
"but if the bucket is already occupied (a _collision_), an available one in "
"the vicinity of the original position is used."

#: :379
#, read-only, safe-html, strict-same
msgid ""
"The size of the bucket array can be automatically increased by a call to "
"`insert`/`emplace`, or as a result of calling `rehash`/`reserve`. The _load "
"factor_ of the table (number of elements divided by number of buckets) is "
"never greater than `max_load_factor()`, except possibly for small sizes "
"where the implementation may decide to allow for higher loads."
msgstr ""
"The size of the bucket array can be automatically increased by a call to "
"`insert`/`emplace`, or as a result of calling `rehash`/`reserve`. The _load "
"factor_ of the table (number of elements divided by number of buckets) is "
"never greater than `max_load_factor()`, except possibly for small sizes "
"where the implementation may decide to allow for higher loads."

#: :384
#, read-only, safe-html, strict-same
msgid ""
"If `link:../../../../../container_hash/doc/html/"
"hash.html#ref_hash_is_avalanchinghash[hash_is_avalanching]<Hash>::value` is "
"`true`, the hash function is used as-is; otherwise, a bit-mixing post-"
"processing stage is added to increase the quality of hashing at the expense "
"of extra computational cost."
msgstr ""
"If `link:../../../../../container_hash/doc/html/"
"hash.html#ref_hash_is_avalanchinghash[hash_is_avalanching]<Hash>::value` is "
"`true`, the hash function is used as-is; otherwise, a bit-mixing post-"
"processing stage is added to increase the quality of hashing at the expense "
"of extra computational cost."

#: :388
#, read-only, safe-html, strict-same
msgctxt ":388"
msgid "---"
msgstr "---"

#: :390
#, read-only, safe-html, strict-same
msgid "Concurrency Requirements and Guarantees"
msgstr "Concurrency Requirements and Guarantees"

#: :392
#, read-only, safe-html, strict-same
msgid ""
"Concurrent invocations of `operator()` on the same const instance of `Hash` "
"or `Pred` are required to not introduce data races. For `Alloc` being either "
"`Allocator` or any allocator type rebound from `Allocator`, concurrent "
"invocations of the following operations on the same instance `al` of `Alloc` "
"are required to not introduce data races:"
msgstr ""
"Concurrent invocations of `operator()` on the same const instance of `Hash` "
"or `Pred` are required to not introduce data races. For `Alloc` being either "
"`Allocator` or any allocator type rebound from `Allocator`, concurrent "
"invocations of the following operations on the same instance `al` of `Alloc` "
"are required to not introduce data races:"

#: :397
#, read-only, safe-html, strict-same
msgid "Copy construction from `al` of an allocator rebound from `Alloc`"
msgstr "Copy construction from `al` of an allocator rebound from `Alloc`"

#: :398
#, read-only, safe-html, strict-same
msgid "`std::allocator_traits<Alloc>::allocate`"
msgstr "`std::allocator_traits<Alloc>::allocate`"

#: :399
#, read-only, safe-html, strict-same
msgid "`std::allocator_traits<Alloc>::deallocate`"
msgstr "`std::allocator_traits<Alloc>::deallocate`"

#: :400
#, read-only, safe-html, strict-same
msgid "`std::allocator_traits<Alloc>::construct`"
msgstr "`std::allocator_traits<Alloc>::construct`"

#: :401
#, read-only, safe-html, strict-same
msgid "`std::allocator_traits<Alloc>::destroy`"
msgstr "`std::allocator_traits<Alloc>::destroy`"

#: :403
#, read-only, safe-html, strict-same
msgid ""
"In general, these requirements on `Hash`, `Pred` and `Allocator` are met if "
"these types are not stateful or if the operations only involve constant "
"access to internal data members."
msgstr ""
"In general, these requirements on `Hash`, `Pred` and `Allocator` are met if "
"these types are not stateful or if the operations only involve constant "
"access to internal data members."

#: :406
#, read-only, safe-html, strict-same
msgid ""
"With the exception of destruction, concurrent invocations of any operation "
"on the same instance of a `concurrent_node_map` do not introduce data races "
"— that is, they are thread-safe."
msgstr ""
"With the exception of destruction, concurrent invocations of any operation "
"on the same instance of a `concurrent_node_map` do not introduce data races "
"— that is, they are thread-safe."

#: :409
#, read-only, safe-html, strict-same
msgid ""
"If an operation *op* is explicitly designated as _blocking on_ `x`, where "
"`x` is an instance of a `boost::concurrent_node_map`, prior blocking "
"operations on `x` synchronize with *op*. So, blocking operations on the same "
"`concurrent_node_map` execute sequentially in a multithreaded scenario."
msgstr ""
"If an operation *op* is explicitly designated as _blocking on_ `x`, where "
"`x` is an instance of a `boost::concurrent_node_map`, prior blocking "
"operations on `x` synchronize with *op*. So, blocking operations on the same "
"`concurrent_node_map` execute sequentially in a multithreaded scenario."

#: :413
#, read-only, safe-html, strict-same
msgid ""
"An operation is said to be _blocking on rehashing of_ ``__x__`` if it blocks "
"on `x` only when an internal rehashing is issued."
msgstr ""
"An operation is said to be _blocking on rehashing of_ ``__x__`` if it blocks "
"on `x` only when an internal rehashing is issued."

#: :416
#, read-only, safe-html, strict-same
msgid ""
"When executed internally by a `boost::concurrent_node_map`, the following "
"operations by a user-provided visitation function on the element passed do "
"not introduce data races:"
msgstr ""
"When executed internally by a `boost::concurrent_node_map`, the following "
"operations by a user-provided visitation function on the element passed do "
"not introduce data races:"

#: :419
#, read-only, safe-html, strict-same
msgid "Read access to the element."
msgstr "Read access to the element."

#: :420
#, read-only, safe-html, strict-same
msgid "Non-mutable modification of the element."
msgstr "Non-mutable modification of the element."

#: :421
#, read-only, safe-html, strict-same
msgid "Mutable modification of the element:"
msgstr "Mutable modification of the element:"

#: :422
#, read-only, safe-html, strict-same
msgid ""
"** Within a container function accepting two visitation functions, always "
"for the first function. ** Within a non-const container function whose name "
"does not contain `cvisit`, for the last (or only) visitation function."
msgstr ""
"** Within a container function accepting two visitation functions, always "
"for the first function. ** Within a non-const container function whose name "
"does not contain `cvisit`, for the last (or only) visitation function."

#: :425
#, read-only, safe-html, strict-same
msgid ""
"Any `boost::concurrent_node_map operation` that inserts or modifies an "
"element `e` synchronizes with the internal invocation of a visitation "
"function on `e`."
msgstr ""
"Any `boost::concurrent_node_map operation` that inserts or modifies an "
"element `e` synchronizes with the internal invocation of a visitation "
"function on `e`."

#: :428
#, read-only, safe-html, strict-same
msgid ""
"Visitation functions executed by a `boost::concurrent_node_map` `x` are not "
"allowed to invoke any operation on `x`; invoking operations on a different "
"`boost::concurrent_node_map` instance `y` is allowed only if concurrent "
"outstanding operations on `y` do not access `x` directly or indirectly."
msgstr ""
"Visitation functions executed by a `boost::concurrent_node_map` `x` are not "
"allowed to invoke any operation on `x`; invoking operations on a different "
"`boost::concurrent_node_map` instance `y` is allowed only if concurrent "
"outstanding operations on `y` do not access `x` directly or indirectly."

#: :432
#, read-only, safe-html, strict-same
msgctxt ":432"
msgid "---"
msgstr "---"

#: :434
#, read-only, safe-html, strict-same
msgid "Configuration Macros"
msgstr "Configuration Macros"

#: :436
#, read-only, safe-html, strict-same
msgid "`BOOST_UNORDERED_DISABLE_REENTRANCY_CHECK`"
msgstr "`BOOST_UNORDERED_DISABLE_REENTRANCY_CHECK`"

#: :438
#, read-only, safe-html, strict-same
msgid ""
"In debug builds (more precisely, when link:../../../../../assert/doc/html/"
"assert.html#boost_assert_is_void[`BOOST_ASSERT_IS_VOID`^] is not defined), "
"__container reentrancies__ (illegaly invoking an operation on `m` from "
"within a function visiting elements of `m`) are detected and signalled "
"through `BOOST_ASSERT_MSG`. When run-time speed is a concern, the feature "
"can be disabled by globally defining this macro."
msgstr ""
"In debug builds (more precisely, when link:../../../../../assert/doc/html/"
"assert.html#boost_assert_is_void[`BOOST_ASSERT_IS_VOID`^] is not defined), "
"__container reentrancies__ (illegaly invoking an operation on `m` from "
"within a function visiting elements of `m`) are detected and signalled "
"through `BOOST_ASSERT_MSG`. When run-time speed is a concern, the feature "
"can be disabled by globally defining this macro."

#: :445
#, read-only, safe-html, strict-same
msgctxt ":445"
msgid "---"
msgstr "---"

#: :447
#, read-only, safe-html, strict-same
msgid "`BOOST_UNORDERED_ENABLE_STATS`"
msgstr "`BOOST_UNORDERED_ENABLE_STATS`"

#: :449
#, read-only, safe-html, strict-same
msgid ""
"Globally define this macro to enable xref:reference/"
"stats.adoc#stats[statistics calculation] for the table. Note that this "
"option decreases the overall performance of many operations."
msgstr ""
"Globally define this macro to enable xref:reference/"
"stats.adoc#stats[statistics calculation] for the table. Note that this "
"option decreases the overall performance of many operations."

#: :452
#, read-only, safe-html, strict-same
msgctxt ":452"
msgid "---"
msgstr "---"

#: :454
#, read-only, safe-html, strict-same
msgid "Typedefs"
msgstr "Typedefs"

#: :461
#, read-only, safe-html, strict-same
msgid ""
"A class for holding extracted table elements, modelling https://"
"en.cppreference.com/w/cpp/container/node_handle[NodeHandle]."
msgstr ""
"A class for holding extracted table elements, modelling https://"
"en.cppreference.com/w/cpp/container/node_handle[NodeHandle]."

#: :464
#, read-only, safe-html, strict-same
msgctxt ":464"
msgid "---"
msgstr "---"

#: :471
#, read-only, safe-html, strict-same
msgid "A specialization of an internal class template:"
msgstr "A specialization of an internal class template:"

#: :483
#, read-only, safe-html, strict-same
msgid "with `NodeType` = `node_type`."
msgstr "with `NodeType` = `node_type`."

#: :485
#, read-only, safe-html, strict-same
msgctxt ":485"
msgid "---"
msgstr "---"

#: :487
#, read-only, safe-html, strict-same
msgid "Constants"
msgstr "Constants"

#: :489
#, read-only, safe-html, strict-same
msgid "```cpp static constexpr size_type bulk_visit_size; ```"
msgstr "```cpp static constexpr size_type bulk_visit_size; ```"

#: :493
#, read-only, safe-html, strict-same
msgid ""
"Chunk size internally used in xref:concurrent_node_map_bulk_visit[bulk "
"visit] operations."
msgstr ""
"Chunk size internally used in xref:concurrent_node_map_bulk_visit[bulk "
"visit] operations."

#: :495
#, read-only, safe-html, strict-same
msgctxt ":495"
msgid "---"
msgstr "---"

#: :497
#, read-only, safe-html, strict-same
msgid "Constructors"
msgstr "Constructors"

#: :499
#, read-only, safe-html, strict-same
msgid "Default Constructor"
msgstr "Default Constructor"

#: :500
#, read-only, safe-html, strict-same
msgid "```c++ concurrent_node_map(); ```"
msgstr "```c++ concurrent_node_map(); ```"

#: :504
#, read-only, safe-html, strict-same
msgid ""
"Constructs an empty table using `hasher()` as the hash function, `key_equal()"
"` as the key equality predicate and `allocator_type()` as the allocator."
msgstr ""
"Constructs an empty table using `hasher()` as the hash function, `key_equal()"
"` as the key equality predicate and `allocator_type()` as the allocator."

#: :508
#, read-only, safe-html, strict-same
msgctxt ":508"
msgid ""
"Postconditions:;; `size() == 0` Requires:;; If the defaults are used, "
"`hasher`, `key_equal` and `allocator_type` need to be https://"
"en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."
msgstr ""
"Postconditions:;; `size() == 0` Requires:;; If the defaults are used, "
"`hasher`, `key_equal` and `allocator_type` need to be https://"
"en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."

#: :511
#, read-only, safe-html, strict-same
msgctxt ":511"
msgid "---"
msgstr "---"

#: :513
#, read-only, safe-html, strict-same
msgid "Bucket Count Constructor"
msgstr "Bucket Count Constructor"

#: :514
#, read-only, safe-html, strict-same
msgid ""
"```c++ explicit concurrent_node_map(size_type n, const hasher& hf = hasher()"
", const key_equal& eql = key_equal(), const allocator_type& a = "
"allocator_type()); ```"
msgstr ""
"```c++ explicit concurrent_node_map(size_type n, const hasher& hf = hasher()"
", const key_equal& eql = key_equal(), const allocator_type& a = "
"allocator_type()); ```"

#: :521
#, read-only, safe-html, strict-same
msgid ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, `eql` as the key equality predicate, and `a` as the allocator."
msgstr ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, `eql` as the key equality predicate, and `a` as the allocator."

#: :525
#, read-only, safe-html, strict-same
msgctxt ":525"
msgid ""
"Postconditions:;; `size() == 0` Requires:;; If the defaults are used, "
"`hasher`, `key_equal` and `allocator_type` need to be https://"
"en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."
msgstr ""
"Postconditions:;; `size() == 0` Requires:;; If the defaults are used, "
"`hasher`, `key_equal` and `allocator_type` need to be https://"
"en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."

#: :528
#, read-only, safe-html, strict-same
msgctxt ":528"
msgid "---"
msgstr "---"

#: :530
#, read-only, safe-html, strict-same
msgid "Iterator Range Constructor"
msgstr "Iterator Range Constructor"

#: :541
#, read-only, safe-html, strict-same
msgid ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, `eql` as the key equality predicate and `a` as the allocator, and "
"inserts the elements from `[f, l)` into it."
msgstr ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, `eql` as the key equality predicate and `a` as the allocator, and "
"inserts the elements from `[f, l)` into it."

#: :544
#, read-only, safe-html, strict-same
msgctxt ":544"
msgid ""
"Requires:;; If the defaults are used, `hasher`, `key_equal` and "
"`allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."
msgstr ""
"Requires:;; If the defaults are used, `hasher`, `key_equal` and "
"`allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."

#: :546
#, read-only, safe-html, strict-same
msgctxt ":546"
msgid "---"
msgstr "---"

#: :548
#, read-only, safe-html, strict-same
msgid "Copy Constructor"
msgstr "Copy Constructor"

#: :549
#, read-only, safe-html, strict-same
msgid "```c++ concurrent_node_map(concurrent_node_map const& other); ```"
msgstr "```c++ concurrent_node_map(concurrent_node_map const& other); ```"

#: :553
#, read-only, safe-html, strict-same
msgid ""
"The copy constructor. Copies the contained elements, hash function, "
"predicate and allocator."
msgstr ""
"The copy constructor. Copies the contained elements, hash function, "
"predicate and allocator."

#: :555
#, read-only, safe-html, strict-same
msgid ""
"If `Allocator::select_on_container_copy_construction` exists and has the "
"right signature, the allocator will be constructed from its result."
msgstr ""
"If `Allocator::select_on_container_copy_construction` exists and has the "
"right signature, the allocator will be constructed from its result."

#: :558
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is copy constructible Concurrency:;; Blocking on "
"`other`."
msgstr ""
"Requires:;; `value_type` is copy constructible Concurrency:;; Blocking on "
"`other`."

#: :561
#, read-only, safe-html, strict-same
msgctxt ":561"
msgid "---"
msgstr "---"

#: :563
#, read-only, safe-html, strict-same
msgid "Move Constructor"
msgstr "Move Constructor"

#: :564
#, read-only, safe-html, strict-same
msgid "```c++ concurrent_node_map(concurrent_node_map&& other); ```"
msgstr "```c++ concurrent_node_map(concurrent_node_map&& other); ```"

#: :568
#, read-only, safe-html, strict-same
msgid ""
"The move constructor. The internal bucket array of `other` is transferred "
"directly to the new table. The hash function, predicate and allocator are "
"moved-constructed from `other`. If statistics are "
"xref:concurrent_node_map_boost_unordered_enable_stats[enabled], transfers "
"the internal statistical information from `other` and calls "
"`other.reset_stats()`."
msgstr ""
"The move constructor. The internal bucket array of `other` is transferred "
"directly to the new table. The hash function, predicate and allocator are "
"moved-constructed from `other`. If statistics are "
"xref:concurrent_node_map_boost_unordered_enable_stats[enabled], transfers "
"the internal statistical information from `other` and calls "
"`other.reset_stats()`."

#: :574
#, read-only, safe-html, strict-same
msgctxt ":574"
msgid "Concurrency:;; Blocking on `other`."
msgstr "Concurrency:;; Blocking on `other`."

#: :576
#, read-only, safe-html, strict-same
msgctxt ":576"
msgid "---"
msgstr "---"

#: :578
#, read-only, safe-html, strict-same
msgid "Iterator Range Constructor with Allocator"
msgstr "Iterator Range Constructor with Allocator"

#: :579
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class InputIterator> concurrent_node_map(InputIterator f, "
"InputIterator l, const allocator_type& a); ```"
msgstr ""
"```c++ template<class InputIterator> concurrent_node_map(InputIterator f, "
"InputIterator l, const allocator_type& a); ```"

#: :584
#, read-only, safe-html, strict-same
msgid ""
"Constructs an empty table using `a` as the allocator, with the default hash "
"function and key equality predicate and inserts the elements from `[f, l)` "
"into it."
msgstr ""
"Constructs an empty table using `a` as the allocator, with the default hash "
"function and key equality predicate and inserts the elements from `[f, l)` "
"into it."

#: :587
#, read-only, safe-html, strict-same
msgctxt ":587"
msgid ""
"Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/"
"cpp/named_req/DefaultConstructible[DefaultConstructible^]."
msgstr ""
"Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/"
"cpp/named_req/DefaultConstructible[DefaultConstructible^]."

#: :589
#, read-only, safe-html, strict-same
msgctxt ":589"
msgid "---"
msgstr "---"

#: :591
#, read-only, safe-html, strict-same
msgid "Allocator Constructor"
msgstr "Allocator Constructor"

#: :592
#, read-only, safe-html, strict-same
msgid "```c++ explicit concurrent_node_map(Allocator const& a); ```"
msgstr "```c++ explicit concurrent_node_map(Allocator const& a); ```"

#: :596
#, read-only, safe-html, strict-same
msgid "Constructs an empty table, using allocator `a`."
msgstr "Constructs an empty table, using allocator `a`."

#: :598
#, read-only, safe-html, strict-same
msgctxt ":598"
msgid "---"
msgstr "---"

#: :600
#, read-only, safe-html, strict-same
msgid "Copy Constructor with Allocator"
msgstr "Copy Constructor with Allocator"

#: :601
#, read-only, safe-html, strict-same
msgid ""
"```c++ concurrent_node_map(concurrent_node_map const& other, Allocator "
"const& a); ```"
msgstr ""
"```c++ concurrent_node_map(concurrent_node_map const& other, Allocator "
"const& a); ```"

#: :605
#, read-only, safe-html, strict-same
msgid ""
"Constructs a table, copying ``other``'s contained elements, hash function, "
"and predicate, but using allocator `a`."
msgstr ""
"Constructs a table, copying ``other``'s contained elements, hash function, "
"and predicate, but using allocator `a`."

#: :608
#, read-only, safe-html, strict-same
msgctxt ":608"
msgid "Concurrency:;; Blocking on `other`."
msgstr "Concurrency:;; Blocking on `other`."

#: :610
#, read-only, safe-html, strict-same
msgctxt ":610"
msgid "---"
msgstr "---"

#: :612
#, read-only, safe-html, strict-same
msgid "Move Constructor with Allocator"
msgstr "Move Constructor with Allocator"

#: :613
#, read-only, safe-html, strict-same
msgid ""
"```c++ concurrent_node_map(concurrent_node_map&& other, Allocator const& a); "
"```"
msgstr ""
"```c++ concurrent_node_map(concurrent_node_map&& other, Allocator const& a); "
"```"

#: :617
#, read-only, safe-html, strict-same
msgid ""
"If `a == other.get_allocator()`, the elements of `other` are transferred "
"directly to the new table; otherwise, elements are moved-constructed from "
"those of `other`. The hash function and predicate are moved-constructed from "
"`other`, and the allocator is copy-constructed from `a`. If statistics are "
"xref:concurrent_node_map_boost_unordered_enable_stats[enabled], transfers "
"the internal statistical information from `other` iff `a == "
"other.get_allocator()`, and always calls `other.reset_stats()`."
msgstr ""
"If `a == other.get_allocator()`, the elements of `other` are transferred "
"directly to the new table; otherwise, elements are moved-constructed from "
"those of `other`. The hash function and predicate are moved-constructed from "
"`other`, and the allocator is copy-constructed from `a`. If statistics are "
"xref:concurrent_node_map_boost_unordered_enable_stats[enabled], transfers "
"the internal statistical information from `other` iff `a == "
"other.get_allocator()`, and always calls `other.reset_stats()`."

#: :625
#, read-only, safe-html, strict-same
msgctxt ":625"
msgid "Concurrency:;; Blocking on `other`."
msgstr "Concurrency:;; Blocking on `other`."

#: :627
#, read-only, safe-html, strict-same
msgctxt ":627"
msgid "---"
msgstr "---"

#: :629
#, read-only, safe-html, strict-same
msgid "Move Constructor from unordered_node_map"
msgstr "Move Constructor from unordered_node_map"

#: :631
#, read-only, safe-html, strict-same
msgid ""
"```c++ concurrent_node_map(unordered_node_map<Key, T, Hash, Pred, Allocator>"
"&& other); ```"
msgstr ""
"```c++ concurrent_node_map(unordered_node_map<Key, T, Hash, Pred, Allocator>"
"&& other); ```"

#: :635
#, read-only, safe-html, strict-same
msgid ""
"Move construction from a xref:#unordered_node_map[`unordered_node_map`]. The "
"internal bucket array of `other` is transferred directly to the new "
"container. The hash function, predicate and allocator are moved-constructed "
"from `other`. If statistics are "
"xref:concurrent_node_map_boost_unordered_enable_stats[enabled], transfers "
"the internal statistical information from `other` and calls "
"`other.reset_stats()`."
msgstr ""
"Move construction from a xref:#unordered_node_map[`unordered_node_map`]. The "
"internal bucket array of `other` is transferred directly to the new "
"container. The hash function, predicate and allocator are moved-constructed "
"from `other`. If statistics are "
"xref:concurrent_node_map_boost_unordered_enable_stats[enabled], transfers "
"the internal statistical information from `other` and calls "
"`other.reset_stats()`."

#: :642
#, read-only, safe-html, strict-same
msgid "Complexity:;; O(`bucket_count()`)"
msgstr "Complexity:;; O(`bucket_count()`)"

#: :644
#, read-only, safe-html, strict-same
msgctxt ":644"
msgid "---"
msgstr "---"

#: :646
#, read-only, safe-html, strict-same
msgid "Initializer List Constructor"
msgstr "Initializer List Constructor"

#: :656
#, read-only, safe-html, strict-same
msgid ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, `eql` as the key equality predicate and `a`, and inserts the "
"elements from `il` into it."
msgstr ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, `eql` as the key equality predicate and `a`, and inserts the "
"elements from `il` into it."

#: :659
#, read-only, safe-html, strict-same
msgctxt ":659"
msgid ""
"Requires:;; If the defaults are used, `hasher`, `key_equal` and "
"`allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."
msgstr ""
"Requires:;; If the defaults are used, `hasher`, `key_equal` and "
"`allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."

#: :661
#, read-only, safe-html, strict-same
msgctxt ":661"
msgid "---"
msgstr "---"

#: :663
#, read-only, safe-html, strict-same
msgid "Bucket Count Constructor with Allocator"
msgstr "Bucket Count Constructor with Allocator"

#: :664
#, read-only, safe-html, strict-same
msgid "```c++ concurrent_node_map(size_type n, allocator_type const& a); ```"
msgstr "```c++ concurrent_node_map(size_type n, allocator_type const& a); ```"

#: :668
#, read-only, safe-html, strict-same
msgid ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, the default hash function and key equality predicate and `a` as "
"the allocator."
msgstr ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, the default hash function and key equality predicate and `a` as "
"the allocator."

#: :671
#, read-only, safe-html, strict-same
msgid ""
"Postconditions:;; `size() == 0` Requires:;; `hasher` and `key_equal` need to "
"be https://en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."
msgstr ""
"Postconditions:;; `size() == 0` Requires:;; `hasher` and `key_equal` need to "
"be https://en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."

#: :674
#, read-only, safe-html, strict-same
msgctxt ":674"
msgid "---"
msgstr "---"

#: :676
#, read-only, safe-html, strict-same
msgid "Bucket Count Constructor with Hasher and Allocator"
msgstr "Bucket Count Constructor with Hasher and Allocator"

#: :677
#, read-only, safe-html, strict-same
msgid ""
"```c++ concurrent_node_map(size_type n, hasher const& hf, allocator_type "
"const& a); ```"
msgstr ""
"```c++ concurrent_node_map(size_type n, hasher const& hf, allocator_type "
"const& a); ```"

#: :681
#, read-only, safe-html, strict-same
msgid ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, the default key equality predicate and `a` as the allocator."
msgstr ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, the default key equality predicate and `a` as the allocator."

#: :684
#, read-only, safe-html, strict-same
msgid ""
"Postconditions:;; `size() == 0` Requires:;; `key_equal` needs to be https://"
"en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."
msgstr ""
"Postconditions:;; `size() == 0` Requires:;; `key_equal` needs to be https://"
"en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^]."

#: :687
#, read-only, safe-html, strict-same
msgctxt ":687"
msgid "---"
msgstr "---"

#: :689
#, read-only, safe-html, strict-same
msgid "Iterator Range Constructor with Bucket Count and Allocator"
msgstr "Iterator Range Constructor with Bucket Count and Allocator"

#: :696
#, read-only, safe-html, strict-same
msgid ""
"Constructs an empty table with at least `n` buckets, using `a` as the "
"allocator and default hash function and key equality predicate, and inserts "
"the elements from `[f, l)` into it."
msgstr ""
"Constructs an empty table with at least `n` buckets, using `a` as the "
"allocator and default hash function and key equality predicate, and inserts "
"the elements from `[f, l)` into it."

#: :699
#, read-only, safe-html, strict-same
msgctxt ":699"
msgid ""
"Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/"
"cpp/named_req/DefaultConstructible[DefaultConstructible^]."
msgstr ""
"Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/"
"cpp/named_req/DefaultConstructible[DefaultConstructible^]."

#: :701
#, read-only, safe-html, strict-same
msgctxt ":701"
msgid "---"
msgstr "---"

#: :703
#, read-only, safe-html, strict-same
msgid "Iterator Range Constructor with Bucket Count and Hasher"
msgstr "Iterator Range Constructor with Bucket Count and Hasher"

#: :711
#, read-only, safe-html, strict-same
msgid ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, `a` as the allocator, with the default key equality predicate, and "
"inserts the elements from `[f, l)` into it."
msgstr ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, `a` as the allocator, with the default key equality predicate, and "
"inserts the elements from `[f, l)` into it."

#: :714
#, read-only, safe-html, strict-same
msgctxt ":714"
msgid ""
"Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/"
"named_req/DefaultConstructible[DefaultConstructible^]."
msgstr ""
"Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/"
"named_req/DefaultConstructible[DefaultConstructible^]."

#: :716
#, read-only, safe-html, strict-same
msgctxt ":716"
msgid "---"
msgstr "---"

#: :718
#, read-only, safe-html, strict-same
msgid "initializer_list Constructor with Allocator"
msgstr "initializer_list Constructor with Allocator"

#: :720
#, read-only, safe-html, strict-same
msgid ""
"```c++ concurrent_node_map(std::initializer_list<value_type> il, const "
"allocator_type& a); ```"
msgstr ""
"```c++ concurrent_node_map(std::initializer_list<value_type> il, const "
"allocator_type& a); ```"

#: :724
#, read-only, safe-html, strict-same
msgid ""
"Constructs an empty table using `a` and default hash function and key "
"equality predicate, and inserts the elements from `il` into it."
msgstr ""
"Constructs an empty table using `a` and default hash function and key "
"equality predicate, and inserts the elements from `il` into it."

#: :727
#, read-only, safe-html, strict-same
msgctxt ":727"
msgid ""
"Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/"
"w/cpp/named_req/DefaultConstructible[DefaultConstructible^]."
msgstr ""
"Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/"
"w/cpp/named_req/DefaultConstructible[DefaultConstructible^]."

#: :729
#, read-only, safe-html, strict-same
msgctxt ":729"
msgid "---"
msgstr "---"

#: :731
#, read-only, safe-html, strict-same
msgid "initializer_list Constructor with Bucket Count and Allocator"
msgstr "initializer_list Constructor with Bucket Count and Allocator"

#: :733
#, read-only, safe-html, strict-same
msgid ""
"```c++ concurrent_node_map(std::initializer_list<value_type> il, size_type "
"n, const allocator_type& a); ```"
msgstr ""
"```c++ concurrent_node_map(std::initializer_list<value_type> il, size_type "
"n, const allocator_type& a); ```"

#: :737
#, read-only, safe-html, strict-same
msgid ""
"Constructs an empty table with at least `n` buckets, using `a` and default "
"hash function and key equality predicate, and inserts the elements from `il` "
"into it."
msgstr ""
"Constructs an empty table with at least `n` buckets, using `a` and default "
"hash function and key equality predicate, and inserts the elements from `il` "
"into it."

#: :740
#, read-only, safe-html, strict-same
msgctxt ":740"
msgid ""
"Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/"
"w/cpp/named_req/DefaultConstructible[DefaultConstructible^]."
msgstr ""
"Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/"
"w/cpp/named_req/DefaultConstructible[DefaultConstructible^]."

#: :742
#, read-only, safe-html, strict-same
msgctxt ":742"
msgid "---"
msgstr "---"

#: :744
#, read-only, safe-html, strict-same
msgid "initializer_list Constructor with Bucket Count and Hasher and Allocator"
msgstr "initializer_list Constructor with Bucket Count and Hasher and Allocator"

#: :746
#, read-only, safe-html, strict-same
msgid ""
"```c++ concurrent_node_map(std::initializer_list<value_type> il, size_type "
"n, const hasher& hf, const allocator_type& a); ```"
msgstr ""
"```c++ concurrent_node_map(std::initializer_list<value_type> il, size_type "
"n, const hasher& hf, const allocator_type& a); ```"

#: :751
#, read-only, safe-html, strict-same
msgid ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, `a` as the allocator and default key equality predicate,and "
"inserts the elements from `il` into it."
msgstr ""
"Constructs an empty table with at least `n` buckets, using `hf` as the hash "
"function, `a` as the allocator and default key equality predicate,and "
"inserts the elements from `il` into it."

#: :754
#, read-only, safe-html, strict-same
msgctxt ":754"
msgid ""
"Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/"
"named_req/DefaultConstructible[DefaultConstructible^]."
msgstr ""
"Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/"
"named_req/DefaultConstructible[DefaultConstructible^]."

#: :756
#, read-only, safe-html, strict-same
msgctxt ":756"
msgid "---"
msgstr "---"

#: :758
#, read-only, safe-html, strict-same
msgid "Destructor"
msgstr "Destructor"

#: :760
#, read-only, safe-html, strict-same
msgid "```c++ ~concurrent_node_map(); ```"
msgstr "```c++ ~concurrent_node_map(); ```"

#: :765
#, read-only, safe-html, strict-same
msgid ""
"Note:;; The destructor is applied to every element, and all memory is "
"deallocated"
msgstr ""
"Note:;; The destructor is applied to every element, and all memory is "
"deallocated"

#: :767
#, read-only, safe-html, strict-same
msgctxt ":767"
msgid "---"
msgstr "---"

#: :769
#, read-only, safe-html, strict-same
msgid "Assignment"
msgstr "Assignment"

#: :771
#, read-only, safe-html, strict-same
msgid "Copy Assignment"
msgstr "Copy Assignment"

#: :773
#, read-only, safe-html, strict-same
msgid ""
"```c++ concurrent_node_map& operator=(concurrent_node_map const& other); ```"
msgstr ""
"```c++ concurrent_node_map& operator=(concurrent_node_map const& other); ```"

#: :777
#, read-only, safe-html, strict-same
msgid ""
"The assignment operator. Destroys previously existing elements, copy-assigns "
"the hash function and predicate from `other`, copy-assigns the allocator "
"from `other` if `Alloc::propagate_on_container_copy_assignment` exists and "
"`Alloc::propagate_on_container_copy_assignment::value` is `true`, and "
"finally inserts copies of the elements of `other`."
msgstr ""
"The assignment operator. Destroys previously existing elements, copy-assigns "
"the hash function and predicate from `other`, copy-assigns the allocator "
"from `other` if `Alloc::propagate_on_container_copy_assignment` exists and "
"`Alloc::propagate_on_container_copy_assignment::value` is `true`, and "
"finally inserts copies of the elements of `other`."

#: :782
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[CopyInsertable^] Concurrency:;; Blocking on `*this` and "
"`other`."
msgstr ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[CopyInsertable^] Concurrency:;; Blocking on `*this` and "
"`other`."

#: :785
#, read-only, safe-html, strict-same
msgctxt ":785"
msgid "---"
msgstr "---"

#: :787
#, read-only, safe-html, strict-same
msgid "Move Assignment"
msgstr "Move Assignment"

#: :788
#, read-only, safe-html, strict-same
msgid ""
"```c++ concurrent_node_map& operator=(concurrent_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 `*this`; otherwise, inserts move-"
"constructed copies of the elements of `other`. If statistics are "
"xref:concurrent_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()`."
msgstr ""
"```c++ concurrent_node_map& operator=(concurrent_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 `*this`; otherwise, inserts move-"
"constructed copies of the elements of `other`. If statistics are "
"xref:concurrent_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()`."

#: :803
#, read-only, safe-html, strict-same
msgid "Concurrency:;; Blocking on `*this` and `other`."
msgstr "Concurrency:;; Blocking on `*this` and `other`."

#: :805
#, read-only, safe-html, strict-same
msgctxt ":805"
msgid "---"
msgstr "---"

#: :807
#, read-only, safe-html, strict-same
msgid "Initializer List Assignment"
msgstr "Initializer List Assignment"

#: :808
#, read-only, safe-html, strict-same
msgid ""
"```c++ concurrent_node_map& operator=(std::initializer_list<value_type> il); "
"```"
msgstr ""
"```c++ concurrent_node_map& operator=(std::initializer_list<value_type> il); "
"```"

#: :812
#, read-only, safe-html, strict-same
msgid ""
"Assign from values in initializer list. All previously existing elements are "
"destroyed."
msgstr ""
"Assign from values in initializer list. All previously existing elements are "
"destroyed."

#: :815
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[CopyInsertable^] Concurrency:;; Blocking on `*this`."
msgstr ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[CopyInsertable^] Concurrency:;; Blocking on `*this`."

#: :818
#, read-only, safe-html, strict-same
msgctxt ":818"
msgid "---"
msgstr "---"

#: :820
#, read-only, safe-html, strict-same
msgid "Visitation"
msgstr "Visitation"

#: :822
#, read-only, safe-html, strict-same
msgid "[c]visit"
msgstr "[c]visit"

#: :824
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class F> size_t visit(const key_type& k, F f); "
"template<class F> size_t visit(const key_type& k, F f) const; template<class "
"F> size_t cvisit(const key_type& k, F f) const; template<class K, class F> "
"size_t visit(const K& k, F f); template<class K, class F> size_t visit(const "
"K& k, F f) const; template<class K, class F> size_t cvisit(const K& k, F f) "
"const; ```"
msgstr ""
"```c++ template<class F> size_t visit(const key_type& k, F f); "
"template<class F> size_t visit(const key_type& k, F f) const; template<class "
"F> size_t cvisit(const key_type& k, F f) const; template<class K, class F> "
"size_t visit(const K& k, F f); template<class K, class F> size_t visit(const "
"K& k, F f) const; template<class K, class F> size_t cvisit(const K& k, F f) "
"const; ```"

#: :833
#, read-only, safe-html, strict-same
msgid ""
"If an element `x` exists with key equivalent to `k`, invokes `f` with a "
"reference to `x`. Such reference is const iff `*this` is const."
msgstr ""
"If an element `x` exists with key equivalent to `k`, invokes `f` with a "
"reference to `x`. Such reference is const iff `*this` is const."

#: :837
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; The number of elements visited (0 or 1). Notes:;; The "
"`template<class K, class F>` 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."
msgstr ""
"Returns:;; The number of elements visited (0 or 1). Notes:;; The "
"`template<class K, class F>` 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."

#: :840
#, read-only, safe-html, strict-same
msgctxt ":840"
msgid "---"
msgstr "---"

#: :842
#, read-only, safe-html, strict-same
msgid "Bulk visit"
msgstr "Bulk visit"

#: :844
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class FwdIterator, class F> size_t visit(FwdIterator first, "
"FwdIterator last, F f); template<class FwdIterator, class F> size_t visit"
"(FwdIterator first, FwdIterator last, F f) const; template<class "
"FwdIterator, class F> size_t cvisit(FwdIterator first, FwdIterator last, F "
"f) const; ```"
msgstr ""
"```c++ template<class FwdIterator, class F> size_t visit(FwdIterator first, "
"FwdIterator last, F f); template<class FwdIterator, class F> size_t visit"
"(FwdIterator first, FwdIterator last, F f) const; template<class "
"FwdIterator, class F> size_t cvisit(FwdIterator first, FwdIterator last, F "
"f) const; ```"

#: :853
#, read-only, safe-html, strict-same
msgid ""
"For each element `k` in the range [`first`, `last`), if there is an element "
"`x` in the container with key equivalent to `k`, invokes `f` with a "
"reference to `x`. Such reference is const iff `*this` is const."
msgstr ""
"For each element `k` in the range [`first`, `last`), if there is an element "
"`x` in the container with key equivalent to `k`, invokes `f` with a "
"reference to `x`. Such reference is const iff `*this` is const."

#: :858
#, read-only, safe-html, strict-same
msgid ""
"Although functionally equivalent to individually invoking "
"xref:concurrent_node_map_cvisit[`[c\\]visit`] for each key, bulk visitation "
"performs generally faster due to internal streamlining optimizations. It is "
"advisable that `std::distance(first,last)` be at least "
"xref:#concurrent_node_map_constants[`bulk_visit_size`] to enjoy a "
"performance gain: beyond this size, performance is not expected to increase "
"further."
msgstr ""
"Although functionally equivalent to individually invoking "
"xref:concurrent_node_map_cvisit[`[c\\]visit`] for each key, bulk visitation "
"performs generally faster due to internal streamlining optimizations. It is "
"advisable that `std::distance(first,last)` be at least "
"xref:#concurrent_node_map_constants[`bulk_visit_size`] to enjoy a "
"performance gain: beyond this size, performance is not expected to increase "
"further."

#: :867
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `FwdIterator` is a https://en.cppreference.com/w/cpp/named_req/"
"ForwardIterator[LegacyForwardIterator^] ({cpp}11 to {cpp}17), or satisfies "
"https://en.cppreference.com/w/cpp/iterator/"
"forward_iterator[std::forward_iterator^] ({cpp}20 and later). For `K` = "
"`std::iterator_traits<FwdIterator>::value_type`, either `K` is `key_type` or "
"else `Hash::is_transparent` and `Pred::is_transparent` are valid member "
"typedefs. In the latter case, 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. Returns:;; The number of elements visited."
msgstr ""
"Requires:;; `FwdIterator` is a https://en.cppreference.com/w/cpp/named_req/"
"ForwardIterator[LegacyForwardIterator^] ({cpp}11 to {cpp}17), or satisfies "
"https://en.cppreference.com/w/cpp/iterator/"
"forward_iterator[std::forward_iterator^] ({cpp}20 and later). For `K` = "
"`std::iterator_traits<FwdIterator>::value_type`, either `K` is `key_type` or "
"else `Hash::is_transparent` and `Pred::is_transparent` are valid member "
"typedefs. In the latter case, 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. Returns:;; The number of elements visited."

#: :876
#, read-only, safe-html, strict-same
msgctxt ":876"
msgid "---"
msgstr "---"

#: :878
#, read-only, safe-html, strict-same
msgid "[c]visit_all"
msgstr "[c]visit_all"

#: :880
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class F> size_t visit_all(F f); template<class F> size_t "
"visit_all(F f) const; template<class F> size_t cvisit_all(F f) const; ```"
msgstr ""
"```c++ template<class F> size_t visit_all(F f); template<class F> size_t "
"visit_all(F f) const; template<class F> size_t cvisit_all(F f) const; ```"

#: :886
#, read-only, safe-html, strict-same
msgid ""
"Successively invokes `f` with references to each of the elements in the "
"table. Such references are const iff `*this` is const."
msgstr ""
"Successively invokes `f` with references to each of the elements in the "
"table. Such references are const iff `*this` is const."

#: :890
#, read-only, safe-html, strict-same
msgid "Returns:;; The number of elements visited."
msgstr "Returns:;; The number of elements visited."

#: :892
#, read-only, safe-html, strict-same
msgctxt ":892"
msgid "---"
msgstr "---"

#: :894
#, read-only, safe-html, strict-same
msgid "Parallel [c]visit_all"
msgstr "Parallel [c]visit_all"

#: :896
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class ExecutionPolicy, class F> void visit_all"
"(ExecutionPolicy&& policy, F f); template<class ExecutionPolicy, class F> "
"void visit_all(ExecutionPolicy&& policy, F f) const; template<class "
"ExecutionPolicy, class F> void cvisit_all(ExecutionPolicy&& policy, F f) "
"const; ```"
msgstr ""
"```c++ template<class ExecutionPolicy, class F> void visit_all"
"(ExecutionPolicy&& policy, F f); template<class ExecutionPolicy, class F> "
"void visit_all(ExecutionPolicy&& policy, F f) const; template<class "
"ExecutionPolicy, class F> void cvisit_all(ExecutionPolicy&& policy, F f) "
"const; ```"

#: :902
#, read-only, safe-html, strict-same
msgid ""
"Invokes `f` with references to each of the elements in the table. Such "
"references are const iff `*this` is const. Execution is parallelized "
"according to the semantics of the execution policy specified."
msgstr ""
"Invokes `f` with references to each of the elements in the table. Such "
"references are const iff `*this` is const. Execution is parallelized "
"according to the semantics of the execution policy specified."

#: :906
#, read-only, safe-html, strict-same
msgid ""
"Throws:;; Depending on the exception handling mechanism of the execution "
"policy used, may call `std::terminate` if an exception is thrown within `f`. "
"Notes:;; Only available in compilers supporting C++17 parallel algorithms. + "
"+ These overloads only participate in overload resolution if "
"`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is "
"`true`. + + Unsequenced execution policies are not allowed."
msgstr ""
"Throws:;; Depending on the exception handling mechanism of the execution "
"policy used, may call `std::terminate` if an exception is thrown within `f`. "
"Notes:;; Only available in compilers supporting C++17 parallel algorithms. + "
"+ These overloads only participate in overload resolution if "
"`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is "
"`true`. + + Unsequenced execution policies are not allowed."

#: :913
#, read-only, safe-html, strict-same
msgctxt ":913"
msgid "---"
msgstr "---"

#: :915
#, read-only, safe-html, strict-same
msgid "[c]visit_while"
msgstr "[c]visit_while"

#: :917
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class F> bool visit_while(F f); template<class F> bool "
"visit_while(F f) const; template<class F> bool cvisit_while(F f) const; ```"
msgstr ""
"```c++ template<class F> bool visit_while(F f); template<class F> bool "
"visit_while(F f) const; template<class F> bool cvisit_while(F f) const; ```"

#: :923
#, read-only, safe-html, strict-same
msgid ""
"Successively invokes `f` with references to each of the elements in the "
"table until `f` returns `false` or all the elements are visited. Such "
"references to the elements are const iff `*this` is const."
msgstr ""
"Successively invokes `f` with references to each of the elements in the "
"table until `f` returns `false` or all the elements are visited. Such "
"references to the elements are const iff `*this` is const."

#: :928
#, read-only, safe-html, strict-same
msgid "Returns:;; `false` iff `f` ever returns `false`."
msgstr "Returns:;; `false` iff `f` ever returns `false`."

#: :930
#, read-only, safe-html, strict-same
msgctxt ":930"
msgid "---"
msgstr "---"

#: :932
#, read-only, safe-html, strict-same
msgid "Parallel [c]visit_while"
msgstr "Parallel [c]visit_while"

#: :934
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class ExecutionPolicy, class F> bool visit_while"
"(ExecutionPolicy&& policy, F f); template<class ExecutionPolicy, class F> "
"bool visit_while(ExecutionPolicy&& policy, F f) const; template<class "
"ExecutionPolicy, class F> bool cvisit_while(ExecutionPolicy&& policy, F f) "
"const; ```"
msgstr ""
"```c++ template<class ExecutionPolicy, class F> bool visit_while"
"(ExecutionPolicy&& policy, F f); template<class ExecutionPolicy, class F> "
"bool visit_while(ExecutionPolicy&& policy, F f) const; template<class "
"ExecutionPolicy, class F> bool cvisit_while(ExecutionPolicy&& policy, F f) "
"const; ```"

#: :940
#, read-only, safe-html, strict-same
msgid ""
"Invokes `f` with references to each of the elements in the table until `f` "
"returns `false` or all the elements are visited. Such references to the "
"elements are const iff `*this` is const. Execution is parallelized according "
"to the semantics of the execution policy specified."
msgstr ""
"Invokes `f` with references to each of the elements in the table until `f` "
"returns `false` or all the elements are visited. Such references to the "
"elements are const iff `*this` is const. Execution is parallelized according "
"to the semantics of the execution policy specified."

#: :946
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; `false` iff `f` ever returns `false`. Throws:;; Depending on the "
"exception handling mechanism of the execution policy used, may call "
"`std::terminate` if an exception is thrown within `f`. Notes:;; Only "
"available in compilers supporting C++17 parallel algorithms. + + These "
"overloads only participate in overload resolution if "
"`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is "
"`true`. + + Unsequenced execution policies are not allowed. + + "
"Parallelization implies that execution does not necessary finish as soon as "
"`f` returns `false`, and as a result `f` may be invoked with further "
"elements for which the return value is also `false`."
msgstr ""
"Returns:;; `false` iff `f` ever returns `false`. Throws:;; Depending on the "
"exception handling mechanism of the execution policy used, may call "
"`std::terminate` if an exception is thrown within `f`. Notes:;; Only "
"available in compilers supporting C++17 parallel algorithms. + + These "
"overloads only participate in overload resolution if "
"`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is "
"`true`. + + Unsequenced execution policies are not allowed. + + "
"Parallelization implies that execution does not necessary finish as soon as "
"`f` returns `false`, and as a result `f` may be invoked with further "
"elements for which the return value is also `false`."

#: :957
#, read-only, safe-html, strict-same
msgctxt ":957"
msgid "---"
msgstr "---"

#: :959
#, read-only, safe-html, strict-same
msgid "Size and Capacity"
msgstr "Size and Capacity"

#: :961
#, read-only, safe-html, strict-same
msgid "empty"
msgstr "empty"

#: :963
#, read-only, safe-html, strict-same
msgid "```c++ [[nodiscard]] bool empty() const noexcept; ```"
msgstr "```c++ [[nodiscard]] bool empty() const noexcept; ```"

#: :968
#, read-only, safe-html, strict-same
msgid "Returns:;; `size() == 0`"
msgstr "Returns:;; `size() == 0`"

#: :970
#, read-only, safe-html, strict-same
msgctxt ":970"
msgid "---"
msgstr "---"

#: :972
#, read-only, safe-html, strict-same
msgid "size"
msgstr "size"

#: :974
#, read-only, safe-html, strict-same
msgid "```c++ size_type size() const noexcept; ```"
msgstr "```c++ size_type size() const noexcept; ```"

#: :979
#, read-only, safe-html, strict-same
msgid "Returns:;; The number of elements in the table."
msgstr "Returns:;; The number of elements in the table."

#: :982
#, read-only, safe-html, strict-same
msgid ""
"Notes:;; In the presence of concurrent insertion operations, the value "
"returned may not accurately reflect the true size of the table right after "
"execution."
msgstr ""
"Notes:;; In the presence of concurrent insertion operations, the value "
"returned may not accurately reflect the true size of the table right after "
"execution."

#: :985
#, read-only, safe-html, strict-same
msgctxt ":985"
msgid "---"
msgstr "---"

#: :987
#, read-only, safe-html, strict-same
msgid "max_size"
msgstr "max_size"

#: :989
#, read-only, safe-html, strict-same
msgid "```c++ size_type max_size() const noexcept; ```"
msgstr "```c++ size_type max_size() const noexcept; ```"

#: :994
#, read-only, safe-html, strict-same
msgid "Returns:;; `size()` of the largest possible table."
msgstr "Returns:;; `size()` of the largest possible table."

#: :996
#, read-only, safe-html, strict-same
msgctxt ":996"
msgid "---"
msgstr "---"

#: :998
#, read-only, safe-html, strict-same
msgid "Modifiers"
msgstr "Modifiers"

#: :1000
#, read-only, safe-html, strict-same
msgid "emplace"
msgstr "emplace"

#: :1001
#, read-only, safe-html, strict-same
msgid "```c++ template<class... Args> bool emplace(Args&&... args); ```"
msgstr "```c++ template<class... Args> bool emplace(Args&&... args); ```"

#: :1005
#, read-only, safe-html, strict-same
msgid ""
"Inserts an object, constructed with the arguments `args`, in the table if "
"and only if there is no element in the table with an equivalent key."
msgstr ""
"Inserts an object, constructed with the arguments `args`, in the table if "
"and only if there is no element in the table with an equivalent key."

#: :1008
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`. "
"Notes:;; If `args...` is of the form `k,v`, it delays constructing the whole "
"object until it is certain that an element should be inserted, using only "
"the `k` argument to check."
msgstr ""
"Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`. "
"Notes:;; If `args...` is of the form `k,v`, it delays constructing the whole "
"object until it is certain that an element should be inserted, using only "
"the `k` argument to check."

#: :1013
#, read-only, safe-html, strict-same
msgctxt ":1013"
msgid "---"
msgstr "---"

#: :1015
#, read-only, safe-html, strict-same
msgid "Copy Insert"
msgstr "Copy Insert"

#: :1016
#, read-only, safe-html, strict-same
msgid ""
"```c++ bool insert(const value_type& obj); bool insert(const init_type& obj)"
"; ```"
msgstr ""
"```c++ bool insert(const value_type& obj); bool insert(const init_type& obj)"
"; ```"

#: :1021
#, read-only, safe-html, strict-same
msgctxt ":1021"
msgid ""
"Inserts `obj` in the table if and only if there is no element in the table "
"with an equivalent key."
msgstr ""
"Inserts `obj` in the table if and only if there is no element in the table "
"with an equivalent key."

#: :1024
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[CopyInsertable^]. Returns:;; `true` if an insert took place. "
"+ Concurrency:;; Blocking on rehashing of `*this`. Notes:;; A call of the "
"form `insert(x)`, where `x` is equally convertible to both `const "
"value_type&` and `const init_type&`, is not ambiguous and selects the "
"`init_type` overload."
msgstr ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[CopyInsertable^]. Returns:;; `true` if an insert took place. "
"+ Concurrency:;; Blocking on rehashing of `*this`. Notes:;; A call of the "
"form `insert(x)`, where `x` is equally convertible to both `const "
"value_type&` and `const init_type&`, is not ambiguous and selects the "
"`init_type` overload."

#: :1029
#, read-only, safe-html, strict-same
msgctxt ":1029"
msgid "---"
msgstr "---"

#: :1031
#, read-only, safe-html, strict-same
msgid "Move Insert"
msgstr "Move Insert"

#: :1032
#, read-only, safe-html, strict-same
msgid "```c++ bool insert(value_type&& obj); bool insert(init_type&& obj); ```"
msgstr "```c++ bool insert(value_type&& obj); bool insert(init_type&& obj); ```"

#: :1037
#, read-only, safe-html, strict-same
msgctxt ":1037"
msgid ""
"Inserts `obj` in the table if and only if there is no element in the table "
"with an equivalent key."
msgstr ""
"Inserts `obj` in the table if and only if there is no element in the table "
"with an equivalent key."

#: :1040
#, read-only, safe-html, strict-same
msgid ""
"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:;; 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."
msgstr ""
"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:;; 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."

#: :1045
#, read-only, safe-html, strict-same
msgctxt ":1045"
msgid "---"
msgstr "---"

#: :1047
#, read-only, safe-html, strict-same
msgid "Insert Iterator Range"
msgstr "Insert Iterator Range"

#: :1048
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class InputIterator> size_type insert(InputIterator first, "
"InputIterator last); ```"
msgstr ""
"```c++ template<class InputIterator> size_type insert(InputIterator first, "
"InputIterator last); ```"

#: :1052
#, read-only, safe-html, strict-same
msgctxt ":1052"
msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]"
msgstr "Equivalent to [listing,subs=\"+macros,+quotes\"]"

#: :1059
#, read-only, safe-html, strict-same
msgctxt ":1059"
msgid "Returns:;; The number of elements inserted."
msgstr "Returns:;; The number of elements inserted."

#: :1061
#, read-only, safe-html, strict-same
msgctxt ":1061"
msgid "---"
msgstr "---"

#: :1063
#, read-only, safe-html, strict-same
msgid "Insert Initializer List"
msgstr "Insert Initializer List"

#: :1064
#, read-only, safe-html, strict-same
msgid "```c++ size_type insert(std::initializer_list<value_type> il); ```"
msgstr "```c++ size_type insert(std::initializer_list<value_type> il); ```"

#: :1068
#, read-only, safe-html, strict-same
msgctxt ":1068"
msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]"
msgstr "Equivalent to [listing,subs=\"+macros,+quotes\"]"

#: :1075
#, read-only, safe-html, strict-same
msgctxt ":1075"
msgid "Returns:;; The number of elements inserted."
msgstr "Returns:;; The number of elements inserted."

#: :1077
#, read-only, safe-html, strict-same
msgctxt ":1077"
msgid "---"
msgstr "---"

#: :1079
#, read-only, safe-html, strict-same
msgid "Insert Node"
msgstr "Insert Node"

#: :1080
#, read-only, safe-html, strict-same
msgid "```c++ insert_return_type insert(node_type&& nh); ```"
msgstr "```c++ insert_return_type insert(node_type&& nh); ```"

#: :1084
#, read-only, safe-html, strict-same
msgid ""
"If `nh` is not empty, inserts the associated element in the table  if and "
"only if there is no element in the table with a key equivalent to `nh.key()"
"`. `nh` is empty when the function returns."
msgstr ""
"If `nh` is not empty, inserts the associated element in the table  if and "
"only if there is no element in the table with a key equivalent to `nh.key()"
"`. `nh` is empty when the function returns."

#: :1088
#, read-only, safe-html, strict-same
msgctxt ":1088"
msgid ""
"Returns:;; An `insert_return_type` object constructed from `inserted` and "
"`node`: +"
msgstr ""
"Returns:;; An `insert_return_type` object constructed from `inserted` and "
"`node`: +"

#: :1089
#, read-only, safe-html, strict-same
msgctxt ":1089"
msgid "If `nh` is empty, `inserted` is `false` and `node` is empty."
msgstr "If `nh` is empty, `inserted` is `false` and `node` is empty."

#: :1090
#, read-only, safe-html, strict-same
msgctxt ":1090"
msgid ""
"Otherwise if the insertion took place, `inserted` is true and `node` is "
"empty."
msgstr ""
"Otherwise if the insertion took place, `inserted` is true and `node` is "
"empty."

#: :1091
#, read-only, safe-html, strict-same
msgctxt ":1091"
msgid ""
"If the insertion failed, `inserted` is false and `node` has the previous "
"value of `nh`."
msgstr ""
"If the insertion failed, `inserted` is false and `node` has the previous "
"value of `nh`."

#: :1092
#, read-only, safe-html, strict-same
msgid ""
"Throws:;; If an exception is thrown by an operation other than a call to "
"`hasher` the function has no effect. Concurrency:;; Blocking on rehashing of "
"`*this`. Notes:;; Behavior is undefined if `nh` is not empty and the "
"allocators of `nh` and the container are not equal."
msgstr ""
"Throws:;; If an exception is thrown by an operation other than a call to "
"`hasher` the function has no effect. Concurrency:;; Blocking on rehashing of "
"`*this`. Notes:;; Behavior is undefined if `nh` is not empty and the "
"allocators of `nh` and the container are not equal."

#: :1096
#, read-only, safe-html, strict-same
msgctxt ":1096"
msgid "---"
msgstr "---"

#: :1098
#, read-only, safe-html, strict-same
msgid "emplace_or_[c]visit"
msgstr "emplace_or_[c]visit"

#: :1099
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class... Args, class F> bool emplace_or_visit(Args&&... "
"args, F&& f); template<class... Args, class F> bool emplace_or_cvisit"
"(Args&&... args, F&& f); ```"
msgstr ""
"```c++ template<class... Args, class F> bool emplace_or_visit(Args&&... "
"args, F&& f); template<class... Args, class F> bool emplace_or_cvisit"
"(Args&&... args, F&& f); ```"

#: :1104
#, read-only, safe-html, strict-same
msgid ""
"Inserts an object, constructed with the arguments `args`, in the table if "
"there is no element in the table with an equivalent key. Otherwise, invokes "
"`f` with a reference to the equivalent element; such reference is const iff "
"`emplace_or_cvisit` is used."
msgstr ""
"Inserts an object, constructed with the arguments `args`, in the table if "
"there is no element in the table with an equivalent key. Otherwise, invokes "
"`f` with a reference to the equivalent element; such reference is const iff "
"`emplace_or_cvisit` is used."

#: :1108
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`. "
"Notes:;; The interface is exposition only, as C++ does not allow to declare "
"a parameter `f` after a variadic parameter pack."
msgstr ""
"Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`. "
"Notes:;; The interface is exposition only, as C++ does not allow to declare "
"a parameter `f` after a variadic parameter pack."

#: :1113
#, read-only, safe-html, strict-same
msgctxt ":1113"
msgid "---"
msgstr "---"

#: :1115
#, read-only, safe-html, strict-same
msgid "Copy insert_or_[c]visit"
msgstr "Copy insert_or_[c]visit"

#: :1116
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class F> bool insert_or_visit(const value_type& obj, F f); "
"template<class F> bool insert_or_cvisit(const value_type& obj, F f); "
"template<class F> bool insert_or_visit(const init_type& obj, F f); "
"template<class F> bool insert_or_cvisit(const init_type& obj, F f); ```"
msgstr ""
"```c++ template<class F> bool insert_or_visit(const value_type& obj, F f); "
"template<class F> bool insert_or_cvisit(const value_type& obj, F f); "
"template<class F> bool insert_or_visit(const init_type& obj, F f); "
"template<class F> bool insert_or_cvisit(const init_type& obj, F f); ```"

#: :1123
#, read-only, safe-html, strict-same
msgctxt ":1123"
msgid ""
"Inserts `obj` in the table if and only if there is no element in the table "
"with an equivalent key. Otherwise, invokes `f` with a reference to the "
"equivalent element; such reference is const iff a `*_cvisit` overload is "
"used."
msgstr ""
"Inserts `obj` in the table if and only if there is no element in the table "
"with an equivalent key. Otherwise, invokes `f` with a reference to the "
"equivalent element; such reference is const iff a `*_cvisit` overload is "
"used."

#: :1127
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[CopyInsertable^]. Returns:;; `true` if an insert took place. "
"+ Concurrency:;; Blocking on rehashing of `*this`. Notes:;; In a call of the "
"form `insert_or_[c]visit(obj, f)`, the overloads accepting a `const "
"value_type&` argument participate in overload resolution only if "
"`std::remove_cv<std::remove_reference<decltype(obj)>::type>::type` is "
"`value_type`."
msgstr ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[CopyInsertable^]. Returns:;; `true` if an insert took place. "
"+ Concurrency:;; Blocking on rehashing of `*this`. Notes:;; In a call of the "
"form `insert_or_[c]visit(obj, f)`, the overloads accepting a `const "
"value_type&` argument participate in overload resolution only if "
"`std::remove_cv<std::remove_reference<decltype(obj)>::type>::type` is "
"`value_type`."

#: :1133
#, read-only, safe-html, strict-same
msgctxt ":1133"
msgid "---"
msgstr "---"

#: :1135
#, read-only, safe-html, strict-same
msgid "Move insert_or_[c]visit"
msgstr "Move insert_or_[c]visit"

#: :1136
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class F> bool insert_or_visit(value_type&& obj, F f); "
"template<class F> bool insert_or_cvisit(value_type&& obj, F f); "
"template<class F> bool insert_or_visit(init_type&& obj, F f); template<class "
"F> bool insert_or_cvisit(init_type&& obj, F f); ```"
msgstr ""
"```c++ template<class F> bool insert_or_visit(value_type&& obj, F f); "
"template<class F> bool insert_or_cvisit(value_type&& obj, F f); "
"template<class F> bool insert_or_visit(init_type&& obj, F f); template<class "
"F> bool insert_or_cvisit(init_type&& obj, F f); ```"

#: :1143
#, read-only, safe-html, strict-same
msgctxt ":1143"
msgid ""
"Inserts `obj` in the table if and only if there is no element in the table "
"with an equivalent key. Otherwise, invokes `f` with a reference to the "
"equivalent element; such reference is const iff a `*_cvisit` overload is "
"used."
msgstr ""
"Inserts `obj` in the table if and only if there is no element in the table "
"with an equivalent key. Otherwise, invokes `f` with a reference to the "
"equivalent element; such reference is const iff a `*_cvisit` overload is "
"used."

#: :1147
#, read-only, safe-html, strict-same
msgid ""
"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:;; In a call of the "
"form `insert_or_[c]visit(obj, f)`, the overloads accepting a `value_type&&` "
"argument participate in overload resolution only if "
"`std::remove_reference<decltype(obj)>::type` is `value_type`."
msgstr ""
"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:;; In a call of the "
"form `insert_or_[c]visit(obj, f)`, the overloads accepting a `value_type&&` "
"argument participate in overload resolution only if "
"`std::remove_reference<decltype(obj)>::type` is `value_type`."

#: :1153
#, read-only, safe-html, strict-same
msgctxt ":1153"
msgid "---"
msgstr "---"

#: :1155
#, read-only, safe-html, strict-same
msgid "Insert Iterator Range or Visit"
msgstr "Insert Iterator Range or Visit"

#: :1156
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class InputIterator,class F> size_type insert_or_visit"
"(InputIterator first, InputIterator last, F f); template<class "
"InputIterator,class F> size_type insert_or_cvisit(InputIterator first, "
"InputIterator last, F f); ```"
msgstr ""
"```c++ template<class InputIterator,class F> size_type insert_or_visit"
"(InputIterator first, InputIterator last, F f); template<class "
"InputIterator,class F> size_type insert_or_cvisit(InputIterator first, "
"InputIterator last, F f); ```"

#: :1163
#, read-only, safe-html, strict-same
msgctxt ":1163"
msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]"
msgstr "Equivalent to [listing,subs=\"+macros,+quotes\"]"

#: :1170
#, read-only, safe-html, strict-same
msgctxt ":1170"
msgid "Returns:;; The number of elements inserted."
msgstr "Returns:;; The number of elements inserted."

#: :1172
#, read-only, safe-html, strict-same
msgctxt ":1172"
msgid "---"
msgstr "---"

#: :1174
#, read-only, safe-html, strict-same
msgid "Insert Initializer List or Visit"
msgstr "Insert Initializer List or Visit"

#: :1175
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class F> size_type insert_or_visit"
"(std::initializer_list<value_type> il, F f); template<class F> size_type "
"insert_or_cvisit(std::initializer_list<value_type> il, F f); ```"
msgstr ""
"```c++ template<class F> size_type insert_or_visit"
"(std::initializer_list<value_type> il, F f); template<class F> size_type "
"insert_or_cvisit(std::initializer_list<value_type> il, F f); ```"

#: :1180
#, read-only, safe-html, strict-same
msgctxt ":1180"
msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]"
msgstr "Equivalent to [listing,subs=\"+macros,+quotes\"]"

#: :1187
#, read-only, safe-html, strict-same
msgctxt ":1187"
msgid "Returns:;; The number of elements inserted."
msgstr "Returns:;; The number of elements inserted."

#: :1189
#, read-only, safe-html, strict-same
msgctxt ":1189"
msgid "---"
msgstr "---"

#: :1191
#, read-only, safe-html, strict-same
msgid "Insert Node or Visit"
msgstr "Insert Node or Visit"

#: :1192
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class F> insert_return_type insert_or_visit(node_type&& nh, "
"F f); template<class F> insert_return_type insert_or_cvisit(node_type&& nh, "
"F f); ```"
msgstr ""
"```c++ template<class F> insert_return_type insert_or_visit(node_type&& nh, "
"F f); template<class F> insert_return_type insert_or_cvisit(node_type&& nh, "
"F f); ```"

#: :1197
#, read-only, safe-html, strict-same
msgid ""
"If `nh` is empty, does nothing. Otherwise, inserts the associated element in "
"the table if and only if there is no element in the table with a key "
"equivalent to `nh.key()`. Otherwise, invokes `f` with a reference to the "
"equivalent element; such reference is const iff `insert_or_cvisit` is used."
msgstr ""
"If `nh` is empty, does nothing. Otherwise, inserts the associated element in "
"the table if and only if there is no element in the table with a key "
"equivalent to `nh.key()`. Otherwise, invokes `f` with a reference to the "
"equivalent element; such reference is const iff `insert_or_cvisit` is used."

#: :1202
#, read-only, safe-html, strict-same
msgctxt ":1202"
msgid ""
"Returns:;; An `insert_return_type` object constructed from `inserted` and "
"`node`: +"
msgstr ""
"Returns:;; An `insert_return_type` object constructed from `inserted` and "
"`node`: +"

#: :1203
#, read-only, safe-html, strict-same
msgctxt ":1203"
msgid "If `nh` is empty, `inserted` is `false` and `node` is empty."
msgstr "If `nh` is empty, `inserted` is `false` and `node` is empty."

#: :1204
#, read-only, safe-html, strict-same
msgctxt ":1204"
msgid ""
"Otherwise if the insertion took place, `inserted` is true and `node` is "
"empty."
msgstr ""
"Otherwise if the insertion took place, `inserted` is true and `node` is "
"empty."

#: :1205
#, read-only, safe-html, strict-same
msgctxt ":1205"
msgid ""
"If the insertion failed, `inserted` is false and `node` has the previous "
"value of `nh`."
msgstr ""
"If the insertion failed, `inserted` is false and `node` has the previous "
"value of `nh`."

#: :1206
#, read-only, safe-html, strict-same
msgid ""
"Throws:;; If an exception is thrown by an operation other than a call to "
"`hasher` or call to `f`, the function has no effect. Concurrency:;; Blocking "
"on rehashing of `*this`. Notes:;; Behavior is undefined if `nh` is not empty "
"and the allocators of `nh` and the container are not equal."
msgstr ""
"Throws:;; If an exception is thrown by an operation other than a call to "
"`hasher` or call to `f`, the function has no effect. Concurrency:;; Blocking "
"on rehashing of `*this`. Notes:;; Behavior is undefined if `nh` is not empty "
"and the allocators of `nh` and the container are not equal."

#: :1210
#, read-only, safe-html, strict-same
msgctxt ":1210"
msgid "---"
msgstr "---"

#: :1212
#, read-only, safe-html, strict-same
msgid "emplace_and_[c]visit"
msgstr "emplace_and_[c]visit"

#: :1213
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class... Args, class F1, class F2> bool emplace_and_visit"
"(Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class "
"F2> bool emplace_and_cvisit(Args&&... args, F1&& f1, F2&& f2); ```"
msgstr ""
"```c++ template<class... Args, class F1, class F2> bool emplace_and_visit"
"(Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class "
"F2> bool emplace_and_cvisit(Args&&... args, F1&& f1, F2&& f2); ```"

#: :1220
#, read-only, safe-html, strict-same
msgid ""
"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 non-const reference to the newly created element. Otherwise, "
"invokes `f2` with a reference to the equivalent element; such reference is "
"const iff `emplace_and_cvisit` is used."
msgstr ""
"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 non-const reference to the newly created element. Otherwise, "
"invokes `f2` with a reference to the equivalent element; such reference is "
"const iff `emplace_and_cvisit` is used."

#: :1225
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`. "
"Notes:;; The interface is exposition only, as C++ does not allow to declare "
"parameters `f1` and `f2` after a variadic parameter pack."
msgstr ""
"Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`. "
"Notes:;; The interface is exposition only, as C++ does not allow to declare "
"parameters `f1` and `f2` after a variadic parameter pack."

#: :1230
#, read-only, safe-html, strict-same
msgctxt ":1230"
msgid "---"
msgstr "---"

#: :1232
#, read-only, safe-html, strict-same
msgid "Copy insert_and_[c]visit"
msgstr "Copy insert_and_[c]visit"

#: :1233
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class F1, class F2> bool insert_and_visit(const value_type& "
"obj, F1 f1, F2 f2); template<class F1, class F2> bool insert_and_cvisit"
"(const value_type& obj, F1 f1, F2 f2); template<class F1, class F2> bool "
"insert_and_visit(const init_type& obj, F1 f1, F2 f2); template<class F1, "
"class F2> bool insert_and_cvisit(const init_type& obj, F1 f1, F2 f2); ```"
msgstr ""
"```c++ template<class F1, class F2> bool insert_and_visit(const value_type& "
"obj, F1 f1, F2 f2); template<class F1, class F2> bool insert_and_cvisit"
"(const value_type& obj, F1 f1, F2 f2); template<class F1, class F2> bool "
"insert_and_visit(const init_type& obj, F1 f1, F2 f2); template<class F1, "
"class F2> bool insert_and_cvisit(const init_type& obj, F1 f1, F2 f2); ```"

#: :1240
#, read-only, safe-html, strict-same
msgctxt ":1240"
msgid ""
"Inserts `obj` in the table if and only if there is no element in the table "
"with an equivalent key, and then invokes `f1` with a non-const reference to "
"the newly created element. Otherwise, invokes `f2` with a reference to the "
"equivalent element; such reference is const iff a `*_cvisit` overload is "
"used."
msgstr ""
"Inserts `obj` in the table if and only if there is no element in the table "
"with an equivalent key, and then invokes `f1` with a non-const reference to "
"the newly created element. Otherwise, invokes `f2` with a reference to the "
"equivalent element; such reference is const iff a `*_cvisit` overload is "
"used."

#: :1245
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[CopyInsertable^]. Returns:;; `true` if an insert took place. "
"+ Concurrency:;; Blocking on rehashing of `*this`. Notes:;; In a call of the "
"form `insert_and_[c]visit(obj, f1, f2)`, the overloads accepting a `const "
"value_type&` argument participate in overload resolution only if "
"`std::remove_cv<std::remove_reference<decltype(obj)>::type>::type` is "
"`value_type`."
msgstr ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"CopyInsertable[CopyInsertable^]. Returns:;; `true` if an insert took place. "
"+ Concurrency:;; Blocking on rehashing of `*this`. Notes:;; In a call of the "
"form `insert_and_[c]visit(obj, f1, f2)`, the overloads accepting a `const "
"value_type&` argument participate in overload resolution only if "
"`std::remove_cv<std::remove_reference<decltype(obj)>::type>::type` is "
"`value_type`."

#: :1251
#, read-only, safe-html, strict-same
msgctxt ":1251"
msgid "---"
msgstr "---"

#: :1253
#, read-only, safe-html, strict-same
msgid "Move insert_and_[c]visit"
msgstr "Move insert_and_[c]visit"

#: :1254
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class F1, class F2> bool insert_and_visit(value_type&& obj, "
"F1 f1, F2 f2); template<class F1, class F2> bool insert_and_cvisit"
"(value_type&& obj, F1 f1, F2 f2); template<class F1, class F2> bool "
"insert_and_visit(init_type&& obj, F1 f1, F2 f2); template<class F1, class "
"F2> bool insert_and_cvisit(init_type&& obj, F1 f1, F2 f2); ```"
msgstr ""
"```c++ template<class F1, class F2> bool insert_and_visit(value_type&& obj, "
"F1 f1, F2 f2); template<class F1, class F2> bool insert_and_cvisit"
"(value_type&& obj, F1 f1, F2 f2); template<class F1, class F2> bool "
"insert_and_visit(init_type&& obj, F1 f1, F2 f2); template<class F1, class "
"F2> bool insert_and_cvisit(init_type&& obj, F1 f1, F2 f2); ```"

#: :1261
#, read-only, safe-html, strict-same
msgctxt ":1261"
msgid ""
"Inserts `obj` in the table if and only if there is no element in the table "
"with an equivalent key, and then invokes `f1` with a non-const reference to "
"the newly created element. Otherwise, invokes `f2` with a reference to the "
"equivalent element; such reference is const iff a `*_cvisit` overload is "
"used."
msgstr ""
"Inserts `obj` in the table if and only if there is no element in the table "
"with an equivalent key, and then invokes `f1` with a non-const reference to "
"the newly created element. Otherwise, invokes `f2` with a reference to the "
"equivalent element; such reference is const iff a `*_cvisit` overload is "
"used."

#: :1266
#, read-only, safe-html, strict-same
msgid ""
"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:;; 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`."
msgstr ""
"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:;; 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`."

#: :1272
#, read-only, safe-html, strict-same
msgctxt ":1272"
msgid "---"
msgstr "---"

#: :1274
#, read-only, safe-html, strict-same
msgid "Insert Iterator Range and Visit"
msgstr "Insert Iterator Range and Visit"

#: :1275
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class InputIterator, class F1, class F2> size_type "
"insert_or_visit(InputIterator first, InputIterator last, F1 f1, F2 f2); "
"template<class InputIterator, class F1, class F2> size_type insert_or_cvisit"
"(InputIterator first, InputIterator last, F1 f2, F2 f2); ```"
msgstr ""
"```c++ template<class InputIterator, class F1, class F2> size_type "
"insert_or_visit(InputIterator first, InputIterator last, F1 f1, F2 f2); "
"template<class InputIterator, class F1, class F2> size_type insert_or_cvisit"
"(InputIterator first, InputIterator last, F1 f2, F2 f2); ```"

#: :1282
#, read-only, safe-html, strict-same
msgctxt ":1282"
msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]"
msgstr "Equivalent to [listing,subs=\"+macros,+quotes\"]"

#: :1289
#, read-only, safe-html, strict-same
msgctxt ":1289"
msgid "Returns:;; The number of elements inserted."
msgstr "Returns:;; The number of elements inserted."

#: :1291
#, read-only, safe-html, strict-same
msgctxt ":1291"
msgid "---"
msgstr "---"

#: :1293
#, read-only, safe-html, strict-same
msgid "Insert Initializer List and Visit"
msgstr "Insert Initializer List and Visit"

#: :1294
#, read-only, safe-html, strict-same
msgid ""
"```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); ```"
msgstr ""
"```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); ```"

#: :1301
#, read-only, safe-html, strict-same
msgctxt ":1301"
msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]"
msgstr "Equivalent to [listing,subs=\"+macros,+quotes\"]"

#: :1308
#, read-only, safe-html, strict-same
msgctxt ":1308"
msgid "Returns:;; The number of elements inserted."
msgstr "Returns:;; The number of elements inserted."

#: :1310
#, read-only, safe-html, strict-same
msgctxt ":1310"
msgid "---"
msgstr "---"

#: :1312
#, read-only, safe-html, strict-same
msgid "Insert Node and Visit"
msgstr "Insert Node and Visit"

#: :1313
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class F1, class F2> insert_return_type insert_and_visit"
"(node_type&& nh, F1 f1, F2 f2); template<class F1, class F2> "
"insert_return_type insert_and_cvisit(node_type&& nh, F1 f1, F2 f2); ```"
msgstr ""
"```c++ template<class F1, class F2> insert_return_type insert_and_visit"
"(node_type&& nh, F1 f1, F2 f2); template<class F1, class F2> "
"insert_return_type insert_and_cvisit(node_type&& nh, F1 f1, F2 f2); ```"

#: :1320
#, read-only, safe-html, strict-same
msgid ""
"If `nh` is empty, does nothing. Otherwise, inserts the associated element in "
"the table if and only if there is no element in the table with a key "
"equivalent to `nh.key()`, and then invokes `f1` with a non-const reference "
"to the newly inserted element. Otherwise, invokes `f2` with a reference to "
"the equivalent element; such reference is const iff `insert_or_cvisit` is "
"used."
msgstr ""
"If `nh` is empty, does nothing. Otherwise, inserts the associated element in "
"the table if and only if there is no element in the table with a key "
"equivalent to `nh.key()`, and then invokes `f1` with a non-const reference "
"to the newly inserted element. Otherwise, invokes `f2` with a reference to "
"the equivalent element; such reference is const iff `insert_or_cvisit` is "
"used."

#: :1326
#, read-only, safe-html, strict-same
msgctxt ":1326"
msgid ""
"Returns:;; An `insert_return_type` object constructed from `inserted` and "
"`node`: +"
msgstr ""
"Returns:;; An `insert_return_type` object constructed from `inserted` and "
"`node`: +"

#: :1327
#, read-only, safe-html, strict-same
msgctxt ":1327"
msgid "If `nh` is empty, `inserted` is `false` and `node` is empty."
msgstr "If `nh` is empty, `inserted` is `false` and `node` is empty."

#: :1328
#, read-only, safe-html, strict-same
msgctxt ":1328"
msgid ""
"Otherwise if the insertion took place, `inserted` is true and `node` is "
"empty."
msgstr ""
"Otherwise if the insertion took place, `inserted` is true and `node` is "
"empty."

#: :1329
#, read-only, safe-html, strict-same
msgctxt ":1329"
msgid ""
"If the insertion failed, `inserted` is false and `node` has the previous "
"value of `nh`."
msgstr ""
"If the insertion failed, `inserted` is false and `node` has the previous "
"value of `nh`."

#: :1330
#, read-only, safe-html, strict-same
msgid ""
"Throws:;; If an exception is thrown by an operation other than a call to "
"`hasher` or call to `f1` or `f2`, the function has no effect. Concurrency:;; "
"Blocking on rehashing of `*this`. Notes:;; Behavior is undefined if `nh` is "
"not empty and the allocators of `nh` and the container are not equal."
msgstr ""
"Throws:;; If an exception is thrown by an operation other than a call to "
"`hasher` or call to `f1` or `f2`, the function has no effect. Concurrency:;; "
"Blocking on rehashing of `*this`. Notes:;; Behavior is undefined if `nh` is "
"not empty and the allocators of `nh` and the container are not equal."

#: :1334
#, read-only, safe-html, strict-same
msgctxt ":1334"
msgid "---"
msgstr "---"

#: :1336
#, read-only, safe-html, strict-same
msgid "try_emplace"
msgstr "try_emplace"

#: :1337
#, read-only, safe-html, strict-same
msgid ""
"```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); "
"```"
msgstr ""
"```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); "
"```"

#: :1343
#, read-only, safe-html, strict-same
msgid ""
"Inserts an element constructed from `k` and `args` into the table if there "
"is no existing element with key `k` contained within it."
msgstr ""
"Inserts an element constructed from `k` and `args` into the table if there "
"is no existing element with key `k` contained within it."

#: :1346
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on "
"rehashing of `*this`. Notes:;; This function is similiar to "
"xref:#concurrent_node_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++"
msgstr ""
"Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on "
"rehashing of `*this`. Notes:;; This function is similiar to "
"xref:#concurrent_node_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++"

#: :1354
#, read-only, safe-html, strict-same
msgctxt ":1354"
msgid ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>"
"(k)), std::forward_as_tuple(std::forward<Args>(args)...))"
msgstr ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>"
"(k)), std::forward_as_tuple(std::forward<Args>(args)...))"

#: :1359
#, read-only, safe-html, strict-same
msgctxt ":1359"
msgid ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>"
"(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```"
msgstr ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>"
"(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```"

#: :1364
#, read-only, safe-html, strict-same
msgid ""
"unlike xref:#concurrent_node_map_emplace[emplace], which simply forwards all "
"arguments to ``value_type``'s constructor."
msgstr ""
"unlike xref:#concurrent_node_map_emplace[emplace], which simply forwards all "
"arguments to ``value_type``'s constructor."

#: :1366
#, read-only, safe-html, strict-same
msgid ""
"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."
msgstr ""
"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."

#: :1368
#, read-only, safe-html, strict-same
msgctxt ":1368"
msgid "--"
msgstr "--"

#: :1370
#, read-only, safe-html, strict-same
msgctxt ":1370"
msgid "---"
msgstr "---"

#: :1372
#, read-only, safe-html, strict-same
msgid "try_emplace_or_[c]visit"
msgstr "try_emplace_or_[c]visit"

#: :1373
#, read-only, safe-html, strict-same
msgid ""
"```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); ```"
msgstr ""
"```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); ```"

#: :1388
#, read-only, safe-html, strict-same
msgid ""
"Inserts an element constructed from `k` and `args` into the table if there "
"is no existing element with key `k` contained within it. Otherwise, invokes "
"`f` with a reference to the equivalent element; such reference is const iff "
"a `*_cvisit` overload is used."
msgstr ""
"Inserts an element constructed from `k` and `args` into the table if there "
"is no existing element with key `k` contained within it. Otherwise, invokes "
"`f` with a reference to the equivalent element; such reference is const iff "
"a `*_cvisit` overload is used."

#: :1392
#, read-only, safe-html, strict-same
msgctxt ":1392"
msgid ""
"Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on "
"rehashing of `*this`. Notes:;; No `value_type` is constructed if there is an "
"element with an equivalent key; otherwise, the construction is of the form: "
"+ + -- ```c++"
msgstr ""
"Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on "
"rehashing of `*this`. Notes:;; No `value_type` is constructed if there is an "
"element with an equivalent key; otherwise, the construction is of the form: "
"+ + -- ```c++"

#: :1400
#, read-only, safe-html, strict-same
msgctxt ":1400"
msgid ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>"
"(k)), std::forward_as_tuple(std::forward<Args>(args)...))"
msgstr ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>"
"(k)), std::forward_as_tuple(std::forward<Args>(args)...))"

#: :1405
#, read-only, safe-html, strict-same
msgctxt ":1405"
msgid ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>"
"(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```"
msgstr ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>"
"(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```"

#: :1410
#, read-only, safe-html, strict-same
msgid ""
"The interface is exposition only, as C++ does not allow to declare a "
"parameter `f` after a variadic parameter pack."
msgstr ""
"The interface is exposition only, as C++ does not allow to declare a "
"parameter `f` after a variadic parameter pack."

#: :1412
#, read-only, safe-html, strict-same
msgid ""
"The `template<class K, class\\... Args, class F>` 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."
msgstr ""
"The `template<class K, class\\... Args, class F>` 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."

#: :1414
#, read-only, safe-html, strict-same
msgctxt ":1414"
msgid "--"
msgstr "--"

#: :1416
#, read-only, safe-html, strict-same
msgctxt ":1416"
msgid "---"
msgstr "---"

#: :1418
#, read-only, safe-html, strict-same
msgid "try_emplace_and_[c]visit"
msgstr "try_emplace_and_[c]visit"

#: :1419
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class... Args, class F1, class F2> bool try_emplace_and_visit"
"(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template<class... "
"Args, class F1, class F2> bool try_emplace_and_cvisit(const key_type& k, "
"Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class "
"F2> bool try_emplace_and_visit(key_type&& k, Args&&... args, F1&& f1, F2&& "
"f2); template<class... Args, class F1, class F2> bool try_emplace_and_cvisit"
"(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template<class K, class... "
"Args, class F1, class F2> bool try_emplace_and_visit(K&& k, Args&&... args, "
"F1&& f1, F2&& f2); template<class K, class... Args, class F1, class F2> bool "
"try_emplace_and_cvisit(K&& k, Args&&... args, F1&& f1, F2&& f2); ```"
msgstr ""
"```c++ template<class... Args, class F1, class F2> bool try_emplace_and_visit"
"(const key_type& k, Args&&... args, F1&& f1, F2&& f2); template<class... "
"Args, class F1, class F2> bool try_emplace_and_cvisit(const key_type& k, "
"Args&&... args, F1&& f1, F2&& f2); template<class... Args, class F1, class "
"F2> bool try_emplace_and_visit(key_type&& k, Args&&... args, F1&& f1, F2&& "
"f2); template<class... Args, class F1, class F2> bool try_emplace_and_cvisit"
"(key_type&& k, Args&&... args, F1&& f1, F2&& f2); template<class K, class... "
"Args, class F1, class F2> bool try_emplace_and_visit(K&& k, Args&&... args, "
"F1&& f1, F2&& f2); template<class K, class... Args, class F1, class F2> bool "
"try_emplace_and_cvisit(K&& k, Args&&... args, F1&& f1, F2&& f2); ```"

#: :1434
#, read-only, safe-html, strict-same
msgid ""
"Inserts an element constructed from `k` and `args` into the table if there "
"is no existing element with key `k` contained within it, and then invokes "
"`f1` with a non-const reference to the newly created element. Otherwise, "
"invokes `f2` with a reference to the equivalent element; such reference is "
"const iff a `*_cvisit` overload is used."
msgstr ""
"Inserts an element constructed from `k` and `args` into the table if there "
"is no existing element with key `k` contained within it, and then invokes "
"`f1` with a non-const reference to the newly created element. Otherwise, "
"invokes `f2` with a reference to the equivalent element; such reference is "
"const iff a `*_cvisit` overload is used."

#: :1439
#, read-only, safe-html, strict-same
msgctxt ":1439"
msgid ""
"Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on "
"rehashing of `*this`. Notes:;; No `value_type` is constructed if there is an "
"element with an equivalent key; otherwise, the construction is of the form: "
"+ + -- ```c++"
msgstr ""
"Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on "
"rehashing of `*this`. Notes:;; No `value_type` is constructed if there is an "
"element with an equivalent key; otherwise, the construction is of the form: "
"+ + -- ```c++"

#: :1447
#, read-only, safe-html, strict-same
msgctxt ":1447"
msgid ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>"
"(k)), std::forward_as_tuple(std::forward<Args>(args)...))"
msgstr ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>"
"(k)), std::forward_as_tuple(std::forward<Args>(args)...))"

#: :1452
#, read-only, safe-html, strict-same
msgctxt ":1452"
msgid ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>"
"(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```"
msgstr ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>"
"(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```"

#: :1457
#, read-only, safe-html, strict-same
msgid ""
"The interface is exposition only, as C++ does not allow to declare parameter "
"`f1` and `f2` after a variadic parameter pack."
msgstr ""
"The interface is exposition only, as C++ does not allow to declare parameter "
"`f1` and `f2` after a variadic parameter pack."

#: :1459
#, read-only, safe-html, strict-same
msgid ""
"The `template<class K, class\\... Args, class F1, class F2>` 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."
msgstr ""
"The `template<class K, class\\... Args, class F1, class F2>` 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."

#: :1461
#, read-only, safe-html, strict-same
msgctxt ":1461"
msgid "--"
msgstr "--"

#: :1463
#, read-only, safe-html, strict-same
msgctxt ":1463"
msgid "---"
msgstr "---"

#: :1465
#, read-only, safe-html, strict-same
msgid "insert_or_assign"
msgstr "insert_or_assign"

#: :1466
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class M> bool insert_or_assign(const key_type& k, M&& obj); "
"template<class M> bool insert_or_assign(key_type&& k, M&& obj); "
"template<class K, class M> bool insert_or_assign(K&& k, M&& obj); ```"
msgstr ""
"```c++ template<class M> bool insert_or_assign(const key_type& k, M&& obj); "
"template<class M> bool insert_or_assign(key_type&& k, M&& obj); "
"template<class K, class M> bool insert_or_assign(K&& k, M&& obj); ```"

#: :1472
#, read-only, safe-html, strict-same
msgid ""
"Inserts a new element into the table or updates an existing one by assigning "
"to the contained value."
msgstr ""
"Inserts a new element into the table or updates an existing one by assigning "
"to the contained value."

#: :1474
#, read-only, safe-html, strict-same
msgid ""
"If there is an element with key `k`, then it is updated by assigning "
"`std::forward<M>(obj)`."
msgstr ""
"If there is an element with key `k`, then it is updated by assigning "
"`std::forward<M>(obj)`."

#: :1476
#, read-only, safe-html, strict-same
msgid "If there is no such element, it is added to the table as: ```c++"
msgstr "If there is no such element, it is added to the table as: ```c++"

#: :1479
#, read-only, safe-html, strict-same
msgid ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>"
"(k)), std::forward_as_tuple(std::forward<M>(obj)))"
msgstr ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>"
"(k)), std::forward_as_tuple(std::forward<M>(obj)))"

#: :1484
#, read-only, safe-html, strict-same
msgid ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>"
"(k)), std::forward_as_tuple(std::forward<M>(obj))) ```"
msgstr ""
"value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>"
"(k)), std::forward_as_tuple(std::forward<M>(obj))) ```"

#: :1490
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; `true` if an insert took place. Concurrency:;; Blocking on "
"rehashing of `*this`. Notes:;; The `template<class K, class M>` 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."
msgstr ""
"Returns:;; `true` if an insert took place. Concurrency:;; Blocking on "
"rehashing of `*this`. Notes:;; The `template<class K, class M>` 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."

#: :1494
#, read-only, safe-html, strict-same
msgctxt ":1494"
msgid "---"
msgstr "---"

#: :1496
#, read-only, safe-html, strict-same
msgid "erase"
msgstr "erase"

#: :1497
#, read-only, safe-html, strict-same
msgid ""
"```c++ size_type erase(const key_type& k); template<class K> size_type erase"
"(const K& k); ```"
msgstr ""
"```c++ size_type erase(const key_type& k); template<class K> size_type erase"
"(const K& k); ```"

#: :1502
#, read-only, safe-html, strict-same
msgid "Erases the element with key equivalent to `k` if it exists."
msgstr "Erases the element with key equivalent to `k` if it exists."

#: :1505
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; The number of elements erased (0 or 1). 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."
msgstr ""
"Returns:;; The number of elements erased (0 or 1). 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."

#: :1509
#, read-only, safe-html, strict-same
msgctxt ":1509"
msgid "---"
msgstr "---"

#: :1511
#, read-only, safe-html, strict-same
msgid "erase_if by Key"
msgstr "erase_if by Key"

#: :1512
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class F> size_type erase_if(const key_type& k, F f); "
"template<class K, class F> size_type erase_if(const K& k, F f); ```"
msgstr ""
"```c++ template<class F> size_type erase_if(const key_type& k, F f); "
"template<class K, class F> size_type erase_if(const K& k, F f); ```"

#: :1517
#, read-only, safe-html, strict-same
msgid ""
"Erases the element `x` with key equivalent to `k` if it exists and `f(x)` is "
"`true`."
msgstr ""
"Erases the element `x` with key equivalent to `k` if it exists and `f(x)` is "
"`true`."

#: :1520
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; The number of elements erased (0 or 1). Throws:;; Only throws an "
"exception if it is thrown by `hasher`, `key_equal` or `f`. Notes:;; `f` is "
"passed a non-const reference to `x`. + + The `template<class K, class F>` "
"overload only participates in overload resolution if "
"`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is "
"`false`. + + The `template<class K, class F>` 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."
msgstr ""
"Returns:;; The number of elements erased (0 or 1). Throws:;; Only throws an "
"exception if it is thrown by `hasher`, `key_equal` or `f`. Notes:;; `f` is "
"passed a non-const reference to `x`. + + The `template<class K, class F>` "
"overload only participates in overload resolution if "
"`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is "
"`false`. + + The `template<class K, class F>` 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."

#: :1528
#, read-only, safe-html, strict-same
msgctxt ":1528"
msgid "---"
msgstr "---"

#: :1530
#, read-only, safe-html, strict-same
msgctxt ":1530"
msgid "erase_if"
msgstr "erase_if"

#: :1531
#, read-only, safe-html, strict-same
msgid "```c++ template<class F> size_type erase_if(F f); ```"
msgstr "```c++ template<class F> size_type erase_if(F f); ```"

#: :1535
#, read-only, safe-html, strict-same
msgid ""
"Successively invokes `f` with non-const references to each of the elements "
"in the table, and erases those for which `f` returns `true`."
msgstr ""
"Successively invokes `f` with non-const references to each of the elements "
"in the table, and erases those for which `f` returns `true`."

#: :1538
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; The number of elements erased. Throws:;; Only throws an exception "
"if it is thrown by `f`."
msgstr ""
"Returns:;; The number of elements erased. Throws:;; Only throws an exception "
"if it is thrown by `f`."

#: :1541
#, read-only, safe-html, strict-same
msgctxt ":1541"
msgid "---"
msgstr "---"

#: :1543
#, read-only, safe-html, strict-same
msgid "Parallel erase_if"
msgstr "Parallel erase_if"

#: :1544
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class ExecutionPolicy, class  F> void erase_if"
"(ExecutionPolicy&& policy, F f); ```"
msgstr ""
"```c++ template<class ExecutionPolicy, class  F> void erase_if"
"(ExecutionPolicy&& policy, F f); ```"

#: :1548
#, read-only, safe-html, strict-same
msgid ""
"Invokes `f` with non-const references to each of the elements in the table, "
"and erases those for which `f` returns `true`. Execution is parallelized "
"according to the semantics of the execution policy specified."
msgstr ""
"Invokes `f` with non-const references to each of the elements in the table, "
"and erases those for which `f` returns `true`. Execution is parallelized "
"according to the semantics of the execution policy specified."

#: :1552
#, read-only, safe-html, strict-same
msgid ""
"Throws:;; Depending on the exception handling mechanism of the execution "
"policy used, may call `std::terminate` if an exception is thrown within `f`. "
"Notes:;; Only available in compilers supporting C++17 parallel algorithms. + "
"+ This overload only participates in overload resolution if "
"`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is "
"`true`. + + Unsequenced execution policies are not allowed."
msgstr ""
"Throws:;; Depending on the exception handling mechanism of the execution "
"policy used, may call `std::terminate` if an exception is thrown within `f`. "
"Notes:;; Only available in compilers supporting C++17 parallel algorithms. + "
"+ This overload only participates in overload resolution if "
"`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is "
"`true`. + + Unsequenced execution policies are not allowed."

#: :1559
#, read-only, safe-html, strict-same
msgctxt ":1559"
msgid "---"
msgstr "---"

#: :1561
#, read-only, safe-html, strict-same
msgid "swap"
msgstr "swap"

#: :1562
#, read-only, safe-html, strict-same
msgid ""
"```c++ void swap(concurrent_node_map& other) noexcept"
"(boost::allocator_traits<Allocator>::is_always_equal::value || "
"boost::allocator_traits<Allocator>::propagate_on_container_swap::value); ```"
msgstr ""
"```c++ void swap(concurrent_node_map& other) noexcept"
"(boost::allocator_traits<Allocator>::is_always_equal::value || "
"boost::allocator_traits<Allocator>::propagate_on_container_swap::value); ```"

#: :1568
#, read-only, safe-html, strict-same
msgid "Swaps the contents of the table with the parameter."
msgstr "Swaps the contents of the table with the parameter."

#: :1570
#, read-only, safe-html, strict-same
msgid ""
"If `Allocator::propagate_on_container_swap` is declared and "
"`Allocator::propagate_on_container_swap::value` is `true` then the tables' "
"allocators are swapped. Otherwise, swapping with unequal allocators results "
"in undefined behavior."
msgstr ""
"If `Allocator::propagate_on_container_swap` is declared and "
"`Allocator::propagate_on_container_swap::value` is `true` then the tables' "
"allocators are swapped. Otherwise, swapping with unequal allocators results "
"in undefined behavior."

#: :1573
#, read-only, safe-html, strict-same
msgid ""
"Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. "
"Concurrency:;; Blocking on `*this` and `other`."
msgstr ""
"Throws:;; Nothing unless `key_equal` or `hasher` throw on swapping. "
"Concurrency:;; Blocking on `*this` and `other`."

#: :1576
#, read-only, safe-html, strict-same
msgctxt ":1576"
msgid "---"
msgstr "---"

#: :1578
#, read-only, safe-html, strict-same
msgid "extract"
msgstr "extract"

#: :1579
#, read-only, safe-html, strict-same
msgid ""
"```c++ node_type extract(const key_type& k); template<class K> node_type "
"extract(K&& k); ```"
msgstr ""
"```c++ node_type extract(const key_type& k); template<class K> node_type "
"extract(K&& k); ```"

#: :1584
#, read-only, safe-html, strict-same
msgid "Extracts the element with key equivalent to `k`, if it exists."
msgstr "Extracts the element with key equivalent to `k`, if it exists."

#: :1587
#, read-only, safe-html, strict-same
msgid ""
"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."
msgstr ""
"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."

#: :1591
#, read-only, safe-html, strict-same
msgctxt ":1591"
msgid "---"
msgstr "---"

#: :1593
#, read-only, safe-html, strict-same
msgid "extract_if"
msgstr "extract_if"

#: :1594
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class F> node_type extract_if(const key_type& k, F f); "
"template<class K, class F> node_type extract_if(K&& k, F f); ```"
msgstr ""
"```c++ template<class F> node_type extract_if(const key_type& k, F f); "
"template<class K, class F> node_type extract_if(K&& k, F f); ```"

#: :1599
#, read-only, safe-html, strict-same
msgid ""
"Extracts the element `x` with key equivalent to `k`, if it exists and `f(x)` "
"is `true`."
msgstr ""
"Extracts the element `x` with key equivalent to `k`, if it exists and `f(x)` "
"is `true`."

#: :1602
#, read-only, safe-html, strict-same
msgid ""
"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` or `f`. 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."
msgstr ""
"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` or `f`. 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."

#: :1606
#, read-only, safe-html, strict-same
msgctxt ":1606"
msgid "---"
msgstr "---"

#: :1608
#, read-only, safe-html, strict-same
msgid "clear"
msgstr "clear"

#: :1609
#, read-only, safe-html, strict-same
msgid "```c++ void clear() noexcept; ```"
msgstr "```c++ void clear() noexcept; ```"

#: :1613
#, read-only, safe-html, strict-same
msgid "Erases all elements in the table."
msgstr "Erases all elements in the table."

#: :1616
#, read-only, safe-html, strict-same
msgid ""
"Postconditions:;; `size() == 0`, `max_load() >= max_load_factor() * "
"bucket_count()` Concurrency:;; Blocking on `*this`."
msgstr ""
"Postconditions:;; `size() == 0`, `max_load() >= max_load_factor() * "
"bucket_count()` Concurrency:;; Blocking on `*this`."

#: :1619
#, read-only, safe-html, strict-same
msgctxt ":1619"
msgid "---"
msgstr "---"

#: :1621
#, read-only, safe-html, strict-same
msgid "merge"
msgstr "merge"

#: :1622
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class H2, class P2> size_type merge(concurrent_node_map<Key, "
"T, H2, P2, Allocator>& source); template<class H2, class P2> size_type merge"
"(concurrent_node_map<Key, T, H2, P2, Allocator>&& source); ```"
msgstr ""
"```c++ template<class H2, class P2> size_type merge(concurrent_node_map<Key, "
"T, H2, P2, Allocator>& source); template<class H2, class P2> size_type merge"
"(concurrent_node_map<Key, T, H2, P2, Allocator>&& source); ```"

#: :1629
#, read-only, safe-html, strict-same
msgid ""
"Move-inserts all the elements from `source` whose key is not already present "
"in `*this`, and erases them from `source`."
msgstr ""
"Move-inserts all the elements from `source` whose key is not already present "
"in `*this`, and erases them from `source`."

#: :1632
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; The number of elements inserted. Concurrency:;; Blocking on "
"`*this` and `source`."
msgstr ""
"Returns:;; The number of elements inserted. Concurrency:;; Blocking on "
"`*this` and `source`."

#: :1635
#, read-only, safe-html, strict-same
msgctxt ":1635"
msgid "---"
msgstr "---"

#: :1637
#, read-only, safe-html, strict-same
msgid "Observers"
msgstr "Observers"

#: :1639
#, read-only, safe-html, strict-same
msgid "get_allocator"
msgstr "get_allocator"

#: :1640
#, read-only, safe-html, strict-same
msgid "``` allocator_type get_allocator() const noexcept; ```"
msgstr "``` allocator_type get_allocator() const noexcept; ```"

#: :1645
#, read-only, safe-html, strict-same
msgid "Returns:;; The table's allocator."
msgstr "Returns:;; The table's allocator."

#: :1647
#, read-only, safe-html, strict-same
msgctxt ":1647"
msgid "---"
msgstr "---"

#: :1649
#, read-only, safe-html, strict-same
msgid "hash_function"
msgstr "hash_function"

#: :1650
#, read-only, safe-html, strict-same
msgid "``` hasher hash_function() const; ```"
msgstr "``` hasher hash_function() const; ```"

#: :1655
#, read-only, safe-html, strict-same
msgid "Returns:;; The table's hash function."
msgstr "Returns:;; The table's hash function."

#: :1657
#, read-only, safe-html, strict-same
msgctxt ":1657"
msgid "---"
msgstr "---"

#: :1659
#, read-only, safe-html, strict-same
msgid "key_eq"
msgstr "key_eq"

#: :1660
#, read-only, safe-html, strict-same
msgid "``` key_equal key_eq() const; ```"
msgstr "``` key_equal key_eq() const; ```"

#: :1665
#, read-only, safe-html, strict-same
msgid "Returns:;; The table's key equality predicate."
msgstr "Returns:;; The table's key equality predicate."

#: :1667
#, read-only, safe-html, strict-same
msgctxt ":1667"
msgid "---"
msgstr "---"

#: :1669
#, read-only, safe-html, strict-same
msgid "Map Operations"
msgstr "Map Operations"

#: :1671
#, read-only, safe-html, strict-same
msgid "count"
msgstr "count"

#: :1672
#, read-only, safe-html, strict-same
msgid ""
"```c++ size_type        count(const key_type& k) const; template<class K> "
"size_type      count(const K& k) const; ```"
msgstr ""
"```c++ size_type        count(const key_type& k) const; template<class K> "
"size_type      count(const K& k) const; ```"

#: :1679
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; The number of elements with key equivalent to `k` (0 or 1). "
"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. + + In "
"the presence of concurrent insertion operations, the value returned may not "
"accurately reflect the true state of the table right after execution."
msgstr ""
"Returns:;; The number of elements with key equivalent to `k` (0 or 1). "
"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. + + In "
"the presence of concurrent insertion operations, the value returned may not "
"accurately reflect the true state of the table right after execution."

#: :1685
#, read-only, safe-html, strict-same
msgctxt ":1685"
msgid "---"
msgstr "---"

#: :1687
#, read-only, safe-html, strict-same
msgid "contains"
msgstr "contains"

#: :1688
#, read-only, safe-html, strict-same
msgid ""
"```c++ bool             contains(const key_type& k) const; template<class K> "
"bool           contains(const K& k) const; ```"
msgstr ""
"```c++ bool             contains(const key_type& k) const; template<class K> "
"bool           contains(const K& k) const; ```"

#: :1695
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; A boolean indicating whether or not there is an element with key "
"equal to `k` in the table. 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.  + + In the presence of concurrent insertion "
"operations, the value returned may not accurately reflect the true state of "
"the table right after execution."
msgstr ""
"Returns:;; A boolean indicating whether or not there is an element with key "
"equal to `k` in the table. 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.  + + In the presence of concurrent insertion "
"operations, the value returned may not accurately reflect the true state of "
"the table right after execution."

#: :1701
#, read-only, safe-html, strict-same
msgctxt ":1701"
msgid "---"
msgstr "---"

#: :1702
#, read-only, safe-html, strict-same
msgid "Bucket Interface"
msgstr "Bucket Interface"

#: :1704
#, read-only, safe-html, strict-same
msgid "bucket_count"
msgstr "bucket_count"

#: :1705
#, read-only, safe-html, strict-same
msgid "```c++ size_type bucket_count() const noexcept; ```"
msgstr "```c++ size_type bucket_count() const noexcept; ```"

#: :1710
#, read-only, safe-html, strict-same
msgid "Returns:;; The size of the bucket array."
msgstr "Returns:;; The size of the bucket array."

#: :1712
#, read-only, safe-html, strict-same
msgctxt ":1712"
msgid "---"
msgstr "---"

#: :1714
#, read-only, safe-html, strict-same
msgid "Hash Policy"
msgstr "Hash Policy"

#: :1716
#, read-only, safe-html, strict-same
msgid "load_factor"
msgstr "load_factor"

#: :1717
#, read-only, safe-html, strict-same
msgid "```c++ float load_factor() const noexcept; ```"
msgstr "```c++ float load_factor() const noexcept; ```"

#: :1722
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; `static_cast<float>(size())/static_cast<float>(bucket_count())`, "
"or `0` if `bucket_count() == 0`."
msgstr ""
"Returns:;; `static_cast<float>(size())/static_cast<float>(bucket_count())`, "
"or `0` if `bucket_count() == 0`."

#: :1724
#, read-only, safe-html, strict-same
msgctxt ":1724"
msgid "---"
msgstr "---"

#: :1726
#, read-only, safe-html, strict-same
msgid "max_load_factor"
msgstr "max_load_factor"

#: :1728
#, read-only, safe-html, strict-same
msgid "```c++ float max_load_factor() const noexcept; ```"
msgstr "```c++ float max_load_factor() const noexcept; ```"

#: :1733
#, read-only, safe-html, strict-same
msgid "Returns:;; Returns the table's maximum load factor."
msgstr "Returns:;; Returns the table's maximum load factor."

#: :1735
#, read-only, safe-html, strict-same
msgctxt ":1735"
msgid "---"
msgstr "---"

#: :1737
#, read-only, safe-html, strict-same
msgid "Set max_load_factor"
msgstr "Set max_load_factor"

#: :1738
#, read-only, safe-html, strict-same
msgid "```c++ void max_load_factor(float z); ```"
msgstr "```c++ void max_load_factor(float z); ```"

#: :1743
#, read-only, safe-html, strict-same
msgid ""
"Effects:;; Does nothing, as the user is not allowed to change this "
"parameter. Kept for compatibility with `boost::unordered_map`."
msgstr ""
"Effects:;; Does nothing, as the user is not allowed to change this "
"parameter. Kept for compatibility with `boost::unordered_map`."

#: :1745
#, read-only, safe-html, strict-same
msgctxt ":1745"
msgid "---"
msgstr "---"

#: :1748
#, read-only, safe-html, strict-same
msgid "max_load"
msgstr "max_load"

#: :1750
#, read-only, safe-html, strict-same
msgid "```c++ size_type max_load() const noexcept; ```"
msgstr "```c++ size_type max_load() const noexcept; ```"

#: :1755
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; The maximum number of elements the table can hold without "
"rehashing, assuming that no further elements will be erased. Note:;; After "
"construction, rehash or clearance, the table's maximum load is at least "
"`max_load_factor() * bucket_count()`. This number may decrease on erasure "
"under high-load conditions. + + In the presence of concurrent insertion "
"operations, the value returned may not accurately reflect the true state of "
"the table right after execution."
msgstr ""
"Returns:;; The maximum number of elements the table can hold without "
"rehashing, assuming that no further elements will be erased. Note:;; After "
"construction, rehash or clearance, the table's maximum load is at least "
"`max_load_factor() * bucket_count()`. This number may decrease on erasure "
"under high-load conditions. + + In the presence of concurrent insertion "
"operations, the value returned may not accurately reflect the true state of "
"the table right after execution."

#: :1762
#, read-only, safe-html, strict-same
msgctxt ":1762"
msgid "---"
msgstr "---"

#: :1764
#, read-only, safe-html, strict-same
msgid "rehash"
msgstr "rehash"

#: :1765
#, read-only, safe-html, strict-same
msgid "```c++ void rehash(size_type n); ```"
msgstr "```c++ void rehash(size_type n); ```"

#: :1769
#, read-only, safe-html, strict-same
msgid ""
"Changes if necessary the size of the bucket array so that there are at least "
"`n` buckets, and so that the load factor is less than or equal to the "
"maximum load factor. When applicable, this will either grow or shrink the "
"`bucket_count()` associated with the table."
msgstr ""
"Changes if necessary the size of the bucket array so that there are at least "
"`n` buckets, and so that the load factor is less than or equal to the "
"maximum load factor. When applicable, this will either grow or shrink the "
"`bucket_count()` associated with the table."

#: :1771
#, read-only, safe-html, strict-same
msgid ""
"When `size() == 0`, `rehash(0)` will deallocate the underlying buckets array."
msgstr ""
"When `size() == 0`, `rehash(0)` will deallocate the underlying buckets array."

#: :1774
#, read-only, safe-html, strict-same
msgid ""
"Throws:;; The function has no effect if an exception is thrown, unless it is "
"thrown by the table's hash function or comparison function. Concurrency:;; "
"Blocking on `*this`. ---"
msgstr ""
"Throws:;; The function has no effect if an exception is thrown, unless it is "
"thrown by the table's hash function or comparison function. Concurrency:;; "
"Blocking on `*this`. ---"

#: :1778
#, read-only, safe-html, strict-same
msgid "reserve"
msgstr "reserve"

#: :1779
#, read-only, safe-html, strict-same
msgid "```c++ void reserve(size_type n); ```"
msgstr "```c++ void reserve(size_type n); ```"

#: :1783
#, read-only, safe-html, strict-same
msgid "Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`."
msgstr "Equivalent to `a.rehash(ceil(n / a.max_load_factor()))`."

#: :1785
#, read-only, safe-html, strict-same
msgid ""
"Similar to `rehash`, this function can be used to grow or shrink the number "
"of buckets in the table."
msgstr ""
"Similar to `rehash`, this function can be used to grow or shrink the number "
"of buckets in the table."

#: :1788
#, read-only, safe-html, strict-same
msgid ""
"Throws:;; The function has no effect if an exception is thrown, unless it is "
"thrown by the table's hash function or comparison function. Concurrency:;; "
"Blocking on `*this`."
msgstr ""
"Throws:;; The function has no effect if an exception is thrown, unless it is "
"thrown by the table's hash function or comparison function. Concurrency:;; "
"Blocking on `*this`."

#: :1791
#, read-only, safe-html, strict-same
msgctxt ":1791"
msgid "---"
msgstr "---"

#: :1793
#, read-only, safe-html, strict-same
msgid "Statistics"
msgstr "Statistics"

#: :1795
#, read-only, safe-html, strict-same
msgid "get_stats"
msgstr "get_stats"

#: :1796
#, read-only, safe-html, strict-same
msgid "```c++ stats get_stats() const; ```"
msgstr "```c++ stats get_stats() const; ```"

#: :1801
#, read-only, safe-html, strict-same
msgid ""
"Returns:;; A statistical description of the insertion and lookup operations "
"performed by the table so far. Notes:;; Only available if xref:reference/"
"stats.adoc#stats[statistics calculation] is "
"xref:concurrent_node_map_boost_unordered_enable_stats[enabled]."
msgstr ""
"Returns:;; A statistical description of the insertion and lookup operations "
"performed by the table so far. Notes:;; Only available if xref:reference/"
"stats.adoc#stats[statistics calculation] is "
"xref:concurrent_node_map_boost_unordered_enable_stats[enabled]."

#: :1804
#, read-only, safe-html, strict-same
msgctxt ":1804"
msgid "---"
msgstr "---"

#: :1806
#, read-only, safe-html, strict-same
msgid "reset_stats"
msgstr "reset_stats"

#: :1807
#, read-only, safe-html, strict-same
msgid "```c++ void reset_stats() noexcept; ```"
msgstr "```c++ void reset_stats() noexcept; ```"

#: :1812
#, read-only, safe-html, strict-same
msgid ""
"Effects:;; Sets to zero the internal statistics kept by the table. Notes:;; "
"Only available if xref:reference/stats.adoc#stats[statistics calculation] is "
"xref:concurrent_node_map_boost_unordered_enable_stats[enabled]."
msgstr ""
"Effects:;; Sets to zero the internal statistics kept by the table. Notes:;; "
"Only available if xref:reference/stats.adoc#stats[statistics calculation] is "
"xref:concurrent_node_map_boost_unordered_enable_stats[enabled]."

#: :1815
#, read-only, safe-html, strict-same
msgctxt ":1815"
msgid "---"
msgstr "---"

#: :1817
#, read-only, safe-html, strict-same
msgid "Deduction Guides"
msgstr "Deduction Guides"

#: :1818
#, read-only, safe-html, strict-same
msgid ""
"A deduction guide will not participate in overload resolution if any of the "
"following are true:"
msgstr ""
"A deduction guide will not participate in overload resolution if any of the "
"following are true:"

#: :1820
#, read-only, safe-html, strict-same
msgid ""
"- It has an `InputIterator` template parameter and a type that does not "
"qualify as an input iterator is deduced for that parameter. - It has an "
"`Allocator` template parameter and a type that does not qualify as an "
"allocator is deduced for that parameter. - It has a `Hash` template "
"parameter and an integral type or a type that qualifies as an allocator is "
"deduced for that parameter. - It has a `Pred` template parameter and a type "
"that qualifies as an allocator is deduced for that parameter."
msgstr ""
"- It has an `InputIterator` template parameter and a type that does not "
"qualify as an input iterator is deduced for that parameter. - It has an "
"`Allocator` template parameter and a type that does not qualify as an "
"allocator is deduced for that parameter. - It has a `Hash` template "
"parameter and an integral type or a type that qualifies as an allocator is "
"deduced for that parameter. - It has a `Pred` template parameter and a type "
"that qualifies as an allocator is deduced for that parameter."

#: :1825
#, read-only, safe-html, strict-same
msgid ""
"A `size_­type` parameter type in a deduction guide refers to the `size_­type` "
"member type of the table type deduced by the deduction guide. Its default "
"value coincides with the default value of the constructor selected."
msgstr ""
"A `size_­type` parameter type in a deduction guide refers to the `size_­type` "
"member type of the table type deduced by the deduction guide. Its default "
"value coincides with the default value of the constructor selected."

#: :1829
#, read-only, safe-html, strict-same
msgid "__iter-value-type__"
msgstr "__iter-value-type__"

#: :1837
#, read-only, safe-html, strict-same
msgid "__iter-key-type__"
msgstr "__iter-key-type__"

#: :1845
#, read-only, safe-html, strict-same
msgid "__iter-mapped-type__"
msgstr "__iter-mapped-type__"

#: :1853
#, read-only, safe-html, strict-same
msgid "__iter-to-alloc-type__"
msgstr "__iter-to-alloc-type__"

#: :1862
#, read-only, safe-html, strict-same
msgid "Equality Comparisons"
msgstr "Equality Comparisons"

#: :1864
#, read-only, safe-html, strict-same
msgid "operator"
msgstr "operator"

#: :1865
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class Key, class T, class Hash, class Pred, class Alloc> "
"bool operator==(const concurrent_node_map<Key, T, Hash, Pred, Alloc>& x, "
"const concurrent_node_map<Key, T, Hash, Pred, Alloc>& y); ```"
msgstr ""
"```c++ template<class Key, class T, class Hash, class Pred, class Alloc> "
"bool operator==(const concurrent_node_map<Key, T, Hash, Pred, Alloc>& x, "
"const concurrent_node_map<Key, T, Hash, Pred, Alloc>& y); ```"

#: :1871
#, read-only, safe-html, strict-same
msgid ""
"Returns `true` if `x.size() == y.size()` and for every element in `x`, there "
"is an element in `y` with the same key, with an equal value (using "
"`operator==` to compare the value types)."
msgstr ""
"Returns `true` if `x.size() == y.size()` and for every element in `x`, there "
"is an element in `y` with the same key, with an equal value (using "
"`operator==` to compare the value types)."

#: :1874
#, read-only, safe-html, strict-same
msgctxt ":1874"
msgid ""
"Concurrency:;; Blocking on `x` and `y`. Notes:;; Behavior is undefined if "
"the two tables don't have equivalent equality predicates."
msgstr ""
"Concurrency:;; Blocking on `x` and `y`. Notes:;; Behavior is undefined if "
"the two tables don't have equivalent equality predicates."

#: :1877
#, read-only, safe-html, strict-same
msgctxt ":1877"
msgid "---"
msgstr "---"

#: :1879
#, read-only, safe-html, strict-same
msgid "operator!"
msgstr "operator!"

#: :1880
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class Key, class T, class Hash, class Pred, class Alloc> "
"bool operator!=(const concurrent_node_map<Key, T, Hash, Pred, Alloc>& x, "
"const concurrent_node_map<Key, T, Hash, Pred, Alloc>& y); ```"
msgstr ""
"```c++ template<class Key, class T, class Hash, class Pred, class Alloc> "
"bool operator!=(const concurrent_node_map<Key, T, Hash, Pred, Alloc>& x, "
"const concurrent_node_map<Key, T, Hash, Pred, Alloc>& y); ```"

#: :1886
#, read-only, safe-html, strict-same
msgid ""
"Returns `false` if `x.size() == y.size()` and for every element in `x`, "
"there is an element in `y` with the same key, with an equal value (using "
"`operator==` to compare the value types)."
msgstr ""
"Returns `false` if `x.size() == y.size()` and for every element in `x`, "
"there is an element in `y` with the same key, with an equal value (using "
"`operator==` to compare the value types)."

#: :1889
#, read-only, safe-html, strict-same
msgctxt ":1889"
msgid ""
"Concurrency:;; Blocking on `x` and `y`. Notes:;; Behavior is undefined if "
"the two tables don't have equivalent equality predicates."
msgstr ""
"Concurrency:;; Blocking on `x` and `y`. Notes:;; Behavior is undefined if "
"the two tables don't have equivalent equality predicates."

#: :1892
#, read-only, safe-html, strict-same
msgctxt ":1892"
msgid "---"
msgstr "---"

#: :1894
#, read-only, safe-html, strict-same
msgid "Swap"
msgstr "Swap"

#: :1895
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class Key, class T, class Hash, class Pred, class Alloc> "
"void swap(concurrent_node_map<Key, T, Hash, Pred, Alloc>& x, "
"concurrent_node_map<Key, T, Hash, Pred, Alloc>& y) noexcept(noexcept(x.swap"
"(y))); ```"
msgstr ""
"```c++ template<class Key, class T, class Hash, class Pred, class Alloc> "
"void swap(concurrent_node_map<Key, T, Hash, Pred, Alloc>& x, "
"concurrent_node_map<Key, T, Hash, Pred, Alloc>& y) noexcept(noexcept(x.swap"
"(y))); ```"

#: :1902
#, read-only, safe-html, strict-same
msgctxt ":1902"
msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]"
msgstr "Equivalent to [listing,subs=\"+macros,+quotes\"]"

#: :1908
#, read-only, safe-html, strict-same
msgctxt ":1908"
msgid "---"
msgstr "---"

#: :1910
#, read-only, safe-html, strict-same
msgctxt ":1910"
msgid "erase_if"
msgstr "erase_if"

#: :1911
#, read-only, safe-html, strict-same
msgid ""
"```c++ template<class K, class T, class H, class P, class A, class "
"Predicate> typename concurrent_node_map<K, T, H, P, A>::size_type erase_if"
"(concurrent_node_map<K, T, H, P, A>& c, Predicate pred); ```"
msgstr ""
"```c++ template<class K, class T, class H, class P, class A, class "
"Predicate> typename concurrent_node_map<K, T, H, P, A>::size_type erase_if"
"(concurrent_node_map<K, T, H, P, A>& c, Predicate pred); ```"

#: :1917
#, read-only, safe-html, strict-same
msgctxt ":1917"
msgid "Equivalent to [listing,subs=\"+macros,+quotes\"]"
msgstr "Equivalent to [listing,subs=\"+macros,+quotes\"]"

#: :1923
#, read-only, safe-html, strict-same
msgid "Serialization"
msgstr "Serialization"

#: :1925
#, read-only, safe-html, strict-same
msgid ""
"``concurrent_node_map``s can be archived/retrieved by means of link:../../../"
"../../serialization/index.html[Boost.Serialization^] using the API provided "
"by this library. Both regular and XML archives are supported."
msgstr ""
"``concurrent_node_map``s can be archived/retrieved by means of link:../../../"
"../../serialization/index.html[Boost.Serialization^] using the API provided "
"by this library. Both regular and XML archives are supported."

#: :1929
#, read-only, safe-html, strict-same
msgid "Saving an concurrent_node_map to an archive"
msgstr "Saving an concurrent_node_map to an archive"

#: :1931
#, read-only, safe-html, strict-same
msgid ""
"Saves all the elements of a `concurrent_node_map` `x` to an archive (XML "
"archive) `ar`."
msgstr ""
"Saves all the elements of a `concurrent_node_map` `x` to an archive (XML "
"archive) `ar`."

#: :1934
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `std::remove_const<key_type>::type` and "
"`std::remove_const<mapped_type>::type` are serializable (XML serializable), "
"and they do support Boost.Serialization `save_construct_data`/"
"`load_construct_data` protocol (automatically suported by https://"
"en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^] types). Concurrency:;; Blocking "
"on `x`."
msgstr ""
"Requires:;; `std::remove_const<key_type>::type` and "
"`std::remove_const<mapped_type>::type` are serializable (XML serializable), "
"and they do support Boost.Serialization `save_construct_data`/"
"`load_construct_data` protocol (automatically suported by https://"
"en.cppreference.com/w/cpp/named_req/"
"DefaultConstructible[DefaultConstructible^] types). Concurrency:;; Blocking "
"on `x`."

#: :1941
#, read-only, safe-html, strict-same
msgctxt ":1941"
msgid "---"
msgstr "---"

#: :1943
#, read-only, safe-html, strict-same
msgid "Loading an concurrent_node_map from an archive"
msgstr "Loading an concurrent_node_map from an archive"

#: :1945
#, read-only, safe-html, strict-same
msgid ""
"Deletes all preexisting elements of a `concurrent_node_map` `x` and inserts "
"from an archive (XML archive) `ar` restored copies of the elements of the "
"original `concurrent_node_map` `other` saved to the storage read by `ar`."
msgstr ""
"Deletes all preexisting elements of a `concurrent_node_map` `x` and inserts "
"from an archive (XML archive) `ar` restored copies of the elements of the "
"original `concurrent_node_map` `other` saved to the storage read by `ar`."

#: :1950
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `x.key_equal()` is functionally equivalent to `other.key_equal()"
"`. Concurrency:;; Blocking on `x`."
msgstr ""
"Requires:;; `x.key_equal()` is functionally equivalent to `other.key_equal()"
"`. Concurrency:;; Blocking on `x`."
