msgid ""
msgstr ""
"Project-Id-Version: English (Boost Unordered Translation (zh_Hans))\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-06-06 23:54+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-set-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_set]"
msgstr "﻿[#concurrent_node_set]"

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

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

#: :6
#, read-only, safe-html, strict-same
msgid ""
"`boost::concurrent_node_set` — A node-based hash table that stores unique "
"values and allows for concurrent element insertion, erasure, lookup and "
"access without external synchronization mechanisms."
msgstr ""
"`boost::concurrent_node_set` — A node-based hash table that stores unique "
"values 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_set` 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 is done "
"through user-provided _visitation functions_ that are passed to "
"`concurrent_node_set` 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_set` 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 is done "
"through user-provided _visitation functions_ that are passed to "
"`concurrent_node_set` 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_set` is similar to "
"that of `boost::unordered_node_set`. Unlike `boost::concurrent_flat_set`, "
"pointer stability and node handling functionalities are provided, at the "
"expense of potentially lower performance."
msgstr ""
"The internal data structure of `boost::concurrent_node_set` is similar to "
"that of `boost::unordered_node_set`. Unlike `boost::concurrent_flat_set`, "
"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"

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

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

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

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

#: :303
#, read-only, safe-html, strict-same
msgid ""
"`Key` must be https://en.cppreference.com/w/cpp/named_req/"
"MoveInsertable[MoveInsertable^] into the container"
msgstr ""
"`Key` must be https://en.cppreference.com/w/cpp/named_req/"
"MoveInsertable[MoveInsertable^] into the container"

#: :307
#, read-only, safe-html, strict-same
msgid ""
"and https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] from the "
"container."
msgstr ""
"and https://en.cppreference.com/w/cpp/named_req/Erasable[Erasable^] from the "
"container."

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

#: :309
#, 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`."

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

#: :309
#, 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`."

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

#: :309
#, 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."

#: :317
#, read-only, safe-html, strict-same
msgid ""
"`std::allocator_traits<Allocator>::pointer` and "
"`std::allocator_traits<Allocator>::const_pointer` must be convertible to/"
"from `value_type*` and `const value_type*`, respectively."
msgstr ""
"`std::allocator_traits<Allocator>::pointer` and "
"`std::allocator_traits<Allocator>::const_pointer` must be convertible to/"
"from `value_type*` and `const value_type*`, respectively."

#: :322
#, 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."

#: :326
#, 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."

#: :331
#, 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."

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

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

#: :339
#, 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:"

#: :344
#, 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`"

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

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

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

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

#: :350
#, 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."

#: :353
#, 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_set` 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_set` do not introduce data races "
"— that is, they are thread-safe."

#: :356
#, 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_set`, prior blocking "
"operations on `x` synchronize with *op*. So, blocking operations on the same "
"`concurrent_node_set` 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_set`, prior blocking "
"operations on `x` synchronize with *op*. So, blocking operations on the same "
"`concurrent_node_set` execute sequentially in a multithreaded scenario."

#: :360
#, 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."

#: :363
#, read-only, safe-html, strict-same
msgid ""
"When executed internally by a `boost::concurrent_node_set`, 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_set`, the following "
"operations by a user-provided visitation function on the element passed do "
"not introduce data races:"

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

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

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

#: :369
#, 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."

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

#: :375
#, read-only, safe-html, strict-same
msgid ""
"Visitation functions executed by a `boost::concurrent_node_set` `x` are not "
"allowed to invoke any operation on `x`; invoking operations on a different "
"`boost::concurrent_node_set` 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_set` `x` are not "
"allowed to invoke any operation on `x`; invoking operations on a different "
"`boost::concurrent_node_set` instance `y` is allowed only if concurrent "
"outstanding operations on `y` do not access `x` directly or indirectly."

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

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

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

#: :385
#, 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."

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

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

#: :396
#, 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."

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

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

#: :408
#, 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]."

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

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

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

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

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

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

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

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

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

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

#: :449
#, 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."

#: :453
#, read-only, safe-html, strict-same
msgctxt ":453"
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^]."

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

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

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

#: :466
#, 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."

#: :470
#, read-only, safe-html, strict-same
msgctxt ":470"
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^]."

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

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

#: :486
#, 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."

#: :489
#, read-only, safe-html, strict-same
msgctxt ":489"
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^]."

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

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

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

#: :498
#, 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."

#: :500
#, 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."

#: :503
#, 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`."

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

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

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

#: :513
#, 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_set_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_set_boost_unordered_enable_stats[enabled], transfers "
"the internal statistical information from `other` and calls "
"`other.reset_stats()`."

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

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

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

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

#: :529
#, 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."

#: :532
#, read-only, safe-html, strict-same
msgctxt ":532"
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^]."

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

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

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

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

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

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

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

