boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-29 19:07:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Unordered: fix swap documentation.

Browse Source 
[SVN r74376]
This commit is contained in:
Daniel James
2011-09-14 21:04:23 +00:00
parent f8abb9633a
commit b496bc3fa2
3 changed files with 100 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
doc/rationale.qbk
View File

@ -126,17 +126,6 @@ attempts to respecify them without concepts. I'll try to implement this (or
an appropriate later version) in a future version of boost, possibly changed
a little to accomodate non-C++0x compilers.
[h3 Swapping containers with unequal allocators]
/TODO/: This is out of date.
It isn't clear how to swap containers when their allocators aren't equal.
This is
[@http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#431
Issue 431: Swapping containers with unequal allocators]. This has been resolved
with the new allocator specification, so this should be fixed when
support is added.
[h3 Are insert and erase stable for unordered_multiset and unordered_multimap?]
It wan't specified if `unordered_multiset` and `unordered_multimap` preserve the order

28
doc/ref.php
View File

@ -658,13 +658,19 @@ EOL;
<paramtype><?php echo $name; ?>&amp;</paramtype>
</parameter>
<type>void</type>
<description>
<para>Swaps the contents of the container with the parameter.</para>
<para>If <code>Allocator::propagate_on_container_swap</code> is declared and
<code>Allocator::propagate_on_container_swap::value</code> is true then the
containers' allocators are swapped. Otherwise, swapping with unequal allocators
results in undefined behavior.</para>
</description>
<throws>
<para>If the allocators are equal, doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
<para>Doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
</throws>
<notes>
<para><emphasis>TODO</emphasis>: Update swap documentation, no longer correct.</para>
<para>For a discussion of the behavior when allocators aren't equal see
<link linkend="unordered.rationale.swapping_containers_with_unequal_allocators">the implementation details</link>.</para>
<para>The exception specifications aren't quite the same as the C++11 standard, as
the equality predieate and hash function are swapped using their copy constructors.</para>
</notes>
</method>
</method-group>
@ -1014,13 +1020,19 @@ EOL;
<effects>
<para><code>x.swap(y)</code></para>
</effects>
<description>
<para>Swaps the contents of <code>x</code> and <code>y</code>.</para>
<para>If <code>Allocator::propagate_on_container_swap</code> is declared and
<code>Allocator::propagate_on_container_swap::value</code> is true then the
containers' allocators are swapped. Otherwise, swapping with unequal allocators
results in undefined behavior.</para>
</description>
<throws>
<para>If the allocators are equal, doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>Hash</code> or <code>Pred</code>.</para>
<para>Doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
</throws>
<notes>
<para><emphasis>TODO</emphasis>: Update swap documentation, no longer correct.</para>
<para>For a discussion of the behavior when allocators aren't equal see
<link linkend="unordered.rationale.swapping_containers_with_unequal_allocators">the implementation details</link>.</para>
<para>The exception specifications aren't quite the same as the C++11 standard, as
the equality predieate and hash function are swapped using their copy constructors.</para>
</notes>
</function>
</free-function-group>

112
doc/ref.xml
View File

