Gitiles
Code Review Sign In
realtimeroboticsgroup.org / RealtimeRoboticsGroup / test / 3cbbaca6b1a4c98b648739251c948e49c6980ad9 / . / doc / reference / key_extraction.html
blob: f618c39e83f47acf61252e20188747bced275a11 [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 - Key extraction reference</title>
7<link rel="stylesheet" href="../style.css" type="text/css">
8<link rel="start" href="../index.html">
9<link rel="prev" href="rnd_indices.html">
10<link rel="up" href="index.html">
11<link rel="next" href="../compiler_specifics.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 Key extraction reference</h1>
17
18<div class="prev_link"><a href="rnd_indices.html"><img src="../prev.gif" alt="random access indices" border="0"><br>
19Random access indices
20</a></div>
21<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
22Boost.MultiIndex reference
23</a></div>
24<div class="next_link"><a href="../compiler_specifics.html"><img src="../next.gif" alt="compiler specifics" border="0"><br>
25Compiler specifics
26</a></div><br clear="all" style="clear: all;">
27
28<hr>
29
30<h2>Contents</h2>
31
32<ul>
33 <li><a href="#key_extractors">Key Extractors</a>
34 <ul>
35 <li><a href="#chained_pointers">Chained pointers</a></li>
36 </ul>
37 </li>
38 <li><a href="#synopsis">Header
39 <code>"boost/multi_index/key_extractors.hpp"</code> synopsis</a>
40 </li>
41 <li><a href="#identity_synopsis">Header
42 <code>"boost/multi_index/identity.hpp"</code> synopsis</a>
43 <ul>
44 <li><a href="#identity">Class template <code>identity</code></a></li>
45 </ul>
46 </li>
47 <li><a href="#member_synopsis">Header
48 <code>"boost/multi_index/member.hpp"</code> synopsis</a>
49 <ul>
50 <li><a href="#member">Class template <code>member</code></a></li>
51 <li><a href="#member_offset">Class template <code>member_offset</code></a></li>
52 <li><a href="#boost_multi_index_member">Macro <code>BOOST_MULTI_INDEX_MEMBER</code></a></li>
53 </ul>
54 </li>
55 <li><a href="#mem_fun_synopsis">Header
56 <code>"boost/multi_index/mem_fun.hpp"</code> synopsis</a>
57 <ul>
58 <li><a href="#const_mem_fun">Class template <code>const_mem_fun</code></a></li>
59 <li><a href="#mem_fun">Class template <code>mem_fun</code></a></li>
60 <li><a href="#const_mem_fun_explicit">Class templates <code>const_mem_fun_explicit</code> and <code>mem_fun_explicit</code></a></li>
61 <li><a href="#boost_multi_index_const_mem_fun">Macros <code>BOOST_MULTI_INDEX_CONST_MEM_FUN</code> and <code>BOOST_MULTI_INDEX_MEM_FUN</code></a></li>
62 </ul>
63 </li>
64 <li><a href="#global_fun_synopsis">Header
65 <code>"boost/multi_index/global_fun.hpp"</code> synopsis</a>
66 <ul>
67 <li><a href="#global_fun">Class template <code>global_fun</code></a></li>
68 </ul>
69 </li>
70 <li><a href="#composite_key_synopsis">Header
71 <code>"boost/multi_index/composite_key.hpp"</code> synopsis</a>
72 <ul>
73 <li><a href="#composite_key">Class template <code>composite_key</code></a></li>
74 <li><a href="#composite_key_result">Class template <code>composite_key_result</code></a></li>
75 <li><a href="#ckey_result_equality">Equality</a>
76 <ul>
77 <li><a href="#composite_key_equal_to">Class template <code>composite_key_equal_to</code></a></li>
78 <li><a href="#composite_key_result_equal_to">Class template <code>composite_key_result_equal_to</code></a></li>
79 <li><a href="#equal_to_composite_key_result">Specialization of <code>std::equal_to</code> for <code>composite_key</code> results</a></li>
80 </ul>
81 </li>
82 <li><a href="#ckey_result_comparison">Comparison</a>
83 <ul>
84 <li><a href="#composite_key_compare">Class template <code>composite_key_compare</code></a></li>
85 <li><a href="#composite_key_result_less">Class template <code>composite_key_result_less</code></a></li>
86 <li><a href="#composite_key_result_greater">Class template <code>composite_key_result_greater</code></a></li>
87 <li><a href="#less_composite_key_result">Specialization of <code>std::less</code> for <code>composite_key</code> results</a></li>
88 <li><a href="#greater_composite_key_result">Specialization of <code>std::greater</code> for <code>composite_key</code> results</a></li>
89 </ul>
90 </li>
91 <li><a href="#ckey_result_hashing">Hashing</a>
92 <ul>
93 <li><a href="#composite_key_hash">Class template <code>composite_key_hash</code></a></li>
94 <li><a href="#composite_key_result_hash">Class template <code>composite_key_result_hash</code></a></li>
95 <li><a href="#hash_composite_key_result">Specialization of <code>boost::hash</code> for <code>composite_key</code> results</a></li>
96 </ul>
97 </li>
98 <li><a href="#ckey_result_semantics">Semantics of <code>composite_key_result</code></a></li>
99 </ul>
100 </li>
101</ul>
102
103<h2><a name="key_extractors">Key Extractors</a></h2>
104
105<p>
106Key extraction classes are used by
107<a href="indices.html#key_based_indices">key-based indices</a> to
108obtain the indexing keys from the elements of a <code>multi_index_container</code>.
109A <code>CopyConstructible</code> and <code>CopyAssignable</code>
110class <code>KeyFromValue</code> is said to be a key extractor from a
111type <code>Type</code> if
112<ol>
113 <li>the type <code>KeyFromValue::result_type</code> is defined,</li>
114 <li><code>k1(ca)</code> is defined and returns a value convertible
115 to <code>const KeyFromValue::result_type&amp;</code>,</li>
116 <li>if <code>k2</code> is a copy of <code>k1</code>, <code>k1(ca)</code> is the
117 same value as <code>k2(ca)</code>,</li>
118</ol>
119for every <code>k1</code>, <code>k2</code> of type <code>const KeyFromValue</code>,
120and <code>ca</code> of type <code>const Type&amp;</code>.
121</p>
122
123<p>
124Additionally, <code>KeyFromValue</code> is a <i>read/write</i> key extractor
125if the following extra conditions are met:
126<ol>
127 <li><code>k1(a)</code> is defined and returns a value convertible
128 to <code>KeyFromValue::result_type&amp;</code>,</li>
129 <li><code>const_cast&lt;const KeyFromValue::result_type&amp;>(k1(a))</code>
130 is the same value as
131 <code>k1(const_cast&lt;const Type&amp;>(a))</code>,</li>
132</ol>
133for every <code>k1</code> of type <code>const KeyFromValue</code> and
134<code>a</code> of type <code>Type&amp;</code>.
135</p>
136
137<p>
138Boost.MultiIndex provides six general-purpose key extractors:
139<ul>
140 <li><a href="#identity"><code>identity</code></a>,</li>
141 <li><a href="#member"><code>member</code></a>,</li>
142 <li><a href="#const_mem_fun"><code>const_mem_fun</code></a>,</li>
143 <li><a href="#mem_fun"><code>mem_fun</code></a>,</li>
144 <li><a href="#global_fun"><code>global_fun</code></a> and</li>
145 <li><a href="#composite_key"><code>composite_key</code></a>.</li>
146</ul>
147</p>
148
149<h3><a name="chained_pointers">Chained pointers</a></h3>
150
151<p>
152The key extractors provided by Boost.MultiIndex are templatized according
153to the type <code>Type</code> and serve to extract keys not only from objects
154of type <code>Type</code>, but also from reference wrappers provided by
155<a href="../../../../doc/html/ref.html">Boost.Ref</a> and from <i>chained pointers</i>
156to <code>Type</code> (or to reference wrappers of <code>Type</code>): a chained pointer
157is any type <code>P</code> such that, for an object <code>p</code> of type
158<code>const P</code>
159<ul>
160 <li><code>*p</code> yields an object of type <code>Type&amp;</code> or
161 <code>boost::reference_wrapper&lt;Type></code>, OR</li>
162 <li><code>*p</code> yields a chained pointer to <code>Type</code>,</li>
163</ul>
164that is, chained pointers are arbitrary compositions of pointer-like objects
165ultimately dereferencing to values of <code>Type&amp;</code> or
166<code>boost::reference_wrapper&lt;Type></code>.
167<p>
168
169<h2><a name="synopsis">Header
170<a href="../../../../boost/multi_index/key_extractors.hpp">
171<code>"boost/multi_index/key_extractors.hpp"</code></a> synopsis</a>
172</h2>
173
174<blockquote><pre>
175<span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>identity</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
176<span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>member</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
177<span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>mem_fun</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
178<span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>global_fun</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
179<span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>multi_index</span><span class=special>/</span><span class=identifier>composite_key</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
180</pre></blockquote>
181
182<p>
183This header includes all the key extractors provided by Boost.MultiIndex.
184</p>
185
186<h2>
187<a name="identity_synopsis">Header
188<a href="../../../../boost/multi_index/identity.hpp">
189<code>"boost/multi_index/identity.hpp"</code></a> synopsis</a></h2>
190
191<blockquote><pre>
192<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
193
194<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
195
196<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>T</span><span class=special>&gt;</span> <span class=keyword>struct</span> <span class=identifier>identity</span><span class=special>;</span>
197
198<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
199
200<span class=special>}</span> <span class=comment>// namespace boost</span>
201</pre></blockquote>
202
203<h3><a name="identity">Class template <code>identity</code></a></h3>
204
205<p>
206<code>identity</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
207that acts as a do-nothing identity functor.
208</p>
209
210<blockquote><pre>
211<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>&gt;</span>
212<span class=keyword>struct</span> <span class=identifier>identity</span>
213<span class=special>{</span>
214 <span class=keyword>typedef</span> <span class=identifier>Type</span> <span class=identifier>result_type</span><span class=special>;</span>
215
216 <span class=comment>// only provided if const ChainedPtr&amp; is not convertible to const Type&amp;</span>
217 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</span> <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
218
219 <span class=keyword>const</span> <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>Type</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
220 <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=identifier>Type</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span> <span class=comment>// only provided if Type is non-const
221
222 // only provided if Type is non-const</span>
223 <span class=keyword>const</span> <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span><span class=keyword>const</span> <span class=identifier>Type</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
224
225 <span class=comment>// only provided if Type is const</span>
226 <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span>
227 <span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>remove_const</span><span class=special>&lt;</span><span class=identifier>Type</span><span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
228
229 <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span><span class=identifier>Type</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
230<span class=special>};</span>
231</pre></blockquote>
232
233<p>
234<code>identity&lt;Type></code> is a model of:
235<ul>
236 <li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
237 from <code>Type</code>,</li>
238 <li><a href="#key_extractors"><code>Key Extractor</code></a>
239 from <code>reference_wrapper&lt;const Type></code>,</li>
240 <li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
241 from <code>reference_wrapper&lt;Type></code>,</li>
242 <li><a href="#key_extractors"><code>Key Extractor</code></a>
243 from any <a href="#chained_pointers">chained pointer</a> to
244 <code>const Type</code>,</li>
245 <li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
246 from any <a href="#chained_pointers">chained pointer</a>
247 to <code>Type</code>.</li>
248</ul>
249</p>
250
251<h4><code>identity</code> members</h4>
252
253<code>template&lt;typename ChainedPtr> Type&amp; operator()(const ChainedPtr&amp; x)const;</code>
254
255<blockquote>
256<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
257type to <code>Type</code>.<br>
258<b>Returns:</b> a reference to the object chained-pointed to by <code>x</code>.
259</blockquote>
260
261<code>const Type&amp; operator()(const Type&amp; x)const;</code>
262
263<blockquote>
264<b>Returns:</b> <code>x</code>.
265</blockquote>
266
267<code>Type&amp; operator()(Type&amp; x)const;</code>
268
269<blockquote>
270<b>Returns:</b> <code>x</code>.
271</blockquote>
272
273<code>const Type&amp; operator()(const reference_wrapper&lt;const Type>&amp; x)const;</code>
274<blockquote>
275<b>Returns:</b> <code>x.get()</code>.
276</blockquote>
277
278<code>Type&amp; operator()(const reference_wrapper&lt;typename remove_const&lt;Type>::type>&amp; x)const;</code>
279<blockquote>
280<b>Returns:</b> <code>x.get()</code>.
281</blockquote>
282
283<code>Type&amp; operator()(const reference_wrapper&lt;Type>&amp; x)const;</code>
284<blockquote>
285<b>Returns:</b> <code>x.get()</code>.
286</blockquote>
287
288
289<h2>
290<a name="member_synopsis">Header
291<a href="../../../../boost/multi_index/member.hpp">
292<code>"boost/multi_index/member.hpp"</code></a> synopsis</a></h2>
293
294<blockquote><pre>
295<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
296
297<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
298
299<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=identifier>Class</span><span class=special>::*</span><span class=identifier>PtrToMember</span><span class=special>&gt;</span>
300<span class=keyword>struct</span> <span class=identifier>member</span><span class=special>;</span>
301
302<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=identifier>OffsetOfMember</span><span class=special>&gt;</span>
303<span class=keyword>struct</span> <span class=identifier>member_offset</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
304
305<span class=preprocessor>#define</span> <span class=identifier>BOOST_MULTI_INDEX_MEMBER</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>Type</span><span class=special>,</span><span class=identifier>MemberName</span><span class=special>)</span> <b>implementation defined</b>
306
307<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
308
309<span class=special>}</span> <span class=comment>// namespace boost</span>
310</pre></blockquote>
311
312<h3><a name="member">Class template <code>member</code></a></h3>
313
314<p>
315<code>member</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
316aimed at accessing a given member of a class.
317</p>
318
319<blockquote><pre>
320<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=identifier>Class</span><span class=special>::*</span><span class=identifier>PtrToMember</span><span class=special>&gt;</span>
321<span class=keyword>struct</span> <span class=identifier>member</span>
322<span class=special>{</span>
323 <span class=keyword>typedef</span> <span class=identifier>Type</span> <span class=identifier>result_type</span><span class=special>;</span>
324
325 <span class=comment>// only provided if const ChainedPtr&amp; is not convertible to const Class&amp;</span>
326 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</span> <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
327
328 <span class=keyword>const</span> <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>Class</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
329 <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=identifier>Class</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span> <span class=comment>// only provided if Type is non-const</span>
330 <span class=keyword>const</span> <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span><span class=keyword>const</span> <span class=identifier>Class</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
331 <span class=identifier>Type</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span><span class=identifier>Class</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
332<span class=special>};</span>
333</pre></blockquote>
334
335<p>
336The <code>PtrToMember</code> template argument specifies the particular
337<code>Type Class::*</code> pointer to the member to be extracted.
338<code>member&lt;Class,Type,PtrToMember></code> is a model of:
339<ul>
340 <li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
341 from <code>Class</code>,</li>
342 <li><a href="#key_extractors"><code>Key Extractor</code></a>
343 from <code>reference_wrapper&lt;const Class></code>,</li>
344 <li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
345 from <code>reference_wrapper&lt;Class></code>,</li>
346 <li><a href="#key_extractors"><code>Key Extractor</code></a>
347 from any <a href="#chained_pointers">chained pointer</a>
348 to <code>const Class</code>,</li>
349 <li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
350 from any <a href="#chained_pointers">chained pointer</a>
351 to <code>Class</code>.</li>
352</ul>
353</p>
354
355<h4><code>member</code> members</h4>
356
357<code>template&lt;typename ChainedPtr> Type&amp; operator()(const ChainedPtr&amp; x)const;</code>
358
359<blockquote>
360<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
361type to <code>Type</code>.<br>
362<b>Returns:</b> a reference to the object chained-pointed to by <code>x</code>.
363</blockquote>
364
365<code>const Type&amp; operator()(const Class&amp; x)const;</code>
366
367<blockquote>
368<b>Returns:</b> <code>x.*PtrToMember</code>.
369</blockquote>
370
371<code>Type&amp; operator()(Class&amp; x)const;</code>
372
373<blockquote>
374<b>Returns:</b> <code>x.*PtrToMember</code>.
375</blockquote>
376
377<code>const Type&amp; operator()(const reference_wrapper&lt;const Class>&amp; x)const;</code>
378
379<blockquote>
380<b>Returns:</b> <code>x.get().*PtrToMember</code>.
381</blockquote>
382
383<code>Type&amp; operator()(const reference_wrapper&lt;Class>&amp; x)const;</code>
384
385<blockquote>
386<b>Returns:</b> <code>x.get().*PtrToMember</code>.
387</blockquote>
388
389<h3><a name="member_offset">Class template <code>member_offset</code></a></h3>
390
391<p>
392<code>member_offset</code> was designed to overcome limitations of some legacy
393compilers and its use is currently deprecated. Refer to a
394<a href="http://www.boost.org/doc/libs/1_54_0/libs/multi_index/doc/reference/key_extraction.html#member_offset">former version</a>
395of Boost.MultiIndex for further information.
396</p>
397
398<h3><a name="boost_multi_index_member">Macro <code>BOOST_MULTI_INDEX_MEMBER</code></a></h3>
399
400<blockquote><pre>
401<span class=identifier>BOOST_MULTI_INDEX_MEMBER</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>Type</span><span class=special>,</span><span class=identifier>MemberName</span><span class=special>)</span>
402</pre></blockquote>
403
404<p>
405This macro was designed as a portability mechanism for legacy compilers where <code>member</code>
406could not be supported.
407As such it is no longer needed in modern environments, though some users might still prefer it
408to plain <code>member</code> because it provides a slightly more concise syntax.
409</p>
410
411<h2>
412<a name="mem_fun_synopsis">Header
413<a href="../../../../boost/multi_index/mem_fun.hpp">
414<code>"boost/multi_index/mem_fun.hpp"</code></a> synopsis</a></h2>
415
416<blockquote><pre>
417<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
418
419<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
420
421<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=special>(</span><span class=identifier>Class</span><span class=special>::*</span><span class=identifier>PtrToMemberFunction</span><span class=special>)()</span><span class=keyword>const</span><span class=special>&gt;</span>
422<span class=keyword>struct</span> <span class=identifier>const_mem_fun</span><span class=special>;</span>
423
424<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=special>(</span><span class=identifier>Class</span><span class=special>::*</span><span class=identifier>PtrToMemberFunction</span><span class=special>)()&gt;</span>
425<span class=keyword>struct</span> <span class=identifier>mem_fun</span><span class=special>;</span>
426
427<span class=keyword>template</span><span class=special>&lt;</span>
428 <span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span>
429 <span class=keyword>typename</span> <span class=identifier>PtrToMemberFunctionType</span><span class=special>,</span><span class=identifier>PtrToMemberFunctionType</span> <span class=identifier>PtrToMemberFunction</span>
430<span class=special>&gt;</span>
431<span class=keyword>struct</span> <span class=identifier>const_mem_fun_explicit</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
432
433<span class=keyword>template</span><span class=special>&lt;</span>
434 <span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span>
435 <span class=keyword>typename</span> <span class=identifier>PtrToMemberFunctionType</span><span class=special>,</span><span class=identifier>PtrToMemberFunctionType</span> <span class=identifier>PtrToMemberFunction</span>
436<span class=special>&gt;</span>
437<span class=keyword>struct</span> <span class=identifier>mem_fun_explicit</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
438
439<span class=preprocessor>#define</span> <span class=identifier>BOOST_MULTI_INDEX_CONST_MEM_FUN</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>Type</span><span class=special>,</span><span class=identifier>MemberFunName</span><span class=special>)</span> <span class=special>\</span>
440<b>implementation defined</b>
441<span class=preprocessor>#define</span> <span class=identifier>BOOST_MULTI_INDEX_MEM_FUN</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>Type</span><span class=special>,</span><span class=identifier>MemberFunName</span><span class=special>)</span> <span class=special>\</span>
442<b>implementation defined</b>
443
444<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
445
446<span class=special>}</span> <span class=comment>// namespace boost</span>
447</pre></blockquote>
448
449<h3><a name="const_mem_fun">Class template <code>const_mem_fun</code></a></h3>
450
451<p>
452<code>const_mem_fun</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
453returning as key the result of invoking a given constant member function of a class.
454</p>
455
456<blockquote><pre>
457<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=special>(</span><span class=identifier>Class</span><span class=special>::*</span><span class=identifier>PtrToMemberFunction</span><span class=special>)()</span><span class=keyword>const</span><span class=special>&gt;</span>
458<span class=keyword>struct</span> <span class=identifier>const_mem_fun</span>
459<span class=special>{</span>
460 <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>remove_reference</span><span class=special>&lt;</span><span class=identifier>Type</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=identifier>result_type</span><span class=special>;</span>
461
462 <span class=comment>// only provided if const ChainedPtr&amp; is not convertible to const Class&amp;</span>
463 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</span> <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
464
465 <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>Class</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
466 <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span><span class=keyword>const</span> <span class=identifier>Class</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
467 <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span><span class=identifier>Class</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
468<span class=special>};</span>
469</pre></blockquote>
470
471<p>
472The <code>PtrToMemberFunction</code> template argument specifies the particular
473<code>Type (Class::*PtrToMemberFunction)()const</code> pointer to the constant
474member function used in the extraction.
475<code>const_mem_fun&lt;Class,Type,PtrToMemberFunction></code> is a model of:
476<ul>
477 <li><a href="#key_extractors"><code>Key Extractor</code></a>
478 from <code>Class</code>,</li>
479 <li><a href="#key_extractors"><code>Key Extractor</code></a>
480 from <code>reference_wrapper&lt;const Class></code>,</li>
481 <li><a href="#key_extractors"><code>Key Extractor</code></a>
482 from <code>reference_wrapper&lt;Class></code>,</li>
483 <li><a href="#key_extractors"><code>Key Extractor</code></a>
484 from any <a href="#chained_pointers">chained pointer</a>
485 to <code>const Class</code>,</li>
486 <li><a href="#key_extractors"><code>Key Extractor</code></a>
487 from any <a href="#chained_pointers">chained pointer</a>
488 to <code>Class</code>.</li>
489</ul>
490</p>
491
492<h4><code>const_mem_fun</code> members</h4>
493
494<code>template&lt;typename ChainedPtr> Type operator()(const ChainedPtr&amp; x)const;</code>
495
496<blockquote>
497<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
498type to <code>Type</code>.<br>
499<b>Returns:</b> <code>(y.*PtrToMemberFunction)()</code>, where <code>y</code> is the
500object chained-pointed to by <code>x</code>.
501</blockquote>
502
503<code>Type operator()(const Class&amp; x)const;</code>
504
505<blockquote>
506<b>Returns:</b> <code>(x.*PtrToMemberFunction)()</code>.
507</blockquote>
508
509<code>Type operator()(const reference_wrapper&lt;const Class>&amp; x)const;</code>
510
511<blockquote>
512<b>Returns:</b> <code>(x.get().*PtrToMemberFunction)()</code>.
513</blockquote>
514
515<code>Type operator()(const reference_wrapper&lt;Class>&amp; x)const;</code>
516
517<blockquote>
518<b>Returns:</b> <code>(x.get().*PtrToMemberFunction)()</code>.
519</blockquote>
520
521<h3><a name="mem_fun">Class template <code>mem_fun</code></a></h3>
522
523<p>
524<code>mem_fun</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
525returning as key the result of invoking a given member function of a class.
526</p>
527
528<blockquote><pre>
529<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>class</span> <span class=identifier>Class</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=special>(</span><span class=identifier>Class</span><span class=special>::*</span><span class=identifier>PtrToMemberFunction</span><span class=special>)()&gt;</span>
530<span class=keyword>struct</span> <span class=identifier>mem_fun</span>
531<span class=special>{</span>
532 <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>remove_reference</span><span class=special>&lt;</span><span class=identifier>Type</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=identifier>result_type</span><span class=special>;</span>
533
534 <span class=comment>// only provided if ChainedPtr&amp; is not convertible to Class&amp;</span>
535 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</span> <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
536
537 <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=identifier>Class</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
538 <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span><span class=identifier>Class</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
539<span class=special>};</span>
540</pre></blockquote>
541
542<p>
543The <code>PtrToMemberFunction</code> template argument specifies the particular
544<code>Type (Class::*PtrToMemberFunction)()</code> pointer to the member
545function used in the extraction.
546<code>mem_fun&lt;Class,Type,PtrToMemberFunction></code> is a model of:
547<ul>
548 <li><a href="#key_extractors"><code>Key Extractor</code></a>
549 from <code>reference_wrapper&lt;Class></code>,</li>
550 <li><a href="#key_extractors"><code>Key Extractor</code></a>
551 from any <a href="#chained_pointers">chained pointer</a>
552 to <code>Class</code>.</li>
553</ul>
554</p>
555
556<h4><code>mem_fun</code> members</h4>
557
558<code>template&lt;typename ChainedPtr> Type operator()(const ChainedPtr&amp; x)const;</code>
559
560<blockquote>
561<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
562type to <code>Type</code>.<br>
563<b>Returns:</b> <code>(y.*PtrToMemberFunction)()</code>, where <code>y</code> is the
564object chained-pointed to by <code>x</code>.
565</blockquote>
566
567<code>Type operator()(Class&amp; x)const;</code>
568
569<blockquote>
570<b>Returns:</b> <code>(x.*PtrToMemberFunction)()</code>.
571</blockquote>
572
573<code>Type operator()(const reference_wrapper&lt;Class>&amp; x)const;</code>
574
575<blockquote>
576<b>Returns:</b> <code>(x.get().*PtrToMemberFunction)()</code>.
577</blockquote>
578
579<h3><a name="const_mem_fun_explicit">Class templates <code>const_mem_fun_explicit</code> and <code>mem_fun_explicit</code></a></h3>
580
581<p>
582These extractors were provided as a workaround for MSVC++ 6.0 and are now deprecated.
583Refer to a
584<a href="http://www.boost.org/doc/libs/1_54_0/libs/multi_index/doc/reference/key_extraction.html#const_mem_fun_explicit">former version</a>
585of Boost.MultiIndex for further information.
586</p>
587
588<h3><a name="boost_multi_index_const_mem_fun">Macros
589<code>BOOST_MULTI_INDEX_CONST_MEM_FUN</code>
590and <code>BOOST_MULTI_INDEX_MEM_FUN</code></a></h3>
591
592<blockquote><pre>
593<span class=identifier>BOOST_MULTI_INDEX_CONST_MEM_FUN</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>Type</span><span class=special>,</span><span class=identifier>MemberFunName</span><span class=special>)</span>
594<span class=identifier>BOOST_MULTI_INDEX_MEM_FUN</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>Type</span><span class=special>,</span><span class=identifier>MemberFunName</span><span class=special>)</span>
595</pre></blockquote>
596
597<p>
598Portability macros for usage of <code>const_mem_fun</code> and <code>mem_fun</code>.
599Although no longer needed in modern compilers, some users might still decide to
600resort to them as they provide a slightly more concise syntax.
601</p>
602
603<h2>
604<a name="global_fun_synopsis">Header
605<a href="../../../../boost/multi_index/global_fun.hpp">
606<code>"boost/multi_index/global_fun.hpp"</code></a> synopsis</a></h2>
607
608<blockquote><pre>
609<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
610
611<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
612
613<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>class</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=special>(*</span><span class=identifier>PtrToFunction</span><span class=special>)(</span><span class=identifier>Value</span><span class=special>)&gt;</span>
614<span class=keyword>struct</span> <span class=identifier>global_fun</span><span class=special>;</span>
615
616<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
617
618<span class=special>}</span> <span class=comment>// namespace boost</span>
619</pre></blockquote>
620
621<h3><a name="global_fun">Class template <code>global_fun</code></a></h3>
622
623<p>
624<code>global_fun</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
625based on a given global or static member function accepting the base type as argument
626and returning the associated key.
627</p>
628
629<blockquote><pre>
630<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>class</span> <span class=identifier>Value</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>,</span><span class=identifier>Type</span> <span class=special>(*</span><span class=identifier>PtrToFunction</span><span class=special>)(</span><span class=identifier>Value</span><span class=special>)&gt;</span>
631<span class=keyword>struct</span> <span class=identifier>global_fun</span>
632<span class=special>{</span>
633 <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>remove_reference</span><span class=special>&lt;</span><span class=identifier>Type</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=identifier>result_type</span><span class=special>;</span>
634
635 <span class=comment>// Only provided under the following circumstances:
636 // - If Value is a reference to a constant type, only provided
637 // when const ChainedPtr&amp; is not convertible to Value;
638 // - if Value is a reference to a non-const type, only provided
639 // when ChainedPtr&amp; is not convertible to Value;
640 // - else, only provided when const ChainedPtr&amp; is not
641 // convertible to const Value&amp;.</span>
642 <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
643
644 <span class=comment>// only provided if Value is a reference type</span>
645 <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=identifier>Value</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
646
647 <span class=comment>// only provided if Value is not a reference type</span>
648 <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
649
650 <span class=comment>// only provided if Value is not a reference type</span>
651 <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span><span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
652
653 <span class=comment>// only provided if Value is a reference type</span>
654 <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span>
655 <span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span>
656 <span class=identifier>remove_reference</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
657
658 <span class=comment>// only provided if Value is not a reference type or is
659 // a reference to a constant type</span>
660 <span class=identifier>Type</span> <span class=keyword>operator</span><span class=special>()(</span>
661 <span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span>
662 <span class=keyword>typename</span> <span class=identifier>remove_const</span><span class=special>&lt;</span>
663 <span class=keyword>typename</span> <span class=identifier>remove_reference</span><span class=special>&lt;</span><span class=identifier>Value</span><span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&gt;::</span><span class=identifier>type</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
664<span class=special>};</span>
665</pre></blockquote>
666
667<p>
668<code>PtrToFunction</code> specifies the particular function used to extract
669the key of type <code>Type</code> from some <code>BaseType</code>.
670<code>global_fun</code> supports the following function signatures:
671<ul>
672 <li><code>Type f(BaseType)</code> (<code>Value</code> is <code>BaseType</code>),</li>
673 <li><code>Type f(const BaseType&amp;)</code> (<code>Value</code> is <code>const BaseType&amp;</code>),</li>
674 <li><code>Type f(BaseType&amp;)</code> (<code>Value</code> is <code>BaseType&amp;</code>).</li>
675</ul>
676<code>global_fun&lt;Type,Value,PtrToFunction&gt;</code> is a model of:
677<ul>
678 <li><a href="#key_extractors"><code>Key Extractor</code></a>
679 from <code>reference_wrapper&lt;BaseType></code>,</li>
680 <li><a href="#key_extractors"><code>Key Extractor</code></a>
681 from any <a href="#chained_pointers">chained pointer</a>
682 to <code>BaseType</code>.</li>
683</ul>
684When <code>Value</code> is <code>BaseType</code> or
685<code>const BaseType&amp;</code>,
686<code>global_fun&lt;Type,Value,PtrToFunction&gt;</code> is also a model of:
687<ul>
688 <li><a href="#key_extractors"><code>Key Extractor</code></a>
689 from <code>BaseType</code>,</li>
690 <li><a href="#key_extractors"><code>Key Extractor</code></a>
691 from <code>reference_wrapper&lt;const BaseType></code>,</li>
692 <li><a href="#key_extractors"><code>Key Extractor</code></a>
693 from any <a href="#chained_pointers">chained pointer</a>
694 to <code>const BaseType</code>.</li>
695</ul>
696</p>
697
698<h4><code>global_fun</code> members</h4>
699
700<code>template&lt;typename ChainedPtr> Type operator()(const ChainedPtr&amp; x)const;</code>
701
702<blockquote>
703<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
704type to <code>Value</code>.<br>
705<b>Returns:</b> <code>PtrToFunction)(y)</code>, where <code>y</code> is the
706object chained-pointed to by <code>x</code>.
707</blockquote>
708
709<code>Type operator()(Value x)const;</code>
710
711<blockquote>
712<b>Returns:</b> <code>PtrToFunction(x)</code>.
713</blockquote>
714
715<code>Type operator()(const Value&amp; x)const;</code>
716
717<blockquote>
718<b>Returns:</b> <code>PtrToFunction(x)</code>.
719</blockquote>
720
721<code>Type operator()(const reference_wrapper&lt;const Value&gt;&amp; x)const;</code>
722
723<blockquote>
724<b>Returns:</b> <code>PtrToFunction(x.get())</code>.
725</blockquote>
726
727<code>
728Type operator()(<br>
729&nbsp;&nbsp;const reference_wrapper&lt;remove_reference&lt;Value&gt;::type&gt;&amp; x)const;</code>
730
731<blockquote>
732<b>Returns:</b> <code>PtrToFunction(x.get())</code>.
733</blockquote>
734
735<code>Type operator()(<br>
736&nbsp;&nbsp;const reference_wrapper&lt;<br>
737&nbsp;&nbsp;&nbsp;&nbsp;typename remove_const&lt;<br>
738&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;typename remove_reference&lt;Value&gt;::type&gt;::type&gt;&amp; x)const;</code>
739
740<blockquote>
741<b>Returns:</b> <code>PtrToFunction(x.get())</code>.
742</blockquote>
743
744<h2>
745<a name="composite_key_synopsis">Header
746<a href="../../../../boost/multi_index/composite_key.hpp">
747<code>"boost/multi_index/composite_key.hpp"</code></a> synopsis</a></h2>
748
749<blockquote><pre>
750<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
751
752<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
753
754<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>KeyFromValue0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>KeyFromValuen</span><span class=special>&gt;</span>
755<span class=keyword>struct</span> <span class=identifier>composite_key</span><span class=special>;</span>
756
757<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
758<span class=keyword>struct</span> <span class=identifier>composite_key_result</span><span class=special>;</span>
759
760<span class=comment>// comparison operators for composite_key_result:</span>
761
762<span class=comment>// <b>OP</b> is any of ==,&lt;,!=,&gt;,&gt;=,&lt;=</span>
763
764<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>&gt;</span>
765<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
766 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey1</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
767 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey2</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
768
769<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
770<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
771 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
772 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
773
774<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
775<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
776 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
777 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
778
779<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>&gt;</span>
780<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
781 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
782 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
783
784<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
785<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
786 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
787 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
788
789<span class=comment>// equality functors:</span>
790
791<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Pred0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Predn</span><span class=special>&gt;</span>
792<span class=keyword>struct</span> <span class=identifier>composite_key_equal_to</span><span class=special>;</span>
793
794<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKeyResult</span><span class=special>&gt;</span>
795<span class=keyword>struct</span> <span class=identifier>composite_key_result_equal_to</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
796
797<span class=comment>// comparison functors:</span>
798
799<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Compare0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Comparen</span><span class=special>&gt;</span>
800<span class=keyword>struct</span> <span class=identifier>composite_key_compare</span><span class=special>;</span>
801
802<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKeyResult</span><span class=special>&gt;</span>
803<span class=keyword>struct</span> <span class=identifier>composite_key_result_less</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
804
805<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKeyResult</span><span class=special>&gt;</span>
806<span class=keyword>struct</span> <span class=identifier>composite_key_result_greater</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
807
808<span class=comment>// hash functors:</span>
809
810<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Hash0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Hashn</span><span class=special>&gt;</span>
811<span class=keyword>struct</span> <span class=identifier>composite_key_hash</span><span class=special>;</span>
812
813<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKeyResult</span><span class=special>&gt;</span>
814<span class=keyword>struct</span> <span class=identifier>composite_key_result_hash</span><span class=special>;</span> <span class=comment><b>// deprecated</b></span>
815
816<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
817
818<span class=special>}</span> <span class=comment>// namespace boost</span>
819
820<span class=comment>// specializations of external functors for composite_key_result:</span>
821
822<span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
823
824<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
825<span class=keyword>struct</span> <span class=identifier>equal_to</span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;</span> <span class=special>&gt;;</span>
826
827<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
828<span class=keyword>struct</span> <span class=identifier>less</span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;</span> <span class=special>&gt;;</span>
829
830<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
831<span class=keyword>struct</span> <span class=identifier>greater</span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;</span> <span class=special>&gt;;</span>
832
833<span class=special>}</span> <span class=comment>// namespace std</span>
834
835<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
836
837<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
838<span class=keyword>struct</span> <span class=identifier>hash</span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;</span> <span class=special>&gt;;</span>
839
840<span class=special>}</span> <span class=comment>// namespace boost</span>
841</pre></blockquote>
842
843<h3><a name="composite_key">Class template <code>composite_key</code></a></h3>
844
845<p>
846<code>composite_key</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
847returning the combined value of several key extractors whose type is specified
848at compile time. The returned object is of type
849<a href="#composite_key_result">
850<code>composite_key_result</code></a><code>&lt;composite_key></code>.
851</p>
852
853<blockquote><pre>
854<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>KeyFromValue0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>KeyFromValuen</span><span class=special>&gt;</span>
855<span class=keyword>struct</span> <span class=identifier>composite_key</span>
856<span class=special>{</span>
857 <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>KeyFromValue0</span><span class=special>,...,</span><span class=identifier>KeyFromValuen</span><span class=special>&gt;</span> <span class=identifier>key_extractor_tuple</span><span class=special>;</span>
858 <span class=keyword>typedef</span> <span class=identifier>Value</span> <span class=identifier>value_type</span><span class=special>;</span>
859 <span class=keyword>typedef</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>composite_key</span><span class=special>&gt;</span> <span class=identifier>result_type</span><span class=special>;</span>
860
861 <span class=identifier>composite_key</span><span class=special>(</span>
862 <span class=keyword>const</span> <span class=identifier>KeyFromValue0</span><span class=special>&amp;</span> <span class=identifier>k0</span><span class=special>=</span><span class=identifier>KeyFromValue0</span><span class=special>(),</span>
863 <span class=special>...</span>
864 <span class=keyword>const</span> <span class=identifier>KeyFromValuen</span><span class=special>&amp;</span> <span class=identifier>kn</span><span class=special>=</span><span class=identifier>KeyFromValuen</span><span class=special>());</span>
865
866 <span class=identifier>composite_key</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>key_extractor_tuple</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
867
868 <span class=keyword>const</span> <span class=identifier>key_extractor_tuple</span><span class=special>&amp;</span> <span class=identifier>key_extractors</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
869 <span class=identifier>key_extractor_tuple</span><span class=special>&amp;</span> <span class=identifier>key_extractors</span><span class=special>()</span>
870
871 <span class=comment>// only provided if const ChainedPtr&amp; is not convertible to const value_type&amp;</span>
872 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ChainedPtr</span><span class=special>&gt;</span>
873 <span class=identifier>result_type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>ChainedPtr</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
874
875 <span class=identifier>result_type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
876 <span class=identifier>result_type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
877 <span class=identifier>result_type</span> <span class=keyword>operator</span><span class=special>()(</span><span class=keyword>const</span> <span class=identifier>reference_wrapper</span><span class=special>&lt;</span><span class=identifier>value_type</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
878<span class=special>};</span>
879</pre></blockquote>
880
881<p>
882<code>KeyFromValue0</code>, ... , <code>KeyFromValuen</code> are the types of
883the key extractors combined into the composite key. Each of these types
884must be a <a href="#key_extractors"><code>Key Extractor</code></a> from
885<code>Value</code>. At least a key extractor must be provided. The maximum
886number of key extractors of a <code>composite_key</code> instantiation is
887implementation defined. <code>composite_key</code> internally stores an
888object of every constituent key extractor type.
889<code>composite_key&lt;Value,KeyFromValue0,...,KeyFromValuen></code> is a model
890of:
891<ul>
892 <li><a href="#key_extractors"><code>Key Extractor</code></a>
893 from <code>Value</code>,</li>
894 <li><a href="#key_extractors"><code>Key Extractor</code></a>
895 from <code>reference_wrapper&lt;const Value></code>,</li>
896 <li><a href="#key_extractors"><code>Key Extractor</code></a>
897 from <code>reference_wrapper&lt;Value></code>,</li>
898 <li><a href="#key_extractors"><code>Key Extractor</code></a>
899 from any <a href="#chained_pointers">chained pointer</a>
900 to <code>const Value</code>,</li>
901 <li><a href="#key_extractors"><code>Key Extractor</code></a>
902 from any <a href="#chained_pointers">chained pointer</a>
903 to <code>Value</code>.</li>
904</ul>
905</p>
906
907<h4><code>composite_key</code> members</h4>
908
909<code>composite_key(<br>
910&nbsp;&nbsp;const KeyFromValue0&amp; k0=KeyFromValue0(),<br>
911&nbsp;&nbsp;...<br>
912&nbsp;&nbsp;const KeyFromValuen&amp; kn=KeyFromValuen());
913</code>
914
915<blockquote>
916<b>Effects:</b> Constructs a <code>composite_key</code> that stores
917copies of the key extractor objects supplied.
918</blockquote>
919
920<code>composite_key(const key_extractor_tuple&amp; x);</code>
921
922<blockquote>
923<b>Effects:</b> Constructs a <code>composite_key</code> that stores
924copies of the key extractor objects supplied in <code>x</code>.
925</blockquote>
926
927<code>const key_extractor_tuple&amp; key_extractors()const;</code>
928
929<blockquote>
930<b>Returns:</b> a constant reference to a tuple holding the
931key extractors internally stored by the <code>composite_key</code>.
932</blockquote>
933
934<code>key_extractor_tuple&amp; key_extractors();</code>
935
936<blockquote>
937<b>Returns:</b> a reference to a tuple holding the
938key extractors internally stored by the <code>composite_key</code>.
939</blockquote>
940
941<code>template&lt;typename ChainedPtr><br>
942result_type operator()(const ChainedPtr&amp; x)const;</code>
943
944<blockquote>
945<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
946type to <code>result_type</code>.<br>
947<b>Returns:</b> a <code>result_type</code> object dependent on
948<code>*this</code> and <code>y</code>, where <code>y</code> is the
949object chained-pointed to by <code>x</code>.
950</blockquote>
951
952<code>result_type operator()(const value_type&amp; x)const;</code>
953
954<blockquote>
955<b>Returns:</b> a <code>result_type</code> object dependent on
956<code>*this</code> and <code>x</code>.
957</blockquote>
958
959<code>result_type operator()(const reference_wrapper&lt;const value_type>&amp; x)const;</code>
960
961<blockquote>
962<b>Returns:</b> a <code>result_type</code> object dependent on
963<code>*this</code> and <code>x.get()</code>.
964</blockquote>
965
966<code>result_type operator()(const reference_wrapper&lt;value_type>&amp; x)const;</code>
967
968<blockquote>
969<b>Returns:</b> a <code>result_type</code> object dependent on
970<code>*this</code> and <code>x.get()</code>.
971</blockquote>
972
973<h3><a name="composite_key_result">Class template
974<code>composite_key_result</code></a></h3>
975
976<p>
977This is an opaque type returned by <code>composite_key</code>
978instantiations as their extracted key.
979</p>
980
981<blockquote><pre>
982<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
983<span class=keyword>struct</span> <span class=identifier>composite_key_result</span>
984<span class=special>{</span>
985 <b>no public interface available</b>
986<span class=special>};</span>
987
988<span class=comment>// comparison:</span>
989
990<span class=comment>// <b>OP</b> is any of ==,&lt;,!=,&gt;,&gt;=,&lt;=</span>
991
992<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>&gt;</span>
993<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
994 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey1</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
995 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey2</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
996
997<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
998<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
999 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1000 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
1001
1002<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1003<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
1004 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1005 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
1006
1007<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>&gt;</span>
1008<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
1009 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1010 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
1011
1012<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
1013<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
1014 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1015 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
1016</pre></blockquote>
1017
1018<code>CompositeKey</code> is the <code>composite_key</code> instantiation to
1019which the <code>composite_key_result</code> type is associated. Objects of type
1020<code>composite_key_result</code> returned by a composite key must be always treated
1021as <i>temporary</i>, i.e. they should not be stored or copied.
1022<code>composite_key_result</code> is <i>not</i> guaranteed to be
1023<code>DefaultConstructible</code> or <code>CopyAssignable</code>.
1024Every object of type <code>composite_key_result&lt;CompositeKey></code> is
1025internally associated to the <code>CompositeKey</code> from which it is returned
1026and the object of type <code>CompositeKey::value_type</code> to which the
1027composite key was applied.
1028</p>
1029
1030<h4><a name="ckey_result_notation">Notation</a></h4>
1031
1032<p>
1033Given an <code>x</code> of type <code>composite_key_result&lt;CompositeKey></code>,
1034we use the following notation:
1035<ul>
1036 <li><code>ck(x)</code> is the <code>CompositeKey</code> object associated to
1037 <code>x</code>,</li>
1038 <li><code>v(x)</code> is the object of type <code>CompositeKey::value_type</code>
1039 associated to <code>x</code>,</li>
1040 <li><code>k<sub>i</sub>(x) = ck(x).key_extractors().get&lt;i>()</code>,
1041 that is, is the <code>i</code>-th key extractor of <code>ck(x)</code>,</li>
1042 <li><code>x<sub>i</sub> = k<sub>i</sub>(x)(v(x))</code>, that is, the
1043 key extracted from <code>v(x)</code> by the <code>i</code>-th key extractor,</li>
1044 <li><code>length(x)</code> is the number of key extractors of <code>ck(x)</code>.</li>
1045</ul>
1046Also, if <code>y</code> is an <code>std::tuple</code> or <code>boost::tuple</code> of values, we define:
1047<ul>
1048 <li><code>y<sub>i</sub>=get&lt;i>(y)</code>,</li>
1049 <li><code>length(y)</code> is the number of elements of <code>y</code>.</li>
1050</ul>
1051</p>
1052
1053<h4>Comparison operators</h4>
1054
1055<code>template&lt;typename CompositeKey1,typename CompositeKey2><br>
1056bool operator==(<br>
1057&nbsp;&nbsp;const composite_key_result&lt;CompositeKey1>&amp; x,<br>
1058&nbsp;&nbsp;const composite_key_result&lt;CompositeKey2>&amp; y);<br>
1059template&lt;typename CompositeKey,typename... Values><br>
1060bool operator==(<br>
1061&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; x,<br>
1062&nbsp;&nbsp;const std::tuple&lt;Values...>&amp; y);<br>
1063template&lt;typename CompositeKey,typename... Values><br>
1064bool operator==(<br>
1065&nbsp;&nbsp;const std::tuple&lt;Values...>&amp; x,<br>
1066&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; y);<br>
1067template&lt;typename CompositeKey,typename Value0,...,typename Valuen><br>
1068bool operator==(<br>
1069&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; x,<br>
1070&nbsp;&nbsp;const boost::tuple&lt;Value0,...,Valuen>&amp; y);<br>
1071template&lt;typename Value0,...,typename Valuen,typename CompositeKey><br>
1072bool operator==(<br>
1073&nbsp;&nbsp;const boost::tuple&lt;Value0,...,Valuen>&amp; x,<br>
1074&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; y);
1075</code>
1076
1077<blockquote>
1078<b>Requires:</b> <code>length(x)==length(y)</code>. The expression
1079<code>x<sub>i</sub>==y<sub>i</sub></code> is valid for all <code>i</code>
1080in <code>[0,length(x))</code>.<br>
1081<b>Returns:</b> <code>true</code> if and only if
1082<blockquote>
1083<code>x<sub>i</sub>==y<sub>i</sub></code> for all <code>i</code>
1084in <code>[0,length(x))</code>.
1085</blockquote>
1086<b>Complexity:</b> No more key extraction operations and comparisons
1087are performed than those necessary for the evaluation of the expression above,
1088starting at <code>i==0</code>. The evaluation is short-circuited as soon as
1089the result is determined to be <code>false</code>.
1090</blockquote>
1091
1092<code>template&lt;typename CompositeKey1,typename CompositeKey2><br>
1093bool operator<(<br>
1094&nbsp;&nbsp;const composite_key_result&lt;CompositeKey1>&amp; x,<br>
1095&nbsp;&nbsp;const composite_key_result&lt;CompositeKey2>&amp; y);<br>
1096template&lt;typename CompositeKey,typename... Values><br>
1097bool operator<(<br>
1098&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; x,<br>
1099&nbsp;&nbsp;const std::tuple&lt;Values...>&amp; y);<br>
1100template&lt;typename CompositeKey,typename... Values><br>
1101bool operator<(<br>
1102&nbsp;&nbsp;const std::tuple&lt;Values...>&amp; x,<br>
1103&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; y);<br>
1104template&lt;typename CompositeKey,typename Value0,...,typename Valuen><br>
1105bool operator<(<br>
1106&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; x,<br>
1107&nbsp;&nbsp;const boost::tuple&lt;Value0,...,Valuen>&amp; y);<br>
1108template&lt;typename Value0,...,typename Valuen,typename CompositeKey><br>
1109bool operator<(<br>
1110&nbsp;&nbsp;const boost::tuple&lt;Value0,...,Valuen>&amp; x,<br>
1111&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; y);
1112</code>
1113
1114<blockquote>
1115<b>Requires:</b> The expressions
1116<code>x<sub>i</sub>&lt;y<sub>i</sub></code> and
1117<code>y<sub>i</sub>&lt;x<sub>i</sub></code> are valid for all <code>i</code>
1118in <code>[0,min(length(x),length(y)))</code>.<br>
1119<b>Returns:</b> <code>true</code> if and only if there exists some
1120<code>j</code> in the range <code>[0,min(length(x),length(y)))</code>
1121such that
1122<blockquote>
1123<code>!(x<sub>i</sub>&lt;y<sub>i</sub>) &amp;&amp; !(y<sub>i</sub>&lt;x<sub>i</sub>)</code>
1124for all <code>i</code> in <code>[0,j)</code>,<br>
1125<code>&nbsp;&nbsp;x<sub>j</sub>&lt;y<sub>j</sub></code>.
1126</blockquote>
1127<b>Complexity:</b> No more key extraction operations and comparisons
1128are performed than those necessary for the evaluation of the expression above,
1129starting at <code>i==0</code>. The evaluation is short-circuited as soon as
1130the result is determined to be <code>false</code>.
1131</blockquote>
1132
1133<code>template&lt;typename CompositeKey1,typename CompositeKey2><br>
1134bool operator <b><i>OP</i></b>(<br>
1135&nbsp;&nbsp;const composite_key_result&lt;CompositeKey1>&amp; x,<br>
1136&nbsp;&nbsp;const composite_key_result&lt;CompositeKey2>&amp; y);<br>
1137template&lt;typename CompositeKey,typename... Values><br>
1138bool operator <b><i>OP</i></b>(<br>
1139&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; x,<br>
1140&nbsp;&nbsp;const std::tuple&lt;Values...>&amp; y);<br>
1141template&lt;typename CompositeKey,typename... Values><br>
1142bool operator <b><i>OP</i></b>(<br>
1143&nbsp;&nbsp;const std::tuple&lt;Values...>&amp; x,<br>
1144&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; y);<br>
1145template&lt;typename CompositeKey,typename Value0,...,typename Valuen><br>
1146bool operator <b><i>OP</i></b>(<br>
1147&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; x,<br>
1148&nbsp;&nbsp;const boost::tuple&lt;Value0,...,Valuen>&amp; y);<br>
1149template&lt;typename Value0,...,typename Valuen,typename CompositeKey><br>
1150bool operator <b><i>OP</i></b>(<br>
1151&nbsp;&nbsp;const boost::tuple&lt;Value0,...,Valuen>&amp; x,<br>
1152&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; y);
1153</code>
1154
1155<p>
1156(<code><b><i>OP</i></b></code> is any of <code>!=</code>, <code>></code>,
1157<code>>=</code>, <code>&lt;=</code>.)
1158</p>
1159
1160<blockquote>
1161<b>Requires:</b> The expressions given below are valid (for the particular
1162<code><b><i>OP</i></b></code> considered.)<br>
1163<b>Returns:</b> <code>true</code> if and only if
1164<blockquote>
1165<code>!(x==y)</code> (<code><b><i>OP</i></b></code> is <code>!=</code>),<br>
1166<code>&nbsp;&nbsp;y&lt;&nbsp;x&nbsp;</code> (<code><b><i>OP</i></b></code> is <code>>&nbsp;</code>),<br>
1167<code>!(x&lt;&nbsp;y)</code> (<code><b><i>OP</i></b></code> is <code>>=</code>),<br>
1168<code>!(y&lt;&nbsp;x)</code> (<code><b><i>OP</i></b></code> is <code>&lt;=</code>).
1169</blockquote>
1170</blockquote>
1171
1172<h3><a name="ckey_result_equality">Equality</a></h3>
1173
1174<h4><a name="composite_key_equal_to">Class template
1175<code>composite_key_equal_to</code></a></h4>
1176
1177<p>
1178<code>composite_key_equal_to</code> tests for equality between
1179<code>composite_key_result</code> instantiations and between
1180these and tuples of values, using an internally stored
1181collection of elementary equality predicates.
1182</p>
1183
1184<blockquote><pre>
1185<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Pred0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Predn</span><span class=special>&gt;</span>
1186<span class=keyword>struct</span> <span class=identifier>composite_key_equal_to</span>
1187<span class=special>{</span>
1188 <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Pred0</span><span class=special>,...,</span><span class=identifier>Predn</span><span class=special>&gt;</span> <span class=identifier>key_eq_tuple</span><span class=special>;</span>
1189
1190 <span class=identifier>composite_key_equal_to</span><span class=special>(</span>
1191 <span class=keyword>const</span> <span class=identifier>Pred0</span><span class=special>&amp;</span> <span class=identifier>p0</span><span class=special>=</span><span class=identifier>Pred0</span><span class=special>(),</span>
1192 <span class=special>...</span>
1193 <span class=keyword>const</span> <span class=identifier>Predn</span><span class=special>&amp;</span> <span class=identifier>pn</span><span class=special>=</span><span class=identifier>Predn</span><span class=special>());</span>
1194
1195 <span class=identifier>composite_key_equal_to</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>key_eq_tuple</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
1196
1197 <span class=keyword>const</span> <span class=identifier>key_eq_tuple</span><span class=special>&amp;</span> <span class=identifier>key_eqs</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
1198 <span class=identifier>key_eq_tuple</span><span class=special>&amp;</span> <span class=identifier>key_eqs</span><span class=special>()</span><span class=special>;</span>
1199
1200 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>&gt;</span>
1201 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1202 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey1</span><span class=special>&gt;</span> <span class=special>&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1203 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey2</span><span class=special>&gt;</span> <span class=special>&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1204
1205 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1206 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1207 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1208 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1209
1210 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1211 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1212 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1213 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1214
1215 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>&gt;</span>
1216 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1217 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1218 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1219
1220 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
1221 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1222 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1223 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1224<span class=special>};</span>
1225</pre></blockquote>
1226
1227<p>
1228<code>Pred0</code>, ... , <code>Predn</code> are the types of the equality
1229binary predicates stored by <code>composite_key_equal_to</code>. Each of these predicates
1230must be <code>CopyConstructible</code> and <code>CopyAssignable</code>. At least an
1231equality predicate must be provided. The maximum number of equality predicates of
1232a <code>composite_key_equal_to</code> instantiation is implementation defined.
1233<code>composite_key_equal_to</code> is
1234<code>CopyConstructible</code> and <code>CopyAssignable</code>.
1235It is also <code>DefaultConstructible</code>
1236if each <code>Predi</code> is <code>DefaultConstructible</code> in its turn.
1237</p>
1238
1239<p>
1240Note that formally it is not required that the <code>Predi</code> types
1241behave as equality predicates in any definite way. However, the
1242semantics of <code>composite_key_equal_to</code> is well defined if this
1243is the case, as explained in the section on the
1244<a href="#ckey_result_semantics">semantics of <code>composite_key_result</code></a>.
1245</p>
1246
1247<h4>Notation</h4>
1248
1249<p>
1250In what follows we use the same <a href="#ckey_result_notation">notation</a>
1251introduced for <code>composite_key_result</code>.
1252
1253<h4><code>composite_key_equal_to</code> members</h4>
1254
1255<code>composite_key_equal_to(<br>
1256&nbsp;&nbsp;const Pred0&amp; p0=Pred0(),<br>
1257&nbsp;&nbsp;...<br>
1258&nbsp;&nbsp;const Predn&amp; pn=Predn());
1259</code>
1260
1261<blockquote>
1262<b>Effects:</b> Constructs a <code>composite_key_equal_to</code> that stores
1263copies of the equality predicates supplied.
1264</blockquote>
1265
1266<code>composite_key_equal_to(const key_eq_tuple&amp; x);</code>
1267
1268<blockquote>
1269<b>Effects:</b> Constructs a <code>composite_key_equal_to</code> that stores
1270copies of the equality predicate objects supplied in <code>x</code>.
1271</blockquote>
1272
1273<code>const key_eq_tuple&amp; key_eqs()const;</code>
1274
1275<blockquote>
1276<b>Returns:</b> a constant reference to a tuple holding the
1277equality predicate objects internally stored by the
1278<code>composite_key_equal_to</code>.
1279</blockquote>
1280
1281<code>key_eq_tuple&amp; key_eqs();</code>
1282
1283<blockquote>
1284<b>Returns:</b> a reference to a tuple holding the
1285equality predicate objects internally stored by the
1286<code>composite_key_equal_to</code>.
1287</blockquote>
1288
1289<code>
1290template&lt;typename CompositeKey1,typename CompositeKey2><br>
1291bool operator()(<br>
1292&nbsp;&nbsp;const composite_key_result&lt;CompositeKey1> &amp; x,<br>
1293&nbsp;&nbsp;const composite_key_result&lt;CompositeKey2> &amp; y)const;<br>
1294template&lt;typename CompositeKey,typename Values...><br>
1295bool operator()(<br>
1296&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; x,<br>
1297&nbsp;&nbsp;const std::tuple&lt;Values...>&amp; y)const;<br>
1298template&lt;typename CompositeKey,typename Values...><br>
1299bool operator()(<br>
1300&nbsp;&nbsp;const std::tuple&lt;Values...>&amp; x,<br>
1301&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; y)const;<br>
1302template&lt;typename CompositeKey,typename Value0,...,typename Valuen><br>
1303bool operator()(<br>
1304&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; x,<br>
1305&nbsp;&nbsp;const boost::tuple&lt;Value0,...,Valuen>&amp; y)const;<br>
1306template&lt;typename Value0,...,typename Valuen,typename CompositeKey><br>
1307bool operator()(<br>
1308&nbsp;&nbsp;const boost::tuple&lt;Value0,...,Valuen>&amp; x,<br>
1309&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; y)const;<br>
1310</code>
1311
1312<blockquote>
1313<b>Requires:</b> <code>length(x)==length(y)</code>. The expressions
1314<code>key_eqs().get&lt;i>()(x<sub>i</sub>,y<sub>i</sub>)</code> and
1315<code>key_eqs().get&lt;i>()(y<sub>i</sub>,x<sub>i</sub>)</code>
1316are valid for all <code>i</code> in <code>[0,length(x))</code>.<br>
1317<b>Returns:</b> <code>true</code> if and only
1318<blockquote>
1319<code>key_eqs().get&lt;i>()(x<sub>i</sub>,y<sub>i</sub>)</code>
1320for all <code>i</code> in <code>[0,length(x))</code>.<br>
1321</blockquote>
1322<b>Complexity:</b> No more key extraction operations and comparisons
1323are performed than those necessary for the evaluation of the expression above,
1324starting at <code>i==0</code>. The evaluation is short-circuited as soon as
1325the result is determined to be <code>false</code>.
1326</blockquote>
1327
1328<h4><a name="composite_key_result_equal_to">Class template
1329<code>composite_key_result_equal_to</code></a></h4>
1330
1331<p>
1332Deprecated. Use <code>std::equal_to&lt;CompositeKeyResult&gt;</code> instead.
1333</p>
1334
1335<h4><a name="equal_to_composite_key_result">Specialization of
1336<code>std::equal_to</code> for <code>composite_key</code> results</a></h4>
1337
1338<p>
1339<code>std::equal_to&lt;CompositeKeyResult></code>, with <code>CompositeKeyResult</code>
1340an instantiation of <code>composite_key_result</code>,
1341behaves as a particularization of
1342<code>composite_key_equal_to</code> where all the comparison predicates supplied
1343are instantiations of <code>std::equal_to</code>.
1344</p>
1345
1346<blockquote><pre>
1347<span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
1348
1349<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
1350<span class=keyword>struct</span> <span class=identifier>equal_to</span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;</span> <span class=special>&gt;</span>
1351<span class=special>{</span>
1352 <span class=keyword>typedef</span>
1353 <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span>
1354 <span class=identifier>CompositeKey</span><span class=special>&gt;</span> <span class=identifier>first_argument_type</span><span class=special>;</span>
1355 <span class=keyword>typedef</span> <span class=identifier>first_argument_type</span> <span class=identifier>second_argument_type</span><span class=special>;</span>
1356 <span class=keyword>typedef</span> <span class=keyword>bool</span> <span class=identifier>result_type</span><span class=special>;</span>
1357
1358 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>&gt;</span>
1359 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1360 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey1</span><span class=special>&gt;</span> <span class=special>&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1361 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey2</span><span class=special>&gt;</span> <span class=special>&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1362
1363 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1364 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1365 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1366 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1367
1368 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1369 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1370 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1371 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1372
1373 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>&gt;</span>
1374 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1375 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1376 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1377
1378 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
1379 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1380 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1381 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1382<span class=special>};</span>
1383
1384<span class=special>}</span> <span class=comment>// namespace std</span>
1385</pre></blockquote>
1386
1387<p>
1388<code>CompositeKeyResult</code> must be an instantiation of
1389<code>composite_key_result</code> for some type
1390<code>composite_key&lt;KeyFromValue0,...,KeyFromValuen></code>.
1391<code>std::equal:to&lt;CompositeKeyResult>::operator()</code> is
1392then equivalent to
1393<code>composite_key_equal_to&lt;Pred0,...,Predn>::operator()</code>, taking
1394<blockquote>
1395<code>Predi = std::equal_to&lt;KeyFromValuei::result_type></code> for all
1396<code>i = 0,...,n</code>.
1397</blockquote>
1398</p>
1399
1400<p>
1401In addition to the requirements on <code>Predi</code> imposed by
1402<code>composite_key_equal_to</code>, each of these types must be
1403<code>DefaultConstructible</code>. <code>std::equal_to&lt;CompositeKeyResult></code>
1404is <code>DefaultConstructible</code>, <code>CopyConstructible</code> and
1405<code>CopyAssignable</code>.
1406</p>
1407
1408<h3><a name="ckey_result_comparison">Comparison</a></h3>
1409
1410<h4><a name="composite_key_compare">Class template
1411<code>composite_key_compare</code></a></h4>
1412
1413<p>
1414<code>composite_key_compare</code> compares <code>composite_key_result</code>
1415instantiations between them and with tuples of values using an internally stored
1416collection of elementary comparison predicates.
1417</p>
1418
1419<blockquote><pre>
1420<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Compare0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Comparen</span><span class=special>&gt;</span>
1421<span class=keyword>struct</span> <span class=identifier>composite_key_compare</span>
1422<span class=special>{</span>
1423 <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Compare0</span><span class=special>,...,</span><span class=identifier>Comparen</span><span class=special>&gt;</span> <span class=identifier>key_comp_tuple</span><span class=special>;</span>
1424
1425 <span class=identifier>composite_key_compare</span><span class=special>(</span>
1426 <span class=keyword>const</span> <span class=identifier>Compare0</span><span class=special>&amp;</span> <span class=identifier>c0</span><span class=special>=</span><span class=identifier>Compare0</span><span class=special>(),</span>
1427 <span class=special>...</span>
1428 <span class=keyword>const</span> <span class=identifier>Comparen</span><span class=special>&amp;</span> <span class=identifier>cn</span><span class=special>=</span><span class=identifier>Comparen</span><span class=special>());</span>
1429
1430 <span class=identifier>composite_key_compare</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>key_comp_tuple</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
1431
1432 <span class=keyword>const</span> <span class=identifier>key_comp_tuple</span><span class=special>&amp;</span> <span class=identifier>key_comps</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
1433 <span class=identifier>key_comp_tuple</span><span class=special>&amp;</span> <span class=identifier>key_comps</span><span class=special>()</span><span class=special>;</span>
1434
1435 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>&gt;</span>
1436 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1437 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey1</span><span class=special>&gt;</span> <span class=special>&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1438 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey2</span><span class=special>&gt;</span> <span class=special>&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1439
1440 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1441 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1442 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1443 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1444
1445 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1446 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1447 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1448 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1449
1450 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>&gt;</span>
1451 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1452 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1453 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1454
1455 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
1456 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1457 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1458 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1459
1460 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>&gt;</span>
1461 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1462 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1463
1464 <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>CompositeKey</span><span class=special>&gt;</span>
1465 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1466 <span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1467<span class=special>};</span>
1468</pre></blockquote>
1469
1470<p>
1471<code>Compare0</code>, ... , <code>Comparen</code> are the types of the comparison
1472binary predicates stored by <code>composite_key_compare</code>. Each of these predicates must be
1473<code>CopyConstructible</code> and <code>CopyAssignable</code>. At least a
1474comparison predicate must be provided. The maximum number of comparison predicates of
1475a <code>composite_key_compare</code> instantiation is implementation defined.
1476<code>composite_key_compare</code> is
1477<code>CopyConstructible</code> and <code>CopyAssignable</code>.
1478It is also
1479<code>DefaultConstructible</code>
1480if each <code>Comparei</code> is <code>DefaultConstructible</code> in its turn.
1481</p>
1482
1483<p>
1484Note that formally it is not required that the <code>Comparei</code> types
1485behave as comparison predicates in any definite way. However, the
1486semantics of <code>composite_key_compare</code> is well defined if this
1487is the case, as explained in the section on the
1488<a href="#ckey_result_semantics">semantics of <code>composite_key_result</code></a>.
1489</p>
1490
1491<h4>Notation</h4>
1492
1493<p>
1494In what follows we use the same <a href="#ckey_result_notation">notation</a>
1495introduced for <code>composite_key_result</code>.
1496
1497<h4><code>composite_key_compare</code> members</h4>
1498
1499<code>composite_key_compare(<br>
1500&nbsp;&nbsp;const Compare0&amp; c0=Compare0(),<br>
1501&nbsp;&nbsp;...<br>
1502&nbsp;&nbsp;const Comparen&amp; cn=Comparen());
1503</code>
1504
1505<blockquote>
1506<b>Effects:</b> Constructs a <code>composite_key_compare</code> that stores
1507copies of the comparison predicates supplied.
1508</blockquote>
1509
1510<code>composite_key_compare(const key_comp_tuple&amp; x);</code>
1511
1512<blockquote>
1513<b>Effects:</b> Constructs a <code>composite_key_compare</code> that stores
1514copies of the comparison predicate objects supplied in <code>x</code>.
1515</blockquote>
1516
1517<code>const key_comp_tuple&amp; key_comps()const;</code>
1518
1519<blockquote>
1520<b>Returns:</b> a constant reference to a tuple holding the
1521comparison predicate objects internally stored by the
1522<code>composite_key_compare</code>.
1523</blockquote>
1524
1525<code>key_comp_tuple&amp; key_comps();</code>
1526
1527<blockquote>
1528<b>Returns:</b> a reference to a tuple holding the
1529comparison predicate objects internally stored by the
1530<code>composite_key_compare</code>.
1531</blockquote>
1532
1533<code>
1534template&lt;typename CompositeKey1,typename CompositeKey2><br>
1535bool operator()(<br>
1536&nbsp;&nbsp;const composite_key_result&lt;CompositeKey1> &amp; x,<br>
1537&nbsp;&nbsp;const composite_key_result&lt;CompositeKey2> &amp; y)const;<br>
1538template&lt;typename CompositeKey,typename... Values><br>
1539bool operator()(<br>
1540&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; x,<br>
1541&nbsp;&nbsp;const std::tuple&lt;Values...>&amp; y)const;<br>
1542template&lt;typename CompositeKey,typename... Values><br>
1543bool operator()(<br>
1544&nbsp;&nbsp;const std::tuple&lt;Values...>&amp; x,<br>
1545&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; y)const;<br>
1546template&lt;typename CompositeKey,typename Value0,...,typename Valuen><br>
1547bool operator()(<br>
1548&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; x,<br>
1549&nbsp;&nbsp;const boost::tuple&lt;Value0,...,Valuen>&amp; y)const;<br>
1550template&lt;typename Value0,...,typename Valuen,typename CompositeKey><br>
1551bool operator()(<br>
1552&nbsp;&nbsp;const boost::tuple&lt;Value0,...,Valuen>&amp; x,<br>
1553&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; y)const;<br>
1554</code>
1555
1556<blockquote>
1557<b>Requires:</b> The expressions
1558<code>key_comps().get&lt;i>()(x<sub>i</sub>,y<sub>i</sub>)</code> and
1559<code>key_comps().get&lt;i>()(y<sub>i</sub>,x<sub>i</sub>)</code>
1560are valid for all <code>i</code>
1561in <code>[0,min(length(x),length(y)))</code>.<br>
1562<b>Returns:</b> <code>true</code> if and only if there exists some
1563<code>j</code> in the range <code>[0,min(length(x),length(y)))</code>
1564such that
1565<blockquote>
1566<code>!key_comps().get&lt;i>()(x<sub>i</sub>,y<sub>i</sub>) &amp;&amp; !key_comps().get&lt;i>()(y<sub>i</sub>,x<sub>i</sub>)</code>
1567for all <code>i</code> in <code>[0,j)</code>,<br>
1568<code>&nbsp;key_comps().get&lt;j>()(x<sub>j</sub>,y<sub>j</sub>)</code>.
1569</blockquote>
1570<b>Complexity:</b> No more key extraction operations and comparisons
1571are performed than those necessary for the evaluation of the expression above,
1572starting at <code>i==0</code>. The evaluation is short-circuited as soon as
1573the result is determined to be <code>false</code>.
1574</blockquote>
1575
1576<code>
1577template&lt;typename CompositeKey,typename Value&gt;<br>
1578bool operator()(<br>
1579&nbsp;&nbsp;const composite_key_result&lt;CompositeKey&gt;&amp; x,const Value&amp; y)const;
1580</code>
1581
1582<blockquote>
1583<b>Effects:</b>
1584<blockquote><pre>
1585<span class=keyword>return</span> <span class=keyword>operator</span><span class=special>()(</span><span class=identifier>x</span><span class=special>,</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>make_tuple</span><span class=special>(</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>cref</span><span class=special>(</span><span class=identifier>y</span><span class=special>)));</span>
1586</pre></blockquote><br>
1587</blockquote>
1588
1589<code>
1590template&lt;typename Value,typename CompositeKey&gt;<br>
1591bool operator()(<br>
1592&nbsp;&nbsp;const Value&amp; x,const composite_key_result&lt;CompositeKey&gt;&amp; y)const;
1593</code>
1594
1595<blockquote>
1596<b>Effects:</b>
1597<blockquote><pre>
1598<span class=keyword>return</span> <span class=keyword>operator</span><span class=special>()(</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>make_tuple</span><span class=special>(</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>cref</span><span class=special>(</span><span class=identifier>x</span><span class=special>)),</span><span class=identifier>y</span><span class=special>);</span>
1599</pre></blockquote><br>
1600</blockquote>
1601
1602<h4><a name="composite_key_result_less">Class template
1603<code>composite_key_result_less</code></a></h4>
1604
1605<p>
1606Deprecated. Use <code>std::less&lt;CompositeKeyResult&gt;</code> instead.
1607</p>
1608
1609<h4><a name="composite_key_result_greater">Class template
1610<code>composite_key_result_greater</code></a></h4>
1611
1612<p>
1613Deprecated. Use <code>std::greater&lt;CompositeKeyResult&gt;</code> instead.
1614</p>
1615
1616<h4><a name="less_composite_key_result">Specialization of <code>std::less</code> for
1617<code>composite_key</code> results</a></h4>
1618
1619<p>
1620<code>std::less&lt;CompositeKeyResult></code>, with <code>CompositeKeyResult</code>
1621an instantiation of <code>composite_key_result</code>, behaves as a particularization of
1622<code>composite_key_compare</code> where all the comparison predicates supplied are
1623instantiations of <code>std::less</code>.
1624</p>
1625
1626<blockquote><pre>
1627<span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
1628
1629<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
1630<span class=keyword>struct</span> <span class=identifier>less</span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;</span> <span class=special>&gt;</span>
1631<span class=special>{</span>
1632 <span class=keyword>typedef</span>
1633 <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span>
1634 <span class=identifier>CompositeKey</span><span class=special>&gt;</span> <span class=identifier>first_argument_type</span><span class=special>;</span>
1635 <span class=keyword>typedef</span> <span class=identifier>first_argument_type</span> <span class=identifier>second_argument_type</span><span class=special>;</span>
1636 <span class=keyword>typedef</span> <span class=keyword>bool</span> <span class=identifier>result_type</span><span class=special>;</span>
1637
1638 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>&gt;</span>
1639 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1640 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey1</span><span class=special>&gt;</span> <span class=special>&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1641 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey2</span><span class=special>&gt;</span> <span class=special>&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1642
1643 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1644 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1645 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1646 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1647
1648 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1649 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1650 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1651 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1652
1653 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>&gt;</span>
1654 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1655 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1656 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1657
1658 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
1659 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1660 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1661 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1662
1663 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>&gt;</span>
1664 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1665 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1666 <span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1667
1668 <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>CompositeKey</span><span class=special>&gt;</span>
1669 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1670 <span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1671 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1672<span class=special>};</span>
1673
1674<span class=special>}</span> <span class=comment>// namespace std</span>
1675</pre></blockquote>
1676
1677<p>
1678<code>CompositeKeyResult</code> must be an instantiation of
1679<code>composite_key_result</code> for some type
1680<code>composite_key&lt;KeyFromValue0,...,KeyFromValuen></code>.
1681<code>std::less&lt;CompositeKeyResult>::operator()</code> is
1682then equivalent to
1683<code>composite_key_compare&lt;Compare0,...,Comparen>::operator()</code>, taking
1684<blockquote>
1685<code>Comparei = std::less&lt;KeyFromValuei::result_type></code> for all
1686<code>i = 0,...,n</code>.
1687</blockquote>
1688</p>
1689
1690<p>
1691In addition to the requirements on <code>Comparei</code> imposed by
1692<code>composite_key_compare</code>, each of these types must be
1693<code>DefaultConstructible</code>. <code>std::less&lt;CompositeKeyResult></code>
1694is <code>CopyConstructible</code>, <code>CopyConstructible</code>
1695and <code>CopyAssignable</code>.
1696</p>
1697
1698<h4><a name="greater_composite_key_result">Specialization of <code>std::greater</code> for
1699<code>composite_key</code> results</a></h4>
1700
1701<p>
1702<code>std::greater&lt;CompositeKeyResult></code>, with <code>CompositeKeyResult</code>
1703an instantiation of <code>composite_key_result</code>, behaves as a particularization of
1704<code>composite_key_compare</code> where all the comparison predicates supplied
1705are instantiations of <code>std::greater</code>.
1706</p>
1707
1708
1709<blockquote><pre>
1710<span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
1711
1712<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
1713<span class=keyword>struct</span> <span class=identifier>greater</span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;</span> <span class=special>&gt;</span>
1714<span class=special>{</span>
1715 <span class=keyword>typedef</span>
1716 <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span>
1717 <span class=identifier>CompositeKey</span><span class=special>&gt;</span> <span class=identifier>first_argument_type</span><span class=special>;</span>
1718 <span class=keyword>typedef</span> <span class=identifier>first_argument_type</span> <span class=identifier>second_argument_type</span><span class=special>;</span>
1719 <span class=keyword>typedef</span> <span class=keyword>bool</span> <span class=identifier>result_type</span><span class=special>;</span>
1720
1721 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey2</span><span class=special>&gt;</span>
1722 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1723 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey1</span><span class=special>&gt;</span> <span class=special>&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1724 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey2</span><span class=special>&gt;</span> <span class=special>&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1725
1726 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1727 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1728 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1729 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1730
1731 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1732 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1733 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1734 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1735
1736 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>&gt;</span>
1737 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1738 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1739 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1740
1741 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
1742 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1743 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1744 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1745
1746 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Value</span><span class=special>&gt;</span>
1747 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1748 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1749 <span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1750
1751 <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>CompositeKey</span><span class=special>&gt;</span>
1752 <span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
1753 <span class=keyword>const</span> <span class=identifier>Value</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>,</span>
1754 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1755<span class=special>};</span>
1756
1757<span class=special>}</span> <span class=comment>// namespace std</span>
1758</pre></blockquote>
1759
1760<p>
1761<code>CompositeKeyResult</code> must be an instantiation of
1762<code>composite_key_result</code> for some type
1763<code>composite_key&lt;KeyFromValue0,...,KeyFromValuen></code>.
1764<code>std::greater&lt;CompositeKeyResult>::operator()</code> is
1765then equivalent to
1766<code>composite_key_compare&lt;Compare0,...,Comparen>::operator()</code>, taking
1767<blockquote>
1768<code>Comparei = std::greater&lt;KeyFromValuei::result_type></code> for all
1769<code>i = 0,...,n</code>.
1770</blockquote>
1771</p>
1772
1773<p>
1774In addition to the requirements on <code>Comparei</code> imposed by
1775<code>composite_key_compare</code>, each of these types must be
1776<code>DefaultConstructible</code>. <code>std::greater&lt;CompositeKeyResult></code>
1777is <code>CopyConstructible</code>, <code>CopyConstructible</code>
1778and <code>CopyAssignable</code>.
1779</p>
1780
1781<h3><a name="ckey_result_hashing">Hashing</a></h3>
1782
1783<h4><a name="composite_key_hash">Class template
1784<code>composite_key_hash</code></a></h4>
1785
1786<p>
1787<code>composite_key_hash</code> produces hash values for <code>composite_key_result</code>
1788instantiations based on a collection of elementary hash functors.
1789</p>
1790
1791<blockquote><pre>
1792<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Hash0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Hashn</span><span class=special>&gt;</span>
1793<span class=keyword>struct</span> <span class=identifier>composite_key_hash</span>
1794<span class=special>{</span>
1795 <span class=keyword>typedef</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Hash0</span><span class=special>,...,</span><span class=identifier>Hashn</span><span class=special>&gt;</span> <span class=identifier>key_hasher_tuple</span><span class=special>;</span>
1796
1797 <span class=identifier>composite_key_hash</span><span class=special>(</span>
1798 <span class=keyword>const</span> <span class=identifier>Hash0</span><span class=special>&amp;</span> <span class=identifier>h0</span><span class=special>=</span><span class=identifier>Hash0</span><span class=special>(),</span>
1799 <span class=special>...</span>
1800 <span class=keyword>const</span> <span class=identifier>Hashn</span><span class=special>&amp;</span> <span class=identifier>hn</span><span class=special>=</span><span class=identifier>Hashn</span><span class=special>());</span>
1801
1802 <span class=identifier>composite_key_hash</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>key_hasher_tuple</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
1803
1804 <span class=keyword>const</span> <span class=identifier>key_hasher_tuple</span><span class=special>&amp;</span> <span class=identifier>key_hash_functions</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
1805 <span class=identifier>key_hasher_tuple</span><span class=special>&amp;</span> <span class=identifier>key_hash_functions</span><span class=special>()</span><span class=special>;</span>
1806
1807 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
1808 <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=keyword>operator</span><span class=special>()(</span>
1809 <span class=keyword>const</span> <span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1810
1811 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1812 <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=keyword>operator</span><span class=special>()(</span>
1813 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1814
1815 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>&gt;</span>
1816 <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=keyword>operator</span><span class=special>()(</span>
1817 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1818<span class=special>};</span>
1819</pre></blockquote>
1820
1821<p>
1822<code>Hash0</code>, ... , <code>Hashn</code> are the types of the hash unary function objects
1823stored by <code>composite_key_hash</code>. Each of these objects
1824must be <code>CopyConstructible</code> and <code>CopyAssignable</code>
1825and return a value of type <code>std::size_t</code> in the range
1826[0, <code>std::numeric_limits&lt;std::size_t&gt;::max())</code>).
1827At least a hash functor must be provided. The maximum number of hash functors of
1828a <code>composite_key_hash</code> instantiation is implementation defined.
1829<code>composite_key_hash</code> is
1830<code>CopyConstructible</code> and <code>CopyAssignable</code>.
1831It is also <code>DefaultConstructible</code>
1832if each <code>Hashi</code> is <code>DefaultConstructible</code> in its turn.
1833</p>
1834
1835<h4>Notation</h4>
1836
1837<p>
1838In what follows we use the same <a href="#ckey_result_notation">notation</a>
1839introduced for <code>composite_key_result</code>.
1840
1841<h4><code>composite_key_hash</code> members</h4>
1842
1843<code>composite_key_hash(<br>
1844&nbsp;&nbsp;const Hash0&amp; h0=Hash0(),<br>
1845&nbsp;&nbsp;...<br>
1846&nbsp;&nbsp;const Hashn&amp; hn=Hashn());
1847</code>
1848
1849<blockquote>
1850<b>Effects:</b> Constructs a <code>composite_key_hash</code> that stores
1851copies of the hash functors supplied.
1852</blockquote>
1853
1854<code>composite_key_hash(const key_hasher_tuple&amp; x);</code>
1855
1856<blockquote>
1857<b>Effects:</b> Constructs a <code>composite_key_hash</code> that stores
1858copies of the hash functors supplied in <code>x</code>.
1859</blockquote>
1860
1861<code>const key_hasher_tuple&amp; key_hash_functions()const;</code>
1862
1863<blockquote>
1864<b>Returns:</b> a constant reference to a tuple holding the
1865hash functors internally stored by the
1866<code>composite_key_hash</code>.
1867</blockquote>
1868
1869<code>key_hasher_tuple&amp; key_hash_functions();</code>
1870
1871<blockquote>
1872<b>Returns:</b> a reference to a tuple holding the
1873hash functors internally stored by the
1874<code>composite_key_hash</code>.
1875</blockquote>
1876
1877<code>
1878template&lt;typename CompositeKey><br>
1879bool operator()(<br>
1880&nbsp;&nbsp;const composite_key_result&lt;CompositeKey>&amp; x)const;<br>
1881template&lt;typename... Values><br>
1882bool operator()(<br>
1883&nbsp;&nbsp;const std::tuple&lt;Values...>&amp; x)const;<br>
1884template&lt;typename Value0,...,typename Valuen><br>
1885bool operator()(<br>
1886&nbsp;&nbsp;const boost::tuple&lt;Value0,...,Valuen>&amp; x)const;
1887</code>
1888
1889<blockquote>
1890<b>Requires:</b> <code>length(x)==length(key_hash_functions())</code>.
1891The expression
1892<code>key_hash_functions().get&lt;i>()(x<sub>i</sub>)</code>
1893is valid for all <code>i</code> in <code>[0,length(x))</code>.
1894<br>
1895<b>Returns:</b> A value in the range
1896<code>[0, std::numeric_limits&lt;std::size_t&gt;::max())</code> that
1897solely depends on the numerical tuple
1898<blockquote>
1899(<code>key_hash_functions().get&lt;0>()(x<sub>0</sub>)</code>, ... ,
1900<code>key_hash_functions().get&lt;N>()(x<sub>N</sub>)</code>),
1901with <code>N=length(x)-1</code>.
1902</blockquote>
1903</blockquote>
1904
1905<h4><a name="composite_key_result_hash">Class template
1906<code>composite_key_result_hash</code></a></h4>
1907
1908<p>
1909Deprecated. Use <code>boost::hash&lt;CompositeKeyResult&gt;</code> instead.
1910</p>
1911
1912<h4><a name="hash_composite_key_result">Specialization of
1913<a href="../../../functional/hash/index.html"><code>boost::hash</code></a>
1914for <code>composite_key</code> results</a></h4>
1915
1916<p>
1917<code>boost::hash&lt;CompositeKeyResult></code>, with <code>CompositeKeyResult</code>
1918an instantiation of <code>composite_key_result</code>, behaves as a particularization of
1919<code>composite_key_hash</code> where all the hash functors supplied
1920are instantiations of
1921<a href="../../../functional/hash/index.html"><code>boost::hash</code></a>.
1922</p>
1923
1924<blockquote><pre>
1925<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
1926
1927<span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
1928<span class=keyword>struct</span> <span class=identifier>hash</span><span class=special>&lt;</span><span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;</span> <span class=special>&gt;</span>
1929<span class=special>{</span>
1930 <span class=keyword>typedef</span> <span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;</span> <span class=identifier>argument_type</span><span class=special>;</span>
1931 <span class=keyword>typedef</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=identifier>result_type</span><span class=special>;</span>
1932
1933 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>CompositeKey</span><span class=special>&gt;</span>
1934 <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=keyword>operator</span><span class=special>()(</span>
1935 <span class=keyword>const</span> <span class=identifier>multi_index</span><span class=special>::</span><span class=identifier>composite_key_result</span><span class=special>&lt;</span><span class=identifier>CompositeKey</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1936
1937 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Values</span><span class=special>&gt;</span>
1938 <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=keyword>operator</span><span class=special>()(</span>
1939 <span class=keyword>const</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Values</span><span class=special>...&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1940
1941 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Value0</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Valuen</span><span class=special>&gt;</span>
1942 <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=keyword>operator</span><span class=special>()(</span>
1943 <span class=keyword>const</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>tuple</span><span class=special>&lt;</span><span class=identifier>Value0</span><span class=special>,...,</span><span class=identifier>Valuen</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>)</span><span class=keyword>const</span><span class=special>;</span>
1944<span class=special>};</span>
1945
1946<span class=special>}</span> <span class=comment>// namespace boost</span>
1947</pre></blockquote>
1948
1949<p>
1950<code>CompositeKeyResult</code> must be an instantiation of
1951<code>composite_key_result</code> for some type
1952<code>composite_key&lt;KeyFromValue0,...,KeyFromValuen></code>.
1953<code>boost::hash&lt;CompositeKeyResult>::operator()</code> is
1954then equivalent to
1955<code>composite_key_hash&lt;Hash0,...,Hashn>::operator()</code>, taking
1956<blockquote>
1957<code>Hashi = boost::hash&lt;KeyFromValuei::result_type></code> for all
1958<code>i = 0,...,n</code>.
1959</blockquote>
1960</p>
1961
1962<p>
1963In addition to the requirements on <code>Hashi</code> imposed by
1964<code>composite_key_hash</code>, each of these types must be
1965<code>DefaultConstructible</code>. <code>boost::hash&lt;CompositeKeyResult></code> is
1966<code>DefaultConstructible</code>, <code>CopyConstructible</code>
1967and <code>CopyAssignable</code>.
1968</p>
1969
1970<h3><a name="ckey_result_semantics">Semantics of
1971<code>composite_key_result</code></a></h3>
1972
1973<p>
1974The design of equality, comparison and hash operations for
1975<code>composite_key_result</code> objects is based on the following rationale:
1976a <code>composite_key_result</code> is regarded as a "virtual" tuple, each
1977of its elements being the result of the corresponding elementary
1978key extractor. Accordingly, any given operation resolves to a
1979combination of the corresponding elementwise operations.
1980This mapping preserves the fundamental properties of the elementary operations
1981involved; for instance, it defines a true equivalence relation if the
1982basic predicates induce equivalence relations themselves.
1983We can state these facts in a formal way as follows.
1984</p>
1985
1986<p>
1987Consider an instantiation of <code>composite_key_equal_to</code>
1988with types <code>Pred0</code>, ... , <code>Predn</code> such that each
1989<code>Predi</code> induces an equivalence relation on a certain type <code>Ti</code>,
1990and let <code>CompositeKey</code> be a type of the form
1991<code>composite_key&lt;Value,KeyFromValue0,...,KeyFromValuej></code>,
1992with <code>j &lt;= n</code>, such that
1993<blockquote>
1994<code>KeyFromValuei::result_type = Ti</code>, for all <code>i = 0,...,j</code>.
1995</blockquote>
1996Then, <code>composite_key_equal_to</code> induces an equivalence relation
1997on elements of type <code>composite_key_result&lt;CompositeKey></code>;
1998such two objects are equivalent if all its elementary key extractor values
1999are also equivalent. Additionally, given an instantiation
2000<code>composite_key_hash&lt;Hash0,...,Hashj></code>, the following types are
2001<a href="hash_indices.html#lookup"><code>Compatible Keys</code></a> of
2002(<code>composite_key_hash</code>, <code>composite_key_equal_to</code>)
2003with respect to <code>composite_key_result&lt;CompositeKey></code>:
2004<blockquote>
2005<code>tuple&lt;Q0,...,Qj></code>,<br>
2006<code>composite_key_result&lt;composite_key&lt;K0,...,Kj> ></code>, with
2007<code>Ki::result_type = Qi</code> for all <code>i = 0,...,j</code>.
2008</blockquote>
2009provided that each <code>Qi</code> is either <code>Ti</code> or a
2010<a href="hash_indices.html#lookup"><code>Compatible Key</code></a>
2011of (<code>Hashi</code>, <code>Predi</code>).</p>
2012
2013<p>
2014As for comparison, consider an instantiation of <code>composite_key_compare</code>
2015with types <code>Compare0</code>, ... , <code>Comparen</code> such that each
2016<code>Comparei</code> induces a strict weak ordering
2017on the type <code>Ti</code>. Then, for a
2018<code>CompositeKey</code> type defined in the same manner as above,
2019<code>composite_key_compare</code> induces a strict weak ordering on elements of type
2020<code>composite_key_result&lt;CompositeKey></code>, and the order induced
2021is lexicographical. Also, the following types are
2022<a href="ord_indices.html#set_operations"><code>Compatible Keys</code></a> of
2023<code>composite_key_compare</code> with respect to
2024<code>composite_key_result&lt;CompositeKey></code>:
2025<blockquote>
2026<code>tuple&lt;Q0,...,Qk></code>, <code>k &lt;= n</code><br>
2027<code>composite_key_result&lt;composite_key&lt;K0,...,Kk> ></code>, with
2028<code>Ki::result_type = Qi</code> for all <code>i = 0,...,k</code>.
2029</blockquote>
2030provided that
2031<ul>
2032 <li>for <code>i = 0,...,min(j,k)-1</code>, <code>Qi</code> is either <code>Ti</code>
2033 or <i>not coarser</i> than <code>Ti</code> (<code>Qi</code> is a
2034 <a href="ord_indices.html#set_operations"><code>Compatible Key</code></a>
2035 of <code>Comparei</code> and there are no two distinct elements of
2036 <code>Ti</code> equivalent to one single element of <code>Qi</code>);
2037 </li>
2038 <li>
2039 <code>Qm</code> (with <code>m = min(j,k)</code>) is either <code>Tm</code> or a
2040 <a href="ord_indices.html#set_operations"><code>Compatible Key</code></a>
2041 of <code>Comparem</code>.
2042 </li>
2043</ul>
2044
2045In this case, the comparison is done
2046lexicographically only on the first <code>1+min(j,k)</code> elements.
2047</p>
2048
2049<p>
2050Analogous properties hold for the equality and comparison operators
2051of <code>composite_key_result</code>. Note, however,
2052that equality is only defined for objects of the same length, whilst
2053comparison takes the minimum length of the operands considered.
2054Therefore, the equivalence classes induced by <code>x==y</code> are
2055subsets of those associated to <code>!(x&lt;y)&amp;&amp;!(y&lt;x)</code>.
2056</p>
2057
2058<hr>
2059
2060<div class="prev_link"><a href="rnd_indices.html"><img src="../prev.gif" alt="random access indices" border="0"><br>
2061Random access indices
2062</a></div>
2063<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
2064Boost.MultiIndex reference
2065</a></div>
2066<div class="next_link"><a href="../compiler_specifics.html"><img src="../next.gif" alt="compiler specifics" border="0"><br>
2067Compiler specifics
2068</a></div><br clear="all" style="clear: all;">
2069
2070<br>
2071
2072<p>Revised November 24th 2015</p>
2073
2074<p>&copy; Copyright 2003-2015 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz.
2075Distributed under the Boost Software
2076License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
2077LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
2078http://www.boost.org/LICENSE_1_0.txt</a>)
2079</p>
2080
2081</body>
2082</html>