#: :550
#, 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`."

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

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

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

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

#: :562
#, 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_set_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_set_boost_unordered_enable_stats[enabled], transfers "
"the internal statistical information from `other` iff `a == "
"other.get_allocator()`, and always calls `other.reset_stats()`."

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

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

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

#: :576
#, read-only, safe-html, strict-same
msgid ""
"```c++ concurrent_node_set(unordered_node_set<Key, Hash, Pred, Allocator>&& "
"other); ```"
msgstr ""
"```c++ concurrent_node_set(unordered_node_set<Key, Hash, Pred, Allocator>&& "
"other); ```"

#: :580
#, read-only, safe-html, strict-same
msgid ""
"Move construction from a xref:#unordered_node_set[`unordered_node_set`]. 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_set_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_set[`unordered_node_set`]. 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_set_boost_unordered_enable_stats[enabled], transfers "
"the internal statistical information from `other` and calls "
"`other.reset_stats()`."

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

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

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

#: :601
#, 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."

#: :604
#, read-only, safe-html, strict-same
msgctxt ":604"
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^]."

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

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

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

#: :613
#, 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."

#: :616
#, 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^]."

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

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

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

#: :626
#, 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."

#: :629
#, 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^]."

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

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

#: :641
#, 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."

#: :644
#, read-only, safe-html, strict-same
msgctxt ":644"
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^]."

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

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

#: :656
#, 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."

#: :659
#, read-only, safe-html, strict-same
msgctxt ":659"
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^]."

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

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

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

#: :669
#, 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."

#: :672
#, read-only, safe-html, strict-same
msgctxt ":672"
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^]."

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

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

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

#: :682
#, 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."

#: :685
#, read-only, safe-html, strict-same
msgctxt ":685"
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^]."

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

#: :689
#, 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"

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

#: :696
#, 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."

#: :699
#, read-only, safe-html, strict-same
msgctxt ":699"
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^]."

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

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

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

#: :710
#, 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"

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

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

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

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

#: :722
#, 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`."

#: :727
#, 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`."

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

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

#: :733
#, read-only, safe-html, strict-same
msgid ""
"```c++ concurrent_node_set& operator=(concurrent_node_set&& other) noexcept"
"(boost::allocator_traits<Allocator>::is_always_equal::value || "
"boost::allocator_traits<Allocator>"
"::propagate_on_container_move_assignment::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_set_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_set& operator=(concurrent_node_set&& other) noexcept"
"(boost::allocator_traits<Allocator>::is_always_equal::value || "
"boost::allocator_traits<Allocator>"
"::propagate_on_container_move_assignment::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_set_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()`."

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

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

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

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

#: :756
#, 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."

#: :759
#, 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`."

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

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

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

#: :768
#, 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; ```"

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

#: :780
#, 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."

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

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

#: :787
#, 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; ```"

#: :796
#, 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 const "
"reference to `x`."
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 const "
"reference to `x`."

#: :800
#, read-only, safe-html, strict-same
msgid ""
"Although functionally equivalent to individually invoking "
"xref:concurrent_node_set_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_set_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_set_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_set_constants[`bulk_visit_size`] to enjoy a "
"performance gain: beyond this size, performance is not expected to increase "
"further."

#: :809
#, 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."

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

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

#: :822
#, 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; ```"

#: :828
#, read-only, safe-html, strict-same
msgid ""
"Successively invokes `f` with const references to each of the elements in "
"the table."
msgstr ""
"Successively invokes `f` with const references to each of the elements in "
"the table."

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

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

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

#: :837
#, 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; ```"

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

#: :847
#, 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."

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

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

#: :858
#, 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; ```"

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

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

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

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

#: :874
#, 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; ```"

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

#: :885
#, 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`."

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

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

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

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

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

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

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

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

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

#: :921
#, 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."

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

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

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

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

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

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

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

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

#: :944
#, 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."

#: :947
#, 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`."
msgstr ""
"Requires:;; `value_type` is constructible from `args`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`."

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

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

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

#: :958
#, read-only, safe-html, strict-same
msgctxt ":958"
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."

#: :961
#, read-only, safe-html, strict-same
msgctxt ":961"
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`."
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`."

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

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

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

#: :972
#, read-only, safe-html, strict-same
msgctxt ":972"
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."

#: :975
#, 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`."
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`."

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

#: :981
#, read-only, safe-html, strict-same
msgid "Transparent Insert"
msgstr "Transparent Insert"

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

#: :986
#, read-only, safe-html, strict-same
msgid ""
"Inserts an element constructed from `std::forward<K>(k)` in the container if "
"and only if there is no element in the container with an equivalent key."
msgstr ""
"Inserts an element constructed from `std::forward<K>(k)` in the container if "
"and only if there is no element in the container with an equivalent key."

#: :989
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`. "
"Notes:;; This 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 ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`. "
"Notes:;; This 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."

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

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