@ -574,13 +574,19 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<paramtype>unordered_set&amp;</paramtype>
</parameter>
<type>void</type>
<description>
<para>Swaps the contents of the container with the parameter.</para>
<para>If <code>Allocator::propagate_on_container_swap</code> is declared and
<code>Allocator::propagate_on_container_swap::value</code> is true then the
containers' allocators are swapped. Otherwise, swapping with unequal allocators
results in undefined behavior.</para>
</description>
<throws>
<para>If the allocators are equal, doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
<para>Doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
</throws>
<notes>
<para><emphasis>TODO</emphasis>: Update swap documentation, no longer correct.</para>
<para>For a discussion of the behavior when allocators aren't equal see
<link linkend="unordered.rationale.swapping_containers_with_unequal_allocators">the implementation details</link>.</para>
<para>The exception specifications aren't quite the same as the C++11 standard, as
the equality predieate and hash function are swapped using their copy constructors.</para>
</notes>
</method>
</method-group>
@ -896,13 +902,19 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<effects>
<para><code>x.swap(y)</code></para>
</effects>
<description>
<para>Swaps the contents of <code>x</code> and <code>y</code>.</para>
<para>If <code>Allocator::propagate_on_container_swap</code> is declared and
<code>Allocator::propagate_on_container_swap::value</code> is true then the
containers' allocators are swapped. Otherwise, swapping with unequal allocators
results in undefined behavior.</para>
</description>
<throws>
<para>If the allocators are equal, doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>Hash</code> or <code>Pred</code>.</para>
<para>Doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
</throws>
<notes>
<para><emphasis>TODO</emphasis>: Update swap documentation, no longer correct.</para>
<para>For a discussion of the behavior when allocators aren't equal see
<link linkend="unordered.rationale.swapping_containers_with_unequal_allocators">the implementation details</link>.</para>
<para>The exception specifications aren't quite the same as the C++11 standard, as
the equality predieate and hash function are swapped using their copy constructors.</para>
</notes>
</function>
</free-function-group>
@ -1474,13 +1486,19 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<paramtype>unordered_multiset&amp;</paramtype>
</parameter>
<type>void</type>
<description>
<para>Swaps the contents of the container with the parameter.</para>
<para>If <code>Allocator::propagate_on_container_swap</code> is declared and
<code>Allocator::propagate_on_container_swap::value</code> is true then the
containers' allocators are swapped. Otherwise, swapping with unequal allocators
results in undefined behavior.</para>
</description>
<throws>
<para>If the allocators are equal, doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
<para>Doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
</throws>
<notes>
<para><emphasis>TODO</emphasis>: Update swap documentation, no longer correct.</para>
<para>For a discussion of the behavior when allocators aren't equal see
<link linkend="unordered.rationale.swapping_containers_with_unequal_allocators">the implementation details</link>.</para>
<para>The exception specifications aren't quite the same as the C++11 standard, as
the equality predieate and hash function are swapped using their copy constructors.</para>
</notes>
</method>
</method-group>
@ -1796,13 +1814,19 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<effects>
<para><code>x.swap(y)</code></para>
</effects>
<description>
<para>Swaps the contents of <code>x</code> and <code>y</code>.</para>
<para>If <code>Allocator::propagate_on_container_swap</code> is declared and
<code>Allocator::propagate_on_container_swap::value</code> is true then the
containers' allocators are swapped. Otherwise, swapping with unequal allocators
results in undefined behavior.</para>
</description>
<throws>
<para>If the allocators are equal, doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>Hash</code> or <code>Pred</code>.</para>
<para>Doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
</throws>
<notes>
<para><emphasis>TODO</emphasis>: Update swap documentation, no longer correct.</para>
<para>For a discussion of the behavior when allocators aren't equal see
<link linkend="unordered.rationale.swapping_containers_with_unequal_allocators">the implementation details</link>.</para>
<para>The exception specifications aren't quite the same as the C++11 standard, as
the equality predieate and hash function are swapped using their copy constructors.</para>
</notes>
</function>
</free-function-group>
@ -2388,13 +2412,19 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<paramtype>unordered_map&amp;</paramtype>
</parameter>
<type>void</type>
<description>
<para>Swaps the contents of the container with the parameter.</para>
<para>If <code>Allocator::propagate_on_container_swap</code> is declared and
<code>Allocator::propagate_on_container_swap::value</code> is true then the
containers' allocators are swapped. Otherwise, swapping with unequal allocators
results in undefined behavior.</para>
</description>
<throws>
<para>If the allocators are equal, doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
<para>Doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
</throws>
<notes>
<para><emphasis>TODO</emphasis>: Update swap documentation, no longer correct.</para>
<para>For a discussion of the behavior when allocators aren't equal see
<link linkend="unordered.rationale.swapping_containers_with_unequal_allocators">the implementation details</link>.</para>
<para>The exception specifications aren't quite the same as the C++11 standard, as
the equality predieate and hash function are swapped using their copy constructors.</para>
</notes>
</method>
</method-group>
@ -2751,13 +2781,19 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<effects>
<para><code>x.swap(y)</code></para>
</effects>
<description>
<para>Swaps the contents of <code>x</code> and <code>y</code>.</para>
<para>If <code>Allocator::propagate_on_container_swap</code> is declared and
<code>Allocator::propagate_on_container_swap::value</code> is true then the
containers' allocators are swapped. Otherwise, swapping with unequal allocators
results in undefined behavior.</para>
</description>
<throws>
<para>If the allocators are equal, doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>Hash</code> or <code>Pred</code>.</para>
<para>Doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
</throws>
<notes>
<para><emphasis>TODO</emphasis>: Update swap documentation, no longer correct.</para>
<para>For a discussion of the behavior when allocators aren't equal see
<link linkend="unordered.rationale.swapping_containers_with_unequal_allocators">the implementation details</link>.</para>
<para>The exception specifications aren't quite the same as the C++11 standard, as
the equality predieate and hash function are swapped using their copy constructors.</para>
</notes>
</function>
</free-function-group>
@ -3337,13 +3373,19 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<paramtype>unordered_multimap&amp;</paramtype>
</parameter>
<type>void</type>
<description>
<para>Swaps the contents of the container with the parameter.</para>
<para>If <code>Allocator::propagate_on_container_swap</code> is declared and
<code>Allocator::propagate_on_container_swap::value</code> is true then the
containers' allocators are swapped. Otherwise, swapping with unequal allocators
results in undefined behavior.</para>
</description>
<throws>
<para>If the allocators are equal, doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
<para>Doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
</throws>
<notes>
<para><emphasis>TODO</emphasis>: Update swap documentation, no longer correct.</para>
<para>For a discussion of the behavior when allocators aren't equal see
<link linkend="unordered.rationale.swapping_containers_with_unequal_allocators">the implementation details</link>.</para>
<para>The exception specifications aren't quite the same as the C++11 standard, as
the equality predieate and hash function are swapped using their copy constructors.</para>
</notes>
</method>
</method-group>
@ -3665,13 +3707,19 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
<effects>
<para><code>x.swap(y)</code></para>
</effects>
<description>
<para>Swaps the contents of <code>x</code> and <code>y</code>.</para>
<para>If <code>Allocator::propagate_on_container_swap</code> is declared and
<code>Allocator::propagate_on_container_swap::value</code> is true then the
containers' allocators are swapped. Otherwise, swapping with unequal allocators
results in undefined behavior.</para>
</description>
<throws>
<para>If the allocators are equal, doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>Hash</code> or <code>Pred</code>.</para>
<para>Doesn't throw an exception unless it is thrown by the copy constructor or copy assignment operator of <code>key_equal</code> or <code>hasher</code>.</para>
</throws>
<notes>
<para><emphasis>TODO</emphasis>: Update swap documentation, no longer correct.</para>
<para>For a discussion of the behavior when allocators aren't equal see
<link linkend="unordered.rationale.swapping_containers_with_unequal_allocators">the implementation details</link>.</para>
<para>The exception specifications aren't quite the same as the C++11 standard, as
the equality predieate and hash function are swapped using their copy constructors.</para>
</notes>
</function>
</free-function-group>