• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1<html>
2<head>
3<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
4<title>vector_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="list_of_reference.html" title="list_of Reference">
10<link rel="next" href="unconstrained_set_of_reference.html" title="unconstrained_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="list_of_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="unconstrained_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.vector_of_reference"></a><a class="link" href="vector_of_reference.html" title="vector_of Reference">vector_of
28      Reference</a>
29</h3></div></div></div>
30<div class="toc"><dl class="toc">
31<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.header__boost_bimap_vector_of_hpp__synopsis">Header
32        "boost/bimap/vector_of.hpp" synopsis</a></span></dt>
33<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views">vector_of
34        views</a></span></dt>
35<dd><dl>
36<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.complexity_signature">Complexity
37          signature</a></span></dt>
38<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.instantiation_types">Instantiation
39          types</a></span></dt>
40<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.constructors__copy_and_assignment">Constructors,
41          copy and assignment</a></span></dt>
42<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.capacity_operations">Capacity
43          operations</a></span></dt>
44<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.modifiers">Modifiers</a></span></dt>
45<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.list_operations">List
46          operations</a></span></dt>
47<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.rearrange_operations">Rearrange
48          operations</a></span></dt>
49<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.serialization">Serialization</a></span></dt>
50</dl></dd>
51</dl></div>
52<div class="section">
53<div class="titlepage"><div><div><h4 class="title">
54<a name="boost_bimap.reference.vector_of_reference.header__boost_bimap_vector_of_hpp__synopsis"></a><a class="link" href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.header__boost_bimap_vector_of_hpp__synopsis" title='Header "boost/bimap/vector_of.hpp" synopsis'>Header
55        "boost/bimap/vector_of.hpp" synopsis</a>
56</h4></div></div></div>
57<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
58<span class="keyword">namespace</span> <span class="identifier">bimaps</span> <span class="special">{</span>
59
60
61<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">KeyType</span> <span class="special">&gt;</span>
62<span class="keyword">struct</span> <span class="identifier">vector_of</span><span class="special">;</span>
63
64<span class="keyword">struct</span> <span class="identifier">vector_of_relation</span><span class="special">;</span>
65
66
67<span class="special">}</span> <span class="comment">// namespace bimap</span>
68<span class="special">}</span> <span class="comment">// namespace boost</span>
69</pre>
70</div>
71<div class="section">
72<div class="titlepage"><div><div><h4 class="title">
73<a name="boost_bimap.reference.vector_of_reference.vector_of_views"></a><a class="link" href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views" title="vector_of views">vector_of
74        views</a>
75</h4></div></div></div>
76<div class="toc"><dl class="toc">
77<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.complexity_signature">Complexity
78          signature</a></span></dt>
79<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.instantiation_types">Instantiation
80          types</a></span></dt>
81<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.constructors__copy_and_assignment">Constructors,
82          copy and assignment</a></span></dt>
83<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.capacity_operations">Capacity
84          operations</a></span></dt>
85<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.modifiers">Modifiers</a></span></dt>
86<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.list_operations">List
87          operations</a></span></dt>
88<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.rearrange_operations">Rearrange
89          operations</a></span></dt>
90<dt><span class="section"><a href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.serialization">Serialization</a></span></dt>
91</dl></div>
92<p>
93          vector_of views are free-order sequences with constant time positional
94          access and random access iterators. Elements in a vector_of view are by
95          default sorted according to their order of insertion: this means that new
96          elements inserted through a different view of the <code class="computeroutput"><span class="identifier">bimap</span></code>
97          are appended to the end of the vector_of view; additionally, facilities
98          are provided for further rearrangement of the elements. The public interface
99          of vector_of views includes that of list_of views, with differences in
100          the complexity of the operations, plus extra operations for positional
101          access (<code class="computeroutput"><span class="keyword">operator</span><span class="special">[]</span></code>
102          and <code class="computeroutput"><span class="identifier">at</span><span class="special">()</span></code>)
103          and for capacity handling. Validity of iterators and references to elements
104          is preserved in all operations, regardless of the capacity status.
105        </p>
106<p>
107          As is the case with list_of views, vector_of views have the following limitations
108          with respect to STL sequence containers:
109        </p>
110<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
111<li class="listitem">
112              vector_of views are not <a href="https://www.boost.org/sgi/stl/Assignable.html" target="_top">Assignable</a>
113              (like any other view.)
114            </li>
115<li class="listitem">
116              Insertions into a vector_of view may fail due to clashings with other
117              views. This alters the semantics of the operations provided with respect
118              to their analogues in STL sequence containers.
119            </li>
120<li class="listitem">
121              Elements in a vector_of view are not mutable, and can only be changed
122              by means of replace and modify member functions.
123            </li>
124</ul></div>
125<p>
126          Having these restrictions into account, vector of views are models of
127          <a href="https://www.boost.org/sgi/stl/RandomAccessContainer.html" target="_top">Random
128          Access Container</a> and <a href="https://www.boost.org/sgi/stl/BackInsertionSequence.html" target="_top">Back
129          Insertion Sequence</a>. Although these views do not model <a href="https://www.boost.org/sgi/stl/FrontInsertionSequence.html" target="_top">Front
130          Insertion Sequence</a>, because front insertion and deletion take linear
131          time, front operations are nonetheless provided to match the interface
132          of list_of views. We only describe those types and operations that are
133          either not present in the concepts modeled or do not exactly conform to
134          the requirements for these types of containers.
135        </p>
136<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
137<span class="keyword">namespace</span> <span class="identifier">bimaps</span> <span class="special">{</span>
138<span class="keyword">namespace</span> <span class="identifier">views</span> <span class="special">{</span>
139
140<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>
141<span class="keyword">class</span> <span class="emphasis"><em>-implementation defined view name-</em></span>
142<span class="special">{</span>
143    <span class="keyword">public</span><span class="special">:</span>
144
145    <span class="comment">// types</span>
146
147    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">value_type</span><span class="special">;</span>
148    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">allocator_type</span><span class="special">;</span>
149    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">reference</span><span class="special">;</span>
150    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">const_reference</span><span class="special">;</span>
151    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">iterator</span><span class="special">;</span>
152    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">const_iterator</span><span class="special">;</span>
153    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">size_type</span><span class="special">;</span>
154    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">difference_type</span><span class="special">;</span>
155    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">pointer</span><span class="special">;</span>
156    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">const_pointer</span><span class="special">;</span>
157    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">reverse_iterator</span><span class="special">;</span>
158    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">const_reverse_iterator</span><span class="special">;</span>
159
160    <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">info_type</span><span class="special">;</span>
161
162    <span class="comment">// construct / copy / destroy</span>
163
164    <span class="identifier">this_type</span> <span class="special">&amp;</span> <span class="keyword">operator</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>
165
166    <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>
167    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_assign_iterator_iterator">assign</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>
168
169    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_assign_size_value">assign</a><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> <span class="identifier">value</span><span class="special">);</span>
170
171    <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>
172
173    <span class="comment">// iterators</span>
174
175    <span class="identifier">iterator</span>               <span class="identifier">begin</span><span class="special">();</span>
176    <span class="identifier">const_iterator</span>         <span class="identifier">begin</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
177
178    <span class="identifier">iterator</span>               <span class="identifier">end</span><span class="special">();</span>
179    <span class="identifier">const_iterator</span>         <span class="identifier">end</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
180
181    <span class="identifier">reverse_iterator</span>       <span class="identifier">rbegin</span><span class="special">();</span>
182    <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>
183
184    <span class="identifier">reverse_iterator</span>       <span class="identifier">rend</span><span class="special">();</span>
185    <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>
186
187    <span class="comment">// capacity</span>
188
189    <span class="keyword">bool</span>      <span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
190
191    <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
192
193    <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>
194
195    <span class="identifier">size_type</span> <a class="link" href="vector_of_reference.html#reference_vector_of_capacity">capacity</a><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
196
197    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_reserve_size">reserve</a><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">m</span><span class="special">);</span>
198
199    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_resize_size_value">resize</a><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">value_type</span><span class="special">());</span>
200
201    <span class="comment">// access</span>
202
203    <span class="identifier">const_reference</span> <span class="keyword">operator</span><span class="special">[](</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
204
205    <span class="identifier">const_reference</span> <span class="identifier">at</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
206
207    <span class="identifier">const_reference</span> <span class="identifier">front</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
208
209    <span class="identifier">const_reference</span> <span class="identifier">back</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="vector_of_reference.html#reference_vector_of_push_front_value">push_front</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    <span class="keyword">void</span>                     <span class="identifier">pop_front</span><span class="special">();</span>
215
216    <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="vector_of_reference.html#reference_vector_of_push_back_value">push_back</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>
217    <span class="keyword">void</span>                     <span class="identifier">pop_back</span><span class="special">();</span>
218
219    <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="vector_of_reference.html#reference_vector_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>
220
221    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_insert_iterator_size_value">insert</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">m</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>
222
223    <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>
224    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_insert_iterator_iterator_iterator">insert</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</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>
225
226    <span class="identifier">iterator</span> <a class="link" href="vector_of_reference.html#reference_vector_of_erase_iterator">erase</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">);</span>
227    <span class="identifier">iterator</span> <a class="link" href="vector_of_reference.html#reference_vector_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>
228
229    <span class="keyword">bool</span> <a class="link" href="vector_of_reference.html#reference_vector_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>
230
231    <span class="comment">// Only in map views</span>
232    <span class="comment">// {</span>
233      <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">key_type</span><span class="special">;</span>
234      <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">mapped_type</span><span class="special">;</span>
235      <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>
236
237      <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>
238      <span class="keyword">bool</span> <a class="link" href="vector_of_reference.html#reference_vector_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>
239
240      <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>
241      <span class="keyword">bool</span> <a class="link" href="vector_of_reference.html#reference_vector_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>
242
243      <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>
244      <span class="keyword">bool</span> <a class="link" href="vector_of_reference.html#reference_vector_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>
245
246      <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>
247      <span class="keyword">bool</span> <a class="link" href="vector_of_reference.html#reference_vector_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>
248
249    <span class="comment">// }</span>
250
251
252    <span class="keyword">void</span> <span class="identifier">clear</span><span class="special">();</span>
253
254    <span class="comment">// list operations</span>
255
256    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_splice_iterator_this">splice</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</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>
257    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_splice_iterator_this_iterator">splice</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</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> <span class="identifier">iterator</span> <span class="identifier">i</span><span class="special">);</span>
258    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_splice_iterator_this_iterator_iterator">splice</a><span class="special">(</span>
259        <span class="identifier">iterator</span> <span class="identifier">position</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> <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>
260
261    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_remove_value">remove</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> <span class="identifier">value</span><span class="special">);</span>
262
263    <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Predicate</span> <span class="special">&gt;</span>
264    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_remove_if_predicate">remove_if</a><span class="special">(</span><span class="identifier">Predicate</span> <span class="identifier">pred</span><span class="special">);</span>
265
266    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_unique">unique</a><span class="special">();</span>
267
268    <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span> <span class="special">&gt;</span>
269    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_unique_predicate">unique</a><span class="special">(</span><span class="identifier">BinaryPredicate</span> <span class="identifier">binary_pred</span><span class="special">);</span>
270
271    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_merge_this">merge</a><span class="special">(</span><span class="identifier">this_type</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
272
273    <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Compare</span> <span class="special">&gt;</span>
274    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_merge_this_compare">merge</a><span class="special">(</span><span class="identifier">this_type</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">Compare</span> <span class="identifier">comp</span><span class="special">);</span>
275
276    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_sort">sort</a><span class="special">();</span>
277
278    <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Compare</span> <span class="special">&gt;</span>
279    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_sort_compare">sort</a><span class="special">(</span><span class="identifier">Compare</span> <span class="identifier">comp</span><span class="special">);</span>
280
281    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_reverse">reverse</a><span class="special">();</span>
282
283    <span class="comment">// rearrange operations</span>
284
285    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_relocate_iterator_iterator">relocate</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="identifier">i</span><span class="special">);</span>
286    <span class="keyword">void</span> <a class="link" href="vector_of_reference.html#reference_vector_of_relocate_iterator_iterator_iterator">relocate</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</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>
287<span class="special">};</span>
288
289<span class="comment">// view comparison</span>
290
291<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>
292<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>
293<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>
294<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>
295<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>
296<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>
297
298<span class="special">}</span> <span class="comment">// namespace views</span>
299<span class="special">}</span> <span class="comment">// namespace bimap</span>
300<span class="special">}</span> <span class="comment">// namespace boost</span>
301</pre>
302<p>
303          In the case of a <code class="computeroutput"><span class="identifier">bimap</span><span class="special">&lt;</span> <span class="identifier">vector_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>
304        </p>
305<p>
306          In the set view:
307        </p>
308<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>
309<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">value_type</span><span class="special">;</span>
310</pre>
311<p>
312          In the left map view:
313        </p>
314<pre class="programlisting"><span class="keyword">typedef</span>  <span class="identifier">Left</span>  <span class="identifier">key_type</span><span class="special">;</span>
315<span class="keyword">typedef</span>  <span class="special">...</span>   <span class="identifier">mapped_type</span><span class="special">;</span>
316
317<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="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>
318</pre>
319<p>
320          In the right map view:
321        </p>
322<pre class="programlisting"><span class="keyword">typedef</span>  <span class="special">...</span>  <span class="identifier">key_type</span><span class="special">;</span>
323<span class="keyword">typedef</span>  <span class="identifier">Left</span> <span class="identifier">mapped_type</span><span class="special">;</span>
324
325<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="identifier">Left</span> <span class="special">&gt;</span> <span class="identifier">value_type</span><span class="special">;</span>
326</pre>
327<div class="section">
328<div class="titlepage"><div><div><h5 class="title">
329<a name="boost_bimap.reference.vector_of_reference.vector_of_views.complexity_signature"></a><a name="vector_of_complexity_signature"></a><a class="link" href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.complexity_signature" title="Complexity signature">Complexity
330          signature</a>
331</h5></div></div></div>
332<p>
333            Here and in the descriptions of operations of <code class="computeroutput"><span class="identifier">vector_of</span></code>
334            views, we adopt the scheme outlined in the <a class="link" href="bimap_reference.html#complexity_signature_explanation">complexity
335            signature section</a>. The complexity signature of <code class="computeroutput"><span class="identifier">vector_of</span></code>
336            view is:
337          </p>
338<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
339<li class="listitem">
340                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>,
341              </li>
342<li class="listitem">
343                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="number">1</span></code>
344                (amortized constant),
345              </li>
346<li class="listitem">
347                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> (amortized constant),
348              </li>
349<li class="listitem">
350                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="identifier">m</span></code>,
351                where m is the distance from the deleted element to the end of the
352                sequence,
353              </li>
354<li class="listitem">
355                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>
356                (constant),
357              </li>
358<li class="listitem">
359                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>
360                (constant).
361              </li>
362</ul></div>
363<p>
364            The following expressions are also used as a convenience for writing
365            down some of the complexity formulas:
366          </p>
367<div class="blurb">
368<div class="titlepage"><div><div><p class="title"><b></b></p></div></div></div>
369<p>
370            <code class="computeroutput"><span class="identifier">shl</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">a</span><span class="special">+</span><span class="identifier">b</span></code>
371            if a is nonzero, 0 otherwise. <code class="computeroutput"><span class="identifier">rel</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">c</span><span class="special">)</span> <span class="special">=</span></code> if
372            <code class="computeroutput"><span class="identifier">a</span><span class="special">&lt;</span><span class="identifier">b</span></code>, <code class="computeroutput"><span class="identifier">c</span><span class="special">-</span><span class="identifier">a</span></code>,
373            else <code class="computeroutput"><span class="identifier">a</span><span class="special">-</span><span class="identifier">b</span></code>,
374          </p>
375</div>
376<p>
377            (<code class="computeroutput"><span class="identifier">shl</span></code> and <code class="computeroutput"><span class="identifier">rel</span></code> stand for <span class="emphasis"><em>shift left</em></span>
378            and <span class="emphasis"><em>relocate</em></span>, respectively.)
379          </p>
380</div>
381<div class="section">
382<div class="titlepage"><div><div><h5 class="title">
383<a name="boost_bimap.reference.vector_of_reference.vector_of_views.instantiation_types"></a><a class="link" href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.instantiation_types" title="Instantiation types">Instantiation
384          types</a>
385</h5></div></div></div>
386<p>
387            <code class="computeroutput"><span class="identifier">vector_of</span></code> views are instantiated
388            internally to <code class="computeroutput"><span class="identifier">bimap</span></code> and
389            specified by means of the collection type specifiers and the bimap itself.
390            Instantiations are dependent on the following types:
391          </p>
392<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
393<li class="listitem">
394                <code class="computeroutput"><span class="identifier">Value</span></code> from <code class="computeroutput"><span class="identifier">vector_of</span></code>,
395              </li>
396<li class="listitem">
397                <code class="computeroutput"><span class="identifier">Allocator</span></code> from <code class="computeroutput"><span class="identifier">bimap</span></code>,
398              </li>
399</ul></div>
400</div>
401<div class="section">
402<div class="titlepage"><div><div><h5 class="title">
403<a name="boost_bimap.reference.vector_of_reference.vector_of_views.constructors__copy_and_assignment"></a><a class="link" href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.constructors__copy_and_assignment" title="Constructors, copy and assignment">Constructors,
404          copy and assignment</a>
405</h5></div></div></div>
406<p>
407            As explained in the views concepts section, views do not have public
408            constructors or destructors. Assignment, on the other hand, is provided.
409          </p>
410<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>
411</pre>
412<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
413<li class="listitem">
414                <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="identifier">a</span><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>
415                and <code class="computeroutput"><span class="identifier">x</span></code> belong, respectively.
416              </li>
417<li class="listitem">
418                <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
419              </li>
420</ul></div>
421<a name="reference_vector_of_assign_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>
422<span class="keyword">void</span> <span class="identifier">assign</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>
423</pre>
424<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
425<li class="listitem">
426                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">InputIterator</span></code>
427                is a model of <a href="https://www.boost.org/sgi/stl/InputIterator.html" target="_top">Input
428                Iterator</a> over elements of type <code class="computeroutput"><span class="identifier">value_type</span></code>
429                or a type convertible to <code class="computeroutput"><span class="identifier">value_type</span></code>.
430                <code class="computeroutput"><span class="identifier">first</span></code> and <code class="computeroutput"><span class="identifier">last</span></code> are not iterators into any
431                view of the <code class="computeroutput"><span class="identifier">bimap</span></code>
432                to which this view belongs. <code class="computeroutput"><span class="identifier">last</span></code>
433                is reachable from <code class="computeroutput"><span class="identifier">first</span></code>.
434              </li>
435<li class="listitem">
436                <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="identifier">clear</span><span class="special">();</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">end</span><span class="special">(),</span><span class="identifier">first</span><span class="special">,</span><span class="identifier">last</span><span class="special">);</span></code>
437              </li>
438</ul></div>
439<a name="reference_vector_of_assign_size_value"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> <span class="identifier">value</span><span class="special">);</span>
440</pre>
441<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
442                <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="identifier">clear</span><span class="special">();</span> <span class="keyword">for</span><span class="special">(</span><span class="identifier">size_type</span>
443                <span class="identifier">i</span> <span class="special">=</span>
444                <span class="number">0</span><span class="special">;</span>
445                <span class="identifier">i</span> <span class="special">&lt;</span>
446                <span class="identifier">n</span><span class="special">;</span>
447                <span class="special">++</span><span class="identifier">n</span><span class="special">)</span> <span class="identifier">push_back</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span></code>
448              </li></ul></div>
449</div>
450<div class="section">
451<div class="titlepage"><div><div><h5 class="title">
452<a name="boost_bimap.reference.vector_of_reference.vector_of_views.capacity_operations"></a><a class="link" href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.capacity_operations" title="Capacity operations">Capacity
453          operations</a>
454</h5></div></div></div>
455<a name="reference_vector_of_capacity"></a><pre class="programlisting"><span class="identifier">size_type</span> <span class="identifier">capacity</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
456</pre>
457<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
458<li class="listitem">
459                <span class="bold"><strong>Returns:</strong></span> The total number of elements
460                <code class="computeroutput"><span class="identifier">c</span></code> such that, when
461                <code class="computeroutput"><span class="identifier">size</span><span class="special">()</span>
462                <span class="special">&lt;</span> <span class="identifier">c</span></code>,
463                back insertions happen in constant time (the general case as described
464                by i(n) is <span class="emphasis"><em>amortized</em></span> constant time.)
465              </li>
466<li class="listitem">
467                <span class="bold"><strong>Note:</strong></span> Validity of iterators and
468                references to elements is preserved in all insertions, regardless
469                of the capacity status.
470              </li>
471</ul></div>
472<a name="reference_vector_of_reserve_size"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">reserve</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">m</span><span class="special">);</span>
473</pre>
474<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
475<li class="listitem">
476                <span class="bold"><strong>Effects:</strong></span> If the previous value of
477                <code class="computeroutput"><span class="identifier">capacity</span><span class="special">()</span></code>
478                was greater than or equal to <code class="computeroutput"><span class="identifier">m</span></code>,
479                nothing is done; otherwise, the internal capacity is changed so that
480                <code class="computeroutput"><span class="identifier">capacity</span><span class="special">()&gt;=</span><span class="identifier">m</span></code>.
481              </li>
482<li class="listitem">
483                <span class="bold"><strong>Complexity:</strong></span> If the capacity is not
484                changed, constant; otherwise O(n).
485              </li>
486<li class="listitem">
487                <span class="bold"><strong>Exception safety:</strong></span> If the capacity
488                is not changed, nothrow; otherwise, strong.
489              </li>
490</ul></div>
491<a name="reference_vector_of_resize_size_value"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">resize</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">value_type</span><span class="special">());</span>
492</pre>
493<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
494<li class="listitem">
495                <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="keyword">if</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">&gt;</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">)</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">end</span><span class="special">(),</span>
496                <span class="identifier">n</span><span class="special">-</span><span class="identifier">size</span><span class="special">(),</span>
497                <span class="identifier">x</span><span class="special">);</span></code>
498                <code class="computeroutput"><span class="keyword">else</span> <span class="keyword">if</span><span class="special">(</span> <span class="identifier">n</span><span class="special">&lt;</span><span class="identifier">size</span><span class="special">()</span> <span class="special">)</span> <span class="identifier">erase</span><span class="special">(</span><span class="identifier">begin</span><span class="special">()+</span><span class="identifier">n</span><span class="special">,</span><span class="identifier">end</span><span class="special">());</span></code>
499              </li>
500<li class="listitem">
501                <span class="bold"><strong>Note:</strong></span> If an expansion is requested,
502                the size of the view is not guaranteed to be n after this operation
503                (other views may ban insertions.)
504              </li>
505</ul></div>
506</div>
507<div class="section">
508<div class="titlepage"><div><div><h5 class="title">
509<a name="boost_bimap.reference.vector_of_reference.vector_of_views.modifiers"></a><a class="link" href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.modifiers" title="Modifiers">Modifiers</a>
510</h5></div></div></div>
511<a name="reference_vector_of_push_front_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">push_front</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>
512</pre>
513<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
514<li class="listitem">
515                <span class="bold"><strong>Effects:</strong></span> Inserts x at the beginning
516                of the sequence if no other view of the <code class="computeroutput"><span class="identifier">bimap</span></code>
517                bans the insertion.
518              </li>
519<li class="listitem">
520                <span class="bold"><strong>Returns:</strong></span> The return value is a pair
521                <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>
522                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;
523                otherwise, <code class="computeroutput"><span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span></code> points to an element that
524                caused the insertion to be banned. Note that more than one element
525                can be causing insertion not to be allowed.
526              </li>
527<li class="listitem">
528                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
529                O(n+I(n)).
530              </li>
531<li class="listitem">
532                <span class="bold"><strong>Exception safety:</strong></span> Strong.
533              </li>
534</ul></div>
535<a name="reference_vector_of_push_back_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">push_back</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>
536</pre>
537<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
538<li class="listitem">
539                <span class="bold"><strong>Effects:</strong></span> Inserts <code class="computeroutput"><span class="identifier">x</span></code>
540                at the end of the sequence if no other view of the <code class="computeroutput"><span class="identifier">bimap</span></code> bans the insertion.
541              </li>
542<li class="listitem">
543                <span class="bold"><strong>Returns:</strong></span> The return value is a pair
544                <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>
545                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;
546                otherwise, <code class="computeroutput"><span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span></code> points to an element that
547                caused the insertion to be banned. Note that more than one element
548                can be causing insertion not to be allowed.
549              </li>
550<li class="listitem">
551                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
552                O(I(n)).
553              </li>
554<li class="listitem">
555                <span class="bold"><strong>Exception safety:</strong></span> Strong.
556              </li>
557</ul></div>
558<a name="reference_vector_of_insert_iterator_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="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>
559</pre>
560<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
561<li class="listitem">
562                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
563                is a valid iterator of the view.
564              </li>
565<li class="listitem">
566                <span class="bold"><strong>Effects:</strong></span> Inserts <code class="computeroutput"><span class="identifier">x</span></code>
567                before position if insertion is allowed by all other views of the
568                <code class="computeroutput"><span class="identifier">bimap</span></code>.
569              </li>
570<li class="listitem">
571                <span class="bold"><strong>Returns:</strong></span> The return value is a pair
572                <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>
573                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;
574                otherwise, <code class="computeroutput"><span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span></code> points to an element that
575                caused the insertion to be banned. Note that more than one element
576                can be causing insertion not to be allowed.
577              </li>
578<li class="listitem">
579                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
580                O(shl(end()-position,1) + I(n)).
581              </li>
582<li class="listitem">
583                <span class="bold"><strong>Exception safety:</strong></span> Strong.
584              </li>
585</ul></div>
586<a name="reference_vector_of_insert_iterator_size_value"></a><pre class="programlisting"><span class="keyword">void</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="identifier">size_type</span> <span class="identifier">m</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>
587</pre>
588<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
589<li class="listitem">
590                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
591                is a valid iterator of the view.
592              </li>
593<li class="listitem">
594                <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="keyword">for</span><span class="special">(</span><span class="identifier">size_type</span>
595                <span class="identifier">i</span> <span class="special">=</span>
596                <span class="number">0</span><span class="special">;</span>
597                <span class="identifier">i</span> <span class="special">&lt;</span>
598                <span class="identifier">m</span><span class="special">;</span>
599                <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">position</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span></code>
600              </li>
601<li class="listitem">
602                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
603                O(shl(end()-position,m) + m*I(n+m)).
604              </li>
605</ul></div>
606<a name="reference_vector_of_insert_iterator_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>
607<span class="keyword">void</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="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>
608</pre>
609<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
610<li class="listitem">
611                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
612                is a valid iterator of the view. <code class="computeroutput"><span class="identifier">InputIterator</span></code>
613                is a model of <a href="https://www.boost.org/sgi/stl/InputIterator.html" target="_top">Input
614                Iterator</a> over elements of type <code class="computeroutput"><span class="identifier">value_type</span></code>
615                or a type convertible to <code class="computeroutput"><span class="identifier">value_type</span></code>.
616                <code class="computeroutput"><span class="identifier">first</span></code> and <code class="computeroutput"><span class="identifier">last</span></code> are not iterators into any
617                view of the <code class="computeroutput"><span class="identifier">bimap</span></code>
618                to which this view belongs. <code class="computeroutput"><span class="identifier">last</span></code>
619                is reachable from <code class="computeroutput"><span class="identifier">first</span></code>.
620              </li>
621<li class="listitem">
622                <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span><span class="special">!=</span><span class="identifier">last</span><span class="special">)</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">position</span><span class="special">,*</span><span class="identifier">first</span><span class="special">++);</span></code>
623              </li>
624<li class="listitem">
625                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
626                O(shl(end()-position,m) + m*I(n+m)), where m is the number of elements
627                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>.
628              </li>
629<li class="listitem">
630                <span class="bold"><strong>Exception safety:</strong></span> Basic.
631              </li>
632</ul></div>
633<a name="reference_vector_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>
634</pre>
635<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
636<li class="listitem">
637                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
638                is a valid dereferenceable iterator of the view.
639              </li>
640<li class="listitem">
641                <span class="bold"><strong>Effects:</strong></span> Deletes the element pointed
642                to by <code class="computeroutput"><span class="identifier">position</span></code>.
643              </li>
644<li class="listitem">
645                <span class="bold"><strong>Returns:</strong></span> An iterator pointing to
646                the element immediately following the one that was deleted, or <code class="computeroutput"><span class="identifier">end</span><span class="special">()</span></code>
647                if no such element exists.
648              </li>
649<li class="listitem">
650                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
651                O(D(n)).
652              </li>
653<li class="listitem">
654                <span class="bold"><strong>Exception safety:</strong></span> nothrow.
655              </li>
656</ul></div>
657<a name="reference_vector_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>
658</pre>
659<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
660<li class="listitem">
661                <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>
662                is a valid range of the view.
663              </li>
664<li class="listitem">
665                <span class="bold"><strong>Effects:</strong></span> Deletes the elements in
666                <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>.
667              </li>
668<li class="listitem">
669                <span class="bold"><strong>Returns:</strong></span> last.
670              </li>
671<li class="listitem">
672                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
673                O(m*D(n)), where m is the number of elements in <code class="computeroutput"><span class="special">[</span><span class="identifier">first</span><span class="special">,</span><span class="identifier">last</span><span class="special">)</span></code>.
674              </li>
675<li class="listitem">
676                <span class="bold"><strong>Exception safety:</strong></span> nothrow.
677              </li>
678</ul></div>
679<a name="reference_vector_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>
680</pre>
681<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
682<li class="listitem">
683                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
684                is a valid dereferenceable iterator of the view.
685              </li>
686<li class="listitem">
687                <span class="bold"><strong>Effects:</strong></span> Assigns the value x to
688                the element pointed to by position into the <code class="computeroutput"><span class="identifier">bimap</span></code>
689                to which the view belongs if replacing is allowed by all other views
690                of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
691              </li>
692<li class="listitem">
693                <span class="bold"><strong>Postconditions:</strong></span> Validity of position
694                is preserved in all cases.
695              </li>
696<li class="listitem">
697                <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
698                if the replacement took place, <code class="computeroutput"><span class="keyword">false</span></code>
699                otherwise.
700              </li>
701<li class="listitem">
702                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
703                O(R(n)).
704              </li>
705<li class="listitem">
706                <span class="bold"><strong>Exception safety:</strong></span> Strong. If an
707                exception is thrown by some user-provided operation the <code class="computeroutput"><span class="identifier">bimap</span></code> to which the view belongs
708                remains in its original state.
709              </li>
710</ul></div>
711<a name="reference_vector_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>
712<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>
713</pre>
714<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
715<li class="listitem">
716                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
717                is a valid dereferenceable iterator of the set view. <code class="computeroutput"><span class="identifier">CompatibleKey</span></code> can be assigned to
718                <code class="computeroutput"><span class="identifier">key_type</span></code>.
719              </li>
720<li class="listitem">
721                <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>,
722                where <code class="computeroutput"><span class="identifier">e</span></code> is the element
723                pointed to by <code class="computeroutput"><span class="identifier">position</span></code>
724                into the <code class="computeroutput"><span class="identifier">bimap</span></code> to
725                which the set view belongs if replacing is allowed by all other views
726                of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
727              </li>
728<li class="listitem">
729                <span class="bold"><strong>Postconditions:</strong></span> Validity of position
730                is preserved in all cases.
731              </li>
732<li class="listitem">
733                <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
734                if the replacement took place, <code class="computeroutput"><span class="keyword">false</span></code>
735                otherwise.
736              </li>
737<li class="listitem">
738                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
739                O(R(n)).
740              </li>
741<li class="listitem">
742                <span class="bold"><strong>Exception safety:</strong></span> Strong. If an
743                exception is thrown by some user-provided operation, the <code class="computeroutput"><span class="identifier">bimap</span></code> to which the set view belongs
744                remains in its original state.
745              </li>
746</ul></div>
747<a name="reference_vector_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>
748<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>
749</pre>
750<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
751<li class="listitem">
752                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
753                is a valid dereferenceable iterator of the set view. <code class="computeroutput"><span class="identifier">CompatibleKey</span></code> can be assigned to
754                <code class="computeroutput"><span class="identifier">mapped_type</span></code>.
755              </li>
756<li class="listitem">
757                <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>,
758                where <code class="computeroutput"><span class="identifier">e</span></code> is the element
759                pointed to by <code class="computeroutput"><span class="identifier">position</span></code>
760                into the <code class="computeroutput"><span class="identifier">bimap</span></code> to
761                which the set view belongs if replacing is allowed by all other views
762                of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
763              </li>
764<li class="listitem">
765                <span class="bold"><strong>Postconditions:</strong></span> Validity of position
766                is preserved in all cases.
767              </li>
768<li class="listitem">
769                <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
770                if the replacement took place, <code class="computeroutput"><span class="keyword">false</span></code>
771                otherwise.
772              </li>
773<li class="listitem">
774                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
775                O(R(n)).
776              </li>
777<li class="listitem">
778                <span class="bold"><strong>Exception safety:</strong></span> Strong. If an
779                exception is thrown by some user-provided operation, the <code class="computeroutput"><span class="identifier">bimap</span></code> to which the set view belongs
780                remains in its original state.
781              </li>
782</ul></div>
783<a name="reference_vector_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>
784<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>
785</pre>
786<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
787<li class="listitem">
788                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">KeyModifier</span></code>
789                is a model of <a href="https://www.boost.org/sgi/stl/UnaryFunction.html" target="_top">Unary
790                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>
791                is a valid dereferenceable iterator of the view.
792              </li>
793<li class="listitem">
794                <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
795                by position and rearranges <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span></code> into all the views of
796                the <code class="computeroutput"><span class="identifier">bimap</span></code>. If the
797                rearrangement fails, the element is erased. It is successful if the
798                rearrangement is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
799              </li>
800<li class="listitem">
801                <span class="bold"><strong>Postconditions:</strong></span> Validity of <code class="computeroutput"><span class="identifier">position</span></code> is preserved if the operation
802                succeeds.
803              </li>
804<li class="listitem">
805                <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
806                if the operation succeeded, <code class="computeroutput"><span class="keyword">false</span></code>
807                otherwise.
808              </li>
809<li class="listitem">
810                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
811                O(M(n)).
812              </li>
813<li class="listitem">
814                <span class="bold"><strong>Exception safety:</strong></span> Basic. If an exception
815                is thrown by some user-provided operation (except possibly mod),
816                then the element pointed to by position is erased.
817              </li>
818<li class="listitem">
819                <span class="bold"><strong>Note:</strong></span> Only provided for map views.
820              </li>
821</ul></div>
822<a name="reference_vector_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>
823<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>
824</pre>
825<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
826<li class="listitem">
827                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">DataModifier</span></code>
828                is a model of <a href="https://www.boost.org/sgi/stl/UnaryFunction.html" target="_top">Unary
829                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>
830                is a valid dereferenceable iterator of the view.
831              </li>
832<li class="listitem">
833                <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
834                by position and rearranges <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span></code> into all the views of
835                the <code class="computeroutput"><span class="identifier">bimap</span></code>. If the
836                rearrangement fails, the element is erased. It is successful if the
837                rearrangement is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
838              </li>
839<li class="listitem">
840                <span class="bold"><strong>Postconditions:</strong></span> Validity of <code class="computeroutput"><span class="identifier">position</span></code> is preserved if the operation
841                succeeds.
842              </li>
843<li class="listitem">
844                <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
845                if the operation succeeded, <code class="computeroutput"><span class="keyword">false</span></code>
846                otherwise.
847              </li>
848<li class="listitem">
849                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
850                O(M(n)).
851              </li>
852<li class="listitem">
853                <span class="bold"><strong>Exception safety:</strong></span> Basic. If an exception
854                is thrown by some user-provided operation (except possibly mod),
855                then the element pointed to by position is erased.
856              </li>
857<li class="listitem">
858                <span class="bold"><strong>Note:</strong></span> Only provided for map views.
859              </li>
860</ul></div>
861</div>
862<div class="section">
863<div class="titlepage"><div><div><h5 class="title">
864<a name="boost_bimap.reference.vector_of_reference.vector_of_views.list_operations"></a><a class="link" href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.list_operations" title="List operations">List
865          operations</a>
866</h5></div></div></div>
867<p>
868            <code class="computeroutput"><span class="identifier">vector_of</span></code> views replicate
869            the interface of <code class="computeroutput"><span class="identifier">list_of</span></code>
870            views, which in turn includes the list operations provided by <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span></code>. The syntax and behavior of these
871            operations exactly matches those of <code class="computeroutput"><span class="identifier">list_of</span></code>
872            views, but the associated complexity bounds differ in general.
873          </p>
874<a name="reference_vector_of_splice_iterator_this"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">splice</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</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>
875</pre>
876<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
877<li class="listitem">
878                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
879                is a valid iterator of the view. <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">!=</span><span class="keyword">this</span></code>.
880              </li>
881<li class="listitem">
882                <span class="bold"><strong>Effects:</strong></span> Inserts the contents of
883                <code class="computeroutput"><span class="identifier">x</span></code> before position,
884                in the same order as they were in <code class="computeroutput"><span class="identifier">x</span></code>.
885                Those elements successfully inserted are erased from <code class="computeroutput"><span class="identifier">x</span></code>.
886              </li>
887<li class="listitem">
888                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
889                O(shl(end()-position,x.size()) + x.size()*I(n+x.size()) + x.size()*D(x.size())).
890              </li>
891<li class="listitem">
892                <span class="bold"><strong>Exception safety:</strong></span> Basic.
893              </li>
894</ul></div>
895<a name="reference_vector_of_splice_iterator_this_iterator"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">splice</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</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><span class="identifier">iterator</span> <span class="identifier">i</span><span class="special">);</span>
896</pre>
897<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
898<li class="listitem">
899                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
900                is a valid iterator of the view. <code class="computeroutput"><span class="identifier">i</span></code>
901                is a valid dereferenceable iterator <code class="computeroutput"><span class="identifier">x</span></code>.
902              </li>
903<li class="listitem">
904                <span class="bold"><strong>Effects:</strong></span> Inserts the element pointed
905                to by <code class="computeroutput"><span class="identifier">i</span></code> before <code class="computeroutput"><span class="identifier">position</span></code>: if insertion is successful,
906                the element is erased from <code class="computeroutput"><span class="identifier">x</span></code>.
907                In the special case <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>, no copy or deletion is performed,
908                and the operation is always successful. If <code class="computeroutput"><span class="identifier">position</span><span class="special">==</span><span class="identifier">i</span></code>,
909                no operation is performed.
910              </li>
911<li class="listitem">
912                <span class="bold"><strong>Postconditions:</strong></span> If <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>,
913                no iterator or reference is invalidated.
914              </li>
915<li class="listitem">
916                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
917                If <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>,
918                O(rel(position,i,i+1)); otherwise O(shl(end()-position,1) + I(n)
919                + D(n)).
920              </li>
921<li class="listitem">
922                <span class="bold"><strong>Exception safety:</strong></span> If <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>,
923                nothrow; otherwise, strong.
924              </li>
925</ul></div>
926<a name="reference_vector_of_splice_iterator_this_iterator_iterator"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">splice</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</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> <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>
927</pre>
928<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
929<li class="listitem">
930                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
931                is a valid iterator of the view. <code class="computeroutput"><span class="identifier">first</span></code>
932                and <code class="computeroutput"><span class="identifier">last</span></code> are valid
933                iterators of <code class="computeroutput"><span class="identifier">x</span></code>.
934                <code class="computeroutput"><span class="identifier">last</span></code> is reachable
935                from <code class="computeroutput"><span class="identifier">first</span></code>. <code class="computeroutput"><span class="identifier">position</span></code> is not in the range <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>.
936              </li>
937<li class="listitem">
938                <span class="bold"><strong>Effects:</strong></span> For each element in the
939                range <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>, insertion is tried before <code class="computeroutput"><span class="identifier">position</span></code>; if the operation is successful,
940                the element is erased from <code class="computeroutput"><span class="identifier">x</span></code>.
941                In the special case <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>, no copy or deletion is performed,
942                and insertions are always successful.
943              </li>
944<li class="listitem">
945                <span class="bold"><strong>Postconditions:</strong></span> If <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>,
946                no iterator or reference is invalidated.
947              </li>
948<li class="listitem">
949                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
950                If <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>,
951                O(rel(position,first,last)); otherwise O(shl(end()-position,m) +
952                m*I(n+m) + m*D(x.size())) 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>.
953              </li>
954<li class="listitem">
955                <span class="bold"><strong>Exception safety:</strong></span> If <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>,
956                nothrow; otherwise, basic.
957              </li>
958</ul></div>
959<a name="reference_vector_of_remove_value"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">remove</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> <span class="identifier">value</span><span class="special">);</span>
960</pre>
961<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
962<li class="listitem">
963                <span class="bold"><strong>Effects:</strong></span> Erases all elements of
964                the view which compare equal to <code class="computeroutput"><span class="identifier">value</span></code>.
965              </li>
966<li class="listitem">
967                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
968                O(n + m*D(n)), where m is the number of elements erased.
969              </li>
970<li class="listitem">
971                <span class="bold"><strong>Exception safety:</strong></span> Basic.
972              </li>
973</ul></div>
974<a name="reference_vector_of_remove_if_predicate"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Predicate</span> <span class="special">&gt;</span>
975<span class="keyword">void</span> <span class="identifier">remove_if</span><span class="special">(</span><span class="identifier">Predicate</span> <span class="identifier">pred</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>Effects:</strong></span> Erases all elements <code class="computeroutput"><span class="identifier">x</span></code> of the view for which <code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>
980                holds.
981              </li>
982<li class="listitem">
983                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
984                O(n + m*D(n)), where m is the number of elements erased.
985              </li>
986<li class="listitem">
987                <span class="bold"><strong>Exception safety:</strong></span> Basic.
988              </li>
989</ul></div>
990<a name="reference_vector_of_unique"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">unique</span><span class="special">();</span>
991</pre>
992<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
993<li class="listitem">
994                <span class="bold"><strong>Effects:</strong></span> Eliminates all but the
995                first element from every consecutive group of equal elements referred
996                to by the iterator <code class="computeroutput"><span class="identifier">i</span></code>
997                in the range <code class="computeroutput"><span class="special">[</span><span class="identifier">first</span><span class="special">+</span><span class="number">1</span><span class="special">,</span><span class="identifier">last</span><span class="special">)</span></code> for which <code class="computeroutput"><span class="special">*</span><span class="identifier">i</span><span class="special">==*(</span><span class="identifier">i</span><span class="special">-</span><span class="number">1</span><span class="special">)</span></code>.
998              </li>
999<li class="listitem">
1000                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
1001                O(n + m*D(n)), where m is the number of elements erased.
1002              </li>
1003<li class="listitem">
1004                <span class="bold"><strong>Exception safety:</strong></span> Basic.
1005              </li>
1006</ul></div>
1007<a name="reference_vector_of_unique_predicate"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span> <span class="special">&gt;</span>
1008<span class="keyword">void</span> <span class="identifier">unique</span><span class="special">(</span><span class="identifier">BinaryPredicate</span> <span class="identifier">binary_pred</span><span class="special">);</span>
1009</pre>
1010<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1011<li class="listitem">
1012                <span class="bold"><strong>Effects:</strong></span> Eliminates all but the
1013                first element from every consecutive group of elements referred to
1014                by the iterator i in the range <code class="computeroutput"><span class="special">[</span><span class="identifier">first</span><span class="special">+</span><span class="number">1</span><span class="special">,</span><span class="identifier">last</span><span class="special">)</span></code>
1015                for which <code class="computeroutput"><span class="identifier">binary_pred</span><span class="special">(*</span><span class="identifier">i</span><span class="special">,</span> <span class="special">*(</span><span class="identifier">i</span><span class="special">-</span><span class="number">1</span><span class="special">))</span></code>
1016                holds.
1017              </li>
1018<li class="listitem">
1019                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
1020                O(n + m*D(n)), where m is the number of elements erased.
1021              </li>
1022<li class="listitem">
1023                <span class="bold"><strong>Exception safety:</strong></span> Basic.
1024              </li>
1025</ul></div>
1026<a name="reference_vector_of_merge_this"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">merge</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>
1027</pre>
1028<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1029<li class="listitem">
1030                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;</span></code> is a <a href="https://www.boost.org/sgi/stl/StrictWeakOrdering.html" target="_top">Strict
1031                Weak Ordering</a> over <code class="computeroutput"><span class="identifier">value_type</span></code>.
1032                Both the view and <code class="computeroutput"><span class="identifier">x</span></code>
1033                are sorted according to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;</span></code>.
1034              </li>
1035<li class="listitem">
1036                <span class="bold"><strong>Effects:</strong></span> Attempts to insert every
1037                element of x into the corresponding position of the view (according
1038                to the order). Elements successfully inserted are erased from <code class="computeroutput"><span class="identifier">x</span></code>. The resulting sequence is stable,
1039                i.e. equivalent elements of either container preserve their relative
1040                position. In the special case <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>, no operation is performed.
1041              </li>
1042<li class="listitem">
1043                <span class="bold"><strong>Postconditions:</strong></span> Elements in the
1044                view and remaining elements in <code class="computeroutput"><span class="identifier">x</span></code>
1045                are sorted. Validity of iterators to the view and of non-erased elements
1046                of <code class="computeroutput"><span class="identifier">x</span></code> references is
1047                preserved.
1048              </li>
1049<li class="listitem">
1050                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
1051                If <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>,
1052                constant; otherwise O(n + x.size()*I(n+x.size()) + x.size()*D(x.size())).
1053              </li>
1054<li class="listitem">
1055                <span class="bold"><strong>Exception safety:</strong></span> If <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>,
1056                nothrow; otherwise, basic.
1057              </li>
1058</ul></div>
1059<a name="reference_vector_of_merge_this_compare"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Compare</span> <span class="special">&gt;</span>
1060<span class="keyword">void</span> <span class="identifier">merge</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> <span class="identifier">Compare</span> <span class="identifier">comp</span><span class="special">);</span>
1061</pre>
1062<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1063<li class="listitem">
1064                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">Compare</span></code>
1065                is a <a href="https://www.boost.org/sgi/stl/StrictWeakOrdering.html" target="_top">Strict
1066                Weak Ordering</a> over <code class="computeroutput"><span class="identifier">value_type</span></code>.
1067                Both the view and <code class="computeroutput"><span class="identifier">x</span></code>
1068                are sorted according to comp.
1069              </li>
1070<li class="listitem">
1071                <span class="bold"><strong>Effects:</strong></span> Attempts to insert every
1072                element of <code class="computeroutput"><span class="identifier">x</span></code> into
1073                the corresponding position of the view (according to <code class="computeroutput"><span class="identifier">comp</span></code>). Elements successfully inserted
1074                are erased from <code class="computeroutput"><span class="identifier">x</span></code>.
1075                The resulting sequence is stable, i.e. equivalent elements of either
1076                container preserve their relative position. In the special case
1077                <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>,
1078                no operation is performed.
1079              </li>
1080<li class="listitem">
1081                <span class="bold"><strong>Postconditions:</strong></span> Elements in the
1082                view and remaining elements in <code class="computeroutput"><span class="identifier">x</span></code>
1083                are sorted according to <code class="computeroutput"><span class="identifier">comp</span></code>.
1084                Validity of iterators to the view and of non-erased elements of
1085                <code class="computeroutput"><span class="identifier">x</span></code> references is preserved.
1086              </li>
1087<li class="listitem">
1088                <a class="link" href="vector_of_reference.html#vector_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
1089                If <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>,
1090                constant; otherwise O(n + x.size()*I(n+x.size()) + x.size()*D(x.size())).
1091              </li>
1092<li class="listitem">
1093                <span class="bold"><strong>Exception safety:</strong></span> If <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">x</span><span class="special">==</span><span class="keyword">this</span></code>,
1094                nothrow; otherwise, basic.
1095              </li>
1096</ul></div>
1097<a name="reference_vector_of_sort"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">sort</span><span class="special">();</span>
1098</pre>
1099<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1100<li class="listitem">
1101                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;</span></code> is a <a href="https://www.boost.org/sgi/stl/StrictWeakOrdering.html" target="_top">Strict
1102                Weak Ordering</a> over <code class="computeroutput"><span class="identifier">value_type</span></code>.
1103              </li>
1104<li class="listitem">
1105                <span class="bold"><strong>Effects:</strong></span> Sorts the view according
1106                to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;</span></code>.
1107                The sorting is stable, i.e. equivalent elements preserve their relative
1108                position.
1109              </li>
1110<li class="listitem">
1111                <span class="bold"><strong>Postconditions:</strong></span> Validity of iterators
1112                and references is preserved.
1113              </li>
1114<li class="listitem">
1115                <span class="bold"><strong>Complexity:</strong></span> O(n*log(n)).
1116              </li>
1117<li class="listitem">
1118                <span class="bold"><strong>Exception safety:</strong></span> Basic.
1119              </li>
1120</ul></div>
1121<a name="reference_vector_of_sort_compare"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Compare</span> <span class="special">&gt;</span>
1122<span class="keyword">void</span> <span class="identifier">sort</span><span class="special">(</span><span class="identifier">Compare</span> <span class="identifier">comp</span><span class="special">);</span>
1123</pre>
1124<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1125<li class="listitem">
1126                <span class="bold"><strong>Requires:</strong></span> Compare is a <a href="https://www.boost.org/sgi/stl/StrictWeakOrdering.html" target="_top">Strict
1127                Weak Ordering</a> over <code class="computeroutput"><span class="identifier">value_type</span></code>.
1128              </li>
1129<li class="listitem">
1130                <span class="bold"><strong>Effects:</strong></span> Sorts the view according
1131                to <code class="computeroutput"><span class="identifier">comp</span></code>. The sorting
1132                is stable, i.e. equivalent elements preserve their relative position.
1133              </li>
1134<li class="listitem">
1135                <span class="bold"><strong>Postconditions:</strong></span> Validity of iterators
1136                and references is preserved.
1137              </li>
1138<li class="listitem">
1139                <span class="bold"><strong>Complexity:</strong></span> O(n*log(n)).
1140              </li>
1141<li class="listitem">
1142                <span class="bold"><strong>Exception safety:</strong></span> Basic.
1143              </li>
1144</ul></div>
1145<a name="reference_vector_of_reverse"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">reverse</span><span class="special">();</span>
1146</pre>
1147<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1148<li class="listitem">
1149                <span class="bold"><strong>Effects:</strong></span> Reverses the order of the
1150                elements in the view.
1151              </li>
1152<li class="listitem">
1153                <span class="bold"><strong>Postconditions:</strong></span> Validity of iterators
1154                and references is preserved.
1155              </li>
1156<li class="listitem">
1157                <span class="bold"><strong>Complexity:</strong></span> O(n).
1158              </li>
1159<li class="listitem">
1160                <span class="bold"><strong>Exception safety:</strong></span> nothrow.
1161              </li>
1162</ul></div>
1163</div>
1164<div class="section">
1165<div class="titlepage"><div><div><h5 class="title">
1166<a name="boost_bimap.reference.vector_of_reference.vector_of_views.rearrange_operations"></a><a class="link" href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.rearrange_operations" title="Rearrange operations">Rearrange
1167          operations</a>
1168</h5></div></div></div>
1169<p>
1170            These operations, without counterpart in <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span></code>
1171            (although splice provides partially overlapping functionality), perform
1172            individual and global repositioning of elements inside the index.
1173          </p>
1174<a name="reference_vector_of_relocate_iterator_iterator"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">relocate</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="identifier">i</span><span class="special">);</span>
1175</pre>
1176<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1177<li class="listitem">
1178                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
1179                is a valid iterator of the view. <code class="computeroutput"><span class="identifier">i</span></code>
1180                is a valid dereferenceable iterator of the view.
1181              </li>
1182<li class="listitem">
1183                <span class="bold"><strong>Effects:</strong></span> Inserts the element pointed
1184                to by <code class="computeroutput"><span class="identifier">i</span></code> before <code class="computeroutput"><span class="identifier">position</span></code>. If <code class="computeroutput"><span class="identifier">position</span><span class="special">==</span><span class="identifier">i</span></code>,
1185                no operation is performed.
1186              </li>
1187<li class="listitem">
1188                <span class="bold"><strong>Postconditions:</strong></span> No iterator or reference
1189                is invalidated.
1190              </li>
1191<li class="listitem">
1192                <span class="bold"><strong>Complexity:</strong></span> Constant.
1193              </li>
1194<li class="listitem">
1195                <span class="bold"><strong>Exception safety:</strong></span> nothrow.
1196              </li>
1197</ul></div>
1198<a name="reference_vector_of_relocate_iterator_iterator_iterator"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">relocate</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</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>
1199</pre>
1200<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1201<li class="listitem">
1202                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
1203                is a valid iterator of the view. <code class="computeroutput"><span class="identifier">first</span></code>
1204                and <code class="computeroutput"><span class="identifier">last</span></code> are valid
1205                iterators of the view. <code class="computeroutput"><span class="identifier">last</span></code>
1206                is reachable from <code class="computeroutput"><span class="identifier">first</span></code>.
1207                <code class="computeroutput"><span class="identifier">position</span></code> is not in
1208                the range <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>.
1209              </li>
1210<li class="listitem">
1211                <span class="bold"><strong>Effects:</strong></span> The range of elements
1212                <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> is repositioned just before <code class="computeroutput"><span class="identifier">position</span></code>.
1213              </li>
1214<li class="listitem">
1215                <span class="bold"><strong>Postconditions:</strong></span> No iterator or reference
1216                is invalidated.
1217              </li>
1218<li class="listitem">
1219                <span class="bold"><strong>Complexity:</strong></span> Constant.
1220              </li>
1221<li class="listitem">
1222                <span class="bold"><strong>Exception safety:</strong></span> nothrow.
1223              </li>
1224</ul></div>
1225</div>
1226<div class="section">
1227<div class="titlepage"><div><div><h5 class="title">
1228<a name="boost_bimap.reference.vector_of_reference.vector_of_views.serialization"></a><a class="link" href="vector_of_reference.html#boost_bimap.reference.vector_of_reference.vector_of_views.serialization" title="Serialization">Serialization</a>
1229</h5></div></div></div>
1230<p>
1231            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.
1232            In describing the additional preconditions and guarantees associated
1233            to <code class="computeroutput"><span class="identifier">vector_of</span></code> views with
1234            respect to serialization of their embedding containers, we use the concepts
1235            defined in the <code class="computeroutput"><span class="identifier">bimap</span></code>
1236            serialization section.
1237          </p>
1238<div class="blurb">
1239<div class="titlepage"><div><div><p class="title"><b></b></p></div></div></div>
1240<p>
1241            <span class="bold"><strong>Operation:</strong></span> saving of a <code class="computeroutput"><span class="identifier">bimap</span></code> b to an output archive (XML archive)
1242            ar.
1243          </p>
1244</div>
1245<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
1246                <span class="bold"><strong>Requires:</strong></span> No additional requirements
1247                to those imposed by the container.
1248              </li></ul></div>
1249<div class="blurb">
1250<div class="titlepage"><div><div><p class="title"><b></b></p></div></div></div>
1251<p>
1252            <span class="bold"><strong>Operation:</strong></span> loading of a <code class="computeroutput"><span class="identifier">bimap</span></code> b' from an input archive (XML
1253            archive) ar.
1254          </p>
1255</div>
1256<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1257<li class="listitem">
1258                <span class="bold"><strong>Requires:</strong></span> No additional requirements
1259                to those imposed by the container.
1260              </li>
1261<li class="listitem">
1262                <span class="bold"><strong>Postconditions:</strong></span> On successful loading,
1263                each of the elements of <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(),</span>
1264                <span class="identifier">end</span><span class="special">())</span></code>
1265                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>, where <code class="computeroutput"><span class="identifier">i</span></code>
1266                is the position of the <code class="computeroutput"><span class="identifier">vector_of</span></code>
1267                view in the container.
1268              </li>
1269</ul></div>
1270<div class="blurb">
1271<div class="titlepage"><div><div><p class="title"><b></b></p></div></div></div>
1272<p>
1273            <span class="bold"><strong>Operation:</strong></span> saving of an <code class="computeroutput"><span class="identifier">iterator</span></code> or <code class="computeroutput"><span class="identifier">const_iterator</span></code>
1274            <code class="computeroutput"><span class="identifier">it</span></code> to an output archive
1275            (XML archive) ar.
1276          </p>
1277</div>
1278<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
1279                <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">it</span></code>
1280                is a valid iterator of the view. The associated <code class="computeroutput"><span class="identifier">bimap</span></code>
1281                has been previously saved.
1282              </li></ul></div>
1283<div class="blurb">
1284<div class="titlepage"><div><div><p class="title"><b></b></p></div></div></div>
1285<p>
1286            <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>
1287            <code class="computeroutput"><span class="identifier">it</span></code>' from an input archive
1288            (XML archive) ar.
1289          </p>
1290</div>
1291<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1292<li class="listitem">
1293                <span class="bold"><strong>Postconditions:</strong></span> On successful loading,
1294                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>,
1295                otherwise <code class="computeroutput"><span class="identifier">it</span></code>'<code class="computeroutput"><span class="special">==</span><span class="identifier">end</span><span class="special">()</span></code>.
1296              </li>
1297<li class="listitem">
1298                <span class="bold"><strong>Note:</strong></span> It is allowed that it be a
1299                <code class="computeroutput"><span class="identifier">const_iterator</span></code> and
1300                the restored <code class="computeroutput"><span class="identifier">it</span></code>'
1301                an <code class="computeroutput"><span class="identifier">iterator</span></code>, or viceversa.
1302              </li>
1303</ul></div>
1304</div>
1305</div>
1306</div>
1307<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
1308<td align="left"></td>
1309<td align="right"><div class="copyright-footer">Copyright © 2006-2012 Matias Capeletto<p>
1310        Distributed under the Boost Software License, Version 1.0. (See accompanying
1311        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>)
1312      </p>
1313</div></td>
1314</tr></table>
1315<hr>
1316<div class="spirit-nav">
1317<a accesskey="p" href="list_of_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="unconstrained_set_of_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
1318</div>
1319</body>
1320</html>
1321