#: :997
#, 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); ```"

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

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

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

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

#: :1013
#, 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); ```"

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

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

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

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

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

#: :1033
#, 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.value()"
"`. `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.value()"
"`. `nh` is empty when the function returns."

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

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

#: :1039
#, read-only, safe-html, strict-same
msgctxt ":1039"
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."

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

#: :1041
#, 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."

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

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

#: :1048
#, 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); ```"

#: :1053
#, 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 const reference to the equivalent element."
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 const reference to the equivalent element."

#: :1057
#, 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."

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

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

#: :1065
#, 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); ```"
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); ```"

#: :1070
#, read-only, safe-html, strict-same
msgctxt ":1070"
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 const reference to the "
"equivalent element."
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 const reference to the "
"equivalent element."

#: :1074
#, read-only, safe-html, strict-same
msgctxt ":1074"
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`."
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`."

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

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

#: :1081
#, 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); ```"
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); ```"

#: :1086
#, read-only, safe-html, strict-same
msgctxt ":1086"
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 const reference to the "
"equivalent element."
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 const reference to the "
"equivalent element."

#: :1090
#, read-only, safe-html, strict-same
msgctxt ":1090"
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`."
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`."

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

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

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

#: :1102
#, read-only, safe-html, strict-same
msgid ""
"Inserts an element constructed from `std::forward<K>(k)` in the container if "
"and only if there is no element in the container with an equivalent key. "
"Otherwise, invokes `f` with a const reference to the equivalent element."
msgstr ""
"Inserts an element constructed from `std::forward<K>(k)` in the container if "
"and only if there is no element in the container with an equivalent key. "
"Otherwise, invokes `f` with a const reference to the equivalent element."

#: :1106
#, read-only, safe-html, strict-same
msgctxt ":1106"
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`. "
"Notes:;; These overloads only participate in overload resolution if "
"`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. "
"The library assumes that `Hash` is callable with both `K` and `Key` and that "
"`Pred` is transparent. This enables heterogeneous lookup which avoids the "
"cost of instantiating an instance of the `Key` type."
msgstr ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`. "
"Notes:;; These overloads only participate in overload resolution if "
"`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. "
"The library assumes that `Hash` is callable with both `K` and `Key` and that "
"`Pred` is transparent. This enables heterogeneous lookup which avoids the "
"cost of instantiating an instance of the `Key` type."

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

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

#: :1114
#, 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); ```"

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

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

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

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

#: :1133
#, 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); ```"

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

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

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

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

#: :1150
#, 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); ```"

#: :1155
#, 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.value()`. Otherwise, invokes `f` with a const reference to "
"the equivalent element."
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.value()`. Otherwise, invokes `f` with a const reference to "
"the equivalent element."

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

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

#: :1162
#, read-only, safe-html, strict-same
msgctxt ":1162"
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."

#: :1163
#, read-only, safe-html, strict-same
msgctxt ":1163"
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`."

#: :1164
#, 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."

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

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

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

#: :1178
#, 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 const reference to the newly created element. Otherwise, invokes "
"`f2` with a const reference to the equivalent element."
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 const reference to the newly created element. Otherwise, invokes "
"`f2` with a const reference to the equivalent element."

#: :1183
#, 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."

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

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

#: :1191
#, 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 f2, 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 f2, F2 f2); ```"

#: :1196
#, read-only, safe-html, strict-same
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 const reference to the "
"newly created element. Otherwise, invokes `f` with a const reference to the "
"equivalent element."
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 const reference to the "
"newly created element. Otherwise, invokes `f` with a const reference to the "
"equivalent element."

#: :1201
#, read-only, safe-html, strict-same
msgctxt ":1201"
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`."
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`."

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

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

#: :1208
#, 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); ```"
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); ```"

#: :1213
#, read-only, safe-html, strict-same
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 const reference to the "
"newly created element. Otherwise, invokes `f2` with a const reference to the "
"equivalent element."
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 const reference to the "
"newly created element. Otherwise, invokes `f2` with a const reference to the "
"equivalent element."

#: :1218
#, read-only, safe-html, strict-same
msgctxt ":1218"
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`."
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`."

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

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

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

#: :1230
#, read-only, safe-html, strict-same
msgid ""
"Inserts an element constructed from `std::forward<K>(k)` in the container if "
"and only if there is no element in the container with an equivalent key, and "
"then invokes `f1` with a const reference to the newly created element. "
"Otherwise, invokes `f2` with a const reference to the equivalent element."
msgstr ""
"Inserts an element constructed from `std::forward<K>(k)` in the container if "
"and only if there is no element in the container with an equivalent key, and "
"then invokes `f1` with a const reference to the newly created element. "
"Otherwise, invokes `f2` with a const reference to the equivalent element."

#: :1235
#, read-only, safe-html, strict-same
msgctxt ":1235"
msgid ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`. "
"Notes:;; These overloads only participate in overload resolution if "
"`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. "
"The library assumes that `Hash` is callable with both `K` and `Key` and that "
"`Pred` is transparent. This enables heterogeneous lookup which avoids the "
"cost of instantiating an instance of the `Key` type."
msgstr ""
"Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/"
"EmplaceConstructible[EmplaceConstructible^] from `k`. Returns:;; `true` if "
"an insert took place. Concurrency:;; Blocking on rehashing of `*this`. "
"Notes:;; These overloads only participate in overload resolution if "
"`Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. "
"The library assumes that `Hash` is callable with both `K` and `Key` and that "
"`Pred` is transparent. This enables heterogeneous lookup which avoids the "
"cost of instantiating an instance of the `Key` type."

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

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

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

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

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

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

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

