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