Imported Upstream version 1.66.0upstream/1.66.0

8 files changed, 55 insertions, 66 deletions

diff --git a/doc/html/unordered/bibliography.html b/doc/html/unordered/bibliography.html
index d762710b08..1af5c6e30f 100644
--- a/doc/html/unordered/bibliography.html
+++ b/doc/html/unordered/bibliography.html
@@ -28,9 +28,9 @@
 <a name="unordered.bibliography"></a>Bibliography</h2></div></div></div>
 <div class="bibliography">
 <div class="titlepage"><div><div><h3 class="title">
-<a name="idp613244368"></a>Bibliography</h3></div></div></div>
+<a name="id-1.3.45.11.2"></a>Bibliography</h3></div></div></div>
 <div class="biblioentry">
-<a name="idp613244624"></a><p><span class="biblioset"><i>C/C++ Users Journal</i>. <span class="date">February, 2006. </span></span><span class="biblioset"><span class="authorgroup"><span class="firstname">Pete</span> <span class="surname">Becker</span>. </span>&#8220;<a href="http://www.ddj.com/cpp/184402066" target="_top">STL and TR1: Part III - Unordered containers</a>&#8221;. </span><p>An introducation to the standard unordered containers.</p></p>
+<a name="id-1.3.45.11.2.1"></a><p><span class="biblioset"><i>C/C++ Users Journal</i>. <span class="date">February, 2006. </span></span><span class="biblioset"><span class="authorgroup"><span class="firstname">Pete</span> <span class="surname">Becker</span>. </span>&#8220;<a href="http://www.ddj.com/cpp/184402066" target="_top">STL and TR1: Part III - Unordered containers</a>&#8221;. </span><p>An introducation to the standard unordered containers.</p></p>
 </div>
 </div>
 </div>
diff --git a/doc/html/unordered/buckets.html b/doc/html/unordered/buckets.html
index a8b83c4af6..06ea2214b7 100644
--- a/doc/html/unordered/buckets.html
+++ b/doc/html/unordered/buckets.html
@@ -45,7 +45,7 @@
       key is the whole element, but is referred to as the key so that the same terminology
       can be used for sets and maps). This returns a value of type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>.
       <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code> has a much greater range of values
-      then the number of buckets, so that container applies another transformation
+      then the number of buckets, so the container applies another transformation
       to that value to choose a bucket to place the element in.
     </p>
 <p>
@@ -70,7 +70,7 @@
 <p>
       </p>
 <div class="table">
-<a name="idp604253664"></a><p class="title"><b>Table&#160;44.1.&#160;Methods for Accessing Buckets</b></p>
+<a name="id-1.3.45.4.8.1"></a><p class="title"><b>Table&#160;44.1.&#160;Methods for Accessing Buckets</b></p>
 <div class="table-contents"><table class="table" summary="Methods for Accessing Buckets">
 <colgroup>
 <col>
