libs/bimap/doc/html/boost_bimap/reference/set_of_reference.html

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