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