@@ -100,22 +100,20 @@
 <tr>
 <td><code class="computeroutput"><span class="identifier">size_type</span> <span class="identifier">bucket</span><span class="special">(</span><span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">k</span><span class="special">)</span> <span class="keyword">const</span></code></td>
 <td>Returns
-      the index of the bucket which would contain k</td>
+      the index of the bucket which would contain <code class="computeroutput"><span class="identifier">k</span></code>.</td>
 </tr>
 <tr>
-<td><code class="computeroutput"><span class="identifier">local_iterator</span>
-      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span></code></td>
-<td rowspan="6">Return begin and end iterators for bucket
-      <code class="computeroutput"><span class="identifier">n</span></code>.</td>
+<td><code class="computeroutput"><span class="identifier">local_iterator</span> <span class="identifier">begin</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span></code></td>
+<td rowspan="6">Return
+      begin and end iterators for bucket <code class="computeroutput"><span class="identifier">n</span></code>.</td>
 </tr>
-<tr><td><code class="computeroutput"><span class="identifier">local_iterator</span>
-      <span class="identifier">end</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span></code></td></tr>
+<tr><td><code class="computeroutput"><span class="identifier">local_iterator</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span></code></td></tr>
+<tr><td><code class="computeroutput"><span class="identifier">const_local_iterator</span> <span class="identifier">begin</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code></td></tr>
 <tr><td><code class="computeroutput"><span class="identifier">const_local_iterator</span>
-      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code></td></tr>
-<tr><td><code class="computeroutput"><span class="identifier">const_local_iterator</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code></td></tr>
+      <span class="identifier">end</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code></td></tr>
+<tr><td><code class="computeroutput"><span class="identifier">const_local_iterator</span> <span class="identifier">cbegin</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code></td></tr>
 <tr><td><code class="computeroutput"><span class="identifier">const_local_iterator</span>
-      <span class="identifier">cbegin</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code></td></tr>
-<tr><td><code class="computeroutput"><span class="identifier">const_local_iterator</span> <span class="identifier">cend</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code></td></tr>
+      <span class="identifier">cend</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code></td></tr>
 </tbody>
 </table></div>
 </div>
@@ -135,7 +133,7 @@
     </p>
 <p>
       The standard leaves a lot of freedom to the implementer to decide how the number
-      of buckets are chosen, but it does make some requirements based on the container's
+      of buckets is chosen, but it does make some requirements based on the container's
       'load factor', the average number of elements per bucket. Containers also have
       a 'maximum load factor' which they should try to keep the load factor below.
     </p>
@@ -257,8 +255,8 @@
             </td>
 <td>
               <p>
-                Changes the number of buckets so that there at least n buckets, and
-                so that the load factor is less than the maximum load factor.
+                Changes the number of buckets so that there at least <code class="computeroutput"><span class="identifier">n</span></code> buckets, and so that the load
+                factor is less than the maximum load factor.
               </p>
             </td>
 </tr>
@@ -275,8 +273,9 @@
       affect the bucket count, although <code class="computeroutput"><span class="identifier">insert</span></code>
       is only allowed to invalidate iterators when the insertion causes the load
       factor to be greater than or equal to the maximum load factor. For most implementations
-      this means that insert will only change the number of buckets when this happens.
-      While iterators can be invalidated by calls to <code class="computeroutput"><span class="identifier">insert</span></code>
+      this means that <code class="computeroutput"><span class="identifier">insert</span></code> will
+      only change the number of buckets when this happens. While iterators can be
+      invalidated by calls to <code class="computeroutput"><span class="identifier">insert</span></code>
       and <code class="computeroutput"><span class="identifier">rehash</span></code>, pointers and references
       to the container's elements are never invalidated.
     </p>
@@ -290,18 +289,14 @@
       elements into container <code class="computeroutput"><span class="identifier">x</span></code>,
       you could first call:
     </p>
-<pre class="programlisting"><span class="identifier">x</span><span class="special">.</span><span class="identifier">rehash</span><span class="special">((</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">/</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">max_load_factor</span><span class="special">()</span> <span class="special">+</span> <span class="number">1</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">x</span><span class="special">.</span><span class="identifier">rehash</span><span class="special">((</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">/</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">max_load_factor</span><span class="special">());</span>
 </pre>
-<div class="sidebar">
+<div class="blurb">
 <div class="titlepage"><div><div><p class="title"><b></b></p></div></div></div>
 <p>
       Note: <code class="computeroutput"><span class="identifier">rehash</span></code>'s argument is
       the minimum number of buckets, not the number of elements, which is why the
-      new size is divided by the maximum load factor. The <code class="computeroutput"><span class="special">+</span>
-      <span class="number">1</span></code> guarantees there is no invalidation;
-      without it, reallocation could occur if the number of bucket exactly divides
-      the target size, since the container is allowed to rehash when the load factor
-      is equal to the maximum load factor.
+      new size is divided by the maximum load factor.
     </p>
 </div>
 </div>
diff --git a/doc/html/unordered/changes.html b/doc/html/unordered/changes.html
index 2d81f48de1..29392d9c45 100644
--- a/doc/html/unordered/changes.html
+++ b/doc/html/unordered/changes.html
@@ -676,6 +676,20 @@
 </ul></div>
         </li>
 </ul></div>
+<h3>
+<a name="unordered.changes.h26"></a>
+      <span class="phrase"><a name="unordered.changes.boost_1_66_0"></a></span><a class="link" href="changes.html#unordered.changes.boost_1_66_0">Boost
+      1.66.0</a>
+    </h3>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+          Simpler move construction implementation.
+        </li>
+<li class="listitem">
+          Documentation fixes (<a href="https://github.com/boostorg/unordered/pull/6" target="_top">GitHub
+          #6</a>).
+        </li>
+</ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
diff --git a/doc/html/unordered/comparison.html b/doc/html/unordered/comparison.html
index 6e74d03a25..22e418140b 100644
--- a/doc/html/unordered/comparison.html
+++ b/doc/html/unordered/comparison.html
@@ -180,7 +180,7 @@
 <td>
               <p>
                 Iterators iterate through the container in an arbitrary order, that
-                can change as elements are inserted. Although, equivalent elements
+                can change as elements are inserted, although equivalent elements
                 are always adjacent.
               </p>
             </td>
diff --git a/doc/html/unordered/compliance.html b/doc/html/unordered/compliance.html
index 8612841e22..7366e8e032 100644
--- a/doc/html/unordered/compliance.html
+++ b/doc/html/unordered/compliance.html
@@ -37,7 +37,7 @@
 <dt><span class="section"><a href="compliance.html#unordered.compliance.misc">Miscellaneous</a></span></dt>
 </dl></div>
 <p>
-      The intent of Boost.Unordered is to implement a close (but inperfect) implementation
+      The intent of Boost.Unordered is to implement a close (but imperfect) implementation
       of the C++17 standard, that will work with C++98 upwards. The wide compatibility
       does mean some comprimises have to be made. With a compiler and library that
       fully support C++11, the differences should be minor.
@@ -185,7 +185,7 @@
         <code class="computeroutput"><span class="identifier">Hash</span></code> are not currently swapped
         by calling <code class="computeroutput"><span class="identifier">swap</span></code>, their copy
         constructors are used. As a consequence when swapping an exception may be
-        throw from their copy constructor.
+        thrown from their copy constructor.
       </p>
 <p>
         Variadic constructor arguments for <code class="computeroutput"><span class="identifier">emplace</span></code>
diff --git a/doc/html/unordered/hash_equality.html b/doc/html/unordered/hash_equality.html
index f45f188e5f..4818b73ca5 100644
--- a/doc/html/unordered/hash_equality.html
+++ b/doc/html/unordered/hash_equality.html
@@ -45,14 +45,10 @@
       but not the equality predicate. For example, if you wanted to use the <a href="http://www.isthe.com/chongo/tech/comp/fnv/" target="_top">FNV-1 hash</a> you could
       write:
     </p>
-<p>
-</p>
 <pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">hash</span><span class="special">::</span><span class="identifier">fnv_1</span><span class="special">&gt;</span>
     <span class="identifier">dictionary</span><span class="special">;</span>
 </pre>
 <p>
-    </p>
-<p>
       There is an <a href="../../../libs/unordered/examples/fnv1.hpp" target="_top">implementation
       of FNV-1</a> in the examples directory.
     </p>
@@ -61,8 +57,6 @@
       a matching hash function. For example, to implement a case insensitive dictionary
       you need to define a case insensitive equality predicate and hash function:
     </p>
-<p>
-</p>
 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">iequal_to</span>
 <span class="special">{</span>
     <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span>
@@ -90,18 +84,12 @@
 <span class="special">};</span>
 </pre>
 <p>
-    </p>
-<p>
       Which you can then use in a case insensitive dictionary:
     </p>
-<p>
-</p>
 <pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">ihash</span><span class="special">,</span> <span class="identifier">iequal_to</span><span class="special">&gt;</span>
     <span class="identifier">idictionary</span><span class="special">;</span>
 </pre>
 <p>
-    </p>
-<p>
       This is a simplified version of the example at <a href="../../../libs/unordered/examples/case_insensitive.hpp" target="_top">/libs/unordered/examples/case_insensitive.hpp</a>
       which supports other locales and string types.
     </p>
@@ -129,8 +117,6 @@
 <p>
       Similarly, a custom hash function can be used for custom types:
     </p>
-<p>
-</p>
 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">point</span> <span class="special">{</span>
     <span class="keyword">int</span> <span class="identifier">x</span><span class="special">;</span>
     <span class="keyword">int</span> <span class="identifier">y</span><span class="special">;</span>
@@ -155,14 +141,10 @@
 <span class="identifier">boost</span><span class="special">::</span><span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">point</span><span class="special">,</span> <span class="identifier">point_hash</span><span class="special">&gt;</span> <span class="identifier">points</span><span class="special">;</span>
 </pre>
 <p>
-    </p>
-<p>
       Since the default hash function is <a class="link" href="../hash.html" title="Chapter&#160;15.&#160;Boost.Functional/Hash">Boost.Hash</a>,
       we can <a class="link" href="../hash/custom.html" title="Extending boost::hash for a custom data type">extend it to support the type</a> so
       that the hash function doesn't need to be explicitly given:
     </p>
-<p>
-</p>
 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">point</span> <span class="special">{</span>
     <span class="keyword">int</span> <span class="identifier">x</span><span class="special">;</span>
     <span class="keyword">int</span> <span class="identifier">y</span><span class="special">;</span>
@@ -184,8 +166,6 @@
 <span class="identifier">boost</span><span class="special">::</span><span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">point</span><span class="special">&gt;</span> <span class="identifier">points</span><span class="special">;</span>
 </pre>
 <p>
-    </p>
-<p>
       See the <a class="link" href="../hash/custom.html" title="Extending boost::hash for a custom data type">Boost.Hash documentation</a> for more
       detail on how to do this. Remember that it relies on extensions to the draft
       standard - so it won't work for other implementations of the unordered associative
diff --git a/doc/html/unordered/rationale.html b/doc/html/unordered/rationale.html
index 22b0607b95..241f7182eb 100644
--- a/doc/html/unordered/rationale.html
+++ b/doc/html/unordered/rationale.html
@@ -49,7 +49,7 @@
 <p>
       It would be conceivable to write a hash table that uses another method. For
       example, it could use open addressing, and use the lookup chain to act as a
-      bucket but there are a some serious problems with this:
+      bucket but there are some serious problems with this:
     </p>
 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
@@ -95,7 +95,7 @@
     </p>
 <p>
       Using a power of 2 allows for much quicker selection of the bucket to use,
-      but at the expense of loosing the upper bits of the hash value. For some specially
+      but at the expense of losing the upper bits of the hash value. For some specially
       designed hash functions it is possible to do this and still get a good result
       but as the containers can take arbitrary hash functions this can't be relied
       on.
diff --git a/doc/html/unordered/reference.html b/doc/html/unordered/reference.html
index 3b55f98514..bba1eebb38 100644
--- a/doc/html/unordered/reference.html
+++ b/doc/html/unordered/reference.html
@@ -39,31 +39,31 @@
            <span class="keyword">typename</span> Alloc <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">&gt;</span> <span class="special">&gt;</span> 
     <span class="keyword">class</span> <a class="link" href="../boost/unordered_set.html" title="Class template unordered_set">unordered_set</a><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Value<span class="special">,</span> <span class="keyword">typename</span> Hash<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">,</span> <span class="keyword">typename</span> Alloc<span class="special">&gt;</span> 
-    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_set.html#boost.unordered_set.operator==_idp779846368"><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
+    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_set.html#boost.unordered_set.operator=="><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
                     <span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Value<span class="special">,</span> <span class="keyword">typename</span> Hash<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">,</span> <span class="keyword">typename</span> Alloc<span class="special">&gt;</span> 
-    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_set.html#boost.unordered_set.operator!=_idp779858096"><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
+    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_set.html#boost.unordered_set.operator!="><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
                     <span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Value<span class="special">,</span> <span class="keyword">typename</span> Hash<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">,</span> <span class="keyword">typename</span> Alloc<span class="special">&gt;</span> 
-    <span class="keyword">void</span> <a class="link" href="../boost/unordered_set.html#boost.unordered_set.swap_idp779870544"><span class="identifier">swap</span></a><span class="special">(</span><span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">,</span> 
+    <span class="keyword">void</span> <a class="link" href="../boost/unordered_set.html#boost.unordered_set.swap"><span class="identifier">swap</span></a><span class="special">(</span><span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">,</span> 
               <span class="identifier">unordered_set</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Value<span class="special">,</span> <span class="keyword">typename</span> Hash <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">&gt;</span><span class="special">,</span> 
            <span class="keyword">typename</span> Pred <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">&gt;</span><span class="special">,</span> 
            <span class="keyword">typename</span> Alloc <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">&gt;</span> <span class="special">&gt;</span> 
     <span class="keyword">class</span> <a class="link" href="../boost/unordered_multiset.html" title="Class template unordered_multiset">unordered_multiset</a><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Value<span class="special">,</span> <span class="keyword">typename</span> Hash<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">,</span> <span class="keyword">typename</span> Alloc<span class="special">&gt;</span> 
-    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_multiset.html#boost.unordered_multiset.operator==_idp780404368"><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
+    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_multiset.html#boost.unordered_multiset.operator=="><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
                     <span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Value<span class="special">,</span> <span class="keyword">typename</span> Hash<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">,</span> <span class="keyword">typename</span> Alloc<span class="special">&gt;</span> 
-    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_multiset.html#boost.unordered_multiset.operator!=_idp780416064"><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
+    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_multiset.html#boost.unordered_multiset.operator!="><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
                     <span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Value<span class="special">,</span> <span class="keyword">typename</span> Hash<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">,</span> <span class="keyword">typename</span> Alloc<span class="special">&gt;</span> 
-    <span class="keyword">void</span> <a class="link" href="../boost/unordered_multiset.html#boost.unordered_multiset.swap_idp780428480"><span class="identifier">swap</span></a><span class="special">(</span><span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">,</span> 
+    <span class="keyword">void</span> <a class="link" href="../boost/unordered_multiset.html#boost.unordered_multiset.swap"><span class="identifier">swap</span></a><span class="special">(</span><span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">,</span> 
               <span class="identifier">unordered_multiset</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">namespace</span> <span class="identifier">unordered</span> <span class="special">{</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ImplementationDefined<span class="special">&gt;</span> <span class="keyword">class</span> <a class="link" href="../boost/unordered/node_handle_set.html" title="Class template node_handle_set">node_handle_set</a><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ImplementationDefined<span class="special">&gt;</span> 
-      <span class="keyword">void</span> <a class="link" href="../boost/unordered/node_handle_set.html#boost.unordered.node_handle_set.swap_idp780468784"><span class="identifier">swap</span></a><span class="special">(</span><span class="identifier">node_handle_set</span><span class="special">&lt;</span><span class="identifier">ImplementationDefined</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">,</span> 
+      <span class="keyword">void</span> <a class="link" href="../boost/unordered/node_handle_set.html#boost.unordered.node_handle_set.swap"><span class="identifier">swap</span></a><span class="special">(</span><span class="identifier">node_handle_set</span><span class="special">&lt;</span><span class="identifier">ImplementationDefined</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">,</span> 
                 <span class="identifier">node_handle_set</span><span class="special">&lt;</span><span class="identifier">ImplementationDefined</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="special">}</span>
 <span class="special">}</span></pre>
@@ -78,15 +78,15 @@
     <span class="keyword">class</span> <a class="link" href="../boost/unordered_map.html" title="Class template unordered_map">unordered_map</a><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Key<span class="special">,</span> <span class="keyword">typename</span> Mapped<span class="special">,</span> <span class="keyword">typename</span> Hash<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">,</span> 
            <span class="keyword">typename</span> Alloc<span class="special">&gt;</span> 
-    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_map.html#boost.unordered_map.operator==_idp781032320"><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
+    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_map.html#boost.unordered_map.operator=="><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
                     <span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Key<span class="special">,</span> <span class="keyword">typename</span> Mapped<span class="special">,</span> <span class="keyword">typename</span> Hash<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">,</span> 
            <span class="keyword">typename</span> Alloc<span class="special">&gt;</span> 
-    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_map.html#boost.unordered_map.operator!=_idp781044768"><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
+    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_map.html#boost.unordered_map.operator!="><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
                     <span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Key<span class="special">,</span> <span class="keyword">typename</span> Mapped<span class="special">,</span> <span class="keyword">typename</span> Hash<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">,</span> 
            <span class="keyword">typename</span> Alloc<span class="special">&gt;</span> 
-    <span class="keyword">void</span> <a class="link" href="../boost/unordered_map.html#boost.unordered_map.swap_idp781057936"><span class="identifier">swap</span></a><span class="special">(</span><span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">,</span> 
+    <span class="keyword">void</span> <a class="link" href="../boost/unordered_map.html#boost.unordered_map.swap"><span class="identifier">swap</span></a><span class="special">(</span><span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">,</span> 
               <span class="identifier">unordered_map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Key<span class="special">,</span> <span class="keyword">typename</span> Mapped<span class="special">,</span> <span class="keyword">typename</span> Hash <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">hash</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;</span><span class="special">,</span> 
            <span class="keyword">typename</span> Pred <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;</span><span class="special">,</span> 
@@ -94,20 +94,20 @@
     <span class="keyword">class</span> <a class="link" href="../boost/unordered_multimap.html" title="Class template unordered_multimap">unordered_multimap</a><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Key<span class="special">,</span> <span class="keyword">typename</span> Mapped<span class="special">,</span> <span class="keyword">typename</span> Hash<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">,</span> 
            <span class="keyword">typename</span> Alloc<span class="special">&gt;</span> 
-    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_multimap.html#boost.unordered_multimap.operator==_idp781597408"><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="identifier">unordered_multimap</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
+    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_multimap.html#boost.unordered_multimap.operator=="><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="identifier">unordered_multimap</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
                     <span class="identifier">unordered_multimap</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Key<span class="special">,</span> <span class="keyword">typename</span> Mapped<span class="special">,</span> <span class="keyword">typename</span> Hash<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">,</span> 
            <span class="keyword">typename</span> Alloc<span class="special">&gt;</span> 
-    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_multimap.html#boost.unordered_multimap.operator!=_idp781609856"><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="identifier">unordered_multimap</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
+    <span class="keyword">bool</span> <a class="link" href="../boost/unordered_multimap.html#boost.unordered_multimap.operator!="><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="identifier">unordered_multimap</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">,</span> 
                     <span class="identifier">unordered_multimap</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Key<span class="special">,</span> <span class="keyword">typename</span> Mapped<span class="special">,</span> <span class="keyword">typename</span> Hash<span class="special">,</span> <span class="keyword">typename</span> Pred<span class="special">,</span> 
            <span class="keyword">typename</span> Alloc<span class="special">&gt;</span> 
-    <span class="keyword">void</span> <a class="link" href="../boost/unordered_multimap.html#boost.unordered_multimap.swap_idp781623024"><span class="identifier">swap</span></a><span class="special">(</span><span class="identifier">unordered_multimap</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">,</span> 
+    <span class="keyword">void</span> <a class="link" href="../boost/unordered_multimap.html#boost.unordered_multimap.swap"><span class="identifier">swap</span></a><span class="special">(</span><span class="identifier">unordered_multimap</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">,</span> 
               <span class="identifier">unordered_multimap</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Mapped</span><span class="special">,</span> <span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">namespace</span> <span class="identifier">unordered</span> <span class="special">{</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ImplementationDefined<span class="special">&gt;</span> <span class="keyword">class</span> <a class="link" href="../boost/unordered/node_handle_map.html" title="Class template node_handle_map">node_handle_map</a><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> ImplementationDefined<span class="special">&gt;</span> 
-      <span class="keyword">void</span> <a class="link" href="../boost/unordered/node_handle_map.html#boost.unordered.node_handle_map.swap_idp781666672"><span class="identifier">swap</span></a><span class="special">(</span><span class="identifier">node_handle_map</span><span class="special">&lt;</span><span class="identifier">ImplementationDefined</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">,</span> 
+      <span class="keyword">void</span> <a class="link" href="../boost/unordered/node_handle_map.html#boost.unordered.node_handle_map.swap"><span class="identifier">swap</span></a><span class="special">(</span><span class="identifier">node_handle_map</span><span class="special">&lt;</span><span class="identifier">ImplementationDefined</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">,</span> 
                 <span class="identifier">node_handle_map</span><span class="special">&lt;</span><span class="identifier">ImplementationDefined</span><span class="special">&gt;</span><span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="special">}</span>
 <span class="special">}</span></pre>