mirror of
https://github.com/boostorg/unordered.git
synced 2025-07-29 19:07:15 +02:00
Update ref.xml
This commit is contained in:
Christian Mazakas
684
doc/ref.xml
684
doc/ref.xml
@ -840,6 +840,38 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</para>
|
||||
</notes>
|
||||
</method>
|
||||
<method name="extract">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K&&</paramtype>
|
||||
</parameter>
|
||||
<type>node_type</type>
|
||||
<description>
|
||||
<para>Removes an element with key equivalent to <code>k</code>.</para>
|
||||
<para>
|
||||
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
|
||||
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
|
||||
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
|
||||
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
|
||||
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</description>
|
||||
<returns>
|
||||
<para>A <code>node_type</code> owning the element if found, otherwise an empty <code>node_type</code>.</para>
|
||||
</returns>
|
||||
<throws>
|
||||
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
|
||||
</throws>
|
||||
<notes>
|
||||
<para>
|
||||
In C++17 a node extracted using this method can be inserted into a compatible <code>unordered_multiset</code>,
|
||||
but that is not supported yet.
|
||||
</para>
|
||||
</notes>
|
||||
</method>
|
||||
<method name="insert">
|
||||
<parameter name="nh">
|
||||
<paramtype>node_type&&</paramtype>
|
||||
@ -951,6 +983,32 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
|
||||
</throws>
|
||||
</method>
|
||||
<method name="erase">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K&&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
<returns>
|
||||
<para>The number of elements erased.</para>
|
||||
</returns>
|
||||
<throws>
|
||||
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
|
||||
</throws>
|
||||
<description>
|
||||
<para>Erase all elements with key equivalent to <code>k</code>.</para>
|
||||
<para>
|
||||
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
|
||||
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
|
||||
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
|
||||
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
|
||||
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</description>
|
||||
</method>
|
||||
<method name="erase">
|
||||
<parameter name="first">
|
||||
<paramtype>const_iterator</paramtype>
|
||||
@ -1099,6 +1157,24 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</parameter>
|
||||
<type>const_iterator</type>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>iterator</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>const_iterator</type>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="CompatibleKey"/>
|
||||
@ -1136,22 +1212,58 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
<returns>
|
||||
<para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para>
|
||||
</returns>
|
||||
<notes><para>
|
||||
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.
|
||||
</para></notes>
|
||||
</overloaded-method>
|
||||
<method name="count" cv="const">
|
||||
<parameter name="k">
|
||||
<paramtype>key_type const&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
<notes>
|
||||
<para>
|
||||
The templated overloads containing <code>CompatibleKey</code>,
|
||||
<code>CompatibleHash</code> and <code>CompatiblePredicate</code>
|
||||
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 <code>K</code> member function
|
||||
templates should be used.
|
||||
</para>
|
||||
<para>
|
||||
The <code>template <typename K></code> overloads only participate
|
||||
in overload resolution if <code>Hash::is_transparent</code> and
|
||||
<code>Pred::is_transparent</code> are valid member typedefs. The
|
||||
library assumes that <code>Hash</code> is callable with both
|
||||
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
|
||||
transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</notes>
|
||||
</overloaded-method>
|
||||
<overloaded-method name="count">
|
||||
<signature cv="const">
|
||||
<parameter name="k">
|
||||
<paramtype>key_type const&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
</signature>
|
||||
<returns>
|
||||
<para>The number of elements with key equivalent to <code>k</code>.</para>
|
||||
</returns>
|
||||
</method>
|
||||
<notes>
|
||||
<para>
|
||||
The <code>template <typename K></code> overload only participates
|
||||
in overload resolution if <code>Hash::is_transparent</code> and
|
||||
<code>Pred::is_transparent</code> are valid member typedefs. The
|
||||
library assumes that <code>Hash</code> is callable with both
|
||||
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
|
||||
transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</notes>
|
||||
</overloaded-method>
|
||||
<overloaded-method name="equal_range">
|
||||
<signature>
|
||||
<parameter name="k">
|
||||
@ -1165,12 +1277,41 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</parameter>
|
||||
<type>std::pair<const_iterator, const_iterator></type>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>std::pair<iterator, iterator></type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>std::pair<const_iterator, const_iterator></type>
|
||||
</signature>
|
||||
<returns>
|
||||
<para>A range containing all elements with key equivalent to <code>k</code>.
|
||||
If the container doesn't container any such elements, returns
|
||||
If the container doesn't contain any such elements, returns
|
||||
<code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>.
|
||||
</para>
|
||||
</para>
|
||||
</returns>
|
||||
<notes>
|
||||
<para>
|
||||
The <code>template <typename K></code> overloads only participate
|
||||
in overload resolution if <code>Hash::is_transparent</code> and
|
||||
<code>Pred::is_transparent</code> are valid member typedefs. The
|
||||
library assumes that <code>Hash</code> is callable with both
|
||||
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
|
||||
transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</notes>
|
||||
</overloaded-method>
|
||||
</method-group>
|
||||
<method-group name="bucket interface">
|
||||
@ -2254,6 +2395,38 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</para>
|
||||
</notes>
|
||||
</method>
|
||||
<method name="extract">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K&&</paramtype>
|
||||
</parameter>
|
||||
<type>node_type</type>
|
||||
<description>
|
||||
<para>Removes an element with key equivalent to <code>k</code>.</para>
|
||||
<para>
|
||||
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
|
||||
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
|
||||
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
|
||||
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
|
||||
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</description>
|
||||
<returns>
|
||||
<para>A <code>node_type</code> owning the element if found, otherwise an empty <code>node_type</code>.</para>
|
||||
</returns>
|
||||
<throws>
|
||||
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
|
||||
</throws>
|
||||
<notes>
|
||||
<para>
|
||||
In C++17 a node extracted using this method can be inserted into a compatible <code>unordered_set</code>,
|
||||
but that is not supported yet.
|
||||
</para>
|
||||
</notes>
|
||||
</method>
|
||||
<method name="insert">
|
||||
<parameter name="nh">
|
||||
<paramtype>node_type&&</paramtype>
|
||||
@ -2349,6 +2522,32 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
|
||||
</throws>
|
||||
</method>
|
||||
<method name="erase">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K&&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
<returns>
|
||||
<para>The number of elements erased.</para>
|
||||
</returns>
|
||||
<throws>
|
||||
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
|
||||
</throws>
|
||||
<description>
|
||||
<para>Erase all elements with key equivalent to <code>k</code>.</para>
|
||||
<para>
|
||||
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
|
||||
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
|
||||
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
|
||||
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
|
||||
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</description>
|
||||
</method>
|
||||
<method name="erase">
|
||||
<parameter name="first">
|
||||
<paramtype>const_iterator</paramtype>
|
||||
@ -2497,6 +2696,24 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</parameter>
|
||||
<type>const_iterator</type>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>iterator</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>const_iterator</type>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="CompatibleKey"/>
|
||||
@ -2534,22 +2751,58 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
<returns>
|
||||
<para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para>
|
||||
</returns>
|
||||
<notes><para>
|
||||
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.
|
||||
</para></notes>
|
||||
</overloaded-method>
|
||||
<method name="count" cv="const">
|
||||
<parameter name="k">
|
||||
<paramtype>key_type const&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
<notes>
|
||||
<para>
|
||||
The templated overloads containing <code>CompatibleKey</code>,
|
||||
<code>CompatibleHash</code> and <code>CompatiblePredicate</code>
|
||||
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 <code>K</code> member function
|
||||
templates should be used.
|
||||
</para>
|
||||
<para>
|
||||
The <code>template <typename K></code> overloads only participate
|
||||
in overload resolution if <code>Hash::is_transparent</code> and
|
||||
<code>Pred::is_transparent</code> are valid member typedefs. The
|
||||
library assumes that <code>Hash</code> is callable with both
|
||||
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
|
||||
transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</notes>
|
||||
</overloaded-method>
|
||||
<overloaded-method name="count">
|
||||
<signature cv="const">
|
||||
<parameter name="k">
|
||||
<paramtype>key_type const&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
</signature>
|
||||
<returns>
|
||||
<para>The number of elements with key equivalent to <code>k</code>.</para>
|
||||
</returns>
|
||||
</method>
|
||||
<notes>
|
||||
<para>
|
||||
The <code>template <typename K></code> overload only participates
|
||||
in overload resolution if <code>Hash::is_transparent</code> and
|
||||
<code>Pred::is_transparent</code> are valid member typedefs. The
|
||||
library assumes that <code>Hash</code> is callable with both
|
||||
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
|
||||
transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</notes>
|
||||
</overloaded-method>
|
||||
<overloaded-method name="equal_range">
|
||||
<signature>
|
||||
<parameter name="k">
|
||||
@ -2563,12 +2816,41 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</parameter>
|
||||
<type>std::pair<const_iterator, const_iterator></type>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>std::pair<iterator, iterator></type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>std::pair<const_iterator, const_iterator></type>
|
||||
</signature>
|
||||
<returns>
|
||||
<para>A range containing all elements with key equivalent to <code>k</code>.
|
||||
If the container doesn't container any such elements, returns
|
||||
If the container doesn't contain any such elements, returns
|
||||
<code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>.
|
||||
</para>
|
||||
</para>
|
||||
</returns>
|
||||
<notes>
|
||||
<para>
|
||||
The <code>template <typename K></code> overloads only participate
|
||||
in overload resolution if <code>Hash::is_transparent</code> and
|
||||
<code>Pred::is_transparent</code> are valid member typedefs. The
|
||||
library assumes that <code>Hash</code> is callable with both
|
||||
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
|
||||
transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</notes>
|
||||
</overloaded-method>
|
||||
</method-group>
|
||||
<method-group name="bucket interface">
|
||||
@ -3757,6 +4039,38 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</para>
|
||||
</notes>
|
||||
</method>
|
||||
<method name="extract">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K&&</paramtype>
|
||||
</parameter>
|
||||
<type>node_type</type>
|
||||
<description>
|
||||
<para>Removes an element with key equivalent to <code>k</code>.</para>
|
||||
<para>
|
||||
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
|
||||
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
|
||||
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
|
||||
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
|
||||
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</description>
|
||||
<returns>
|
||||
<para>A <code>node_type</code> owning the element if found, otherwise an empty <code>node_type</code>.</para>
|
||||
</returns>
|
||||
<throws>
|
||||
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
|
||||
</throws>
|
||||
<notes>
|
||||
<para>
|
||||
In C++17 a node extracted using this method can be inserted into a compatible <code>unordered_multimap</code>,
|
||||
but that is not supported yet.
|
||||
</para>
|
||||
</notes>
|
||||
</method>
|
||||
<method name="insert">
|
||||
<parameter name="nh">
|
||||
<paramtype>node_type&&</paramtype>
|
||||
@ -3868,6 +4182,32 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
|
||||
</throws>
|
||||
</method>
|
||||
<method name="erase">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K&&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
<returns>
|
||||
<para>The number of elements erased.</para>
|
||||
</returns>
|
||||
<throws>
|
||||
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
|
||||
</throws>
|
||||
<description>
|
||||
<para>Erase all elements with key equivalent to <code>k</code>.</para>
|
||||
<para>
|
||||
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
|
||||
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
|
||||
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
|
||||
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
|
||||
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</description>
|
||||
</method>
|
||||
<method name="erase">
|
||||
<parameter name="first">
|
||||
<paramtype>const_iterator</paramtype>
|
||||
@ -4016,6 +4356,24 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</parameter>
|
||||
<type>const_iterator</type>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>iterator</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>const_iterator</type>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="CompatibleKey"/>
|
||||
@ -4053,22 +4411,58 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
<returns>
|
||||
<para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para>
|
||||
</returns>
|
||||
<notes><para>
|
||||
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.
|
||||
</para></notes>
|
||||
</overloaded-method>
|
||||
<method name="count" cv="const">
|
||||
<parameter name="k">
|
||||
<paramtype>key_type const&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
<notes>
|
||||
<para>
|
||||
The templated overloads containing <code>CompatibleKey</code>,
|
||||
<code>CompatibleHash</code> and <code>CompatiblePredicate</code>
|
||||
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 <code>K</code> member function
|
||||
templates should be used.
|
||||
</para>
|
||||
<para>
|
||||
The <code>template <typename K></code> overloads only participate
|
||||
in overload resolution if <code>Hash::is_transparent</code> and
|
||||
<code>Pred::is_transparent</code> are valid member typedefs. The
|
||||
library assumes that <code>Hash</code> is callable with both
|
||||
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
|
||||
transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</notes>
|
||||
</overloaded-method>
|
||||
<overloaded-method name="count">
|
||||
<signature cv="const">
|
||||
<parameter name="k">
|
||||
<paramtype>key_type const&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
</signature>
|
||||
<returns>
|
||||
<para>The number of elements with key equivalent to <code>k</code>.</para>
|
||||
</returns>
|
||||
</method>
|
||||
<notes>
|
||||
<para>
|
||||
The <code>template <typename K></code> overload only participates
|
||||
in overload resolution if <code>Hash::is_transparent</code> and
|
||||
<code>Pred::is_transparent</code> are valid member typedefs. The
|
||||
library assumes that <code>Hash</code> is callable with both
|
||||
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
|
||||
transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</notes>
|
||||
</overloaded-method>
|
||||
<overloaded-method name="equal_range">
|
||||
<signature>
|
||||
<parameter name="k">
|
||||
@ -4082,12 +4476,41 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</parameter>
|
||||
<type>std::pair<const_iterator, const_iterator></type>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>std::pair<iterator, iterator></type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>std::pair<const_iterator, const_iterator></type>
|
||||
</signature>
|
||||
<returns>
|
||||
<para>A range containing all elements with key equivalent to <code>k</code>.
|
||||
If the container doesn't container any such elements, returns
|
||||
If the container doesn't contain any such elements, returns
|
||||
<code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>.
|
||||
</para>
|
||||
</para>
|
||||
</returns>
|
||||
<notes>
|
||||
<para>
|
||||
The <code>template <typename K></code> overloads only participate
|
||||
in overload resolution if <code>Hash::is_transparent</code> and
|
||||
<code>Pred::is_transparent</code> are valid member typedefs. The
|
||||
library assumes that <code>Hash</code> is callable with both
|
||||
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
|
||||
transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</notes>
|
||||
</overloaded-method>
|
||||
<method name="operator[]">
|
||||
<parameter name="k">
|
||||
@ -5218,6 +5641,38 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</para>
|
||||
</notes>
|
||||
</method>
|
||||
<method name="extract">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K&&</paramtype>
|
||||
</parameter>
|
||||
<type>node_type</type>
|
||||
<description>
|
||||
<para>Removes an element with key equivalent to <code>k</code>.</para>
|
||||
<para>
|
||||
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
|
||||
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
|
||||
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
|
||||
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
|
||||
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</description>
|
||||
<returns>
|
||||
<para>A <code>node_type</code> owning the element if found, otherwise an empty <code>node_type</code>.</para>
|
||||
</returns>
|
||||
<throws>
|
||||
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
|
||||
</throws>
|
||||
<notes>
|
||||
<para>
|
||||
In C++17 a node extracted using this method can be inserted into a compatible <code>unordered_map</code>,
|
||||
but that is not supported yet.
|
||||
</para>
|
||||
</notes>
|
||||
</method>
|
||||
<method name="insert">
|
||||
<parameter name="nh">
|
||||
<paramtype>node_type&&</paramtype>
|
||||
@ -5313,6 +5768,32 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
|
||||
</throws>
|
||||
</method>
|
||||
<method name="erase">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K&&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
<returns>
|
||||
<para>The number of elements erased.</para>
|
||||
</returns>
|
||||
<throws>
|
||||
<para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
|
||||
</throws>
|
||||
<description>
|
||||
<para>Erase all elements with key equivalent to <code>k</code>.</para>
|
||||
<para>
|
||||
This overload only participates in overload resolution if <code>Hash::is_transparent</code>
|
||||
and <code>Pred::is_transparent</code> are valid member typedefs and neither <code>iterator</code>
|
||||
nor <code>const_iterator</code> are implicitly convertible from <code>K</code>. The library
|
||||
assumes that <code>Hash</code> is callable with both <code>K</code> and <code>Key</code> and
|
||||
that <code>Pred</code> is transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</description>
|
||||
</method>
|
||||
<method name="erase">
|
||||
<parameter name="first">
|
||||
<paramtype>const_iterator</paramtype>
|
||||
@ -5461,6 +5942,24 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</parameter>
|
||||
<type>const_iterator</type>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>iterator</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>const_iterator</type>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="CompatibleKey"/>
|
||||
@ -5498,22 +5997,58 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
<returns>
|
||||
<para>An iterator pointing to an element with key equivalent to <code>k</code>, or <code>b.end()</code> if no such element exists.</para>
|
||||
</returns>
|
||||
<notes><para>
|
||||
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.
|
||||
</para></notes>
|
||||
</overloaded-method>
|
||||
<method name="count" cv="const">
|
||||
<parameter name="k">
|
||||
<paramtype>key_type const&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
<notes>
|
||||
<para>
|
||||
The templated overloads containing <code>CompatibleKey</code>,
|
||||
<code>CompatibleHash</code> and <code>CompatiblePredicate</code>
|
||||
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 <code>K</code> member function
|
||||
templates should be used.
|
||||
</para>
|
||||
<para>
|
||||
The <code>template <typename K></code> overloads only participate
|
||||
in overload resolution if <code>Hash::is_transparent</code> and
|
||||
<code>Pred::is_transparent</code> are valid member typedefs. The
|
||||
library assumes that <code>Hash</code> is callable with both
|
||||
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
|
||||
transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</notes>
|
||||
</overloaded-method>
|
||||
<overloaded-method name="count">
|
||||
<signature cv="const">
|
||||
<parameter name="k">
|
||||
<paramtype>key_type const&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>size_type</type>
|
||||
</signature>
|
||||
<returns>
|
||||
<para>The number of elements with key equivalent to <code>k</code>.</para>
|
||||
</returns>
|
||||
</method>
|
||||
<notes>
|
||||
<para>
|
||||
The <code>template <typename K></code> overload only participates
|
||||
in overload resolution if <code>Hash::is_transparent</code> and
|
||||
<code>Pred::is_transparent</code> are valid member typedefs. The
|
||||
library assumes that <code>Hash</code> is callable with both
|
||||
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
|
||||
transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</notes>
|
||||
</overloaded-method>
|
||||
<overloaded-method name="equal_range">
|
||||
<signature>
|
||||
<parameter name="k">
|
||||
@ -5527,12 +6062,41 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
</parameter>
|
||||
<type>std::pair<const_iterator, const_iterator></type>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>std::pair<iterator, iterator></type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="K" />
|
||||
</template>
|
||||
<parameter name="k">
|
||||
<paramtype>K const&</paramtype>
|
||||
</parameter>
|
||||
<type>std::pair<const_iterator, const_iterator></type>
|
||||
</signature>
|
||||
<returns>
|
||||
<para>A range containing all elements with key equivalent to <code>k</code>.
|
||||
If the container doesn't container any such elements, returns
|
||||
If the container doesn't contain any such elements, returns
|
||||
<code><functionname>std::make_pair</functionname>(<methodname>b.end</methodname>(),<methodname>b.end</methodname>())</code>.
|
||||
</para>
|
||||
</para>
|
||||
</returns>
|
||||
<notes>
|
||||
<para>
|
||||
The <code>template <typename K></code> overloads only participate
|
||||
in overload resolution if <code>Hash::is_transparent</code> and
|
||||
<code>Pred::is_transparent</code> are valid member typedefs. The
|
||||
library assumes that <code>Hash</code> is callable with both
|
||||
<code>K</code> and <code>Key</code> and that <code>Pred</code> is
|
||||
transparent. This enables heterogeneous lookup which avoids the cost of
|
||||
instantiating an instance of the <code>Key</code> type.
|
||||
</para>
|
||||
</notes>
|
||||
</overloaded-method>
|
||||
</method-group>
|
||||
<method-group name="bucket interface">
|
||||
|
||||
Reference in New Issue
Block a user