Gitiles
Code Review Sign In
realtimeroboticsgroup.org / RealtimeRoboticsGroup / test / 3cbbaca6b1a4c98b648739251c948e49c6980ad9 / . / doc / reference / multi_index_container.html
blob: 5648ac9bee0f80fb68b3fa41c71e7e20a2cbed4a [file] [log] [blame]
Brian Silverman3cbbaca2018-08-04 23:38:07 -0700[diff] [blame^]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>
20Boost.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>
23Boost.MultiIndex reference
24</a></div>
25<div class="next_link"><a href="indices.html"><img src="../next.gif" alt="index reference" border="0"><br>
26Index 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>
58synopsis</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>
87synopsis</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">
223Class template <code>multi_index_container</code>
224</a></h3>
225
226<p>
227This is the main component of Boost.MultiIndex. A <code>multi_index_container</code>
228is a container class template holding a compile-time user-defined list of
229<a href="indices.html">indices</a>. These indices provide different interfaces
230for 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
232and for access to the indices held.
233</p>
234
235<p>
236A <code>multi_index_container</code> type is instantiated with the type of the
237elements 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
240class.
241</p>
242
243<p>
244For convenience of use, all public methods and types of the first index
245specified are inherited by <code>multi_index_container</code>. This also includes global
246operators 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=identifier>multi_index_container</span><span class=special>();</span>
291 <span class=keyword>explicit</span> <span class=identifier>multi_index_container</span><span class=special>(
292 </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>,
293 </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>
294 <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>
295 <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>
296 <span class=identifier>multi_index_container</span><span class=special>(</span>
297 <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>
298 <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>(),
299 </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>
300 <span class=identifier>multi_index_container</span><span class=special>(</span>
301 <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>
302 <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>
303 <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>
304 <span class=identifier>multi_index_container</span><span class=special>(</span>
305 <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>
306 <span class=identifier>multi_index_container</span><span class=special>(</span>
307 <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>
308
309 <span class=special>~</span><span class=identifier>multi_index_container</span><span class=special>();</span>
310
311 <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>
312 <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>
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;</span> <span class=keyword>operator</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;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
315 <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>
316 <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>
317
318 <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>
319
320 <span class=comment>// retrieval of indices</span>
321
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>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>
323 <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>
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>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>
325 <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>
326
327 <span class=comment>// projection of iterators</span>
328
329 <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>
330 <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>
331 <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>
332 <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>
333 <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>
334 <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>
335 <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>
336 <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>
337<span class=special>};</span>
338
339<span class=comment>// multi_index_container associated global class templates:</span>
340
341<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>
342<span class=special>{</span>
343 <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>
344<span class=special>};</span>
345
346<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>
347<span class=special>{</span>
348 <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>
349<span class=special>};</span>
350
351<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>
352<span class=keyword>struct</span> <span class=identifier>nth_index_iterator</span> <span class=comment><b>// deprecated</b></span>
353<span class=special>{</span>
354 <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>
355<span class=special>};</span>
356
357<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>
358<span class=keyword>struct</span> <span class=identifier>nth_index_const_iterator</span> <span class=comment><b>// deprecated</b></span>
359<span class=special>{</span>
360 <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>
361<span class=special>};</span>
362
363<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>
364<span class=keyword>struct</span> <span class=identifier>index_iterator</span> <span class=comment><b>// deprecated</b></span>
365<span class=special>{</span>
366 <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>
367<span class=special>};</span>
368
369<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>
370<span class=keyword>struct</span> <span class=identifier>index_const_iterator</span> <span class=comment><b>// deprecated</b></span>
371<span class=special>{</span>
372 <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>
373<span class=special>};</span>
374
375<span class=comment>// multi_index_container global functions for index retrieval:</span>
376
377<span class=keyword>template</span><span class=special>&lt;</span>
378 <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>
379<span class=special>&gt;</span>
380<span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span>
381 <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>
382<span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span>
383<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>
384<span class=special>{</span>
385 <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>
386<span class=special>}</span>
387
388<span class=keyword>template</span><span class=special>&lt;</span>
389 <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>
390<span class=special>&gt;</span>
391<span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span>
392 <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>
393<span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span>
394<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>
395<span class=special>{</span>
396 <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>
397<span class=special>}</span>
398
399<span class=keyword>template</span><span class=special>&lt;</span>
400 <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>
401<span class=special>&gt;</span>
402<span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span>
403 <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>
404<span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span>
405<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>
406<span class=special>{</span>
407 <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>
408<span class=special>}</span>
409
410<span class=keyword>template</span><span class=special>&lt;</span>
411 <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>
412<span class=special>&gt;</span>
413<span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span>
414 <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>
415<span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&amp;</span>
416<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>
417<span class=special>{</span>
418 <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>
419<span class=special>}</span>
420
421<span class=comment>// multi_index_container global functions for projection of iterators:</span>
422
423<span class=keyword>template</span><span class=special>&lt;</span>
424 <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>
425 <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>
426<span class=special>&gt;</span>
427<span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span>
428 <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>
429<span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span>
430<span class=identifier>project</span><span class=special>(</span>
431 <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>
432 <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span>
433<span class=special>{</span>
434 <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>
435<span class=special>}</span>
436
437<span class=keyword>template</span><span class=special>&lt;</span>
438 <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>
439 <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>
440<span class=special>&gt;</span>
441<span class=keyword>typename</span> <span class=identifier>nth_index</span><span class=special>&lt;</span>
442 <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>
443<span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span>
444<span class=identifier>project</span><span class=special>(</span>
445 <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>
446 <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span>
447<span class=special>{</span>
448 <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>
449<span class=special>}</span>
450
451<span class=keyword>template</span><span class=special>&lt;</span>
452 <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>
453 <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>
454<span class=special>&gt;</span>
455<span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span>
456 <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>
457<span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>iterator</span>
458<span class=identifier>project</span><span class=special>(</span>
459 <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>
460 <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span>
461<span class=special>{</span>
462 <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>
463<span class=special>}</span>
464
465<span class=keyword>template</span><span class=special>&lt;</span>
466 <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>
467 <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>
468<span class=special>&gt;</span>
469<span class=keyword>typename</span> <span class=identifier>index</span><span class=special>&lt;</span>
470 <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>
471<span class=special>&gt;::</span><span class=identifier>type</span><span class=special>::</span><span class=identifier>const_iterator</span>
472<span class=identifier>project</span><span class=special>(</span>
473 <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>
474 <span class=identifier>IteratorType</span> <span class=identifier>it</span><span class=special>)</span>
475<span class=special>{</span>
476 <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>
477<span class=special>}</span>
478
479<span class=comment>// comparison:</span>
480
481<span class=comment>// <b>OP</b> is any of ==,&lt;,!=,&gt;,&gt;=,&lt;=</span>
482
483<span class=keyword>template</span><span class=special>&lt;</span>
484 <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>
485 <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>
486<span class=special>&gt;</span>
487<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><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>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>
489 <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>
490 <span class=special>{</span>
491 <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>
492 <span class=special>}</span>
493
494<span class=comment>// specialized algorithms:</span>
495
496<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>
497<span class=keyword>void</span> <span class=identifier>swap</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>x</span><span class=special>,</span>
499 <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>
500 <span class=special>{</span>
501 <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>
502 <span class=special>}</span>
503
504<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
505
506<span class=special>}</span> <span class=comment>// namespace boost</span>
507</pre></blockquote>
508
509<h4><a name="complexity">Complexity</a></h4>
510
511<p>
512In the descriptions of operations of <code>multi_index_container</code>, we adopt the
513scheme outlined in the
514<a href="indices.html#complexity_signature">complexity signature section</a>.
515</p>
516
517<h4><a name="instantiation_types">Instantiation types</a></h4>
518
519<p>
520<code>multi_index_container</code> is instantiated with the following types:
521<ol>
522 <li><code>Value</code> is the type of the elements contained. <code>Value</code> must be
523 <code>Erasable</code> from <code>multi_index_container</code>.
524 </li>
525 <li><code>IndexSpecifierList</code> specifies the indices that the
526 <code>multi_index_container</code> is composed of. It must be a non-empty
527 <a href="../../../../libs/mpl/doc/refmanual/forward-sequence.html">
528 <code>MPL Forward Sequence</code></a> (and, preferrably,
529 an <a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
530 <code>MPL Random Access Sequence</code></a>) of index specifiers. For
531 syntactic convenience, the
532 <a href="indices.html#indexed_by"><code>indexed_by</code></a>
533 MPL sequence can be used.
534 </li>
535 <li><code>Allocator</code> must be an allocator of <code>Value</code> objects
536 satisfying the associated C++ requirements at <b>[allocator.requirements]</b>.
537 The following relaxations to the standard requirements are allowed:
538 <ul>
539 <li>Non-equal allocator instances are supported: swapping two non-equal
540 instances must not throw any exception.
541 </li>
542 <li>For every type <code>T</code>,
543 the type <code>Allocator::rebind&lt;T&gt;::other::pointer</code> can be any
544 kind of random access iterator, provided that it is explicitly constructible from
545 the literal <code>0</code> (standing here as the null pointer) or from any
546 <code>p</code> of type <code>T*</code> pointing into an area allocated by
547 some instance of <code>Allocator</code> or some other allocator type rebound
548 from <code>Allocator</code>. A <code>pointer</code> constructed from
549 <code>p</code> shall dereference to <code>*p</code>.
550 </li>
551 </ul>
552 </li>
553</ol>
554Indices of a given <code>multi_index_container</code> instantiation cannot have
555duplicate <a href="indices.html#tags">tags</a>, either within a single
556index or in two different indices.
557</p>
558
559<h4><a name="types">Nested types</a></h4>
560
561<code>ctor_args_list</code>
562
563<blockquote>
564Although the exact definition of <code>ctor_args_list</code> is
565implementation defined, from the user point of view this type can be
566treated as equivalent to
567<code>::boost::tuple&lt;C<sub>0</sub>,...,C<sub>I-1</sub>></code>,
568where <code>C<sub>i</sub></code> is the <code>ctor_args</code> type of the
569<code>i</code>-th index held by the <code>multi_index_container</code>, in the
570same order as they were specified. Strictly speaking, there is an
571implicit conversion from
572<code>const ::boost::tuple&lt;C<sub>0</sub>,...,C<sub>I-1</sub>>&amp;</code>
573to <code>const ctor_args_list&amp;</code>. This type is used for
574providing the construction arguments of the indices of the
575<code>multi_index_container</code>. <code>ctor_args_list</code> is
576<code>DefaultConstructible</code>, provided that all <code>ctor_args</code> types
577involved are <code>DefaultConstructible</code>.
578</blockquote>
579
580<code>index_specifier_type_list</code>
581
582<blockquote>
583Same type as <code>IndexSpecifierList</code>.
584</blockquote>
585
586<code>index_type_list</code>
587
588<blockquote>
589Model of
590<a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
591<code>MPL Random Access Sequence</code></a> and
592<a href="../../../../libs/mpl/doc/refmanual/extensible-sequence.html">
593<code>MPL Extensible Sequence</code></a> containing the types of the indices held by
594the <code>multi_index_container</code>, in the same order as they were specified.
595</blockquote>
596
597<code>iterator_type_list</code>
598
599<blockquote>
600Model of
601<a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
602<code>MPL Random Access Sequence</code></a> and
603<a href="../../../../libs/mpl/doc/refmanual/extensible-sequence.html">
604<code>MPL Extensible Sequence</code></a> containing the types of the iterators of
605the indices held by the <code>multi_index_container</code>, in the same order as they were
606specified.
607</blockquote>
608
609<code>const_iterator_type_list</code>
610
611<blockquote>
612Model of
613<a href="../../../../libs/mpl/doc/refmanual/random-access-sequence.html">
614<code>MPL Random Access Sequence</code></a> and
615<a href="../../../../libs/mpl/doc/refmanual/extensible-sequence.html">
616<code>MPL Extensible Sequence</code></a> containing the types of the constant
617iterators of the indices held by the <code>multi_index_container</code>, in the same order
618as they were specified.
619</blockquote>
620
621<h4><a name="nested_templates">Nested class templates</a></h4>
622
623<code>template&lt;int N> struct nth_index</code>
624
625<blockquote>
626<code>nth_index&lt;N>::type</code> yields the type of the
627<code>N</code>-th (0-based) index held by the <code>multi_index_container</code>, in
628the same order as they were specified.<br>
629<b>Requires:</b> <code>0 &lt;= N &lt; I</code>.
630</blockquote>
631
632<code>template&lt;typename Tag> struct index</code>
633
634<blockquote>
635<code>index&lt;Tag>::type</code> yields the type of the index which
636has <code>Tag</code> as an associated <a href="indices.html#tags">tag type</a>.<br>
637<b>Requires:</b> Some index of the <code>multi_index_container</code> has <code>Tag</code>
638as an associated tag type.
639</blockquote>
640
641<code>template&lt;int N> struct nth_index_iterator</code>
642
643<blockquote>
644<code>nth_index_iterator&lt;N>::type</code> is equivalent to
645<code>nth_index&lt;N>::type::iterator</code>.<br>
646<b>Note:</b> The use of <code>nth_index_iterator</code> is deprecated.
647</blockquote>
648
649<code>template&lt;int N> struct nth_index_const_iterator</code>
650
651<blockquote>
652<code>nth_index_const_iterator&lt;N>::type</code> is equivalent to
653<code>nth_index&lt;N>::type::const_iterator</code>.<br>
654<b>Note:</b> The use of <code>nth_index_const_iterator</code> is deprecated.
655</blockquote>
656
657<code>template&lt;typename Tag> struct index_iterator</code>
658
659<blockquote>
660<code>index_iterator&lt;Tag>::type</code> is equivalent to
661<code>index&lt;Tag>::type::iterator</code>.<br>
662<b>Note:</b> The use of <code>index_iterator</code> is deprecated.
663</blockquote>
664
665<code>template&lt;typename Tag> struct index_const_iterator</code>
666
667<blockquote>
668<code>index_const_iterator&lt;Tag>::type</code> is equivalent to
669<code>index&lt;Tag>::type::const_iterator</code>.<br>
670<b>Note:</b> The use of <code>index_const_iterator</code> is deprecated.
671</blockquote>
672
673<h4><a name="constructors">Constructors, copy and assignment</a></h4>
674
675<code>multi_index_container();</code>
676
677<blockquote>
678<b>Effects:</b> Constructs an empty <code>multi_index_container</code> using the
679default values of <code>ctor_args_list</code> and <code>allocator_type</code>.<br>
680<b>Complexity:</b> Constant.
681</blockquote>
682
683<code>explicit multi_index_container(<br>
684&nbsp;&nbsp;const ctor_args_list&amp; args_list,<br>
685&nbsp;&nbsp;const allocator_type&amp; al=allocator_type());</code>
686
687<blockquote>
688<b>Effects:</b> Constructs an empty <code>multi_index_container</code> using the
689specified argument list and allocator.<br>
690<b>Complexity:</b> Constant.
691</blockquote>
692
693<code>explicit multi_index_container(const allocator_type&amp; al);</code>
694
695<blockquote>
696<b>Effects:</b> Constructs an empty <code>multi_index_container</code> using the
697specified allocator and the default value of <code>ctor_args_list</code>.<br>
698<b>Complexity:</b> Constant.
699</blockquote>
700
701<code>template&lt;typename InputIterator><br>
702multi_index_container(<br>
703&nbsp;&nbsp;InputIterator first,InputIterator last,<br>
704&nbsp;&nbsp;const ctor_args_list&amp; args_list=ctor_args_list(),<br>
705&nbsp;&nbsp;const allocator_type&amp; al=allocator_type());</code>
706
707<blockquote>
708<b>Requires:</b> <code>InputIterator</code> is an input iterator.
709<code>Value</code> is
710<code>EmplaceConstructible</code> into <code>multi_index_container</code>
711from <code>*first</code>.
712<code>last</code> is reachable from <code>first</code>.<br>
713<b>Effects:</b> Constructs and empty <code>multi_index_container</code> using the
714specified argument list and allocator and fills it with
715the elements in the range [<code>first</code>,<code>last</code>).
716Insertion of each element may or may not succeed depending
717on the acceptance by all the indices of the <code>multi_index_container</code>.<br>
718<b>Complexity:</b> <code>O(m*H(m))</code>, where <code>m</code> is
719the number of elements in [<code>first</code>,<code>last</code>).<br>
720</blockquote>
721
722<code>multi_index_container(<br>
723&nbsp;&nbsp;std::initializer_list&lt;Value&gt; list,<br>
724&nbsp;&nbsp;const ctor_args_list&amp; args_list=ctor_args_list(),<br>
725&nbsp;&nbsp;const allocator_type&amp; al=allocator_type());</code>
726
727<blockquote>
728<b>Effects:</b> Equivalent to
729<code>multi_index_container(list.begin(),list.end(),args_list,al)</code>.
730</blockquote>
731
732<code>multi_index_container(<br>
733&nbsp;&nbsp;const multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp; x);</code>
734
735<blockquote>
736<b>Requires:</b> <code>Value</code> is <code>CopyInsertable</code> into
737<code>multi_index_container</code>.<br>
738<b>Effects:</b> Constructs a copy of <code>x</code>, copying its
739elements as well as its internal objects (those specified
740in <code>ctor_args_list</code> and the allocator.)<br>
741<b>Postconditions:</b> <code>*this==x</code>. The order on every index
742of the <code>multi_index_container</code> is preserved as well.<br>
743<b>Complexity:</b> <code>O(x.size()*log(x.size()) + C(x.size()))</code>.
744</blockquote>
745
746<code>multi_index_container(<br>
747&nbsp;&nbsp;multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp;&amp; x);</code>
748
749<blockquote>
750<b>Effects:</b> Constructs a <code>multi_index_container</code> by moving the
751elements of <code>x</code> and copying its internal objects (those specified
752in <code>ctor_args_list</code> and the allocator.)<br>
753<b>Postconditions:</b> If <code>x==y</code> just
754before the movement, <code>*this==y</code>. The order on every index
755of the <code>multi_index_container</code> is preserved as well.<br>
756<b>Complexity:</b> Constant.
757</blockquote>
758
759<code>~multi_index_container()</code>
760<blockquote>
761<b>Effects:</b> Destroys the <code>multi_index_container</code> and all the elements
762contained. The order in which the elements are destroyed is not specified.<br>
763<b>Complexity:</b> <code>O(n)</code>.
764</blockquote>
765
766<code>multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp; operator=(<br>
767&nbsp;&nbsp;const multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp; x);</code>
768
769<blockquote>
770<b>Requires:</b> <code>Value</code> is <code>CopyInsertable</code> into
771<code>multi_index_container</code>.<br>
772<b>Effects:</b> Replaces the elements and internal objects of the <code>multi_index_container</code>
773with copies from <code>x</code>.<br>
774<b>Postconditions:</b> <code>*this==x</code>. The order on every index
775of the <code>multi_index_container</code> is preserved as well.<br>
776<b>Returns:</b> <code>*this</code>.<br>
777<b>Complexity:</b> <code>O(n + x.size()*log(x.size()) +
778C(x.size()))</code>.<br>
779<b>Exception safety:</b> Strong, provided the copy and assignment operations
780of the types of <code>ctor_args_list</code> do not throw.
781</blockquote>
782
783<code>multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp; operator=(<br>
784&nbsp;&nbsp;multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp;&amp; x);</code>
785
786<blockquote>
787<b>Effects:</b> Replaces the elements of <code>multi_index_container</code>
788with those of <code>x</code> and its internal objects with copies from the
789corresponding objects in <code>x</code>.<br>
790<b>Postconditions:</b> If <code>x==y</code> just
791before the movement, <code>*this==y</code>. The order on every index
792of the <code>multi_index_container</code> is preserved as well.<br>
793<b>Returns:</b> <code>*this</code>.<br>
794<b>Complexity:</b> <code>O(n)</code>.<br>
795<b>Exception safety:</b> Strong, provided the copy and assignment operations
796of the types of <code>ctor_args_list</code> do not throw.
797</blockquote>
798
799<code>multi_index_container&lt;Value,IndexSpecifierList,Allocator>&amp; operator=(<br>
800&nbsp;&nbsp;std::initializer_list&lt;Value&gt; list);</code>
801
802<blockquote>
803<b>Requires:</b> <code>Value</code> is <code>CopyInsertable</code> into
804<code>multi_index_container</code>.<br>
805<b>Effects:</b> Replaces the elements the <code>multi_index_container</code>
806with copies of the elements of <code>list</code>, inserted in the specified order.
807Insertion of each element may or may not succeed depending
808on the acceptance by all the indices of the <code>multi_index_container</code>.<br>
809<b>Returns:</b> <code>*this</code>.<br>
810<b>Complexity:</b> <code>O(n + I(m))</code>, where <code>m</code> is the
811number of elements of <code>list</code>.<br>
812<b>Exception safety:</b> Strong, provided the copy and assignment operations
813of the types of <code>ctor_args_list</code> do not throw.
814</blockquote>
815
816<code>allocator_type get_allocator()const noexcept;</code>
817
818<blockquote>
819Returns a copy of the <code>allocator_type</code> object used to construct
820the <code>multi_index_container</code>.<br>
821<b>Complexity:</b> Constant.
822</blockquote>
823
824<h4><a name="index_retrieval">Index retrieval operations</a></h4>
825
826<code>template&lt;int N> typename nth_index&lt;N>::type&amp; get()noexcept;</code>
827
828<blockquote>
829<b>Requires:</b> <code>0 &lt;= N &lt; I</code>.<br>
830<b>Effects:</b> Returns a 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;int N> const typename nth_index&lt;N>::type&amp; get()const noexcept;</code>
836
837<blockquote>
838<b>Requires:</b> <code>0 &lt;= N &lt; I</code>.<br>
839<b>Effects:</b> Returns a <code>const</code> reference to the
840<code>nth_index&lt;N>::type</code> index held by <code>*this</code>.<br>
841<b>Complexity:</b> Constant.<br>
842</blockquote>
843
844<code>template&lt;typename Tag> typename index&lt;Tag>::type&amp; get()noexcept;</code>
845
846<blockquote>
847<b>Requires:</b> <code>Tag</code> is such that <code>index&lt;Tag>::type</code>
848is valid.<br>
849<b>Effects:</b> Returns a reference to the
850<code>index&lt;Tag>::type</code> index held by
851<code>*this</code>.<br>
852<b>Complexity:</b> Constant.<br>
853</blockquote>
854
855<code>template&lt;typename Tag> const typename index&lt;Tag>::type&amp; get()const noexcept;</code>
856
857<blockquote>
858<b>Requires:</b> <code>Tag</code> is such that <code>index&lt;Tag>::type</code>
859is valid.<br>
860<b>Effects:</b> Returns a <code>const</code> reference to the
861<code>index&lt;Tag>::type</code> index held by
862<code>*this</code>.<br>
863<b>Complexity:</b> Constant.<br>
864</blockquote>
865
866<h4><a name="projection">Projection operations</a></h4>
867
868<p>
869Given a <code>multi_index_container</code> with indices <code>i1</code>
870and <code>i2</code>, we say than an <code>i1</code>-iterator
871<code>it1</code> and an <code>i2</code>-iterator <code>it2</code>
872are <i>equivalent</i> if:
873<ul>
874 <li> <code>it1==i1.end()</code> AND <code>it2==i2.end()</code>,</li>
875 <li> OR <code>it1</code> and <code>it2</code> point to the
876 same element.</li>
877</ul>
878</p>
879
880<code>template&lt;int N,typename IteratorType><br>
881typename nth_index&lt;N>::type::iterator project(IteratorType it);</code>
882
883<blockquote>
884<b>Requires:</b> <code>0 &lt;= N &lt; I</code>. <code>IteratorType</code>
885belongs to <code>iterator_type_list</code>. <code>it</code> is a valid
886iterator of some index of <code>*this</code> (i.e. does not refer to some
887other <code>multi_index_container</code>.)<br>
888<b>Effects:</b> Returns an <code>nth_index&lt;N>::type::iterator</code>
889equivalent to <code>it</code>.<br>
890<b>Complexity:</b> Constant.<br>
891<b>Exception safety:</b> <code>nothrow</code>.
892</blockquote>
893
894<code>template&lt;int N,typename IteratorType><br>
895typename nth_index&lt;N>::type::const_iterator project(IteratorType it)const;</code>
896
897<blockquote>
898<b>Requires:</b> <code>0 &lt;= N &lt; I</code>. <code>IteratorType</code>
899belongs to <code>const_iterator_type_list</code> or
900<code>iterator_type_list</code>. <code>it</code> is a
901valid (constant or non-constant) iterator of some index of <code>*this</code>
902(i.e. does not refer to some other <code>multi_index_container</code>.)<br>
903<b>Effects:</b> Returns an <code>nth_index&lt;N>::type::const_iterator</code>
904equivalent to <code>it</code>.<br>
905<b>Complexity:</b> Constant.<br>
906<b>Exception safety:</b> <code>nothrow</code>.
907</blockquote>
908
909<code>template&lt;typename Tag,typename IteratorType><br>
910typename index&lt;Tag>::type::iterator project(IteratorType it);</code>
911
912<blockquote>
913<b>Requires:</b> <code>Tag</code> is such that
914<code>index&lt;Tag>::type</code> is valid. <code>IteratorType</code>
915belongs to <code>iterator_type_list</code>. <code>it</code> is a valid
916iterator of some index of <code>*this</code> (i.e. does not refer to some
917other <code>multi_index_container</code>.)<br>
918<b>Effects:</b> Returns an <code>index&lt;Tag>::type::iterator</code>
919equivalent to <code>it</code>.<br>
920<b>Complexity:</b> Constant.<br>
921<b>Exception safety:</b> <code>nothrow</code>.
922</blockquote>
923
924<code>template&lt;typename Tag,typename IteratorType><br>
925typename index&lt;Tag>::type::const_iterator project(IteratorType it)const;</code>
926
927<blockquote>
928<b>Requires:</b> <code>Tag</code> is such that
929<code>index&lt;Tag>::type</code> is valid. <code>IteratorType</code>
930belongs to <code>const_iterator_type_list</code> or
931<code>iterator_type_list</code>. <code>it</code> is a valid
932(constant or non-constant) iterator of some index of <code>*this</code>
933(i.e. does not refer to some other <code>multi_index_container</code>.)<br>
934<b>Effects:</b> Returns an <code>index&lt;Tag>::type::const_iterator</code>
935iterator equivalent to <code>it</code>.<br>
936<b>Complexity:</b> Constant.<br>
937<b>Exception safety:</b> <code>nothrow</code>.
938</blockquote>
939
940<h4><a name="serialization">Serialization</a></h4>
941
942<p>
943<code>multi_index_container</code>s can be archived/retrieved by means of
944<a href="../../../serialization/index.html">Boost.Serialization</a>.
945Boost.MultiIndex does not expose a public serialization interface, as this
946is provided by Boost.Serialization itself. Both regular and XML
947archives are supported.
948</p>
949
950<p>
951Each of the indices comprising a given <code>multi_index_container</code> contributes
952its own preconditions as well as guarantees on the retrieved containers. In describing
953these, the following concepts are used. A type <code>T</code> is <i>serializable</i>
954(resp. XML-serializable) if any object of type <code>T</code> can be saved to an output
955archive (XML archive) and later retrieved from an input archive (XML archive) associated to
956the same storage. If <code>x'</code> of type <code>T</code> is loaded from the
957serialization information saved from another object <code>x</code>, we say that
958<code>x'</code> is a <i>restored copy</i> of <code>x</code>. Given a binary predicate
959<code>Pred</code> over (<code>T</code>, <code>T</code>), and objects <code>p</code>
960and <code>q</code> of type <code>Pred</code>, we say that <code>q</code>
961is <i>serialization-compatible</i> with <code>p</code> if
962<blockquote>
963<code>p(x,y) == q(x',y')</code>
964</blockquote>
965for every <code>x</code> and <code>y</code> of type <code>T</code> and <code>x'</code> and
966<code>y'</code> being restored copies of <code>x</code> and <code>y</code>,
967respectively.
968</p>
969
970Operation: saving of a <code>multi_index_container</code> <code>m</code> to an
971output archive (XML archive) <code>ar</code>.
972
973<blockquote>
974<b>Requires:</b> <code>Value</code> is serializable (XML-serializable). Additionally,
975each of the indices of <code>m</code> can impose another requirements.<br>
976<b>Exception safety:</b> Strong with respect to <code>m</code>. If an exception
977is thrown, <code>ar</code> may be left in an inconsistent state.
978</blockquote>
979
980Operation: loading of a <code>multi_index_container</code> <code>m'</code> from an
981input archive (XML archive) <code>ar</code>.
982
983<blockquote>
984<b>Requires:</b> <code>Value</code> is serializable (XML-serializable). Additionally,
985each of the indices of <code>m'</code> can impose another requirements.<br>
986<b>Exception safety:</b> Basic. If an exception is thrown, <code>ar</code> may be
987left in an inconsistent state.
988</blockquote>
989
990<hr>
991
992<div class="prev_link"><a href="index.html"><img src="../prev.gif" alt="Boost.MultiIndex reference" border="0"><br>
993Boost.MultiIndex reference
994</a></div>
995<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
996Boost.MultiIndex reference
997</a></div>
998<div class="next_link"><a href="indices.html"><img src="../next.gif" alt="index reference" border="0"><br>
999Index reference
1000</a></div><br clear="all" style="clear: all;">
1001
1002<br>
1003
1004<p>Revised April 13th 2018</p>
1005
1006<p>&copy; Copyright 2003-2018 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz.
1007Distributed under the Boost Software
1008License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
1009LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
1010http://www.boost.org/LICENSE_1_0.txt</a>)
1011</p>
1012
1013</body>
1014</html>