ceph/src/boost/libs/multi_index/doc/reference/multi_index_container.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
   2
   3 <html>
   4 <head>
   5 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
   6 <title>Boost.MultiIndex Documentation - multi_index_container reference</title>
   7 <link rel="stylesheet" href="../style.css" type="text/css">
   8 <link rel="start" href="../index.html">
   9 <link rel="prev" href="index.html">
  10 <link rel="up" href="index.html">
  11 <link rel="next" href="indices.html">
  12 </head>
  13
  14 <body>
  15 <h1><img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
  16 "middle" width="277" height="86">Boost.MultiIndex
  17 <code>multi_index_container</code> reference</h1>
  18
  19 <div class="prev_link"><a href="index.html"><img src="../prev.gif" alt="Boost.MultiIndex reference" border="0"><br>
  20 Boost.MultiIndex reference
  21 </a></div>
  22 <div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
  23 Boost.MultiIndex reference
  24 </a></div>
  25 <div class="next_link"><a href="indices.html"><img src="../next.gif" alt="index reference" border="0"><br>
  26 Index reference
  27 </a></div><br clear="all" style="clear: all;">
  28
  29 <hr>
  30
  31 <h2>Contents</h2>
  32
  33 <ul>
  34   <li><a href="#multi_index_container_fwd_synopsis">Header
  35     <code>"boost/multi_index_container_fwd.hpp"</code> synopsis</a></li>
  36   <li><a href="#synopsis">Header
  37     <code>"boost/multi_index_container.hpp"</code> synopsis</a>
  38     <ul>
  39       <li><a href="#multi_index_container">Class template <code>multi_index_container</code></a>
  40         <ul>
  41           <li><a href="#complexity">Complexity</a></li>
  42           <li><a href="#instantiation_types">Instantiation types</a></li>
  43           <li><a href="#types">Nested types</a></li>
  44           <li><a href="#nested_templates">Nested class templates</a></li>
  45           <li><a href="#constructors">Constructors, copy and assignment</a></li>
  46           <li><a href="#index_retrieval">Index retrieval operations</a></li>
  47           <li><a href="#projection">Projection operations</a></li>
  48           <li><a href="#serialization">Serialization</a></li>
  49         </ul>
  50       </li>
  51     </ul>
  52   </li>
  53 </ul>
  54
  55 <h2>
  56 <a name="multi_index_container_fwd_synopsis">Header
  57 <a href="../../../../boost/multi_index_container_fwd.hpp"><code>"boost/multi_index_container_fwd.hpp"</code></a>
  58 synopsis</a>
  59 </h2>
  60
  61 <blockquote><pre>
  62 <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
  63
  64 <span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
  65
  66 <span class=keyword>template</span><span class=special>&lt;</span>
  67   <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span>
  68   <span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>=</span><span class=identifier>indexed_by</span><span class=special>&lt;</span><span class=identifier>ordered_unique</span><span class=special>&lt;</span><span class=identifier>identity</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>&gt;</span> <span class=special>&gt;</span> <span class=special>&gt;,</span>
  69   <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>=</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>allocator</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>&gt;</span> <span class=special>&gt;</span>
  70 <span class=keyword>class</span> <span class=identifier>multi_index_container</span><span class=special>;</span>
  71
  72 <span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
  73
  74 <span class=keyword>using</span> <span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>multi_index_container</span><span class=special>;</span>
  75
  76 <span class=special>}</span> <span class=comment>// namespace boost</span>
  77 </pre></blockquote>
  78
  79 <p>
  80 <code>multi_index_container_fwd.hpp</code> forward declares the class template
  81 <a href="#multi_index_container"><code>multi_index_container</code></a> and specifies its default parameters.
  82 </p>
  83
  84 <h2>
  85 <a name="synopsis">Header
  86 <a href="../../../../boost/multi_index_container.hpp"><code>"boost/multi_index_container.hpp"</code></a>
  87 synopsis</a>
  88 </h2>
  89
  90 <blockquote><pre>
  91 <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>initializer_list</span><span class=special>&gt;</span>
  92
  93 <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
  94
  95 <span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
  96
  97 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>&gt;</span>
  98 <span class=keyword>class</span> <span class=identifier>multi_index_container</span><span class=special>;</span>
  99
 100 <span class=comment>// multi_index_container associated global class templates:</span>
 101
 102 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>&gt;</span> <span class=keyword>struct</span> <span class=identifier>nth_index</span><span class=special>;</span>
 103 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>&gt;</span> <span class=keyword>struct</span> <span class=identifier>index</span><span class=special>;</span>
 104
 105 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>&gt;</span>
 106 <span class=keyword>struct</span> <span class=identifier>nth_index_iterator</span><span class=special>;</span>                          <span class=comment><b>// deprecated</b></span>
 107 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>&gt;</span>
 108 <span class=keyword>struct</span> <span class=identifier>nth_index_const_iterator</span><span class=special>;</span>                    <span class=comment><b>// deprecated</b></span>
 109 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>&gt;</span>
 110 <span class=keyword>struct</span> <span class=identifier>index_iterator</span><span class=special>;</span>                              <span class=comment><b>// deprecated</b></span>
 111 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>&gt;</span>
 112 <span class=keyword>struct</span> <span class=identifier>index_const_iterator</span><span class=special>;</span>                        <span class=comment><b>// deprecated</b></span>
 113
 114 <span class=comment>// multi_index_container global functions for index retrieval:</span>
 115
 116 <span class=keyword>template</span><span class=special>&lt;</span>
 117   <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 118 <span class=special>&gt;</span>
 119 <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span>
 120   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>N</span>
 121 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span>
 122 <span class=identifier>get</span><span class=special>(</span><span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span><span class=special>;</span>
 123
 124 <span class=keyword>template</span><span class=special>&lt;</span>
 125   <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 126 <span class=special>&gt;</span>
 127 <span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span>
 128   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>N</span>
 129 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span>
 130 <span class=identifier>get</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span><span class=special>;</span>
 131
 132 <span class=keyword>template</span><span class=special>&lt;</span>
 133   <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 134 <span class=special>&gt;</span>
 135 <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span>
 136   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>Tag</span>
 137 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span>
 138 <span class=identifier>get</span><span class=special>(</span><span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span><span class=special>;</span>
 139
 140 <span class=keyword>template</span><span class=special>&lt;</span>
 141   <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 142 <span class=special>&gt;</span>
 143 <span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span>
 144   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>Tag</span>
 145 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span>
 146 <span class=identifier>get</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span><span class=special>;</span>
 147
 148 <span class=comment>// multi_index_container global functions for projection of iterators:</span>
 149
 150 <span class=keyword>template</span><span class=special>&lt;</span>
 151   <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
 152   <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 153 <span class=special>&gt;</span>
 154 <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span>
 155   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>N</span>
 156 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span>
 157 <span class=identifier>project</span><span class=special>(</span>
 158   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>,</span>
 159   <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>);</span>
 160
 161 <span class=keyword>template</span><span class=special>&lt;</span>
 162   <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
 163   <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 164 <span class=special>&gt;</span>
 165 <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span>
 166   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>N</span>
 167 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span>
 168 <span class=identifier>project</span><span class=special>(</span>
 169   <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>,</span>
 170   <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>);</span>
 171
 172 <span class=keyword>template</span><span class=special>&lt;</span>
 173   <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
 174   <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 175 <span class=special>&gt;</span>
 176 <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span>
 177   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>Tag</span>
 178 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span>
 179 <span class=identifier>project</span><span class=special>(</span>
 180   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>,</span>
 181   <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>);</span>
 182
 183 <span class=keyword>template</span><span class=special>&lt;</span>
 184   <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
 185   <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 186 <span class=special>&gt;</span>
 187 <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span>
 188   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>Tag</span>
 189 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span>
 190 <span class=identifier>project</span><span class=special>(</span>
 191   <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>,</span>
 192   <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>);</span>
 193
 194 <span class=comment>// comparison:</span>
 195
 196 <span class=comment>// <b>OP</b> is any of ==,&lt;,!=,&gt;,&gt;=,&lt;=</span>
 197
 198 <span class=keyword>template</span><span class=special>&lt;</span>
 199   <span class=keyword>typename</span> <span class=identifier>Value1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator1</span><span class=special>,</span>
 200   <span class=keyword>typename</span> <span class=identifier>Value2</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList2</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator2</span>
 201 <span class=special>&gt;</span>
 202 <span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
 203   <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value1</span><span class=special>,</span><span class=identifier>IndexSpecifierList1</span><span class=special>,</span><span class=identifier>Allocator1</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
 204   <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value2</span><span class=special>,</span><span class=identifier>IndexSpecifierList2</span><span class=special>,</span><span class=identifier>Allocator2</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
 205
 206 <span class=comment>// specialized algorithms:</span>
 207
 208 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>&gt;</span>
 209 <span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span>
 210   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
 211   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
 212
 213 <span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
 214
 215 <span class=keyword>using</span> <span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>multi_index_container</span><span class=special>;</span>
 216 <span class=keyword>using</span> <span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>get</span><span class=special>;</span>
 217 <span class=keyword>using</span> <span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>project</span><span class=special>;</span>
 218
 219 <span class=special>}</span> <span class=comment>// namespace boost</span>
 220 </pre></blockquote>
 221
 222 <h3><a name="multi_index_container">
 223 Class template <code>multi_index_container</code>
 224 </a></h3>
 225
 226 <p>
 227 This is the main component of Boost.MultiIndex. A <code>multi_index_container</code>
 228 is a container class template holding a compile-time user-defined list of
 229 <a href="indices.html">indices</a>. These indices provide different interfaces
 230 for the management of the elements of the <code>multi_index_container</code>. By itself,
 231 <code>multi_index_container</code> only provides basic functionality for construction
 232 and for access to the indices held.
 233 </p>
 234
 235 <p>
 236 A <code>multi_index_container</code> type is instantiated with the type of the
 237 elements contained and a non-empty
 238 <a href="../../../../libs/mpl/doc/refmanual/forward-sequence.html">
 239 <code>MPL Forward Sequence</code></a> specifying which indices conform the
 240 class.
 241 </p>
 242
 243 <p>
 244 For convenience of use, all public methods and types of the first index
 245 specified are inherited by <code>multi_index_container</code>. This also includes global
 246 operators and functions associated with the index (vg. comparison and
 247 <code>swap</code>.)
 248 </p>
 249
 250 <blockquote><pre>
 251 <span class=keyword>template</span><span class=special>&lt;</span>
 252   <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span>
 253   <span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>=</span><span class=identifier>indexed_by</span><span class=special>&lt;</span><span class=identifier>ordered_unique</span><span class=special>&lt;</span><span class=identifier>identity</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>&gt;</span> <span class=special>&gt;</span> <span class=special>&gt;,</span>
 254   <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>=</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>allocator</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>&gt;</span> <span class=special>&gt;</span>
 255 <span class=keyword>class</span> <span class=identifier>multi_index_container</span>
 256 <span class=special>{</span>
 257 <span class=keyword>public</span><span class=special>:</span>
 258
 259   <span class=comment>// types:</span>
 260
 261   <span class=keyword>typedef</span> <b>implementation defined</b>   <span class=identifier>ctor_args_list</span><span class=special>;</span>
 262   <span class=keyword>typedef</span> <b>implementation defined</b>   <span class=identifier>index_specifier_type_list</span><span class=special>;</span>
 263   <span class=keyword>typedef</span> <b>implementation defined</b>   <span class=identifier>index_type_list</span><span class=special>;</span>
 264   <span class=keyword>typedef</span> <b>implementation defined</b>   <span class=identifier>iterator_type_list</span><span class=special>;</span>
 265   <span class=keyword>typedef</span> <b>implementation defined</b>   <span class=identifier>const_iterator_type_list</span><span class=special>;</span>
 266   <span class=keyword>typedef</span> <span class=identifier>Allocator</span>                <span class=identifier>allocator_type</span><span class=special>;</span>
 267
 268   <span class=comment>// nested class templates:</span>
 269
 270   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>&gt;</span>
 271   <span class=keyword>struct</span> <span class=identifier>nth_index</span>                <span class=special>{</span><span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>type</span><span class=special>;};</span>
 272   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>&gt;</span>
 273   <span class=keyword>struct</span> <span class=identifier>index</span>                    <span class=special>{</span><span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>type</span><span class=special>;};</span>
 274
 275   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>&gt;</span>
 276   <span class=keyword>struct</span> <span class=identifier>nth_index_iterator</span>        <span class=comment><b>// deprecated</b></span>
 277   <span class=special>{</span><span class=keyword>typedef</span> <b><span class=identifier>implementation</span> <span class=identifier>defined</span></b> <span class=identifier>type</span><span class=special>;};</span>
 278   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>&gt;</span>
 279   <span class=keyword>struct</span> <span class=identifier>nth_index_const_iterator</span>  <span class=comment><b>// deprecated</b></span>
 280   <span class=special>{</span><span class=keyword>typedef</span> <b><span class=identifier>implementation</span> <span class=identifier>defined</span></b> <span class=identifier>type</span><span class=special>;};</span>
 281   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>&gt;</span>
 282   <span class=keyword>struct</span> <span class=identifier>index_iterator</span>            <span class=comment><b>// deprecated</b></span>
 283   <span class=special>{</span><span class=keyword>typedef</span> <b><span class=identifier>implementation</span> <span class=identifier>defined</span></b> <span class=identifier>type</span><span class=special>;};</span>
 284   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>&gt;</span>
 285   <span class=keyword>struct</span> <span class=identifier>index_const_iterator</span>      <span class=comment><b>// deprecated</b></span>
 286   <span class=special>{</span><span class=keyword>typedef</span> <b><span class=identifier>implementation</span> <span class=identifier>defined</span></b> <span class=identifier>type</span><span class=special>;};</span>
 287
 288   <span class=comment>// construct/copy/destroy:</span>
 289
 290   <span class=keyword>explicit</span> <span class=identifier>multi_index_container</span><span class=special>(
 291     </span><span class=keyword>const</span> <span class=identifier>ctor_args_list</span><span class=special>&amp;</span> <span class=identifier>args_list</span><span class=special>=</span><span class=identifier>ctor_args_list</span><span class=special>(),
 292     </span><span class=keyword>const</span> <span class=identifier>allocator_type</span><span class=special>&amp;</span> <span class=identifier>al</span><span class=special>=</span><span class=identifier>allocator_type</span><span class=special>());</span>
 293   <span class=keyword>explicit</span> <span class=identifier>multi_index_container</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>allocator_type</span><span class=special>&amp;</span> <span class=identifier>al</span><span class=special>);</span>
 294   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>InputIterator</span><span class=special>&gt;</span>
 295   <span class=identifier>multi_index_container</span><span class=special>(</span>
 296     <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>
 297     <span class=keyword>const</span> <span class=identifier>ctor_args_list</span><span class=special>&amp;</span> <span class=identifier>args_list</span><span class=special>=</span><span class=identifier>ctor_args_list</span><span class=special>(),
 298     </span><span class=keyword>const</span> <span class=identifier>allocator_type</span><span class=special>&amp;</span> <span class=identifier>al</span><span class=special>=</span><span class=identifier>allocator_type</span><span class=special>());</span>
 299   <span class=identifier>multi_index_container</span><span class=special>(</span>
 300     <span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>&gt;</span> <span class=identifier>list</span><span class=special>,</span>
 301     <span class=keyword>const</span> <span class=identifier>ctor_args_list</span><span class=special>&amp;</span> <span class=identifier>args_list</span><span class=special>=</span><span class=identifier>ctor_args_list</span><span class=special>(),</span>
 302     <span class=keyword>const</span> <span class=identifier>allocator_type</span><span class=special>&amp;</span> <span class=identifier>al</span><span class=special>=</span><span class=identifier>allocator_type</span><span class=special>());</span>
 303   <span class=identifier>multi_index_container</span><span class=special>(</span>
 304     <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 305   <span class=identifier>multi_index_container</span><span class=special>(</span>
 306     <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 307
 308   <span class=special>~</span><span class=identifier>multi_index_container</span><span class=special>();</span>
 309
 310   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=keyword>operator</span><span class=special>=(</span>
 311     <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 312   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=keyword>operator</span><span class=special>=(</span>
 313     <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 314   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=keyword>operator</span><span class=special>=(</span>
 315     <span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>&gt;</span> <span class=identifier>list</span><span class=special>)</span>
 316
 317   <span class=identifier>allocator_type</span> <span class=identifier>get_allocator</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
 318
 319   <span class=comment>// retrieval of indices</span>
 320
 321   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>&gt;</span> <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span><span class=identifier>N</span><span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span> <span class=identifier>get</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
 322   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>&gt;</span> <span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span><span class=identifier>N</span><span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span> <span class=identifier>get</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
 323   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>&gt;</span> <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span><span class=identifier>Tag</span><span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span> <span class=identifier>get</span><span class=special>()</span><span class=keyword>noexcept</span><span class=special>;</span>
 324   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>&gt;</span> <span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span><span class=identifier>Tag</span><span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span> <span class=identifier>get</span><span class=special>()</span><span class=keyword>const</span> <span class=keyword>noexcept</span><span class=special>;</span>
 325
 326   <span class=comment>// projection of iterators</span>
 327
 328   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>&gt;</span>
 329     <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span><span class=identifier>N</span><span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span> <span class=identifier>project</span><span class=special>(</span><span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>);</span>
 330   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>&gt;</span>
 331     <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span><span class=identifier>N</span><span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span> <span class=identifier>project</span><span class=special>(</span><span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
 332   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>&gt;</span>
 333     <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span><span class=identifier>Tag</span><span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span> <span class=identifier>project</span><span class=special>(</span><span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>);</span>
 334   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>&gt;</span>
 335     <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span><span class=identifier>Tag</span><span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span> <span class=identifier>project</span><span class=special>(</span><span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
 336 <span class=special>};</span>
 337
 338 <span class=comment>// multi_index_container associated global class templates:</span>
 339
 340 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>&gt;</span> <span class=keyword>struct</span> <span class=identifier>nth_index</span>
 341 <span class=special>{</span>
 342   <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>::</span><span class=identifier>nth_index</span><span class=special>&lt;</span><span class=identifier>N</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=identifier>type</span><span class=special>;</span>
 343 <span class=special>};</span>
 344
 345 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>&gt;</span> <span class=keyword>struct</span> <span class=identifier>index</span>
 346 <span class=special>{</span>
 347   <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>::</span><span class=identifier>index</span><span class=special>&lt;</span><span class=identifier>Tag</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=identifier>type</span><span class=special>;</span>
 348 <span class=special>};</span>
 349
 350 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>&gt;</span>
 351 <span class=keyword>struct</span> <span class=identifier>nth_index_iterator</span>       <span class=comment><b>// deprecated</b></span>
 352 <span class=special>{</span>
 353   <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>::</span><span class=identifier>nth_index_iterator</span><span class=special>&lt;</span><span class=identifier>N</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=identifier>type</span><span class=special>;</span>
 354 <span class=special>};</span>
 355
 356 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>int</span> <span class=identifier>N</span><span class=special>&gt;</span>
 357 <span class=keyword>struct</span> <span class=identifier>nth_index_const_iterator</span> <span class=comment><b>// deprecated</b></span>
 358 <span class=special>{</span>
 359   <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>::</span><span class=identifier>nth_index_const_iterator</span><span class=special>&lt;</span><span class=identifier>N</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=identifier>type</span><span class=special>;</span>
 360 <span class=special>};</span>
 361
 362 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>&gt;</span>
 363 <span class=keyword>struct</span> <span class=identifier>index_iterator</span>           <span class=comment><b>// deprecated</b></span>
 364 <span class=special>{</span>
 365   <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>::</span><span class=identifier>index_iterator</span><span class=special>&lt;</span><span class=identifier>Tag</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=identifier>type</span><span class=special>;</span>
 366 <span class=special>};</span>
 367
 368 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>&gt;</span>
 369 <span class=keyword>struct</span> <span class=identifier>index_const_iterator</span>     <span class=comment><b>// deprecated</b></span>
 370 <span class=special>{</span>
 371   <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>MultiIndexContainer</span><span class=special>::</span><span class=identifier>index_const_iterator</span><span class=special>&lt;</span><span class=identifier>Tag</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=identifier>type</span><span class=special>;</span>
 372 <span class=special>};</span>
 373
 374 <span class=comment>// multi_index_container global functions for index retrieval:</span>
 375
 376 <span class=keyword>template</span><span class=special>&lt;</span>
 377   <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 378 <span class=special>&gt;</span>
 379 <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span>
 380   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>N</span>
 381 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span>
 382 <span class=identifier>get</span><span class=special>(</span><span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span>
 383 <span class=special>{</span>
 384   <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=identifier>get</span><span class=special>&lt;</span><span class=identifier>N</span><span class=special>&gt;();</span>
 385 <span class=special>}</span>
 386
 387 <span class=keyword>template</span><span class=special>&lt;</span>
 388   <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 389 <span class=special>&gt;</span>
 390 <span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span>
 391   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>N</span>
 392 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span>
 393 <span class=identifier>get</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span>
 394 <span class=special>{</span>
 395   <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=identifier>get</span><span class=special>&lt;</span><span class=identifier>N</span><span class=special>&gt;();</span>
 396 <span class=special>}</span>
 397
 398 <span class=keyword>template</span><span class=special>&lt;</span>
 399   <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 400 <span class=special>&gt;</span>
 401 <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span>
 402   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>Tag</span>
 403 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span>
 404 <span class=identifier>get</span><span class=special>(</span><span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span>
 405 <span class=special>{</span>
 406   <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=identifier>get</span><span class=special>&lt;</span><span class=identifier>Tag</span><span class=special>&gt;();</span>
 407 <span class=special>}</span>
 408
 409 <span class=keyword>template</span><span class=special>&lt;</span>
 410   <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 411 <span class=special>&gt;</span>
 412 <span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span>
 413   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>Tag</span>
 414 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span>
 415 <span class=identifier>get</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>)</span><span class=keyword>noexcept</span>
 416 <span class=special>{</span>
 417   <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=identifier>get</span><span class=special>&lt;</span><span class=identifier>Tag</span><span class=special>&gt;();</span>
 418 <span class=special>}</span>
 419
 420 <span class=comment>// multi_index_container global functions for projection of iterators:</span>
 421
 422 <span class=keyword>template</span><span class=special>&lt;</span>
 423   <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
 424   <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 425 <span class=special>&gt;</span>
 426 <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span>
 427   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>N</span>
 428 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span>
 429 <span class=identifier>project</span><span class=special>(</span>
 430   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>,</span>
 431   <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span>
 432 <span class=special>{</span>
 433   <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=keyword>template</span> <span class=identifier>project</span><span class=special>&lt;</span><span class=identifier>N</span><span class=special>&gt;(</span><span class=identifier>it</span><span class=special>);</span>
 434 <span class=special>}</span>
 435
 436 <span class=keyword>template</span><span class=special>&lt;</span>
 437   <span class=keyword>int</span> <span class=identifier>N</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
 438   <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 439 <span class=special>&gt;</span>
 440 <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span>
 441   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>N</span>
 442 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span>
 443 <span class=identifier>project</span><span class=special>(</span>
 444   <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>,</span>
 445   <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span>
 446 <span class=special>{</span>
 447   <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=keyword>template</span> <span class=identifier>project</span><span class=special>&lt;</span><span class=identifier>N</span><span class=special>&gt;(</span><span class=identifier>it</span><span class=special>);</span>
 448 <span class=special>}</span>
 449
 450 <span class=keyword>template</span><span class=special>&lt;</span>
 451   <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
 452   <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 453 <span class=special>&gt;</span>
 454 <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span>
 455   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>Tag</span>
 456 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span>
 457 <span class=identifier>project</span><span class=special>(</span>
 458   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>,</span>
 459   <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span>
 460 <span class=special>{</span>
 461   <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=keyword>template</span> <span class=identifier>project</span><span class=special>&lt;</span><span class=identifier>Tag</span><span class=special>&gt;(</span><span class=identifier>it</span><span class=special>);</span>
 462 <span class=special>}</span>
 463
 464 <span class=keyword>template</span><span class=special>&lt;</span>
 465   <span class=keyword>typename</span> <span class=identifier>Tag</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IteratorType</span><span class=special>,</span>
 466   <span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 467 <span class=special>&gt;</span>
 468 <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span>
 469   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span><span class=identifier>Tag</span>
 470 <span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span>
 471 <span class=identifier>project</span><span class=special>(</span>
 472   <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>m</span><span class=special>,</span>
 473   <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span>
 474 <span class=special>{</span>
 475   <span class=keyword>return</span> <span class=identifier>m</span><span class=special>.</span><span class=keyword>template</span> <span class=identifier>project</span><span class=special>&lt;</span><span class=identifier>Tag</span><span class=special>&gt;(</span><span class=identifier>it</span><span class=special>);</span>
 476 <span class=special>}</span>
 477
 478 <span class=comment>// comparison:</span>
 479
 480 <span class=comment>// <b>OP</b> is any of ==,&lt;,!=,&gt;,&gt;=,&lt;=</span>
 481
 482 <span class=keyword>template</span><span class=special>&lt;</span>
 483   <span class=keyword>typename</span> <span class=identifier>Value1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator1</span><span class=special>,</span>
 484   <span class=keyword>typename</span> <span class=identifier>Value2</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList2</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator2</span>
 485 <span class=special>&gt;</span>
 486 <span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
 487   <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value1</span><span class=special>,</span><span class=identifier>IndexSpecifierList1</span><span class=special>,</span><span class=identifier>Allocator1</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
 488   <span class=keyword>const</span> <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value2</span><span class=special>,</span><span class=identifier>IndexSpecifierList2</span><span class=special>,</span><span class=identifier>Allocator2</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span>
 489   <span class=special>{</span>
 490     <span class=keyword>return</span> <span class=identifier>get</span><span class=special>&lt;</span><span class=number>0</span><span class=special>&gt;(</span><span class=identifier>x</span><span class=special>)</span> <b><i>OP</i></b> <span class=identifier>get</span><span class=special>&lt;</span><span class=number>0</span><span class=special>&gt;(</span><span class=identifier>y</span><span class=special>);</span>
 491   <span class=special>}</span>
 492
 493 <span class=comment>// specialized algorithms:</span>
 494
 495 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>&gt;</span>
 496 <span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span>
 497   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
 498   <span class=identifier>multi_index_container</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>,</span><span class=identifier>IndexSpecifierList</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span>
 499   <span class=special>{</span>
 500     <span class=identifier>x</span><span class=special>.</span><span class=identifier>swap</span><span class=special>(</span><span class=identifier>y</span><span class=special>);</span>
 501   <span class=special>}</span>
 502
 503 <span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
 504
 505 <span class=special>}</span> <span class=comment>// namespace boost</span>
 506 </pre></blockquote>
 507
 508 <h4><a name="complexity">Complexity</a></h4>
 509
 510 <p>
 511 In the descriptions of operations of <code>multi_index_container</code>, we adopt the
 512 scheme outlined in the
 513 <a href="indices.html#complexity_signature">complexity signature section</a>.
 514 </p>
 515
 516 <h4><a name="instantiation_types">Instantiation types</a></h4>
 517
 518 <p>
 519 <code>multi_index_container</code> is instantiated with the following types:
 520 <ol>
 521   <li><code>Value</code> is the type of the elements contained. <code>Value</code> must be
 522       <code>Erasable</code> from <code>multi_index_container</code>.
 523   </li>
 524   <li><code>IndexSpecifierList</code> specifies the indices that the
 525     <code>multi_index_container</code> is composed of. It must be a non-empty
 526     <a href="../../../../libs/mpl/doc/refmanual/forward-sequence.html">
 527     <code>MPL Forward Sequence</code></a> (and, preferrably,
 528     an <a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
 529     <code>MPL Random Access Sequence</code></a>) of index specifiers. For
 530     syntactic convenience, the
 531     <a href="indices.html#indexed_by"><code>indexed_by</code></a>
 532     MPL sequence can be used.
 533   </li>
 534   <li><code>Allocator</code> must be an allocator of <code>Value</code> objects
 535     satisfying the associated C++ requirements at <b>[allocator.requirements]</b>.
 536     The following relaxations to the standard requirements are allowed:
 537     <ul>
 538       <li>Non-equal allocator instances are supported: swapping two non-equal
 539         instances must not throw any exception.
 540       </li>
 541       <li>For every type <code>T</code>,
 542         the type <code>Allocator::rebind&lt;T&gt;::other::pointer</code> can be any
 543         kind of random access iterator, provided that it is explicitly constructible from
 544         the literal <code>0</code> (standing here as the null pointer) or from any
 545         <code>p</code> of type <code>T*</code> pointing into an area allocated by
 546         some instance of <code>Allocator</code> or some other allocator type rebound
 547         from <code>Allocator</code>. A <code>pointer</code> constructed from
 548         <code>p</code> shall dereference to <code>*p</code>.
 549       </li>
 550     </ul>
 551   </li>
 552 </ol>
 553 Indices of a given <code>multi_index_container</code> instantiation cannot have
 554 duplicate <a href="indices.html#tags">tags</a>, either within a single
 555 index or in two different indices.
 556 </p>
 557
 558 <h4><a name="types">Nested types</a></h4>
 559
 560 <code>ctor_args_list</code>
 561
 562 <blockquote>
 563 Although the exact definition of <code>ctor_args_list</code> is
 564 implementation defined, from the user point of view this type can be
 565 treated as equivalent to
 566 <code>::boost::tuple&lt;C<sub>0</sub>,...,C<sub>I-1</sub>></code>,
 567 where <code>C<sub>i</sub></code> is the <code>ctor_args</code> type of the
 568 <code>i</code>-th index held by the <code>multi_index_container</code>, in the
 569 same order as they were specified. Strictly speaking, there is an
 570 implicit conversion from
 571 <code>const ::boost::tuple&lt;C<sub>0</sub>,...,C<sub>I-1</sub>>&amp;</code>
 572 to <code>const ctor_args_list&amp;</code>. This type is used for
 573 providing the construction arguments of the indices of the
 574 <code>multi_index_container</code>. <code>ctor_args_list</code> is
 575 <code>DefaultConstructible</code>, provided that all <code>ctor_args</code> types
 576 involved are <code>DefaultConstructible</code>.
 577 </blockquote>
 578
 579 <code>index_specifier_type_list</code>
 580
 581 <blockquote>
 582 Same type as <code>IndexSpecifierList</code>.
 583 </blockquote>
 584
 585 <code>index_type_list</code>
 586
 587 <blockquote>
 588 Model of
 589 <a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
 590 <code>MPL Random Access Sequence</code></a> and
 591 <a href="../../../../libs/mpl/doc/refmanual/extensible-sequence.html">
 592 <code>MPL Extensible Sequence</code></a> containing the types of the indices held by
 593 the <code>multi_index_container</code>, in the same order as they were specified.
 594 </blockquote>
 595
 596 <code>iterator_type_list</code>
 597
 598 <blockquote>
 599 Model of
 600 <a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
 601 <code>MPL Random Access Sequence</code></a> and
 602 <a href="../../../../libs/mpl/doc/refmanual/extensible-sequence.html">
 603 <code>MPL Extensible Sequence</code></a> containing the types of the iterators of
 604 the indices held by the <code>multi_index_container</code>, in the same order as they were
 605 specified.
 606 </blockquote>
 607
 608 <code>const_iterator_type_list</code>
 609
 610 <blockquote>
 611 Model of
 612 <a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
 613 <code>MPL Random Access Sequence</code></a> and
 614 <a href="../../../../libs/mpl/doc/refmanual/extensible-sequence.html">
 615 <code>MPL Extensible Sequence</code></a> containing the types of the constant
 616 iterators of the indices held by the <code>multi_index_container</code>, in the same order
 617 as they were specified.
 618 </blockquote>
 619
 620 <h4><a name="nested_templates">Nested class templates</a></h4>
 621
 622 <code>template&lt;int N> struct nth_index</code>
 623
 624 <blockquote>
 625 <code>nth_index&lt;N>::type</code> yields the type of the
 626 <code>N</code>-th (0-based) index held by the <code>multi_index_container</code>, in
 627 the same order as they were specified.<br>
 628 <b>Requires:</b> <code>0 &lt;= N &lt; I</code>.
 629 </blockquote>
 630
 631 <code>template&lt;typename Tag> struct index</code>
 632
 633 <blockquote>
 634 <code>index&lt;Tag>::type</code> yields the type of the index which
 635 has <code>Tag</code> as an associated <a href="indices.html#tags">tag type</a>.<br>
 636 <b>Requires:</b> Some index of the <code>multi_index_container</code> has <code>Tag</code>
 637 as an associated tag type.
 638 </blockquote>
 639
 640 <code>template&lt;int N> struct nth_index_iterator</code>
 641
 642 <blockquote>
 643 <code>nth_index_iterator&lt;N>::type</code> is equivalent to
 644 <code>nth_index&lt;N>::type::iterator</code>.<br>
 645 <b>Note:</b> The use of <code>nth_index_iterator</code> is deprecated.
 646 </blockquote>
 647
 648 <code>template&lt;int N> struct nth_index_const_iterator</code>
 649
 650 <blockquote>
 651 <code>nth_index_const_iterator&lt;N>::type</code> is equivalent to
 652 <code>nth_index&lt;N>::type::const_iterator</code>.<br>
 653 <b>Note:</b> The use of <code>nth_index_const_iterator</code> is deprecated.
 654 </blockquote>
 655
 656 <code>template&lt;typename Tag> struct index_iterator</code>
 657
 658 <blockquote>
 659 <code>index_iterator&lt;Tag>::type</code> is equivalent to
 660 <code>index&lt;Tag>::type::iterator</code>.<br>
 661 <b>Note:</b> The use of <code>index_iterator</code> is deprecated.
 662 </blockquote>
 663
 664 <code>template&lt;typename Tag> struct index_const_iterator</code>
 665
 666 <blockquote>
 667 <code>index_const_iterator&lt;Tag>::type</code> is equivalent to
 668 <code>index&lt;Tag>::type::const_iterator</code>.<br>
 669 <b>Note:</b> The use of <code>index_const_iterator</code> is deprecated.
 670 </blockquote>
 671
 672 <h4><a name="constructors">Constructors, copy and assignment</a></h4>
 673
 674 <code>explicit multi_index_container(<br>
 675 &nbsp;&nbsp;const ctor_args_list&amp; args_list=ctor_args_list(),<br>
 676 &nbsp;&nbsp;const allocator_type&amp; al=allocator_type());</code>
 677
 678 <blockquote>
 679 <b>Effects:</b> Constructs an empty <code>multi_index_container</code> using the
 680 specified argument list and allocator.<br>
 681 <b>Complexity:</b> Constant.
 682 </blockquote>
 683
 684 <code>explicit multi_index_container(const allocator_type&amp; al);</code>
 685
 686 <blockquote>
 687 <b>Effects:</b> Constructs an empty <code>multi_index_container</code> using the
 688 specified allocator and the default value of <code>ctor_args_list</code>.<br>
 689 <b>Complexity:</b> Constant.
 690 </blockquote>
 691
 692 <code>template&lt;typename InputIterator><br>
 693 multi_index_container(<br>
 694 &nbsp;&nbsp;InputIterator first,InputIterator last,<br>
 695 &nbsp;&nbsp;const ctor_args_list&amp; args_list=ctor_args_list(),<br>
 696 &nbsp;&nbsp;const allocator_type&amp; al=allocator_type());</code>
 697
 698 <blockquote>
 699 <b>Requires:</b> <code>InputIterator</code> is an input iterator.
 700 <code>Value</code> is
 701 <code>EmplaceConstructible</code> into <code>multi_index_container</code>
 702 from <code>*first</code>.
 703 <code>last</code> is reachable from <code>first</code>.<br>
 704 <b>Effects:</b> Constructs and empty <code>multi_index_container</code> using the
 705 specified argument list and allocator and fills it with
 706 the elements in the range [<code>first</code>,<code>last</code>).
 707 Insertion of each element may or may not succeed depending
 708 on the acceptance by all the indices of the <code>multi_index_container</code>.<br>
 709 <b>Complexity:</b> <code>O(m*H(m))</code>, where <code>m</code> is
 710 the number of elements in [<code>first</code>,<code>last</code>).<br>
 711 </blockquote>
 712
 713 <code>multi_index_container(<br>
 714 &nbsp;&nbsp;std::initializer_list&lt;Value&gt; list,<br>
 715 &nbsp;&nbsp;const ctor_args_list&amp; args_list=ctor_args_list(),<br>
 716 &nbsp;&nbsp;const allocator_type&amp; al=allocator_type());</code>
 717
 718 <blockquote>
 719 <b>Effects:</b> Equivalent to
 720 <code>multi_index_container(list.begin(),list.end(),args_list,al)</code>.
 721 </blockquote>
 722
 723 <code>multi_index_container(<br>
 724 &nbsp;&nbsp;const multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp; x);</code>
 725
 726 <blockquote>
 727 <b>Requires:</b> <code>Value</code> is <code>CopyInsertable</code> into
 728 <code>multi_index_container</code>.<br>
 729 <b>Effects:</b> Constructs a copy of <code>x</code>, copying its
 730 elements as well as its internal objects (those specified
 731 in <code>ctor_args_list</code> and the allocator.)<br>
 732 <b>Postconditions:</b> <code>*this==x</code>. The order on every index
 733 of the <code>multi_index_container</code> is preserved as well.<br>
 734 <b>Complexity:</b> <code>O(x.size()*log(x.size()) + C(x.size()))</code>.
 735 </blockquote>
 736
 737 <code>multi_index_container(<br>
 738 &nbsp;&nbsp;multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp;&amp; x);</code>
 739
 740 <blockquote>
 741 <b>Effects:</b> Constructs a <code>multi_index_container</code> by moving the
 742 elements of <code>x</code> and copying its internal objects (those specified
 743 in <code>ctor_args_list</code> and the allocator.)<br>
 744 <b>Postconditions:</b> If <code>x==y</code> just
 745 before the movement, <code>*this==y</code>. The order on every index
 746 of the <code>multi_index_container</code> is preserved as well.<br>
 747 <b>Complexity:</b> Constant.
 748 </blockquote>
 749
 750 <code>~multi_index_container()</code>
 751 <blockquote>
 752 <b>Effects:</b> Destroys the <code>multi_index_container</code> and all the elements
 753 contained. The order in which the elements are destroyed is not specified.<br>
 754 <b>Complexity:</b> <code>O(n)</code>.
 755 </blockquote>
 756
 757 <code>multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp; operator=(<br>
 758 &nbsp;&nbsp;const multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp; x);</code>
 759
 760 <blockquote>
 761 <b>Requires:</b> <code>Value</code> is <code>CopyInsertable</code> into
 762 <code>multi_index_container</code>.<br>
 763 <b>Effects:</b> Replaces the elements and internal objects of the <code>multi_index_container</code>
 764 with copies from <code>x</code>.<br>
 765 <b>Postconditions:</b> <code>*this==x</code>. The order on every index
 766 of the <code>multi_index_container</code> is preserved as well.<br>
 767 <b>Returns:</b> <code>*this</code>.<br>
 768 <b>Complexity:</b> <code>O(n + x.size()*log(x.size()) +
 769 C(x.size()))</code>.<br>
 770 <b>Exception safety:</b> Strong, provided the copy and assignment operations
 771 of the types of <code>ctor_args_list</code> do not throw.
 772 </blockquote>
 773
 774 <code>multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp; operator=(<br>
 775 &nbsp;&nbsp;multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp;&amp; x);</code>
 776
 777 <blockquote>
 778 <b>Effects:</b> Replaces the elements of <code>multi_index_container</code>
 779 with those of <code>x</code> and its internal objects with copies from the
 780 corresponding objects in <code>x</code>.<br>
 781 <b>Postconditions:</b> If <code>x==y</code> just
 782 before the movement, <code>*this==y</code>. The order on every index
 783 of the <code>multi_index_container</code> is preserved as well.<br>
 784 <b>Returns:</b> <code>*this</code>.<br>
 785 <b>Complexity:</b> <code>O(n)</code>.<br>
 786 <b>Exception safety:</b> Strong, provided the copy and assignment operations
 787 of the types of <code>ctor_args_list</code> do not throw.
 788 </blockquote>
 789
 790 <code>multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp; operator=(<br>
 791 &nbsp;&nbsp;std::initializer_list&lt;Value&gt; list);</code>
 792
 793 <blockquote>
 794 <b>Requires:</b> <code>Value</code> is <code>CopyInsertable</code> into
 795 <code>multi_index_container</code>.<br>
 796 <b>Effects:</b> Replaces the elements the <code>multi_index_container</code>
 797 with copies of the elements of <code>list</code>, inserted in the specified order.
 798 Insertion of each element may or may not succeed depending
 799 on the acceptance by all the indices of the <code>multi_index_container</code>.<br>
 800 <b>Returns:</b> <code>*this</code>.<br>
 801 <b>Complexity:</b> <code>O(n + I(m))</code>, where <code>m</code> is the
 802 number of elements of <code>list</code>.<br>
 803 <b>Exception safety:</b> Strong, provided the copy and assignment operations
 804 of the types of <code>ctor_args_list</code> do not throw.
 805 </blockquote>
 806
 807 <code>allocator_type get_allocator()const noexcept;</code>
 808
 809 <blockquote>
 810 Returns a copy of the <code>allocator_type</code> object used to construct
 811 the <code>multi_index_container</code>.<br>
 812 <b>Complexity:</b> Constant.
 813 </blockquote>
 814
 815 <h4><a name="index_retrieval">Index retrieval operations</a></h4>
 816
 817 <code>template&lt;int N> typename nth_index&lt;N>::type&amp; get()noexcept;</code>
 818
 819 <blockquote>
 820 <b>Requires:</b> <code>0 &lt;= N &lt; I</code>.<br>
 821 <b>Effects:</b> Returns a reference to the
 822 <code>nth_index&lt;N>::type</code> index held by <code>*this</code>.<br>
 823 <b>Complexity:</b> Constant.<br>
 824 </blockquote>
 825
 826 <code>template&lt;int N> const typename nth_index&lt;N>::type&amp; get()const noexcept;</code>
 827
 828 <blockquote>
 829 <b>Requires:</b> <code>0 &lt;= N &lt; I</code>.<br>
 830 <b>Effects:</b> Returns a <code>const</code> reference to the
 831 <code>nth_index&lt;N>::type</code> index held by <code>*this</code>.<br>
 832 <b>Complexity:</b> Constant.<br>
 833 </blockquote>
 834
 835 <code>template&lt;typename Tag> typename index&lt;Tag>::type&amp; get()noexcept;</code>
 836
 837 <blockquote>
 838 <b>Requires:</b> <code>Tag</code> is such that <code>index&lt;Tag>::type</code>
 839 is valid.<br>
 840 <b>Effects:</b> Returns a reference to the
 841 <code>index&lt;Tag>::type</code> index held by
 842 <code>*this</code>.<br>
 843 <b>Complexity:</b> Constant.<br>
 844 </blockquote>
 845
 846 <code>template&lt;typename Tag> const typename index&lt;Tag>::type&amp; get()const noexcept;</code>
 847
 848 <blockquote>
 849 <b>Requires:</b> <code>Tag</code> is such that <code>index&lt;Tag>::type</code>
 850 is valid.<br>
 851 <b>Effects:</b> Returns a <code>const</code> reference to the
 852 <code>index&lt;Tag>::type</code> index held by
 853 <code>*this</code>.<br>
 854 <b>Complexity:</b> Constant.<br>
 855 </blockquote>
 856
 857 <h4><a name="projection">Projection operations</a></h4>
 858
 859 <p>
 860 Given a <code>multi_index_container</code> with indices <code>i1</code>
 861 and <code>i2</code>, we say than an <code>i1</code>-iterator
 862 <code>it1</code> and an <code>i2</code>-iterator <code>it2</code>
 863 are <i>equivalent</i> if:
 864 <ul>
 865   <li> <code>it1==i1.end()</code> AND <code>it2==i2.end()</code>,</li>
 866   <li> OR <code>it1</code> and <code>it2</code> point to the
 867     same element.</li>
 868 </ul>
 869 </p>
 870
 871 <code>template&lt;int N,typename IteratorType><br>
 872 typename nth_index&lt;N>::type::iterator project(IteratorType it);</code>
 873
 874 <blockquote>
 875 <b>Requires:</b> <code>0 &lt;= N &lt; I</code>. <code>IteratorType</code>
 876 belongs to <code>iterator_type_list</code>. <code>it</code> is a valid
 877 iterator of some index of <code>*this</code> (i.e. does not refer to some
 878 other <code>multi_index_container</code>.)<br>
 879 <b>Effects:</b> Returns an <code>nth_index&lt;N>::type::iterator</code>
 880 equivalent to <code>it</code>.<br>
 881 <b>Complexity:</b> Constant.<br>
 882 <b>Exception safety:</b> <code>nothrow</code>.
 883 </blockquote>
 884
 885 <code>template&lt;int N,typename IteratorType><br>
 886 typename nth_index&lt;N>::type::const_iterator project(IteratorType it)const;</code>
 887
 888 <blockquote>
 889 <b>Requires:</b> <code>0 &lt;= N &lt; I</code>. <code>IteratorType</code>
 890 belongs to <code>const_iterator_type_list</code> or
 891 <code>iterator_type_list</code>. <code>it</code> is a
 892 valid (constant or non-constant) iterator of some index of <code>*this</code>
 893 (i.e. does not refer to some other <code>multi_index_container</code>.)<br>
 894 <b>Effects:</b> Returns an <code>nth_index&lt;N>::type::const_iterator</code>
 895 equivalent to <code>it</code>.<br>
 896 <b>Complexity:</b> Constant.<br>
 897 <b>Exception safety:</b> <code>nothrow</code>.
 898 </blockquote>
 899
 900 <code>template&lt;typename Tag,typename IteratorType><br>
 901 typename index&lt;Tag>::type::iterator project(IteratorType it);</code>
 902
 903 <blockquote>
 904 <b>Requires:</b> <code>Tag</code> is such that
 905 <code>index&lt;Tag>::type</code> is valid. <code>IteratorType</code>
 906 belongs to <code>iterator_type_list</code>. <code>it</code> is a valid
 907 iterator of some index of <code>*this</code> (i.e. does not refer to some
 908 other <code>multi_index_container</code>.)<br>
 909 <b>Effects:</b> Returns an <code>index&lt;Tag>::type::iterator</code>
 910 equivalent to <code>it</code>.<br>
 911 <b>Complexity:</b> Constant.<br>
 912 <b>Exception safety:</b> <code>nothrow</code>.
 913 </blockquote>
 914
 915 <code>template&lt;typename Tag,typename IteratorType><br>
 916 typename index&lt;Tag>::type::const_iterator project(IteratorType it)const;</code>
 917
 918 <blockquote>
 919 <b>Requires:</b> <code>Tag</code> is such that
 920 <code>index&lt;Tag>::type</code> is valid. <code>IteratorType</code>
 921 belongs to <code>const_iterator_type_list</code> or
 922 <code>iterator_type_list</code>. <code>it</code> is a valid
 923 (constant or non-constant) iterator of some index of <code>*this</code>
 924 (i.e. does not refer to some other <code>multi_index_container</code>.)<br>
 925 <b>Effects:</b> Returns an <code>index&lt;Tag>::type::const_iterator</code>
 926 iterator equivalent to <code>it</code>.<br>
 927 <b>Complexity:</b> Constant.<br>
 928 <b>Exception safety:</b> <code>nothrow</code>.
 929 </blockquote>
 930
 931 <h4><a name="serialization">Serialization</a></h4>
 932
 933 <p>
 934 <code>multi_index_container</code>s can be archived/retrieved by means of
 935 <a href="../../../serialization/index.html">Boost.Serialization</a>.
 936 Boost.MultiIndex does not expose a public serialization interface, as this
 937 is provided by Boost.Serialization itself. Both regular and XML
 938 archives are supported.
 939 </p>
 940
 941 <p>
 942 Each of the indices comprising a given <code>multi_index_container</code> contributes
 943 its own preconditions as well as guarantees on the retrieved containers. In describing
 944 these, the following concepts are used. A type <code>T</code> is <i>serializable</i>
 945 (resp. XML-serializable) if any object of type <code>T</code> can be saved to an output
 946 archive (XML archive) and later retrieved from an input archive (XML archive) associated to
 947 the same storage. If <code>x'</code> of type <code>T</code> is loaded from the
 948 serialization information saved from another object <code>x</code>, we say that
 949 <code>x'</code> is a <i>restored copy</i> of <code>x</code>. Given a binary predicate
 950 <code>Pred</code> over (<code>T</code>, <code>T</code>), and objects <code>p</code>
 951 and <code>q</code> of type <code>Pred</code>, we say that <code>q</code>
 952 is <i>serialization-compatible</i> with <code>p</code> if
 953 <blockquote>
 954 <code>p(x,y) == q(x',y')</code>
 955 </blockquote>
 956 for every <code>x</code> and <code>y</code> of type <code>T</code> and <code>x'</code> and
 957 <code>y'</code> being restored copies of <code>x</code> and <code>y</code>,
 958 respectively.
 959 </p>
 960
 961 Operation: saving of a <code>multi_index_container</code> <code>m</code> to an
 962 output archive (XML archive) <code>ar</code>.
 963
 964 <blockquote>
 965 <b>Requires:</b> <code>Value</code> is serializable (XML-serializable). Additionally,
 966 each of the indices of <code>m</code> can impose another requirements.<br>
 967 <b>Exception safety:</b> Strong with respect to <code>m</code>. If an exception
 968 is thrown, <code>ar</code> may be left in an inconsistent state.
 969 </blockquote>
 970
 971 Operation: loading of a <code>multi_index_container</code> <code>m'</code> from an
 972 input archive (XML archive) <code>ar</code>.
 973
 974 <blockquote>
 975 <b>Requires:</b> <code>Value</code> is serializable (XML-serializable). Additionally,
 976 each of the indices of <code>m'</code> can impose another requirements.<br>
 977 <b>Exception safety:</b> Basic. If an exception is thrown, <code>ar</code> may be
 978 left in an inconsistent state.
 979 </blockquote>
 980
 981 <hr>
 982
 983 <div class="prev_link"><a href="index.html"><img src="../prev.gif" alt="Boost.MultiIndex reference" border="0"><br>
 984 Boost.MultiIndex reference
 985 </a></div>
 986 <div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
 987 Boost.MultiIndex reference
 988 </a></div>
 989 <div class="next_link"><a href="indices.html"><img src="../next.gif" alt="index reference" border="0"><br>
 990 Index reference
 991 </a></div><br clear="all" style="clear: all;">
 992
 993 <br>
 994
 995 <p>Revised October 12th 2013</p>
 996
 997 <p>&copy; Copyright 2003-2013 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz.
 998 Distributed under the Boost Software
 999 License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
1000 LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
1001 http://www.boost.org/LICENSE_1_0.txt</a>)
1002 </p>
1003
1004 </body>
1005 </html>