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

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   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.77.1">
   7 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Bimap">
   8 <link rel="up" href="../reference.html" title="Reference">
   9 <link rel="prev" href="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 boost_bimap_reference_vector_of_reference">
  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>
  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 boost_bimap_reference_vector_of_reference_header__boost_bimap_vector_of_hpp__synopsis">
  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 boost_bimap_reference_vector_of_reference_vector_of_views">
  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>
  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="http://www.sgi.com/tech/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="http://www.sgi.com/tech/stl/RandomAccessContainer.html" target="_top">Random
 128           Access Container</a> and <a href="http://www.sgi.com/tech/stl/BackInsertionSequence.html" target="_top">Back
 129           Insertion Sequence</a>. Although these views do not model <a href="http://www.sgi.com/tech/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 boost_bimap_reference_vector_of_reference_vector_of_views_complexity_signature">
 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="sidebar">
 368 <div class="titlepage"></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 boost_bimap_reference_vector_of_reference_vector_of_views_instantiation_types">
 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 boost_bimap_reference_vector_of_reference_vector_of_views_constructors__copy_and_assignment">
 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="http://www.sgi.com/tech/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 boost_bimap_reference_vector_of_reference_vector_of_views_capacity_operations">
 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 boost_bimap_reference_vector_of_reference_vector_of_views_modifiers">
 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="http://www.sgi.com/tech/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="http://www.sgi.com/tech/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="http://www.sgi.com/tech/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 boost_bimap_reference_vector_of_reference_vector_of_views_list_operations">
 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="http://www.sgi.com/tech/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="http://www.sgi.com/tech/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="http://www.sgi.com/tech/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="http://www.sgi.com/tech/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 boost_bimap_reference_vector_of_reference_vector_of_views_rearrange_operations">
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 boost_bimap_reference_vector_of_reference_vector_of_views_serialization">
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="sidebar">
1239 <div class="titlepage"></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="sidebar">
1250 <div class="titlepage"></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="sidebar">
1271 <div class="titlepage"></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="sidebar">
1284 <div class="titlepage"></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 &#169; 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>