diff --git a/doc/ref.xml b/doc/ref.xml
index 05f23c87..ebfb3240 100644
--- a/doc/ref.xml
+++ b/doc/ref.xml
@@ -840,6 +840,38 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+
+
+
+ K&&
+
+ node_type
+
+ 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.
+
+
+
+ A node_type owning the element if found, otherwise an empty node_type.
+
+
+ Only throws an exception if it is thrown by hasher or key_equal.
+
+
+
+ In C++17 a node extracted using this method can be inserted into a compatible unordered_multiset,
+ but that is not supported yet.
+
+
+
node_type&&
@@ -951,6 +983,32 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Only throws an exception if it is thrown by hasher or key_equal.
+
+
+
+
+
+ K&&
+
+ size_type
+
+ The number of elements erased.
+
+
+ Only throws an exception if it is thrown by hasher or key_equal.
+
+
+ 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.
+
+
+
const_iterator
@@ -1099,6 +1157,24 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
const_iterator
+
+
+
+
+
+ K const&
+
+ iterator
+
+
+
+
+
+
+ K const&
+
+ const_iterator
+
@@ -1136,22 +1212,58 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
An iterator pointing to an element with key equivalent to k, or b.end() if no such element exists.
-
- The templated overloads are a non-standard extensions which
- allows you to use a compatible hash function and equality
- predicate for a key of a different type in order to avoid
- an expensive type cast. In general, its use is not encouraged.
-
-
-
-
- key_type const&
-
- size_type
+
+
+ The templated overloads containing CompatibleKey,
+ CompatibleHash and CompatiblePredicate
+ are non-standard extensions which allow you to use a compatible
+ hash function and equality predicate for a key of a different type
+ in order to avoid an expensive type cast. In general, its use is
+ not encouraged and instead the K member function
+ templates should be used.
+
+
+ The template <typename K> 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.
+
+
+
+
+
+
+ key_type const&
+
+ size_type
+
+
+
+
+
+
+ K const&
+
+ size_type
+
The number of elements with key equivalent to k.
-
+
+
+ The template <typename 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.
+
+
+
@@ -1165,12 +1277,41 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
std::pair<const_iterator, const_iterator>
+
+
+
+
+
+ K const&
+
+ std::pair<iterator, iterator>
+
+
+
+
+
+
+ K const&
+
+ std::pair<const_iterator, const_iterator>
+
A range containing all elements with key equivalent to k.
- If the container doesn't container any such elements, returns
+ If the container doesn't contain any such elements, returns
std::make_pair(b.end(),b.end()).
-
+
+
+
+ The template <typename K> 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.
+
+
@@ -2254,6 +2395,38 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+
+
+
+ K&&
+
+ node_type
+
+ 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.
+
+
+
+ A node_type owning the element if found, otherwise an empty node_type.
+
+
+ Only throws an exception if it is thrown by hasher or key_equal.
+
+
+
+ In C++17 a node extracted using this method can be inserted into a compatible unordered_set,
+ but that is not supported yet.
+
+
+
node_type&&
@@ -2349,6 +2522,32 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Only throws an exception if it is thrown by hasher or key_equal.
+
+
+
+
+
+ K&&
+
+ size_type
+
+ The number of elements erased.
+
+
+ Only throws an exception if it is thrown by hasher or key_equal.
+
+
+ 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.
+
+
+
const_iterator
@@ -2497,6 +2696,24 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
const_iterator
+
+
+
+
+
+ K const&
+
+ iterator
+
+
+
+
+
+
+ K const&
+
+ const_iterator
+
@@ -2534,22 +2751,58 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
An iterator pointing to an element with key equivalent to k, or b.end() if no such element exists.
-
- The templated overloads are a non-standard extensions which
- allows you to use a compatible hash function and equality
- predicate for a key of a different type in order to avoid
- an expensive type cast. In general, its use is not encouraged.
-
-
-
-
- key_type const&
-
- size_type
+
+
+ The templated overloads containing CompatibleKey,
+ CompatibleHash and CompatiblePredicate
+ are non-standard extensions which allow you to use a compatible
+ hash function and equality predicate for a key of a different type
+ in order to avoid an expensive type cast. In general, its use is
+ not encouraged and instead the K member function
+ templates should be used.
+
+
+ The template <typename K> 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.
+
+
+
+
+
+
+ key_type const&
+
+ size_type
+
+
+
+
+
+
+ K const&
+
+ size_type
+
The number of elements with key equivalent to k.
-
+
+
+ The template <typename 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.
+
+
+
@@ -2563,12 +2816,41 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
std::pair<const_iterator, const_iterator>
+
+
+
+
+
+ K const&
+
+ std::pair<iterator, iterator>
+
+
+
+
+
+
+ K const&
+
+ std::pair<const_iterator, const_iterator>
+
A range containing all elements with key equivalent to k.
- If the container doesn't container any such elements, returns
+ If the container doesn't contain any such elements, returns
std::make_pair(b.end(),b.end()).
-
+
+
+
+ The template <typename K> 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.
+
+
@@ -3757,6 +4039,38 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+
+
+
+ K&&
+
+ node_type
+
+ 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.
+
+
+
+ A node_type owning the element if found, otherwise an empty node_type.
+
+
+ Only throws an exception if it is thrown by hasher or key_equal.
+
+
+
+ In C++17 a node extracted using this method can be inserted into a compatible unordered_multimap,
+ but that is not supported yet.
+
+
+
node_type&&
@@ -3868,6 +4182,32 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Only throws an exception if it is thrown by hasher or key_equal.
+
+
+
+
+
+ K&&
+
+ size_type
+
+ The number of elements erased.
+
+
+ Only throws an exception if it is thrown by hasher or key_equal.
+
+
+ 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.
+
+
+
const_iterator
@@ -4016,6 +4356,24 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
const_iterator
+
+
+
+
+
+ K const&
+
+ iterator
+
+
+
+
+
+
+ K const&
+
+ const_iterator
+
@@ -4053,22 +4411,58 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
An iterator pointing to an element with key equivalent to k, or b.end() if no such element exists.
-
- The templated overloads are a non-standard extensions which
- allows you to use a compatible hash function and equality
- predicate for a key of a different type in order to avoid
- an expensive type cast. In general, its use is not encouraged.
-
-
-
-
- key_type const&
-
- size_type
+
+
+ The templated overloads containing CompatibleKey,
+ CompatibleHash and CompatiblePredicate
+ are non-standard extensions which allow you to use a compatible
+ hash function and equality predicate for a key of a different type
+ in order to avoid an expensive type cast. In general, its use is
+ not encouraged and instead the K member function
+ templates should be used.
+
+
+ The template <typename K> 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.
+
+
+
+
+
+
+ key_type const&
+
+ size_type
+
+
+
+
+
+
+ K const&
+
+ size_type
+
The number of elements with key equivalent to k.
-
+
+
+ The template <typename 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.
+
+
+
@@ -4082,12 +4476,41 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
std::pair<const_iterator, const_iterator>
+
+
+
+
+
+ K const&
+
+ std::pair<iterator, iterator>
+
+
+
+
+
+
+ K const&
+
+ std::pair<const_iterator, const_iterator>
+
A range containing all elements with key equivalent to k.
- If the container doesn't container any such elements, returns
+ If the container doesn't contain any such elements, returns
std::make_pair(b.end(),b.end()).
-
+
+
+
+ The template <typename K> 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.
+
+
@@ -5218,6 +5641,38 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+
+
+
+ K&&
+
+ node_type
+
+ 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.
+
+
+
+ A node_type owning the element if found, otherwise an empty node_type.
+
+
+ Only throws an exception if it is thrown by hasher or key_equal.
+
+
+
+ In C++17 a node extracted using this method can be inserted into a compatible unordered_map,
+ but that is not supported yet.
+
+
+
node_type&&
@@ -5313,6 +5768,32 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Only throws an exception if it is thrown by hasher or key_equal.
+
+
+
+
+
+ K&&
+
+ size_type
+
+ The number of elements erased.
+
+
+ Only throws an exception if it is thrown by hasher or key_equal.
+
+
+ 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.
+
+
+
const_iterator
@@ -5461,6 +5942,24 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
const_iterator
+
+
+
+
+
+ K const&
+
+ iterator
+
+
+
+
+
+
+ K const&
+
+ const_iterator
+
@@ -5498,22 +5997,58 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
An iterator pointing to an element with key equivalent to k, or b.end() if no such element exists.
-
- The templated overloads are a non-standard extensions which
- allows you to use a compatible hash function and equality
- predicate for a key of a different type in order to avoid
- an expensive type cast. In general, its use is not encouraged.
-
-
-
-
- key_type const&
-
- size_type
+
+
+ The templated overloads containing CompatibleKey,
+ CompatibleHash and CompatiblePredicate
+ are non-standard extensions which allow you to use a compatible
+ hash function and equality predicate for a key of a different type
+ in order to avoid an expensive type cast. In general, its use is
+ not encouraged and instead the K member function
+ templates should be used.
+
+
+ The template <typename K> 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.
+
+
+
+
+
+
+ key_type const&
+
+ size_type
+
+
+
+
+
+
+ K const&
+
+ size_type
+
The number of elements with key equivalent to k.
-
+
+
+ The template <typename 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.
+
+
+
@@ -5527,12 +6062,41 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
std::pair<const_iterator, const_iterator>
+
+
+
+
+
+ K const&
+
+ std::pair<iterator, iterator>
+
+
+
+
+
+
+ K const&
+
+ std::pair<const_iterator, const_iterator>
+
A range containing all elements with key equivalent to k.
- If the container doesn't container any such elements, returns
+ If the container doesn't contain any such elements, returns
std::make_pair(b.end(),b.end()).
-
+
+
+
+ The template <typename K> 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.
+
+