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