#: :1262
#, 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); ```"

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

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

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

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

#: :1281
#, 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); ```"

#: :1288
#, 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.value()`, and then invokes `f1` with a const reference to "
"the newly inserted element. Otherwise, invokes `f2` with a const reference "
"to the equivalent element."
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.value()`, and then invokes `f1` with a const reference to "
"the newly inserted element. Otherwise, invokes `f2` with a const reference "
"to the equivalent element."

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

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

#: :1296
#, read-only, safe-html, strict-same
msgctxt ":1296"
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."

#: :1297
#, read-only, safe-html, strict-same
msgctxt ":1297"
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`."

#: :1298
#, 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."

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

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

#: :1305
#, 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); ```"

#: :1310
#, 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."

#: :1313
#, 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."

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

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

#: :1320
#, 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); ```"

#: :1325
#, 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`."

#: :1328
#, 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:;; 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:;; 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."

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

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

#: :1337
#, 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); ```"

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

#: :1344
#, 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`."

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

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

#: :1350
#, 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); ```"

#: :1354
#, read-only, safe-html, strict-same
msgid ""
"Invokes `f` with 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 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."

#: :1358
#, 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."

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

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

#: :1368
#, read-only, safe-html, strict-same
msgid ""
"```c++ void swap(concurrent_node_set& 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_set& other) noexcept"
"(boost::allocator_traits<Allocator>::is_always_equal::value || "
"boost::allocator_traits<Allocator>::propagate_on_container_swap::value); ```"

#: :1374
#, 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."

#: :1376
#, 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."

#: :1379
#, 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`."

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

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

#: :1385
#, 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); ```"

#: :1390
#, 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."

#: :1393
#, 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."

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

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

#: :1400
#, 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); ```"

#: :1405
#, 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`."

#: :1408
#, 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."

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

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

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

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

#: :1422
#, 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`."

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

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

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

#: :1435
#, 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`."

#: :1438
#, 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`."

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: :1475
#, read-only, safe-html, strict-same
msgid "Set Operations"
msgstr "Set Operations"

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

#: :1478
#, 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; ```"

#: :1485
#, 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."

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

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

#: :1494
#, 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; ```"

#: :1501
#, 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."

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

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

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

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

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

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

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

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

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

#: :1528
#, 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`."

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

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

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

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

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

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

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

#: :1549
#, 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_set`."
msgstr ""
"Effects:;; Does nothing, as the user is not allowed to change this "
"parameter. Kept for compatibility with `boost::unordered_set`."

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

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

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

#: :1561
#, 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."

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

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

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

#: :1575
#, 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."

#: :1577
#, 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."

#: :1580
#, 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`. ---"

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

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

#: :1589
#, 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()))`."

#: :1591
#, 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."

#: :1594
#, 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`."

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

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

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

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

#: :1607
#, 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_set_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_set_boost_unordered_enable_stats[enabled]."

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

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

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

#: :1618
#, 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_set_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_set_boost_unordered_enable_stats[enabled]."

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

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

#: :1624
#, 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:"

#: :1626
#, 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."

#: :1631
#, 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 container 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 container type deduced by the deduction guide. Its "
"default value coincides with the default value of the constructor selected."

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

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

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

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

#: :1652
#, 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)."

#: :1655
#, read-only, safe-html, strict-same
msgctxt ":1655"
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."

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

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

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

#: :1667
#, 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)."

#: :1670
#, read-only, safe-html, strict-same
msgctxt ":1670"
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."

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

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

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

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

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

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

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

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

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

#: :1706
#, read-only, safe-html, strict-same
msgid ""
"``concurrent_node_set``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_set``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."

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

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

#: :1715
#, read-only, safe-html, strict-same
msgid ""
"Requires:;; `value_type` is serializable (XML serializable), and it supports "
"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:;; `value_type` is serializable (XML serializable), and it supports "
"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`."

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

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

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

#: :1730
#, 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`."
