diff --git a/doc/unordered/unordered_multimap.adoc b/doc/unordered/unordered_multimap.adoc index 9237d747..bc80967f 100644 --- a/doc/unordered/unordered_multimap.adoc +++ b/doc/unordered/unordered_multimap.adoc @@ -111,14 +111,14 @@ namespace boost { node_type xref:#unordered_multimap_extract_by_iterator[extract](const_iterator position); node_type xref:#unordered_multimap_extract_by_key[extract](const key_type& k); - template node_type xref:#unordered_multimap_transparent_extract_by_key[extract](K&& k); + template node_type xref:#unordered_multimap_extract_by_key[extract](K&& k); iterator xref:#unordered_multimap_insert_with_node_handle[insert](node_type&& nh); iterator xref:#unordered_multimap_insert_with_hint_and_node_handle[insert](const_iterator hint, node_type&& nh); iterator xref:#unordered_multimap_erase_by_position[erase](iterator position); iterator xref:#unordered_multimap_erase_by_position[erase](const_iterator position); size_type xref:#unordered_multimap_erase_by_key[erase](const key_type& k); - template size_type xref:#unordered_multimap_transparent_erase_by_key[erase](K&& k); + template size_type xref:#unordered_multimap_erase_by_key[erase](K&& k); iterator xref:#unordered_multimap_erase_range[erase](const_iterator first, const_iterator last); void xref:#unordered_multimap_quick_erase[quick_erase](const_iterator position); void xref:#unordered_multimap_erase_return_void[erase_return_void](const_iterator position); @@ -172,6 +172,7 @@ namespace boost { size_type xref:#unordered_multimap_max_bucket_count[max_bucket_count]() const noexcept; size_type xref:#unordered_multimap_bucket_size[bucket_size](size_type n) const; size_type xref:#unordered_multimap_bucket[bucket](const key_type& k) const; + template size_type xref:#unordered_multimap_bucket[bucket](const K& k) const; local_iterator xref:#unordered_multimap_begin_2[begin](size_type n); const_local_iterator xref:#unordered_multimap_begin_2[begin](size_type n) const; local_iterator xref:#unordered_multimap_end_2[end](size_type n); @@ -964,30 +965,17 @@ Notes:;; A node extracted using this method can be inserted into a compatible `u ==== Extract by Key ```c++ node_type extract(const key_type& k); -``` - -Removes an element with key equivalent to `k`. - -[horizontal] -Returns:;; A `node_type` owning the element if found, otherwise an empty `node_type`. -Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. -Notes:;; A node extracted using this method can be inserted into a compatible `unordered_map`. - ---- - -==== Transparent Extract by Key -```c++ template node_type extract(K&& k); ``` Removes an element with key equivalent to `k`. -This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. 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. - [horizontal] Returns:;; A `node_type` owning the element if found, otherwise an empty `node_type`. Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. -Notes:;; A node extracted using this method can be inserted into a compatible `unordered_map`. +Notes:;; A node extracted using this method can be inserted into a compatible `unordered_map`. + ++ +The `template` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. 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. --- @@ -1060,28 +1048,15 @@ Notes:;; In older versions this could be inefficient because it had to search th ==== Erase by Key ```c++ size_type erase(const key_type& k); -``` - -Erase all elements with key equivalent to `k`. - -[horizontal] -Returns:;; The number of elements erased. -Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. - ---- - -==== Transparent Erase by Key -```c++ template size_type erase(K&& k); ``` Erase all elements with key equivalent to `k`. -This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. 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. - [horizontal] Returns:;; The number of elements erased. Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`. +Notes:;; The `template` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. 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. --- @@ -1330,11 +1305,13 @@ Returns:;; The number of elements in bucket `n`. ==== bucket ```c++ size_type bucket(const key_type& k) const; +templat size_type bucket(const K& k) const; ``` [horizontal] Returns:;; The index of the bucket which would contain an element with key `k`. Postconditions:;; The return value is less than `bucket_count()`. +Notes:;; The `template` 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. ---