forked from boostorg/unordered
Support node_handle
This commit is contained in:
Daniel James
+261
@@ -189,6 +189,20 @@ EOL;
|
||||
<para>A const_local_iterator object can be used to iterate through a single bucket.</para>
|
||||
</description>
|
||||
</typedef>
|
||||
<typedef name="node_type">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
<description>
|
||||
<para>See <classname>node_handle_<?php echo $map ? 'map' : 'set'; ?></classname> for details.</para>
|
||||
</description>
|
||||
</typedef>
|
||||
<?php if (!$equivalent_keys): ?>
|
||||
<typedef name="insert_return_type">
|
||||
<type><emphasis>implementation-defined</emphasis></type>
|
||||
<description>
|
||||
Structure returned by inserting <code>node_type</code>.
|
||||
</description>
|
||||
</typedef>
|
||||
<?php endif; ?>
|
||||
<constructor>
|
||||
<postconditions>
|
||||
<code><methodname>size</methodname>() == 0</code>
|
||||
@@ -876,6 +890,142 @@ EOL;
|
||||
<para>Pointers and references to elements are never invalidated.</para>
|
||||
</notes>
|
||||
</method>
|
||||
<method name="insert">
|
||||
<parameter name="il">
|
||||
<paramtype>initializer_list<value_type></paramtype>
|
||||
</parameter>
|
||||
<type>void</type>
|
||||
<description>
|
||||
<para>Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent <?php echo $key_name; ?>.</para>
|
||||
</description>
|
||||
<requires>
|
||||
<para><code>value_type</code> is <code>EmplaceConstructible</code> into
|
||||
<code>X</code> from <code>*first</code>.</para>
|
||||
</requires>
|
||||
<throws>
|
||||
<para>When inserting a single element, if an exception is thrown by an operation other than a call to <code>hasher</code> the function has no effect.</para>
|
||||
</throws>
|
||||
<notes>
|
||||
<para>Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.</para>
|
||||
<para>Pointers and references to elements are never invalidated.</para>
|
||||
</notes>
|
||||
</method>
|
||||
<method name="extract">
|
||||
<parameter name="position">
|
||||
<paramtype>const_iterator</paramtype>
|
||||
</parameter>
|
||||
<type>node_type</type>
|
||||
<description>
|
||||
<para>Removes the element pointed to by <code>position</code>.</para>
|
||||
</description>
|
||||
<returns>
|
||||
<para>A <code>node_type</code> owning the element.</para>
|
||||
</returns>
|
||||
</method>
|
||||
<method name="extract">
|
||||
<parameter name="k">
|
||||
<paramtype>key_type const&</paramtype>
|
||||
</parameter>
|
||||
<type>node_type</type>
|
||||
<description>
|
||||
<para>Removes an element with key equivalent to <code>k</code>.</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>
|
||||
</method>
|
||||
<method name="insert">
|
||||
<parameter name="nh">
|
||||
<paramtype>node_type&&</paramtype>
|
||||
</parameter>
|
||||
<type><?php echo $equivalent_keys ? 'iterator' : 'insert_return_type' ?></type>
|
||||
<description>
|
||||
<para>If <code>nh</code> is empty, has no affect.</para>
|
||||
<?php if ($equivalent_keys): ?>
|
||||
<para>Otherwise inserts the element owned by <code>nh</code></para>
|
||||
<?php else: ?>
|
||||
<para>Otherwise inserts the element owned by <code>nh</code>
|
||||
if and only if there is no element in the container with an equivalent <?php echo $key_name; ?>.
|
||||
</para>
|
||||
<?php endif ?>
|
||||
</description>
|
||||
<requires>
|
||||
<para><code>nh</code> is empty or <code>nh.get_allocator()</code> is equal to the container's allocator.</para>
|
||||
</requires>
|
||||
<returns>
|
||||
<?php if ($equivalent_keys): ?>
|
||||
<para>If <code>nh</code> was empty, returns <code>end()</code>.</para>
|
||||
<para>Otherwise returns an iterator pointing to the newly inserted element.</para>
|
||||
<?php else: ?>
|
||||
<para>If <code>nh</code> was empty, returns an <code>insert_return_type</code> with:
|
||||
<code>inserted</code> equal to <code>false</code>,
|
||||
<code>position</code> equal to <code>end()</code> and
|
||||
<code>node</code> empty.</para>
|
||||
<para>Otherwise if there was already an element with an equivalent key, returns an <code>insert_return_type</code> with:
|
||||
<code>inserted</code> equal to <code>false</code>,
|
||||
<code>position</code> pointing to a matching element and
|
||||
<code>node</code> contains the node from <code>nh</code>.</para>
|
||||
<para>Otherwise if the insertion succeeded, returns an <code>insert_return_type</code> with:
|
||||
<code>inserted</code> equal to <code>true</code>,
|
||||
<code>position</code> pointing to the newly inserted element and
|
||||
<code>node</code> empty.</para>
|
||||
<?php endif; ?>
|
||||
</returns>
|
||||
<throws>
|
||||
<para>If an exception is thrown by an operation other than a call to <code>hasher</code> the function has no effect.</para>
|
||||
</throws>
|
||||
<notes>
|
||||
<para>Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.</para>
|
||||
<para>Pointers and references to elements are never invalidated.</para>
|
||||
</notes>
|
||||
</method>
|
||||
<method name="insert">
|
||||
<parameter name="hint">
|
||||
<paramtype>const_iterator</paramtype>
|
||||
</parameter>
|
||||
<parameter name="nh">
|
||||
<paramtype>node_type&&</paramtype>
|
||||
</parameter>
|
||||
<type>iterator</type>
|
||||
<description>
|
||||
<para>If <code>nh</code> is empty, has no affect.</para>
|
||||
<?php if ($equivalent_keys): ?>
|
||||
<para>Otherwise inserts the element owned by <code>nh</code></para>
|
||||
<?php else: ?>
|
||||
<para>Otherwise inserts the element owned by <code>nh</code>
|
||||
if and only if there is no element in the container with an equivalent <?php echo $key_name; ?>.
|
||||
</para>
|
||||
<para>If there is already an element in the container with an equivalent <?php echo $key_name; ?>
|
||||
has no effect on <code>nh</code> (i.e. <code>nh</code> still contains the node.)</para>
|
||||
<?php endif ?>
|
||||
<para>hint is a suggestion to where the element should be inserted.</para>
|
||||
</description>
|
||||
<requires>
|
||||
<para><code>nh</code> is empty or <code>nh.get_allocator()</code> is equal to the container's allocator.</para>
|
||||
</requires>
|
||||
<returns>
|
||||
<?php if ($equivalent_keys): ?>
|
||||
<para>If <code>nh</code> was empty, returns <code>end()</code>.</para>
|
||||
<para>Otherwise returns an iterator pointing to the newly inserted element.</para>
|
||||
<?php else: ?>
|
||||
<para>If <code>nh</code> was empty returns <code>end()</code>.</para>
|
||||
<para>If there was already an element in the container with an equivalent <?php echo $key_name; ?>
|
||||
returns an iterator pointing to that.</para>
|
||||
<para>Otherwise returns an iterator pointing to the newly inserted element.</para>
|
||||
<?php endif; ?>
|
||||
</returns>
|
||||
<throws>
|
||||
<para>If an exception is thrown by an operation other than a call to <code>hasher</code> the function has no effect.</para>
|
||||
</throws>
|
||||
<notes>
|
||||
<para>The standard is fairly vague on the meaning of the hint. But the only practical way to use it, and the only way that Boost.Unordered supports is to point to an existing element with the same <?php echo $key_name; ?>. </para>
|
||||
<para>Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor.</para>
|
||||
<para>Pointers and references to elements are never invalidated.</para>
|
||||
</notes>
|
||||
</method>
|
||||
<method name="erase">
|
||||
<parameter name="position">
|
||||
<paramtype>const_iterator</paramtype>
|
||||
@@ -1416,6 +1566,115 @@ EOL;
|
||||
<?php
|
||||
}
|
||||
|
||||
function echo_node_handle_docs($map)
|
||||
{
|
||||
$type = $map ? 'map' : 'set';
|
||||
$name = 'node_handle_'.$type;
|
||||
$full_type = "{$name}<ImplementationDefined>";
|
||||
?>
|
||||
<namespace name="unordered">
|
||||
<class name="<?php echo $name ?>">
|
||||
<template pack="true">
|
||||
<template-type-parameter name="ImplementationDefined"/>
|
||||
</template>
|
||||
<purpose>
|
||||
<para>
|
||||
An object that owns a single element extracted from an
|
||||
<classname>unordered_<?php echo $type ?></classname> or an
|
||||
<classname>unordered_multi<?php echo $type ?></classname>, that
|
||||
can then be inserted into a compatible container type.
|
||||
</para>
|
||||
<note>
|
||||
<para>
|
||||
The name and template parameters of this type is implementation
|
||||
defined, and should be obtained using the <code>node_type</code>
|
||||
member typedef from the appropriate container.
|
||||
</para>
|
||||
</note>
|
||||
</purpose>
|
||||
<?php if ($map): ?>
|
||||
<typedef name="key_type">
|
||||
<type>typename Container::key_type</type>
|
||||
</typedef>
|
||||
<typedef name="mapped_type">
|
||||
<type>typename Container::mapped_type</type>
|
||||
</typedef>
|
||||
<?php else: ?>
|
||||
<typedef name="value_type">
|
||||
<type>typename Container::value_type></type>
|
||||
</typedef>
|
||||
<?php endif ?>
|
||||
<typedef name="allocator_type">
|
||||
<type>typename Container::allocator_type></type>
|
||||
</typedef>
|
||||
<constructor specifiers="constexpr" cv="noexcept">
|
||||
</constructor>
|
||||
<destructor/>
|
||||
<constructor cv="noexcept">
|
||||
<parameter>
|
||||
<paramtype><?php echo $name; ?> &&</paramtype>
|
||||
</parameter>
|
||||
</constructor>
|
||||
<method name="operator=">
|
||||
<parameter>
|
||||
<paramtype><?php echo $name; ?>&&</paramtype>
|
||||
</parameter>
|
||||
<type><?php echo $name; ?>&</type>
|
||||
</method>
|
||||
<?php if ($map): ?>
|
||||
<method name="key" cv="const">
|
||||
<type>key_type&</type>
|
||||
</method>
|
||||
<method name="mapped" cv="const">
|
||||
<type>mapped_type&</type>
|
||||
</method>
|
||||
<?php else: ?>
|
||||
<method name="value" cv="const">
|
||||
<type>value_type&</type>
|
||||
</method>
|
||||
<?php endif; ?>
|
||||
<method name="get_allocator" cv="const">
|
||||
<type>allocator_type</type>
|
||||
</method>
|
||||
<method name="operator bool" specifiers="explicit" cv="const noexcept">
|
||||
</method>
|
||||
<method name="empty" cv="const noexcept">
|
||||
<type>bool</type>
|
||||
</method>
|
||||
<method name="swap" cv="noexcept(ator_traits::propagate_on_container_swap::value)">
|
||||
<parameter>
|
||||
<paramtype><?php echo $name; ?>&</paramtype>
|
||||
</parameter>
|
||||
<type>void</type>
|
||||
<notes>
|
||||
<para>
|
||||
In C++17 is also <code>noexcept</code> if <code>ator_traits::is_always_equal::value</code> is true.
|
||||
But we don't support that trait yet.
|
||||
</para>
|
||||
</notes>
|
||||
</method>
|
||||
<free-function-group name="swap" cv="noexcept(noexcept(x.swap(y)))">
|
||||
<function name="swap">
|
||||
<template pack="true">
|
||||
<template-type-parameter name="ImplementationDefined"/>
|
||||
</template>
|
||||
<parameter name="x">
|
||||
<paramtype><?php echo $full_type; ?>&</paramtype>
|
||||
</parameter>
|
||||
<parameter name="y">
|
||||
<paramtype><?php echo $full_type; ?>&</paramtype>
|
||||
</parameter>
|
||||
<type>void</type>
|
||||
<effects>
|
||||
<para><code>x.swap(y)</code></para>
|
||||
</effects>
|
||||
</function>
|
||||
</free-function-group>
|
||||
</class>
|
||||
</namespace>
|
||||
<?php
|
||||
}
|
||||
|
||||
?>
|
||||
<!--
|
||||
Copyright Daniel James 2006-2009
|
||||
@@ -1427,6 +1686,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
<?php
|
||||
echo_unordered_docs(false, false);
|
||||
echo_unordered_docs(false, true);
|
||||
echo_node_handle_docs(false);
|
||||
?>
|
||||
</namespace>
|
||||
</header>
|
||||
@@ -1435,6 +1695,7 @@ echo_unordered_docs(false, true);
|
||||
<?php
|
||||
echo_unordered_docs(true, false);
|
||||
echo_unordered_docs(true, true);
|
||||
echo_node_handle_docs(true);
|
||||
?>
|
||||
</namespace>
|
||||
</header>
|
||||
|
||||
Reference in New Issue
Block a user