ceph/src/boost/libs/bimap/doc/html/boost_bimap/reference/unordered_set_of_reference.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>unordered_set_of Reference</title>
   5 <link rel="stylesheet" href="../../boostbook.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
   7 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Bimap">
   8 <link rel="up" href="../reference.html" title="Reference">
   9 <link rel="prev" href="set_of_reference.html" title="set_of Reference">
  10 <link rel="next" href="list_of_reference.html" title="list_of Reference">
  11 </head>
  12 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  13 <table cellpadding="2" width="100%"><tr>
  14 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
  15 <td align="center"><a href="../../../../../../index.html">Home</a></td>
  16 <td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
  17 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
  18 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
  19 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
  20 </tr></table>
  21 <hr>
  22 <div class="spirit-nav">
  23 <a accesskey="p" href="set_of_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="list_of_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
  24 </div>
  25 <div class="section boost_bimap_reference_unordered_set_of_reference">
  26 <div class="titlepage"><div><div><h3 class="title">
  27 <a name="boost_bimap.reference.unordered_set_of_reference"></a><a class="link" href="unordered_set_of_reference.html" title="unordered_set_of Reference">unordered_set_of
  28       Reference</a>
  29 </h3></div></div></div>
  30 <div class="toc"><dl>
  31 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.header__boost_bimap_unordered_set_of_hpp__synopsis">Header
  32         "boost/bimap/unordered_set_of.hpp" synopsis</a></span></dt>
  33 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.header__boost_bimap_unordered_multiset_of_hpp__synopsis">Header
  34         "boost/bimap/unordered_multiset_of.hpp" synopsis</a></span></dt>
  35 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.collection_type_specifiers_unordered_set_of_and_unordered_multiset_of">Collection
  36         type specifiers unordered_set_of and unordered_multiset_of</a></span></dt>
  37 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views">unordered_[multi]set_of
  38         Views</a></span></dt>
  39 <dd><dl>
  40 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.complexity_signature">Complexity
  41           signature</a></span></dt>
  42 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.instantiation_types">Instantiation
  43           types</a></span></dt>
  44 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.nested_types">Nested
  45           types</a></span></dt>
  46 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.constructors__copy_and_assignment">Constructors,
  47           copy and assignment</a></span></dt>
  48 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.modifiers">Modifiers</a></span></dt>
  49 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.lookup">Lookup</a></span></dt>
  50 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.at____info_at___and_operator_______set_of_only">at(),
  51           info_at() and operator[] - set_of only</a></span></dt>
  52 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.hash_policy">Hash
  53           policy</a></span></dt>
  54 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.serialization">Serialization</a></span></dt>
  55 </dl></dd>
  56 </dl></div>
  57 <div class="section boost_bimap_reference_unordered_set_of_reference_header__boost_bimap_unordered_set_of_hpp__synopsis">
  58 <div class="titlepage"><div><div><h4 class="title">
  59 <a name="boost_bimap.reference.unordered_set_of_reference.header__boost_bimap_unordered_set_of_hpp__synopsis"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.header__boost_bimap_unordered_set_of_hpp__synopsis" title='Header "boost/bimap/unordered_set_of.hpp" synopsis'>Header
  60         "boost/bimap/unordered_set_of.hpp" synopsis</a>
  61 </h4></div></div></div>
  62 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
  63 <span class="keyword">namespace</span> <span class="identifier">bimaps</span> <span class="special">{</span>
  64
  65
  66 <span class="keyword">template</span>
  67 <span class="special">&lt;</span>
  68     <span class="keyword">class</span> <span class="identifier">KeyType</span><span class="special">,</span>
  69     <span class="keyword">class</span> <span class="identifier">HashFunctor</span>   <span class="special">=</span> <span class="identifier">hash</span><span class="special">&lt;</span> <span class="identifier">KeyType</span> <span class="special">&gt;,</span>
  70     <span class="keyword">class</span> <span class="identifier">EqualKey</span>      <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">KeyType</span> <span class="special">&gt;</span>
  71 <span class="special">&gt;</span>
  72 <span class="keyword">struct</span> <span class="identifier">unordered_set_of</span><span class="special">;</span>
  73
  74
  75 <span class="keyword">template</span>
  76 <span class="special">&lt;</span>
  77     <span class="keyword">class</span> <span class="identifier">HashFunctor</span>   <span class="special">=</span> <span class="identifier">hash</span><span class="special">&lt;</span> <span class="identifier">_relation</span> <span class="special">&gt;,</span>
  78     <span class="keyword">class</span> <span class="identifier">EqualKey</span>      <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">_relation</span> <span class="special">&gt;</span>
  79 <span class="special">&gt;</span>
  80 <span class="keyword">struct</span> <span class="identifier">unordered_set_of_relation</span><span class="special">;</span>
  81
  82
  83 <span class="special">}</span> <span class="comment">// namespace bimap</span>
  84 <span class="special">}</span> <span class="comment">// namespace boost</span>
  85 </pre>
  86 </div>
  87 <div class="section boost_bimap_reference_unordered_set_of_reference_header__boost_bimap_unordered_multiset_of_hpp__synopsis">
  88 <div class="titlepage"><div><div><h4 class="title">
  89 <a name="boost_bimap.reference.unordered_set_of_reference.header__boost_bimap_unordered_multiset_of_hpp__synopsis"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.header__boost_bimap_unordered_multiset_of_hpp__synopsis" title='Header "boost/bimap/unordered_multiset_of.hpp" synopsis'>Header
  90         "boost/bimap/unordered_multiset_of.hpp" synopsis</a>
  91 </h4></div></div></div>
  92 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
  93 <span class="keyword">namespace</span> <span class="identifier">bimaps</span> <span class="special">{</span>
  94
  95
  96 <span class="keyword">template</span>
  97 <span class="special">&lt;</span>
  98     <span class="keyword">class</span> <span class="identifier">KeyType</span><span class="special">,</span>
  99     <span class="keyword">class</span> <span class="identifier">HashFunctor</span>   <span class="special">=</span> <span class="identifier">hash</span><span class="special">&lt;</span> <span class="identifier">KeyType</span> <span class="special">&gt;,</span>
 100     <span class="keyword">class</span> <span class="identifier">EqualKey</span>      <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">KeyType</span> <span class="special">&gt;</span>
 101 <span class="special">&gt;</span>
 102 <span class="keyword">struct</span> <span class="identifier">unordered_multiset_of</span><span class="special">;</span>
 103
 104
 105 <span class="keyword">template</span>
 106 <span class="special">&lt;</span>
 107     <span class="keyword">class</span> <span class="identifier">HashFunctor</span>   <span class="special">=</span> <span class="identifier">hash</span><span class="special">&lt;</span> <span class="identifier">_relation</span> <span class="special">&gt;,</span>
 108     <span class="keyword">class</span> <span class="identifier">EqualKey</span>      <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">_relation</span> <span class="special">&gt;</span>
 109 <span class="special">&gt;</span>
 110 <span class="keyword">struct</span> <span class="identifier">unordered_multiset_of_relation</span><span class="special">;</span>
 111
 112
 113 <span class="special">}</span> <span class="comment">// namespace bimap</span>
 114 <span class="special">}</span> <span class="comment">// namespace boost</span>
 115 </pre>
 116 </div>
 117 <div class="section boost_bimap_reference_unordered_set_of_reference_collection_type_specifiers_unordered_set_of_and_unordered_multiset_of">
 118 <div class="titlepage"><div><div><h4 class="title">
 119 <a name="boost_bimap.reference.unordered_set_of_reference.collection_type_specifiers_unordered_set_of_and_unordered_multiset_of"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.collection_type_specifiers_unordered_set_of_and_unordered_multiset_of" title="Collection type specifiers unordered_set_of and unordered_multiset_of">Collection
 120         type specifiers unordered_set_of and unordered_multiset_of</a>
 121 </h4></div></div></div>
 122 <p>
 123           These collection types specifiers allow for set views without and with
 124           allowance of duplicate elements, respectively. The syntax of <code class="computeroutput"><span class="identifier">set_of</span></code> and <code class="computeroutput"><span class="identifier">multiset_of</span></code>
 125           coincide, thus we describe them in a grouped manner.
 126         </p>
 127 </div>
 128 <div class="section boost_bimap_reference_unordered_set_of_reference_unordered___multi__set_of_views">
 129 <div class="titlepage"><div><div><h4 class="title">
 130 <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views" title="unordered_[multi]set_of Views">unordered_[multi]set_of
 131         Views</a>
 132 </h4></div></div></div>
 133 <div class="toc"><dl>
 134 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.complexity_signature">Complexity
 135           signature</a></span></dt>
 136 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.instantiation_types">Instantiation
 137           types</a></span></dt>
 138 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.nested_types">Nested
 139           types</a></span></dt>
 140 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.constructors__copy_and_assignment">Constructors,
 141           copy and assignment</a></span></dt>
 142 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.modifiers">Modifiers</a></span></dt>
 143 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.lookup">Lookup</a></span></dt>
 144 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.at____info_at___and_operator_______set_of_only">at(),
 145           info_at() and operator[] - set_of only</a></span></dt>
 146 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.hash_policy">Hash
 147           policy</a></span></dt>
 148 <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.serialization">Serialization</a></span></dt>
 149 </dl></div>
 150 <p>
 151           An unordered_[multi]set_of set view is a tr1::unordered[multi]set signature
 152           compatible interface to the underlying heap of elements contained in a
 153           <code class="computeroutput"><span class="identifier">bimap</span></code>.
 154         </p>
 155 <p>
 156           The interface and semantics of <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code>
 157           views are modeled according to the proposal for unordered associative containers
 158           given in the <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1836.pdf" target="_top">C++
 159           Standard Library Technical Report</a>, also known as TR1. An <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code> view is particularized according
 160           to a given <code class="computeroutput"><span class="identifier">Hash</span></code> function
 161           object which returns hash values for the keys and a binary predicate <code class="computeroutput"><span class="identifier">Pred</span></code> acting as an equivalence relation
 162           on values of Key.
 163         </p>
 164 <p>
 165           There are two variants: unordered_set_of, which do not allow duplicate
 166           elements (with respect to its associated comparison predicate) and unordered_multiset_of,
 167           which accept those duplicates. The interface of these two variants is the
 168           same to a great extent, so they are documented together with their differences
 169           explicitly noted when they exist.
 170         </p>
 171 <p>
 172           If you look the bimap by a side, you will use a map view and if you looked
 173           it as a whole you will be using a set view.
 174         </p>
 175 <p>
 176           Except where noted, <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code>
 177           views (both unique and non-unique) are models of <code class="literal">Unordered Associative
 178           Container</code>. Validity of iterators and references to elements is
 179           preserved in all cases. Occasionally, the exception safety guarantees provided
 180           are actually stronger than required by the extension draft. We only provide
 181           descriptions of those types and operations that are either not present
 182           in the concepts modeled or do not exactly conform to the requirements for
 183           unordered associative containers.
 184         </p>
 185 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
 186 <span class="keyword">namespace</span> <span class="identifier">bimap</span> <span class="special">{</span>
 187 <span class="keyword">namespace</span> <span class="identifier">views</span> <span class="special">{</span>
 188
 189 <span class="keyword">template</span><span class="special">&lt;</span> <span class="emphasis"><em>-implementation defined parameter list-</em></span> <span class="special">&gt;</span>
 190 <span class="keyword">class</span> <span class="emphasis"><em>-implementation defined view name-</em></span>
 191 <span class="special">{</span>
 192     <span class="keyword">public</span><span class="special">:</span>
 193
 194     <span class="comment">// types</span>
 195
 196     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">key_type</span><span class="special">;</span>
 197     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">value_type</span><span class="special">;</span>
 198     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">key_compare</span><span class="special">;</span>
 199     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">value_compare</span><span class="special">;</span>
 200     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">hasher</span><span class="special">;</span>
 201     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">key_equal</span><span class="special">;</span>
 202     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">allocator_type</span><span class="special">;</span>
 203     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">reference</span><span class="special">;</span>
 204     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">const_reference</span><span class="special">;</span>
 205     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">iterator</span><span class="special">;</span>
 206     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">const_iterator</span><span class="special">;</span>
 207     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">size_type</span><span class="special">;</span>
 208     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">difference_type</span><span class="special">;</span>
 209     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">pointer</span><span class="special">;</span>
 210     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">const_pointer</span><span class="special">;</span>
 211     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">local_iterator</span><span class="special">;</span>
 212     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">const_local_iterator</span><span class="special">;</span>
 213
 214     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">info_type</span><span class="special">;</span>
 215
 216     <span class="comment">// construct/destroy/copy:</span>
 217
 218     <span class="identifier">this_type</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">this_type</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 219
 220     <span class="identifier">allocator_type</span> <span class="identifier">get_allocator</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 221
 222     <span class="comment">// size and capacity</span>
 223
 224     <span class="keyword">bool</span>      <span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 225     <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 226     <span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 227
 228     <span class="comment">// iterators</span>
 229
 230     <span class="identifier">iterator</span>       <span class="identifier">begin</span><span class="special">();</span>
 231     <span class="identifier">const_iterator</span> <span class="identifier">begin</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 232     <span class="identifier">iterator</span>       <span class="identifier">end</span><span class="special">();</span>
 233     <span class="identifier">const_iterator</span> <span class="identifier">end</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 234
 235     <span class="comment">// modifiers</span>
 236
 237     <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="keyword">bool</span> <span class="special">&gt;</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_insert_value">insert</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 238
 239     <span class="identifier">iterator</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_insert_iterator_value">insert</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 240
 241     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">InputIterator</span> <span class="special">&gt;</span>
 242     <span class="keyword">void</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_insert_iterator_iterator">insert</a><span class="special">(</span><span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">);</span>
 243
 244     <span class="identifier">iterator</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_erase_iterator">erase</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">);</span>
 245
 246     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 247     <span class="identifier">size_type</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_erase_key">erase</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 248
 249     <span class="identifier">iterator</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_erase_iterator_iterator">erase</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="identifier">last</span><span class="special">);</span>
 250
 251     <span class="keyword">bool</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_replace_iterator_value">replace</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 252
 253     <span class="comment">// Only in map views</span>
 254     <span class="comment">// {</span>
 255
 256       <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">mapped_type</span><span class="special">;</span>
 257       <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">data_type</span><span class="special">;</span> <span class="comment">// Equal to mapped_type</span>
 258
 259       <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 260       <span class="keyword">bool</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_replace_key_iterator_key">replace_key</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 261
 262       <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleData</span> <span class="special">&gt;</span>
 263       <span class="keyword">bool</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_replace_data_iterator_data">replace_data</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">CompatibleData</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 264
 265       <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">KeyModifier</span> <span class="special">&gt;</span>
 266       <span class="keyword">bool</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_modify_key_iterator_modifier">modify_key</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">KeyModifier</span> <span class="identifier">mod</span><span class="special">);</span>
 267
 268       <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">DataModifier</span> <span class="special">&gt;</span>
 269       <span class="keyword">bool</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_modify_data_iterator_modifier">modify_data</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">DataModifier</span> <span class="identifier">mod</span><span class="special">);</span>
 270
 271     <span class="comment">// }</span>
 272
 273
 274     <span class="keyword">void</span> <span class="identifier">clear</span><span class="special">();</span>
 275
 276     <span class="comment">// observers</span>
 277
 278     <span class="identifier">key_from_value</span> <span class="identifier">key_extractor</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 279     <span class="identifier">hasher</span>         <span class="identifier">hash_function</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 280     <span class="identifier">key_equal</span>      <span class="identifier">key_eq</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 281
 282     <span class="comment">// lookup</span>
 283
 284     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 285     <span class="identifier">iterator</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_find_key">find</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 286
 287     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 288     <span class="identifier">const_iterator</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_find_key">find</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 289
 290     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 291     <span class="identifier">size_type</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_count_key">count</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 292
 293     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 294     <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">,</span><span class="identifier">iterator</span><span class="special">&gt;</span>
 295         <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_equal_range_key">equal_range</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 296
 297     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 298     <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">const_iterator</span><span class="special">,</span><span class="identifier">const_iterator</span><span class="special">&gt;</span>
 299         <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_equal_range_key">equal_range</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 300
 301     <span class="comment">// bucket interface</span>
 302
 303     <span class="identifier">size_type</span> <span class="identifier">bucket_count</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 304     <span class="identifier">size_type</span> <span class="identifier">max_bucket_count</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 305     <span class="identifier">size_type</span> <span class="identifier">bucket_size</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>
 306     <span class="identifier">size_type</span> <span class="identifier">bucket</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 307
 308     <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>
 309     <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>
 310     <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>
 311     <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>
 312
 313     <span class="comment">// hash policy</span>
 314
 315     <span class="keyword">float</span> <span class="identifier">load_factor</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 316     <span class="keyword">float</span> <span class="identifier">max_load_factor</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 317     <span class="keyword">void</span>  <span class="identifier">max_load_factor</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">z</span><span class="special">);</span>
 318     <span class="keyword">void</span>  <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_rehash_size">rehash</a><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
 319
 320     <span class="comment">// Only in maps views</span>
 321     <span class="comment">// {</span>
 322
 323     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">mapped_type</span><span class="special">;</span>
 324
 325       <span class="comment">// Only in for `unordered_set_of` collection type</span>
 326       <span class="comment">// {</span>
 327
 328       <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompatibleKey</span><span class="special">&gt;</span>
 329       <span class="keyword">const</span> <span class="identifier">mapped_type</span> <span class="special">&amp;</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_at_key_const">at</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 330
 331         <span class="comment">// Only if the other collection type is mutable</span>
 332         <span class="comment">// {</span>
 333
 334         <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompatibleKey</span><span class="special">&gt;</span>
 335         <span class="identifier">mapped_type</span> <span class="special">&amp;</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_operator_bracket_key">operator[]</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">);</span>
 336
 337         <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompatibleKey</span><span class="special">&gt;</span>
 338         <span class="identifier">mapped_type</span> <span class="special">&amp;</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_at_key">at</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">);</span>
 339
 340         <span class="comment">// }</span>
 341
 342         <span class="comment">// Only if info_hook is used</span>
 343         <span class="comment">// {</span>
 344
 345         <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 346         <span class="identifier">info_type</span> <span class="special">&amp;</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_info_at_key">info_at</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">);</span>
 347
 348         <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 349         <span class="keyword">const</span> <span class="identifier">info_type</span> <span class="special">&amp;</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_info_at_key">info_at</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 350
 351       <span class="comment">// }</span>
 352
 353     <span class="comment">// }</span>
 354
 355 <span class="special">};</span>
 356
 357 <span class="special">}</span> <span class="comment">// namespace views</span>
 358 <span class="special">}</span> <span class="comment">// namespace bimap</span>
 359 <span class="special">}</span> <span class="comment">// namespace boost</span>
 360 </pre>
 361 <p>
 362           In the case of a <code class="computeroutput"><span class="identifier">bimap</span><span class="special">&lt;</span> <span class="identifier">unordered_</span><span class="special">{</span><span class="identifier">multi</span><span class="special">}</span><span class="identifier">set_of</span><span class="special">&lt;</span><span class="identifier">Left</span><span class="special">&gt;,</span> <span class="special">...</span> <span class="special">&gt;</span></code>
 363         </p>
 364 <p>
 365           In the set view:
 366         </p>
 367 <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">signature</span><span class="special">-</span><span class="identifier">compatible</span> <span class="identifier">with</span> <span class="identifier">relation</span><span class="special">&lt;</span>       <span class="identifier">Left</span><span class="special">,</span> <span class="special">...</span> <span class="special">&gt;</span> <span class="identifier">key_type</span><span class="special">;</span>
 368 <span class="keyword">typedef</span> <span class="identifier">signature</span><span class="special">-</span><span class="identifier">compatible</span> <span class="identifier">with</span> <span class="identifier">relation</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Left</span><span class="special">,</span> <span class="special">...</span> <span class="special">&gt;</span> <span class="identifier">value_type</span><span class="special">;</span>
 369 </pre>
 370 <p>
 371           In the left map view:
 372         </p>
 373 <pre class="programlisting"><span class="keyword">typedef</span>  <span class="identifier">Left</span>  <span class="identifier">key_type</span><span class="special">;</span>
 374 <span class="keyword">typedef</span>  <span class="special">...</span>   <span class="identifier">mapped_type</span><span class="special">;</span>
 375
 376 <span class="keyword">typedef</span> <span class="identifier">signature</span><span class="special">-</span><span class="identifier">compatible</span> <span class="identifier">with</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Left</span><span class="special">,</span> <span class="special">...</span> <span class="special">&gt;</span> <span class="identifier">value_type</span><span class="special">;</span>
 377 </pre>
 378 <p>
 379           In the right map view:
 380         </p>
 381 <pre class="programlisting"><span class="keyword">typedef</span>  <span class="special">...</span>  <span class="identifier">key_type</span><span class="special">;</span>
 382 <span class="keyword">typedef</span>  <span class="identifier">Left</span> <span class="identifier">mapped_type</span><span class="special">;</span>
 383
 384 <span class="keyword">typedef</span> <span class="identifier">signature</span><span class="special">-</span><span class="identifier">compatible</span> <span class="identifier">with</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="special">...</span> <span class="special">,</span><span class="keyword">const</span> <span class="identifier">Left</span> <span class="special">&gt;</span> <span class="identifier">value_type</span><span class="special">;</span>
 385 </pre>
 386 <div class="section boost_bimap_reference_unordered_set_of_reference_unordered___multi__set_of_views_complexity_signature">
 387 <div class="titlepage"><div><div><h5 class="title">
 388 <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.complexity_signature"></a><a name="unordered_set_of_complexity_signature"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.complexity_signature" title="Complexity signature">Complexity
 389           signature</a>
 390 </h5></div></div></div>
 391 <p>
 392             Here and in the descriptions of operations of <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code>
 393             views, we adopt the scheme outlined in the <a class="link" href="bimap_reference.html#complexity_signature_explanation">complexity
 394             signature section</a>. The complexity signature of <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code>
 395             view is:
 396           </p>
 397 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 398 <li class="listitem">
 399                 copying: <code class="computeroutput"><span class="identifier">c</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">n</span> <span class="special">*</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span></code>,
 400               </li>
 401 <li class="listitem">
 402                 insertion: average case <code class="computeroutput"><span class="identifier">i</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="number">1</span></code> (constant), worst case <code class="computeroutput"><span class="identifier">i</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">n</span></code>,
 403               </li>
 404 <li class="listitem">
 405                 hinted insertion: average case <code class="computeroutput"><span class="identifier">h</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="number">1</span></code> (constant), worst case <code class="computeroutput"><span class="identifier">h</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">n</span></code>,
 406               </li>
 407 <li class="listitem">
 408                 deletion: average case <code class="computeroutput"><span class="identifier">d</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="number">1</span></code> (constant), worst case <code class="computeroutput"><span class="identifier">d</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">n</span></code>,
 409               </li>
 410 <li class="listitem">
 411                 replacement:
 412                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
 413 <li class="listitem">
 414                       if the new element key is equivalent to the original, <code class="computeroutput"><span class="identifier">r</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span>
 415                       <span class="special">=</span> <span class="number">1</span></code>
 416                       (constant),
 417                     </li>
 418 <li class="listitem">
 419                       otherwise, average case <code class="computeroutput"><span class="identifier">r</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span>
 420                       <span class="number">1</span></code> (constant), worst case
 421                       <code class="computeroutput"><span class="identifier">r</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span>
 422                       <span class="special">=</span> <span class="identifier">n</span></code>,
 423                     </li>
 424 </ul></div>
 425               </li>
 426 <li class="listitem">
 427                 modifying: average case <code class="computeroutput"><span class="identifier">m</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="number">1</span></code> (constant), worst case <code class="computeroutput"><span class="identifier">m</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">n</span></code>.
 428               </li>
 429 </ul></div>
 430 </div>
 431 <div class="section boost_bimap_reference_unordered_set_of_reference_unordered___multi__set_of_views_instantiation_types">
 432 <div class="titlepage"><div><div><h5 class="title">
 433 <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.instantiation_types"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.instantiation_types" title="Instantiation types">Instantiation
 434           types</a>
 435 </h5></div></div></div>
 436 <p>
 437             <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code> views are instantiated internally
 438             to <code class="computeroutput"><span class="identifier">bimap</span></code> specified by
 439             means of the collection type specifiers and the <code class="computeroutput"><span class="identifier">bimap</span></code>
 440             itself. Instantiations are dependent on the following types:
 441           </p>
 442 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 443 <li class="listitem">
 444                 <code class="computeroutput"><span class="identifier">Value</span></code> from <code class="computeroutput"><span class="identifier">bimap</span></code>,
 445               </li>
 446 <li class="listitem">
 447                 <code class="computeroutput"><span class="identifier">Allocator</span></code> from <code class="computeroutput"><span class="identifier">bimap</span></code>,
 448               </li>
 449 <li class="listitem">
 450                 <code class="computeroutput"><span class="identifier">Hash</span></code> from the collection
 451                 type specifier,
 452               </li>
 453 <li class="listitem">
 454                 <code class="computeroutput"><span class="identifier">Pred</span></code> from the collection
 455                 type specifier.
 456               </li>
 457 </ul></div>
 458 <p>
 459             <code class="computeroutput"><span class="identifier">Hash</span></code> is a <a href="http://www.sgi.com/tech/stl/UnaryFunction.html" target="_top">Unary
 460             Function</a> taking a single argument of type <code class="computeroutput"><span class="identifier">key_type</span></code>
 461             and returning a value of type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>
 462             in the range <code class="computeroutput"><span class="special">[</span><span class="number">0</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">())</span></code>. Pred is a <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html" target="_top">Binary
 463             Predicate</a> inducing an equivalence relation on elements of <code class="computeroutput"><span class="identifier">key_type</span></code>. It is required that the
 464             <code class="computeroutput"><span class="identifier">Hash</span></code> object return the
 465             same value for keys equivalent under <code class="computeroutput"><span class="identifier">Pred</span></code>.
 466           </p>
 467 </div>
 468 <div class="section boost_bimap_reference_unordered_set_of_reference_unordered___multi__set_of_views_nested_types">
 469 <div class="titlepage"><div><div><h5 class="title">
 470 <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.nested_types"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.nested_types" title="Nested types">Nested
 471           types</a>
 472 </h5></div></div></div>
 473 <pre class="programlisting"><span class="identifier">iterator</span>
 474 <span class="identifier">const_iterator</span>
 475 <span class="identifier">local_iterator</span>
 476 <span class="identifier">const_local_iterator</span>
 477 </pre>
 478 <div class="blockquote"><blockquote class="blockquote"><p>
 479               These types are models of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html" target="_top">Forward
 480               Iterator</a>.
 481             </p></blockquote></div>
 482 </div>
 483 <div class="section boost_bimap_reference_unordered_set_of_reference_unordered___multi__set_of_views_constructors__copy_and_assignment">
 484 <div class="titlepage"><div><div><h5 class="title">
 485 <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.constructors__copy_and_assignment"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.constructors__copy_and_assignment" title="Constructors, copy and assignment">Constructors,
 486           copy and assignment</a>
 487 </h5></div></div></div>
 488 <p>
 489             As explained in the concepts section, views do not have public constructors
 490             or destructors. Assignment, on the other hand, is provided. Upon construction,
 491             <code class="computeroutput"><span class="identifier">max_load_factor</span><span class="special">()</span></code>
 492             is 1.0.
 493           </p>
 494 <pre class="programlisting"><span class="identifier">this_type</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">this_type</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 495 </pre>
 496 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 497 <li class="listitem">
 498                 <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="identifier">a</span>
 499                 <span class="special">=</span> <span class="identifier">b</span></code>;
 500                 where a and b are the <code class="computeroutput"><span class="identifier">bimap</span></code>
 501                 objects to which <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
 502                 and x belong, respectively.
 503               </li>
 504 <li class="listitem">
 505                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span><span class="special">.</span></code>
 506               </li>
 507 </ul></div>
 508 </div>
 509 <div class="section boost_bimap_reference_unordered_set_of_reference_unordered___multi__set_of_views_modifiers">
 510 <div class="titlepage"><div><div><h5 class="title">
 511 <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.modifiers"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.modifiers" title="Modifiers">Modifiers</a>
 512 </h5></div></div></div>
 513 <a name="reference_unordered_set_of_insert_value"></a><pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">,</span><span class="keyword">bool</span><span class="special">&gt;</span> <span class="identifier">insert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 514 </pre>
 515 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 516 <li class="listitem">
 517                 <span class="bold"><strong>Effects:</strong></span> Inserts <code class="computeroutput"><span class="identifier">x</span></code>
 518                 into the <code class="computeroutput"><span class="identifier">bimap</span></code> to
 519                 which the view belongs if
 520                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
 521 <li class="listitem">
 522                       the view is non-unique OR no other element with equivalent
 523                       key exists,
 524                     </li>
 525 <li class="listitem">
 526                       AND insertion is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
 527                     </li>
 528 </ul></div>
 529               </li>
 530 <li class="listitem">
 531                 <span class="bold"><strong>Returns:</strong></span> The return value is a pair
 532                 <code class="computeroutput"><span class="identifier">p</span></code>. <code class="computeroutput"><span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span></code> is <code class="computeroutput"><span class="keyword">true</span></code>
 533                 if and only if insertion took place. On successful insertion, <code class="computeroutput"><span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span></code> points to the element inserted;
 534                 otherwise, <code class="computeroutput"><span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span></code> points to an element that
 535                 caused the insertion to be banned. Note that more than one element
 536                 can be causing insertion not to be allowed.
 537               </li>
 538 <li class="listitem">
 539                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
 540                 O(I(n)).
 541               </li>
 542 <li class="listitem">
 543                 <span class="bold"><strong>Exception safety:</strong></span> Strong.
 544               </li>
 545 </ul></div>
 546 <a name="reference_unordered_set_of_insert_iterator_value"></a><pre class="programlisting"><span class="identifier">iterator</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 547 </pre>
 548 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 549 <li class="listitem">
 550                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
 551                 is a valid iterator of the view.
 552               </li>
 553 <li class="listitem">
 554                 <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
 555                 is used as a hint to improve the efficiency of the operation. Inserts
 556                 <code class="computeroutput"><span class="identifier">x</span></code> into the <code class="computeroutput"><span class="identifier">bimap</span></code> to which the view belongs
 557                 if
 558                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
 559 <li class="listitem">
 560                       the view is non-unique OR no other element with equivalent
 561                       key exists,
 562                     </li>
 563 <li class="listitem">
 564                       AND insertion is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
 565                     </li>
 566 </ul></div>
 567               </li>
 568 <li class="listitem">
 569                 <span class="bold"><strong>Returns:</strong></span> On successful insertion,
 570                 an iterator to the newly inserted element. Otherwise, an iterator
 571                 to an element that caused the insertion to be banned. Note that more
 572                 than one element can be causing insertion not to be allowed.
 573               </li>
 574 <li class="listitem">
 575                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
 576                 O(H(n)).
 577               </li>
 578 <li class="listitem">
 579                 <span class="bold"><strong>Exception safety:</strong></span> Strong.
 580               </li>
 581 </ul></div>
 582 <a name="reference_unordered_set_of_insert_iterator_iterator"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">InputIterator</span><span class="special">&gt;</span>
 583 <span class="keyword">void</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">);</span>
 584 </pre>
 585 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 586 <li class="listitem">
 587                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">InputIterator</span></code>
 588                 is a model of <a href="http://www.sgi.com/tech/stl/InputIterator.html" target="_top">Input
 589                 Iterator</a> over elements of type <code class="computeroutput"><span class="identifier">value_type</span></code>.
 590                 <code class="computeroutput"><span class="identifier">first</span></code> and <code class="computeroutput"><span class="identifier">last</span></code> are not iterators into any
 591                 views of the <code class="computeroutput"><span class="identifier">bimap</span></code>
 592                 to which this view belongs. <code class="computeroutput"><span class="identifier">last</span></code>
 593                 is reachable from first.
 594               </li>
 595 <li class="listitem">
 596                 <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="identifier">iterator</span>
 597                 <span class="identifier">hint</span> <span class="special">=</span>
 598                 <span class="identifier">end</span><span class="special">();</span></code>
 599                 <code class="computeroutput"><span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span> <span class="special">!=</span>
 600                 <span class="identifier">last</span><span class="special">)</span>
 601                 <span class="identifier">hint</span> <span class="special">=</span>
 602                 <span class="identifier">insert</span><span class="special">(</span><span class="identifier">hint</span><span class="special">,</span>
 603                 <span class="special">*</span><span class="identifier">first</span><span class="special">++);</span></code>
 604               </li>
 605 <li class="listitem">
 606                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
 607                 O(m*H(n+m)), where m is the number of elements in <code class="computeroutput"><span class="special">[</span><span class="identifier">first</span><span class="special">,</span>
 608                 <span class="identifier">last</span><span class="special">)</span></code>.
 609               </li>
 610 <li class="listitem">
 611                 <span class="bold"><strong>Exception safety:</strong></span> Basic.
 612               </li>
 613 </ul></div>
 614 <a name="reference_unordered_set_of_erase_iterator"></a><pre class="programlisting"><span class="identifier">iterator</span> <span class="identifier">erase</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">);</span>
 615 </pre>
 616 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 617 <li class="listitem">
 618                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
 619                 is a valid dereferenceable <code class="computeroutput"><span class="identifier">iterator</span></code>
 620                 of the view.
 621               </li>
 622 <li class="listitem">
 623                 <span class="bold"><strong>Effects:</strong></span> Deletes the element pointed
 624                 to by <code class="computeroutput"><span class="identifier">position</span></code>.
 625               </li>
 626 <li class="listitem">
 627                 <span class="bold"><strong>Returns:</strong></span> An <code class="computeroutput"><span class="identifier">iterator</span></code>
 628                 pointing to the element immediately following the one that was deleted,
 629                 or <code class="computeroutput"><span class="identifier">end</span><span class="special">()</span></code>
 630                 if no such element exists.
 631               </li>
 632 <li class="listitem">
 633                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
 634                 O(D(n)).
 635               </li>
 636 <li class="listitem">
 637                 <span class="bold"><strong>Exception safety:</strong></span> nothrow.
 638               </li>
 639 </ul></div>
 640 <a name="reference_unordered_set_of_erase_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 641 <span class="identifier">size_type</span> <span class="identifier">erase</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 642 </pre>
 643 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 644 <li class="listitem">
 645                 <span class="bold"><strong>Effects:</strong></span> Deletes the elements with
 646                 key equivalent to <code class="computeroutput"><span class="identifier">x</span></code>.
 647               </li>
 648 <li class="listitem">
 649                 <span class="bold"><strong>Returns:</strong></span> Number of elements deleted.
 650               </li>
 651 <li class="listitem">
 652                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
 653                 Average case, O(1 + m*D(n)), worst case O(n + m*D(n)), where m is
 654                 the number of elements deleted.
 655               </li>
 656 <li class="listitem">
 657                 <span class="bold"><strong>Exception safety:</strong></span> Basic.
 658               </li>
 659 </ul></div>
 660 <a name="reference_unordered_set_of_erase_iterator_iterator"></a><pre class="programlisting"><span class="identifier">iterator</span> <span class="identifier">erase</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="identifier">last</span><span class="special">);</span>
 661 </pre>
 662 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 663 <li class="listitem">
 664                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="special">[</span><span class="identifier">first</span><span class="special">,</span><span class="identifier">last</span><span class="special">)</span></code>
 665                 is a valid range of the view.
 666               </li>
 667 <li class="listitem">
 668                 <span class="bold"><strong>Effects:</strong></span> Deletes the elements in
 669                 <code class="computeroutput"><span class="special">[</span><span class="identifier">first</span><span class="special">,</span><span class="identifier">last</span><span class="special">)</span></code>.
 670               </li>
 671 <li class="listitem">
 672                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="identifier">last</span></code>.
 673               </li>
 674 <li class="listitem">
 675                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
 676                 O(m*D(n)), where m is the number of elements in <code class="computeroutput"><span class="special">[</span><span class="identifier">first</span><span class="special">,</span><span class="identifier">last</span><span class="special">)</span></code>.
 677               </li>
 678 <li class="listitem">
 679                 <span class="bold"><strong>Exception safety:</strong></span> nothrow.
 680               </li>
 681 </ul></div>
 682 <a name="reference_unordered_set_of_replace_iterator_value"></a><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">replace</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 683 </pre>
 684 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 685 <li class="listitem">
 686                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
 687                 is a valid dereferenceable <code class="computeroutput"><span class="identifier">iterator</span></code>
 688                 of the view.
 689               </li>
 690 <li class="listitem">
 691                 <span class="bold"><strong>Effects:</strong></span> Assigns the value <code class="computeroutput"><span class="identifier">x</span></code> to the element pointed to by
 692                 <code class="computeroutput"><span class="identifier">position</span></code> into the
 693                 <code class="computeroutput"><span class="identifier">bimap</span></code> to which the
 694                 view belongs if, for the value <code class="computeroutput"><span class="identifier">x</span></code>
 695                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
 696 <li class="listitem">
 697                       the view is non-unique OR no other element with equivalent
 698                       key exists (except possibly <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span></code>),
 699                     </li>
 700 <li class="listitem">
 701                       AND replacing is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
 702                     </li>
 703 </ul></div>
 704               </li>
 705 <li class="listitem">
 706                 <span class="bold"><strong>Postconditions:</strong></span> Validity of position
 707                 is preserved in all cases.
 708               </li>
 709 <li class="listitem">
 710                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
 711                 if the replacement took place, <code class="computeroutput"><span class="keyword">false</span></code>
 712                 otherwise.
 713               </li>
 714 <li class="listitem">
 715                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
 716                 O(R(n)).
 717               </li>
 718 <li class="listitem">
 719                 <span class="bold"><strong>Exception safety:</strong></span> Strong. If an
 720                 exception is thrown by some user-provided operation the <code class="computeroutput"><span class="identifier">bimap</span></code> to which the view belongs
 721                 remains in its original state.
 722               </li>
 723 </ul></div>
 724 <a name="reference_unordered_set_of_replace_key_iterator_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 725 <span class="keyword">bool</span> <span class="identifier">replace_key</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 726 </pre>
 727 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 728 <li class="listitem">
 729                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
 730                 is a valid dereferenceable iterator of the set view. <code class="computeroutput"><span class="identifier">CompatibleKey</span></code> can be assigned to
 731                 <code class="computeroutput"><span class="identifier">key_type</span></code>.
 732               </li>
 733 <li class="listitem">
 734                 <span class="bold"><strong>Effects:</strong></span> Assigns the value <code class="computeroutput"><span class="identifier">x</span></code> to <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">first</span></code>,
 735                 where <code class="computeroutput"><span class="identifier">e</span></code> is the element
 736                 pointed to by <code class="computeroutput"><span class="identifier">position</span></code>
 737                 into the <code class="computeroutput"><span class="identifier">bimap</span></code> to
 738                 which the set view belongs if,
 739                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
 740 <li class="listitem">
 741                       the map view is non-unique OR no other element with equivalent
 742                       key exists (except possibly <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span></code>),
 743                     </li>
 744 <li class="listitem">
 745                       AND replacing is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
 746                     </li>
 747 </ul></div>
 748               </li>
 749 <li class="listitem">
 750                 <span class="bold"><strong>Postconditions:</strong></span> Validity of position
 751                 is preserved in all cases.
 752               </li>
 753 <li class="listitem">
 754                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
 755                 if the replacement took place, <code class="computeroutput"><span class="keyword">false</span></code>
 756                 otherwise.
 757               </li>
 758 <li class="listitem">
 759                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
 760                 O(R(n)).
 761               </li>
 762 <li class="listitem">
 763                 <span class="bold"><strong>Exception safety:</strong></span> Strong. If an
 764                 exception is thrown by some user-provided operation, the <code class="computeroutput"><span class="identifier">bimap</span></code> to which the set view belongs
 765                 remains in its original state.
 766               </li>
 767 </ul></div>
 768 <a name="reference_unordered_set_of_replace_data_iterator_data"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleData</span> <span class="special">&gt;</span>
 769 <span class="keyword">bool</span> <span class="identifier">replace_data</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">CompatibleData</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 770 </pre>
 771 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 772 <li class="listitem">
 773                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
 774                 is a valid dereferenceable iterator of the set view. <code class="computeroutput"><span class="identifier">CompatibleKey</span></code> can be assigned to
 775                 <code class="computeroutput"><span class="identifier">mapped_type</span></code>.
 776               </li>
 777 <li class="listitem">
 778                 <span class="bold"><strong>Effects:</strong></span> Assigns the value <code class="computeroutput"><span class="identifier">x</span></code> to <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">second</span></code>,
 779                 where <code class="computeroutput"><span class="identifier">e</span></code> is the element
 780                 pointed to by <code class="computeroutput"><span class="identifier">position</span></code>
 781                 into the <code class="computeroutput"><span class="identifier">bimap</span></code> to
 782                 which the set view belongs if,
 783                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
 784 <li class="listitem">
 785                       the map view is non-unique OR no other element with equivalent
 786                       key exists (except possibly <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span></code>),
 787                     </li>
 788 <li class="listitem">
 789                       AND replacing is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
 790                     </li>
 791 </ul></div>
 792               </li>
 793 <li class="listitem">
 794                 <span class="bold"><strong>Postconditions:</strong></span> Validity of position
 795                 is preserved in all cases.
 796               </li>
 797 <li class="listitem">
 798                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
 799                 if the replacement took place, <code class="computeroutput"><span class="keyword">false</span></code>
 800                 otherwise.
 801               </li>
 802 <li class="listitem">
 803                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
 804                 O(R(n)).
 805               </li>
 806 <li class="listitem">
 807                 <span class="bold"><strong>Exception safety:</strong></span> Strong. If an
 808                 exception is thrown by some user-provided operation, the <code class="computeroutput"><span class="identifier">bimap</span></code> to which the set view belongs
 809                 remains in its original state.
 810               </li>
 811 </ul></div>
 812 <a name="reference_unordered_set_of_modify_key_iterator_modifier"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">KeyModifier</span> <span class="special">&gt;</span>
 813 <span class="keyword">bool</span> <span class="identifier">modify_key</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">KeyModifier</span> <span class="identifier">mod</span><span class="special">);</span>
 814 </pre>
 815 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 816 <li class="listitem">
 817                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">KeyModifier</span></code>
 818                 is a model of <a href="http://www.sgi.com/tech/stl/UnaryFunction.html" target="_top">Unary
 819                 Function</a> accepting arguments of type: <code class="computeroutput"><span class="identifier">key_type</span><span class="special">&amp;</span></code>; <code class="computeroutput"><span class="identifier">position</span></code>
 820                 is a valid dereferenceable iterator of the view.
 821               </li>
 822 <li class="listitem">
 823                 <span class="bold"><strong>Effects:</strong></span> Calls <code class="computeroutput"><span class="identifier">mod</span><span class="special">(</span><span class="identifier">e</span><span class="special">.</span><span class="identifier">first</span><span class="special">)</span></code> where e is the element pointed to
 824                 by position and rearranges <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span></code> into all the views of
 825                 the <code class="computeroutput"><span class="identifier">bimap</span></code>. If the
 826                 rearrangement fails, the element is erased. Rearrangement is successful
 827                 if
 828                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
 829 <li class="listitem">
 830                       the map view is non-unique OR no other element with equivalent
 831                       key exists,
 832                     </li>
 833 <li class="listitem">
 834                       AND rearrangement is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
 835                     </li>
 836 </ul></div>
 837               </li>
 838 <li class="listitem">
 839                 <span class="bold"><strong>Postconditions:</strong></span> Validity of <code class="computeroutput"><span class="identifier">position</span></code> is preserved if the operation
 840                 succeeds.
 841               </li>
 842 <li class="listitem">
 843                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
 844                 if the operation succeeded, <code class="computeroutput"><span class="keyword">false</span></code>
 845                 otherwise.
 846               </li>
 847 <li class="listitem">
 848                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
 849                 O(M(n)).
 850               </li>
 851 <li class="listitem">
 852                 <span class="bold"><strong>Exception safety:</strong></span> Basic. If an exception
 853                 is thrown by some user-provided operation (except possibly mod),
 854                 then the element pointed to by position is erased.
 855               </li>
 856 <li class="listitem">
 857                 <span class="bold"><strong>Note:</strong></span> Only provided for map views.
 858               </li>
 859 </ul></div>
 860 <a name="reference_unordered_set_of_modify_data_iterator_modifier"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">DataModifier</span> <span class="special">&gt;</span>
 861 <span class="keyword">bool</span> <span class="identifier">modify_data</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">DataModifier</span> <span class="identifier">mod</span><span class="special">);</span>
 862 </pre>
 863 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 864 <li class="listitem">
 865                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">DataModifier</span></code>
 866                 is a model of <a href="http://www.sgi.com/tech/stl/UnaryFunction.html" target="_top">Unary
 867                 Function</a> accepting arguments of type: <code class="computeroutput"><span class="identifier">mapped_type</span><span class="special">&amp;</span></code>; <code class="computeroutput"><span class="identifier">position</span></code>
 868                 is a valid dereferenceable iterator of the view.
 869               </li>
 870 <li class="listitem">
 871                 <span class="bold"><strong>Effects:</strong></span> Calls <code class="computeroutput"><span class="identifier">mod</span><span class="special">(</span><span class="identifier">e</span><span class="special">.</span><span class="identifier">second</span><span class="special">)</span></code> where e is the element pointed to
 872                 by position and rearranges <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span></code> into all the views of
 873                 the <code class="computeroutput"><span class="identifier">bimap</span></code>. If the
 874                 rearrangement fails, the element is erased. Rearrangement is successful
 875                 if
 876                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
 877 <li class="listitem">
 878                       the oppositte map view is non-unique OR no other element with
 879                       equivalent key in that view exists,
 880                     </li>
 881 <li class="listitem">
 882                       AND rearrangement is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
 883                     </li>
 884 </ul></div>
 885               </li>
 886 <li class="listitem">
 887                 <span class="bold"><strong>Postconditions:</strong></span> Validity of <code class="computeroutput"><span class="identifier">position</span></code> is preserved if the operation
 888                 succeeds.
 889               </li>
 890 <li class="listitem">
 891                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
 892                 if the operation succeeded, <code class="computeroutput"><span class="keyword">false</span></code>
 893                 otherwise.
 894               </li>
 895 <li class="listitem">
 896                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
 897                 O(M(n)).
 898               </li>
 899 <li class="listitem">
 900                 <span class="bold"><strong>Exception safety:</strong></span> Basic. If an exception
 901                 is thrown by some user-provided operation (except possibly mod),
 902                 then the element pointed to by position is erased.
 903               </li>
 904 <li class="listitem">
 905                 <span class="bold"><strong>Note:</strong></span> Only provided for map views.
 906               </li>
 907 </ul></div>
 908 </div>
 909 <div class="section boost_bimap_reference_unordered_set_of_reference_unordered___multi__set_of_views_lookup">
 910 <div class="titlepage"><div><div><h5 class="title">
 911 <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.lookup"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.lookup" title="Lookup">Lookup</a>
 912 </h5></div></div></div>
 913 <p>
 914             <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code> views provide the full lookup
 915             functionality required by unordered associative containers, namely <code class="computeroutput"><span class="identifier">find</span></code>, <code class="computeroutput"><span class="identifier">count</span></code>,
 916             and <code class="computeroutput"><span class="identifier">equal_range</span></code>. Additionally,
 917             these member functions are templatized to allow for non-standard arguments,
 918             so extending the types of search operations allowed. The kind of arguments
 919             permissible when invoking the lookup member functions is defined by the
 920             following concept.
 921           </p>
 922 <p>
 923             A type <code class="computeroutput"><span class="identifier">CompatibleKey</span></code>
 924             is said to be a <span class="emphasis"><em>compatible key</em></span> of <code class="computeroutput"><span class="special">(</span><span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">)</span></code> if <code class="computeroutput"><span class="special">(</span><span class="identifier">CompatibleKey</span><span class="special">,</span>
 925             <span class="identifier">Hash</span><span class="special">,</span>
 926             <span class="identifier">Pred</span><span class="special">)</span></code>
 927             is a compatible extension of <code class="computeroutput"><span class="special">(</span><span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">)</span></code>.
 928             This implies that <code class="computeroutput"><span class="identifier">Hash</span></code>
 929             and <code class="computeroutput"><span class="identifier">Pred</span></code> accept arguments
 930             of type <code class="computeroutput"><span class="identifier">CompatibleKey</span></code>,
 931             which usually means they have several overloads of their corresponding
 932             <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>
 933             member functions.
 934           </p>
 935 <a name="reference_unordered_set_of_find_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 936 <span class="identifier">iterator</span> <span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 937
 938 <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 939 <span class="identifier">const_iterator</span> <span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 940 </pre>
 941 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 942 <li class="listitem">
 943                 <span class="bold"><strong>Effects:</strong></span> Returns a pointer to an
 944                 element whose key is equivalent to <code class="computeroutput"><span class="identifier">x</span></code>,
 945                 or <code class="computeroutput"><span class="identifier">end</span><span class="special">()</span></code>
 946                 if such an element does not exist.
 947               </li>
 948 <li class="listitem">
 949                 <span class="bold"><strong>Complexity:</strong></span> Average case O(1) (constant),
 950                 worst case O(n).
 951               </li>
 952 </ul></div>
 953 <a name="reference_unordered_set_of_count_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 954 <span class="identifier">size_type</span> <span class="identifier">count</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 955 </pre>
 956 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 957 <li class="listitem">
 958                 <span class="bold"><strong>Effects:</strong></span> Returns the number of elements
 959                 with key equivalent to <code class="computeroutput"><span class="identifier">x</span></code>.
 960               </li>
 961 <li class="listitem">
 962                 <span class="bold"><strong>Complexity:</strong></span> Average case O(count(x)),
 963                 worst case O(n).
 964               </li>
 965 </ul></div>
 966 <a name="reference_unordered_set_of_equal_range_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 967 <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">,</span><span class="identifier">iterator</span><span class="special">&gt;</span>
 968     <span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
 969
 970 <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 971 <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">const_iterator</span><span class="special">,</span><span class="identifier">const_iterator</span><span class="special">&gt;</span>
 972     <span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 973 </pre>
 974 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 975 <li class="listitem">
 976                 <span class="bold"><strong>Effects:</strong></span> Returns a range containing
 977                 all elements with keys equivalent to <code class="computeroutput"><span class="identifier">x</span></code>
 978                 (and only those).
 979               </li>
 980 <li class="listitem">
 981                 <span class="bold"><strong>Complexity:</strong></span> Average case O(count(x)),
 982                 worst case O(n).
 983               </li>
 984 </ul></div>
 985 </div>
 986 <div class="section boost_bimap_reference_unordered_set_of_reference_unordered___multi__set_of_views_at____info_at___and_operator_______set_of_only">
 987 <div class="titlepage"><div><div><h5 class="title">
 988 <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.at____info_at___and_operator_______set_of_only"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.at____info_at___and_operator_______set_of_only" title="at(), info_at() and operator[] - set_of only">at(),
 989           info_at() and operator[] - set_of only</a>
 990 </h5></div></div></div>
 991 <a name="reference_unordered_set_of_at_key_const"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
 992 <span class="keyword">const</span> <span class="identifier">mapped_type</span> <span class="special">&amp;</span> <span class="identifier">at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 993 </pre>
 994 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 995 <li class="listitem">
 996                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">CompatibleKey</span></code>
 997                 is a compatible key of <code class="computeroutput"><span class="identifier">key_compare</span></code>.
 998               </li>
 999 <li class="listitem">
1000                 <span class="bold"><strong>Effects:</strong></span> Returns the <code class="computeroutput"><span class="identifier">mapped_type</span></code> reference that is associated
1001                 with <code class="computeroutput"><span class="identifier">k</span></code>, or throws
1002                 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">out_of_range</span></code> if such key does not
1003                 exist.
1004               </li>
1005 <li class="listitem">
1006                 <span class="bold"><strong>Complexity:</strong></span> Average case O(1) (constant),
1007                 worst case O(n).
1008               </li>
1009 <li class="listitem">
1010                 <span class="bold"><strong>Note:</strong></span> Only provided when <code class="computeroutput"><span class="identifier">unordered_set_of</span></code> is used.
1011               </li>
1012 </ul></div>
1013 <p>
1014             The symmetry of bimap imposes some constraints on <code class="computeroutput"><span class="keyword">operator</span><span class="special">[]</span></code> and the non constant version of at()
1015             that are not found in <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">maps</span></code>.
1016             Tey are only provided if the other collection type is mutable (<code class="computeroutput"><span class="identifier">list_of</span></code>, <code class="computeroutput"><span class="identifier">vector_of</span></code>
1017             and <code class="computeroutput"><span class="identifier">unconstrained_set_of</span></code>).
1018           </p>
1019 <a name="reference_unordered_set_of_operator_bracket_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
1020 <span class="identifier">mapped_type</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">[](</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">);</span>
1021 </pre>
1022 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1023 <li class="listitem">
1024                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">CompatibleKey</span></code>
1025                 is a compatible key of <code class="computeroutput"><span class="identifier">key_compare</span></code>.
1026               </li>
1027 <li class="listitem">
1028                 <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="keyword">return</span>
1029                 <span class="identifier">insert</span><span class="special">(</span><span class="identifier">value_type</span><span class="special">(</span><span class="identifier">k</span><span class="special">,</span><span class="identifier">mapped_type</span><span class="special">()))-&gt;</span><span class="identifier">second</span><span class="special">;</span></code>
1030               </li>
1031 <li class="listitem">
1032                 <span class="bold"><strong>Complexity:</strong></span> If the insertion is
1033                 performed O(I(n)), else: Average case O(1) (constant), worst case
1034                 O(n).
1035               </li>
1036 <li class="listitem">
1037                 <span class="bold"><strong>Note:</strong></span> Only provided when <code class="computeroutput"><span class="identifier">unordered_set_of</span></code> is used and the
1038                 other collection type is mutable.
1039               </li>
1040 </ul></div>
1041 <a name="reference_unordered_set_of_at_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
1042 <span class="identifier">mapped_type</span> <span class="special">&amp;</span> <span class="identifier">at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">);</span>
1043 </pre>
1044 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1045 <li class="listitem">
1046                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">CompatibleKey</span></code>
1047                 is a compatible key of <code class="computeroutput"><span class="identifier">key_compare</span></code>.
1048               </li>
1049 <li class="listitem">
1050                 <span class="bold"><strong>Effects: </strong></span> Returns the <code class="computeroutput"><span class="identifier">mapped_type</span></code> reference that is associated
1051                 with <code class="computeroutput"><span class="identifier">k</span></code>, or throws
1052                 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">out_of_range</span></code> if such key does not
1053                 exist.
1054               </li>
1055 <li class="listitem">
1056                 <span class="bold"><strong>Complexity:</strong></span> Average case O(1) (constant),
1057                 worst case O(n).
1058               </li>
1059 <li class="listitem">
1060                 <span class="bold"><strong>Note:</strong></span> Only provided when <code class="computeroutput"><span class="identifier">unordered_set_of</span></code> is used and the
1061                 other collection type is mutable.
1062               </li>
1063 </ul></div>
1064 <a name="reference_unordered_set_of_info_at_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
1065 <span class="identifier">info_type</span> <span class="special">&amp;</span> <span class="identifier">info_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">);</span>
1066
1067 <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
1068 <span class="keyword">const</span> <span class="identifier">info_type</span> <span class="special">&amp;</span> <span class="identifier">info_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
1069 </pre>
1070 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1071 <li class="listitem">
1072                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">CompatibleKey</span></code>
1073                 is a compatible key of <code class="computeroutput"><span class="identifier">key_compare</span></code>.
1074               </li>
1075 <li class="listitem">
1076                 <span class="bold"><strong>Effects:</strong></span> Returns the <code class="computeroutput"><span class="identifier">info_type</span></code> reference that is associated
1077                 with <code class="computeroutput"><span class="identifier">k</span></code>, or throws
1078                 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">out_of_range</span></code> if such key does not
1079                 exist.
1080               </li>
1081 <li class="listitem">
1082                 <span class="bold"><strong>Complexity:</strong></span> Average case O(1) (constant),
1083                 worst case O(n).
1084               </li>
1085 <li class="listitem">
1086                 <span class="bold"><strong>Note:</strong></span> Only provided when <code class="computeroutput"><span class="identifier">unordered_set_of</span></code> and <code class="computeroutput"><span class="identifier">info_hook</span></code> are used
1087               </li>
1088 </ul></div>
1089 </div>
1090 <div class="section boost_bimap_reference_unordered_set_of_reference_unordered___multi__set_of_views_hash_policy">
1091 <div class="titlepage"><div><div><h5 class="title">
1092 <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.hash_policy"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.hash_policy" title="Hash policy">Hash
1093           policy</a>
1094 </h5></div></div></div>
1095 <a name="reference_unordered_set_of_rehash_size"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">rehash</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
1096 </pre>
1097 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1098 <li class="listitem">
1099                 <span class="bold"><strong>Effects:</strong></span> Increases if necessary
1100                 the number of internal buckets so that <code class="computeroutput"><span class="identifier">size</span><span class="special">()/</span><span class="identifier">bucket_count</span><span class="special">()</span></code> does not exceed the maximum load
1101                 factor, and <code class="computeroutput"><span class="identifier">bucket_count</span><span class="special">()&gt;=</span><span class="identifier">n</span></code>.
1102               </li>
1103 <li class="listitem">
1104                 <span class="bold"><strong>Postconditions:</strong></span> Validity of iterators
1105                 and references to the elements contained is preserved.
1106               </li>
1107 <li class="listitem">
1108                 <span class="bold"><strong>Complexity:</strong></span> Average case O(size()),
1109                 worst case O(size(n)2).
1110               </li>
1111 <li class="listitem">
1112                 <span class="bold"><strong>Exception safety:</strong></span> Strong.
1113               </li>
1114 </ul></div>
1115 </div>
1116 <div class="section boost_bimap_reference_unordered_set_of_reference_unordered___multi__set_of_views_serialization">
1117 <div class="titlepage"><div><div><h5 class="title">
1118 <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.serialization"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.serialization" title="Serialization">Serialization</a>
1119 </h5></div></div></div>
1120 <p>
1121             Views cannot be serialized on their own, but only as part of the <code class="computeroutput"><span class="identifier">bimap</span></code> into which they are embedded.
1122             In describing the additional preconditions and guarantees associated
1123             to <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code> views with respect to serialization
1124             of their embedding containers, we use the concepts defined in the <code class="computeroutput"><span class="identifier">bimap</span></code> serialization section.
1125           </p>
1126 <div class="sidebar">
1127 <div class="titlepage"></div>
1128 <p>
1129             <span class="bold"><strong>Operation:</strong></span> saving of a <code class="computeroutput"><span class="identifier">bimap</span></code> b to an output archive (XML archive)
1130             ar.
1131           </p>
1132 </div>
1133 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
1134                 <span class="bold"><strong>Requires:</strong></span> No additional requirements
1135                 to those imposed by the container.
1136               </li></ul></div>
1137 <div class="sidebar">
1138 <div class="titlepage"></div>
1139 <p>
1140             <span class="bold"><strong>Operation:</strong></span> loading of a <code class="computeroutput"><span class="identifier">bimap</span></code> b' from an input archive (XML
1141             archive) ar.
1142           </p>
1143 </div>
1144 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1145 <li class="listitem">
1146                 <span class="bold"><strong>Requires:</strong></span> Additionally to the general
1147                 requirements, <code class="computeroutput"><span class="identifier">key_eq</span><span class="special">()</span></code> must be serialization-compatible
1148                 with <code class="computeroutput"><span class="identifier">m</span><span class="special">.</span><span class="identifier">get</span><span class="special">&lt;</span><span class="identifier">i</span><span class="special">&gt;().</span><span class="identifier">key_eq</span><span class="special">()</span></code>,
1149                 where i is the position of the <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code>
1150                 view in the container.
1151               </li>
1152 <li class="listitem">
1153                 <span class="bold"><strong>Postconditions:</strong></span> On successful loading,
1154                 the range <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">())</span></code> contains restored copies of every
1155                 element in <code class="computeroutput"><span class="special">[</span><span class="identifier">m</span><span class="special">.</span><span class="identifier">get</span><span class="special">&lt;</span><span class="identifier">i</span><span class="special">&gt;().</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">m</span><span class="special">.</span><span class="identifier">get</span><span class="special">&lt;</span><span class="identifier">i</span><span class="special">&gt;().</span><span class="identifier">end</span><span class="special">())</span></code>, though not necessarily in the
1156                 same order.
1157               </li>
1158 </ul></div>
1159 <div class="sidebar">
1160 <div class="titlepage"></div>
1161 <p>
1162             <span class="bold"><strong>Operation:</strong></span> saving of an <code class="computeroutput"><span class="identifier">iterator</span></code> or <code class="computeroutput"><span class="identifier">const_iterator</span></code>
1163             <code class="computeroutput"><span class="identifier">it</span></code> to an output archive
1164             (XML archive) ar.
1165           </p>
1166 </div>
1167 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
1168                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">it</span></code>
1169                 is a valid <code class="computeroutput"><span class="identifier">iterator</span></code>
1170                 of the view. The associated <code class="computeroutput"><span class="identifier">bimap</span></code>
1171                 has been previously saved.
1172               </li></ul></div>
1173 <div class="sidebar">
1174 <div class="titlepage"></div>
1175 <p>
1176             <span class="bold"><strong>Operation:</strong></span> loading of an iterator or
1177             <code class="computeroutput"><span class="identifier">const_iterator</span> <span class="identifier">it</span></code>'
1178             from an input archive (XML archive) ar.
1179           </p>
1180 </div>
1181 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1182 <li class="listitem">
1183                 <span class="bold"><strong>Postconditions:</strong></span> On successful loading,
1184                 if <code class="computeroutput"><span class="identifier">it</span></code> was dereferenceable
1185                 then <code class="computeroutput"><span class="special">*</span><span class="identifier">it</span></code>'
1186                 is the restored copy of <code class="computeroutput"><span class="special">*</span><span class="identifier">it</span></code>, otherwise <code class="computeroutput"><span class="identifier">it</span></code>'<code class="computeroutput">
1187                 <span class="special">==</span> <span class="identifier">end</span><span class="special">()</span></code>.
1188               </li>
1189 <li class="listitem">
1190                 <span class="bold"><strong>Note:</strong></span> It is allowed that <code class="computeroutput"><span class="identifier">it</span></code> be a <code class="computeroutput"><span class="identifier">const_iterator</span></code>
1191                 and the restored <code class="computeroutput"><span class="identifier">it</span></code>'
1192                 an <code class="computeroutput"><span class="identifier">iterator</span></code>, or viceversa.
1193               </li>
1194 </ul></div>
1195 <div class="sidebar">
1196 <div class="titlepage"></div>
1197 <p>
1198             <span class="bold"><strong>Operation:</strong></span> saving of a local_iterator
1199             or const_local_iterator it to an output archive (XML archive) ar.
1200           </p>
1201 </div>
1202 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
1203                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">it</span></code>
1204                 is a valid local iterator of the view. The associated <code class="computeroutput"><span class="identifier">bimap</span></code> has been previously saved.
1205               </li></ul></div>
1206 <div class="sidebar">
1207 <div class="titlepage"></div>
1208 <p>
1209             <span class="bold"><strong>Operation:</strong></span> loading of a <code class="computeroutput"><span class="identifier">local_iterator</span></code> or <code class="computeroutput"><span class="identifier">const_local_iterator</span></code>
1210             <code class="computeroutput"><span class="identifier">it</span></code>' from an input archive
1211             (XML archive) ar.
1212           </p>
1213 </div>
1214 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1215 <li class="listitem">
1216                 <span class="bold"><strong>Postconditions:</strong></span> On successful loading,
1217                 if <code class="computeroutput"><span class="identifier">it</span></code> was dereferenceable
1218                 then <code class="computeroutput"><span class="special">*</span><span class="identifier">it</span></code>'
1219                 is the restored copy of <code class="computeroutput"><span class="special">*</span><span class="identifier">it</span></code>; if <code class="computeroutput"><span class="identifier">it</span></code>
1220                 was <code class="computeroutput"><span class="identifier">m</span><span class="special">.</span><span class="identifier">get</span><span class="special">&lt;</span><span class="identifier">i</span><span class="special">&gt;().</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span></code>
1221                 for some n, then <code class="computeroutput"><span class="identifier">it</span></code>'<code class="computeroutput">
1222                 <span class="special">==</span> <span class="identifier">m</span></code>'<code class="computeroutput"><span class="special">.</span><span class="identifier">get</span><span class="special">&lt;</span><span class="identifier">i</span><span class="special">&gt;().</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span></code> (where <code class="computeroutput"><span class="identifier">b</span></code>
1223                 is the original <code class="computeroutput"><span class="identifier">bimap</span></code>,
1224                 <code class="computeroutput"><span class="identifier">b</span></code>' its restored copy
1225                 and <code class="computeroutput"><span class="identifier">i</span></code> is the ordinal
1226                 of the index.)
1227               </li>
1228 <li class="listitem">
1229                 <span class="bold"><strong>Note:</strong></span> It is allowed that <code class="computeroutput"><span class="identifier">it</span></code> be a <code class="computeroutput"><span class="identifier">const_local_iterator</span></code>
1230                 and the restored <code class="computeroutput"><span class="identifier">it</span></code>'
1231                 a <code class="computeroutput"><span class="identifier">local_iterator</span></code>,
1232                 or viceversa.
1233               </li>
1234 </ul></div>
1235 </div>
1236 </div>
1237 </div>
1238 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
1239 <td align="left"></td>
1240 <td align="right"><div class="copyright-footer">Copyright &#169; 2006-2012 Matias Capeletto<p>
1241         Distributed under the Boost Software License, Version 1.0. (See accompanying
1242         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
1243       </p>
1244 </div></td>
1245 </tr></table>
1246 <hr>
1247 <div class="spirit-nav">
1248 <a accesskey="p" href="set_of_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="list_of_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
1249 </div>
1250 </body>
1251 </html>