mirror of
https://github.com/boostorg/multi_index.git
synced 2025-05-09 23:14:04 +00:00
1506 lines
107 KiB
HTML
1506 lines
107 KiB
HTML
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
|
|
|
|
<html>
|
|
<head>
|
|
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
|
|
<title>Boost.MultiIndex Documentation - Key extraction reference</title>
|
|
<link rel="stylesheet" href="../style.css" type="text/css">
|
|
</head>
|
|
|
|
<body>
|
|
<h1><img src="../../../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align=
|
|
"middle" width="277" height="86">Boost.MultiIndex Key extraction reference</h1>
|
|
|
|
<div class="prev_link"><a href="seq_indices.html"><img src="../prev.gif" alt="sequenced indices" border="0"><br>
|
|
Sequenced indices
|
|
</a></div>
|
|
<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
|
|
Boost.MultiIndex reference
|
|
</a></div>
|
|
<div class="next_link"><a href="../compiler_specifics.html"><img src="../next.gif" alt="compiler specifics" border="0"><br>
|
|
Compiler specifics
|
|
</a></div><br clear="all" style="clear: all;">
|
|
|
|
<hr>
|
|
|
|
<h2>Contents</h2>
|
|
|
|
<ul>
|
|
<li><a href="#key_extractors">Key Extractors</a>
|
|
<ul>
|
|
<li><a href="#chained_pointers">Chained pointers</a></li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#synopsis">Header
|
|
<code>"boost/multi_index/key_extractors.hpp"</code> synopsis</a>
|
|
</li>
|
|
<li><a href="#identity_synopsis">Header
|
|
<code>"boost/multi_index/identity.hpp"</code> synopsis</a>
|
|
<ul>
|
|
<li><a href="#identity">Template class <code>identity</code></a></li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#member_synopsis">Header
|
|
<code>"boost/multi_index/member.hpp"</code> synopsis</a>
|
|
<ul>
|
|
<li><a href="#member">Template class <code>member</code></a></li>
|
|
<li><a href="#member_offset">Template class <code>member_offset</code></a></li>
|
|
<li><a href="#boost_multi_index_member">Macro <code>BOOST_MULTI_INDEX_MEMBER</code></a></li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#mem_fun_synopsis">Header
|
|
<code>"boost/multi_index/mem_fun.hpp"</code> synopsis</a>
|
|
<ul>
|
|
<li><a href="#const_mem_fun">Template class <code>const_mem_fun</code></a></li>
|
|
<li><a href="#mem_fun">Template class <code>mem_fun</code></a></li>
|
|
<li><a href="#const_mem_fun_explicit">Template class <code>const_mem_fun_explicit</code></a></li>
|
|
<li><a href="#mem_fun_explicit">Template class <code>mem_fun_explicit</code></a></li>
|
|
<li><a href="#boost_multi_index_const_mem_fun">Macro <code>BOOST_MULTI_INDEX_CONST_MEM_FUN</code></a></li>
|
|
<li><a href="#boost_multi_index_mem_fun">Macro <code>BOOST_MULTI_INDEX_MEM_FUN</code></a></li>
|
|
</ul>
|
|
</li>
|
|
<li><a href="#composite_key_synopsis">Header
|
|
<code>"boost/multi_index/composite_key.hpp"</code> synopsis</a>
|
|
<ul>
|
|
<li><a href="#composite_key">Template class <code>composite_key</code></a></li>
|
|
<li><a href="#composite_key_result">Template class <code>composite_key_result</code></a></li>
|
|
<li><a href="#composite_key_compare">Template class <code>composite_key_compare</code></a></li>
|
|
<li><a href="#composite_key_result_less">Template class <code>composite_key_result_less</code></a></li>
|
|
<li><a href="#composite_key_result_greater">Template class <code>composite_key_result_greater</code></a></li>
|
|
<li><a href="#less_composite_key_result">Specialization of <code>std::less</code> for <code>composite_key</code> results</a></li>
|
|
<li><a href="#greater_composite_key_result">Specialization of <code>std::greater</code> for <code>composite_key</code> results</a></li>
|
|
<li><a href="#ordering_semantics">Ordering semantics</a></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
|
|
<h2><a name="key_extractors">Key Extractors</a></h2>
|
|
|
|
<p>
|
|
Key extraction classes are used by <a href="ord_indices.html">ordered indices</a> to
|
|
obtain the sorting keys from the elements of a <code>multi_index_container</code>.
|
|
An <a href="http://www.sgi.com/tech/stl/Assignable.html"><code>Assignable</code></a>
|
|
class <code>KeyFromValue</code> is said to be a key extractor from a
|
|
type <code>T</code> if
|
|
<ol>
|
|
<li>the type <code>KeyFromValue::result_type</code> is defined,</li>
|
|
<li><code>k1(ca)</code> is defined and returns a value convertible
|
|
to <code>const KeyFromValue::result_type&</code>,</li>
|
|
<li>if <code>k2</code> is a copy of <code>k1</code>, <code>k1(ca)</code> is the
|
|
same value as <code>k2(ca)</code>,</li>
|
|
</ol>
|
|
for every <code>k1</code>, <code>k2</code> of type <code>const KeyFromValue</code>,
|
|
and <code>ca</code> of type <code>const Type&</code>.
|
|
</p>
|
|
|
|
<p>
|
|
Additionally, <code>KeyFromValue</code> is a <i>read/write</i> key extractor
|
|
if the following extra conditions are met:
|
|
<ol>
|
|
<li><code>k1(a)</code> is defined and returns a value convertible
|
|
to <code>KeyFromValue::result_type&</code>,</li>
|
|
<li><code>const_cast<const KeyFromValue::result_type&>(k1(a))</code>
|
|
is the same value as
|
|
<code>k1(const_cast<const Type&>(a))</code>,</li>
|
|
</ol>
|
|
for every <code>k1</code> of type <code>const KeyFromValue</code> and
|
|
<code>a</code> of type <code>Type&</code>.
|
|
</p>
|
|
|
|
<p>
|
|
Boost.MultiIndex provides five general-purpose key extractors:
|
|
<ul>
|
|
<li><a href="#identity"><code>identity</code></a>,</li>
|
|
<li><a href="#member"><code>member</code></a>,</li>
|
|
<li><a href="#const_mem_fun"><code>const_mem_fun</code></a> and</li>
|
|
<li><a href="#mem_fun"><code>mem_fun</code></a>,</li>
|
|
<li><a href="#composite_key"><code>composite_key</code></a>,</li>
|
|
</ul>
|
|
plus replacements for some of them:
|
|
<ul>
|
|
<li><a href="#member_offset"><code>member_offset</code></a>,</li>
|
|
<li><a href="#const_mem_fun_explicit"><code>const_mem_fun_explicit</code></a> and</li>
|
|
<li><a href="#mem_fun_explicit"><code>mem_fun_explicit</code></a>,</li>
|
|
</ul>
|
|
that workaround some deficiencies in the support for non-type template parameters
|
|
by certain compilers.
|
|
</p>
|
|
|
|
<h3><a name="chained_pointers">Chained pointers</a></h3>
|
|
|
|
<p>
|
|
The key extractors provided by Boost.MultiIndex are templatized according
|
|
to the type <code>Type</code> and serve to extract keys not only from objects
|
|
of type <code>Type</code>, but also from reference wrappers provided by
|
|
<a href="../../../../doc/html/ref.html">Boost.Ref</a> and from <i>chained pointers</i>
|
|
to <code>Type</code> (or to reference wrappers of <code>Type</code>): a chained pointer
|
|
is any type <code>P</code> such that, for an object <code>p</code> of type
|
|
<code>const P</code>
|
|
<ul>
|
|
<li><code>*x</code> yields an object of type <code>Type&</code> or
|
|
<code>boost::reference_wrapper<Type></code>, OR</li>
|
|
<li><code>*x</code> yields a chained pointer to <code>Type&</code>,</li>
|
|
</ul>
|
|
that is, chained pointers are arbitrary compositions of pointer-like objects
|
|
ultimately dereferencing to values of <code>Type&</code> or
|
|
<code>boost::reference_wrapper<Type></code>.
|
|
<p>
|
|
|
|
<h2><a name="synopsis">Header
|
|
<a href="../../../../boost/multi_index/key_extractors.hpp">
|
|
<code>"boost/multi_index/key_extractors.hpp"</code></a> synopsis</a>
|
|
</h2>
|
|
|
|
<blockquote><pre>
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<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>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
This header includes all the key extractors provided by Boost.MultiIndex.
|
|
</p>
|
|
|
|
<h2>
|
|
<a name="identity_synopsis">Header
|
|
<a href="../../../../boost/multi_index/identity.hpp">
|
|
<code>"boost/multi_index/identity.hpp"</code></a> synopsis</a></h2>
|
|
|
|
<blockquote><pre>
|
|
<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
|
|
|
|
<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
|
|
|
|
<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>
|
|
|
|
<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
|
|
|
|
<span class=special>}</span> <span class=comment>// namespace boost</span>
|
|
</pre></blockquote>
|
|
|
|
<h3><a name="identity">Template class <code>identity</code></a></h3>
|
|
|
|
<p>
|
|
<code>identity</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
|
|
that acts as a do-nothing identity functor.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>Type</span><span class=special>></span>
|
|
<span class=keyword>struct</span> <span class=identifier>identity</span>
|
|
<span class=special>{</span>
|
|
<span class=keyword>typedef</span> <span class=identifier>Type</span> <span class=identifier>result_type</span><span class=special>;</span>
|
|
|
|
<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>
|
|
<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>
|
|
<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
|
|
|
|
// only provided if Type is non-const</span>
|
|
<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>
|
|
|
|
<span class=comment>// only provided if Type is 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>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>
|
|
|
|
<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>
|
|
<span class=special>};</span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
<code>identity<Type></code> is a model of:
|
|
<ul>
|
|
<li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>Type</code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>reference_wrapper<const Type></code>,</li>
|
|
<li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>reference_wrapper<Type></code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from any <a href="#chained_pointers">chained pointer</a> to
|
|
<code>const Type</code>.</li>
|
|
<li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from any <a href="#chained_pointers">chained pointer</a>
|
|
to <code>Type</code>.</li>
|
|
</ul>
|
|
</p>
|
|
|
|
<h4><code>identity</code> members</h4>
|
|
|
|
<code>template<typename ChainedPtr> Type& operator()(const ChainedPtr& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
|
|
type to <code>Type</code>.<br>
|
|
<b>Returns:</b> a reference to the object chained-pointed to by <code>x</code>.
|
|
</blockquote>
|
|
|
|
<code>const Type& operator()(const Type&x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> <code>x</code>.
|
|
</blockquote>
|
|
|
|
<code>Type& operator()(Type &x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> <code>x</code>.
|
|
</blockquote>
|
|
|
|
<code>const Type& operator()(const reference_wrapper<const Type>& x)const;</code>
|
|
<blockquote>
|
|
<b>Returns:</b> <code>x.get()</code>.
|
|
</blockquote>
|
|
|
|
<code>Type& operator()(const reference_wrapper<typename remove_const<Type>::type>& x)const;</code>
|
|
<blockquote>
|
|
<b>Returns:</b> <code>x.get()</code>.
|
|
</blockquote>
|
|
|
|
<code>Type& operator()(const reference_wrapper<Type>& x)const;</code>
|
|
<blockquote>
|
|
<b>Returns:</b> <code>x.get()</code>.
|
|
</blockquote>
|
|
|
|
|
|
<h2>
|
|
<a name="member_synopsis">Header
|
|
<a href="../../../../boost/multi_index/member.hpp">
|
|
<code>"boost/multi_index/member.hpp"</code></a> synopsis</a></h2>
|
|
|
|
<blockquote><pre>
|
|
<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
|
|
|
|
<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
|
|
|
|
<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>
|
|
<span class=keyword>struct</span> <span class=identifier>member</span><span class=special>;</span>
|
|
|
|
<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>
|
|
<span class=keyword>struct</span> <span class=identifier>member_offset</span><span class=special>;</span>
|
|
|
|
<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>
|
|
|
|
<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
|
|
|
|
<span class=special>}</span> <span class=comment>// namespace boost</span>
|
|
</pre></blockquote>
|
|
|
|
<h3><a name="member">Template class <code>member</code></a></h3>
|
|
|
|
<p>
|
|
<code>member</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
|
|
aimed at accessing a given member of a class.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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>
|
|
<span class=keyword>struct</span> <span class=identifier>member</span>
|
|
<span class=special>{</span>
|
|
<span class=keyword>typedef</span> <span class=identifier>Type</span> <span class=identifier>result_type</span><span class=special>;</span>
|
|
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<span class=special>};</span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
The <code>PtrToMember</code> template argument specifies the particular
|
|
<code>Type Class::*</code> pointer to the member to be extracted.
|
|
<code>member<Class,Type,PtrToMember></code> is a model of:
|
|
<ul>
|
|
<li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>Class</code> if <code>Type</code> is non-<code>const</code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>reference_wrapper<const Class></code>,</li>
|
|
<li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>reference_wrapper<Class></code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from any <a href="#chained_pointers">chained pointer</a>
|
|
to <code>const Class</code>,</li>
|
|
<li>read/write <a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from any <a href="#chained_pointers">chained pointer</a>
|
|
to <code>Class</code>.</li>
|
|
</ul>
|
|
</p>
|
|
|
|
<h4><code>member</code> members</h4>
|
|
|
|
<code>template<typename ChainedPtr> Type& operator()(const ChainedPtr& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
|
|
type to <code>Type</code>.<br>
|
|
<b>Returns:</b> a reference to the object chained-pointed to by <code>x</code>.
|
|
</blockquote>
|
|
|
|
<code>const Type& operator()(const Class&x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> <code>x.*PtrToMember</code>.
|
|
</blockquote>
|
|
|
|
<code>Type& operator()(const Class&x);</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> <code>x.*PtrToMember</code>.
|
|
</blockquote>
|
|
|
|
<code>const Type& operator()(const reference_wrapper<const Class>& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> <code>x.get().*PtrToMember</code>.
|
|
</blockquote>
|
|
|
|
<code>Type& operator()(const reference_wrapper<Class>& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> <code>x.get().*PtrToMember</code>.
|
|
</blockquote>
|
|
|
|
<h3><a name="member_offset">Template class <code>member_offset</code></a></h3>
|
|
|
|
<p>
|
|
Some compilers do not properly support pointers to members as non-type
|
|
template arguments. The following have been confirmed to have bugs in
|
|
this respect:
|
|
<ul>
|
|
<li>MSVC++ 6.0 (see
|
|
<a href="http://support.microsoft.com/default.aspx?scid=kb;EN-US;249045">Microsoft
|
|
Knowledge Base article #249045</a>),</li>
|
|
<li>Intel C++ 7.0/7.1 for Windows (support issue #207321.)</li>
|
|
</ul>
|
|
In this situation, <code>member_offset</code> provides an
|
|
alternative to <a href="#member"><code>member</code></a> accepting offsets
|
|
instead of pointers to members. Please note that the use of
|
|
<code>offsetof</code> on non-POD types is forbidden by the standard;
|
|
luckily enough, most compilers accept it nevertheless, so
|
|
<code>member_offset</code> serves as a workaround for most practical purposes.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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>
|
|
<span class=keyword>struct</span> <span class=identifier>member_offset</span>
|
|
<span class=special>{</span>
|
|
<span class=keyword>typedef</span> <span class=identifier>Type</span> <span class=identifier>result_type</span><span class=special>;</span>
|
|
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<span class=special>};</span>
|
|
</pre></blockquote>
|
|
|
|
<p>As an example of use, given the class</p>
|
|
|
|
<blockquote><pre>
|
|
<span class=keyword>class</span> <span class=identifier>A</span>
|
|
<span class=special>{</span>
|
|
<span class=keyword>int</span> <span class=identifier>x</span><span class=special>;</span>
|
|
<span class=special>}</span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
the instantiation <code>member<A,int,&A::x></code> can be simulated then
|
|
as <code>member_offset<A,int,offsetof(A,x)></code>.
|
|
</p>
|
|
|
|
<h3><a name="boost_multi_index_member">Macro <code>BOOST_MULTI_INDEX_MEMBER</code></a></h3>
|
|
|
|
<blockquote><pre>
|
|
<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>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
This macro is provided as an aid for using <code>member</code> and
|
|
<code>member_offset</code> when writing cross-platform code. In the usual cases,
|
|
it expands to
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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>Class</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>MemberName</span><span class=special>></span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
but it resolves to
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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_offset</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>offsetof</span><span class=special>(</span><span class=identifier>Class</span><span class=special>,</span><span class=identifier>MemberName</span><span class=special>)></span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
for the following compilers:
|
|
<ul>
|
|
<li>MSVC++ 6.0 or lower,
|
|
<li>Intel C++ 7.1 or lower for Windows,
|
|
</ul>
|
|
and/or if the macro <code>BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS</code>
|
|
is defined.
|
|
</p>
|
|
|
|
<h2>
|
|
<a name="mem_fun_synopsis">Header
|
|
<a href="../../../../boost/multi_index/mem_fun.hpp">
|
|
<code>"boost/multi_index/mem_fun.hpp"</code></a> synopsis</a></h2>
|
|
|
|
<blockquote><pre>
|
|
<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
|
|
|
|
<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
|
|
|
|
<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=keyword>struct</span> <span class=identifier>const_mem_fun</span><span class=special>;</span>
|
|
|
|
<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>struct</span> <span class=identifier>mem_fun</span><span class=special>;</span>
|
|
|
|
<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=keyword>typename</span> <span class=identifier>PtrToMemberFunctionType</span><span class=special>,</span><span class=identifier>PtrToMemberFunctionType</span> <span class=identifier>PtrToMemberFunction</span>
|
|
<span class=special>></span>
|
|
<span class=keyword>struct</span> <span class=identifier>const_mem_fun_explicit</span><span class=special>;</span>
|
|
|
|
<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=keyword>typename</span> <span class=identifier>PtrToMemberFunctionType</span><span class=special>,</span><span class=identifier>PtrToMemberFunctionType</span> <span class=identifier>PtrToMemberFunction</span>
|
|
<span class=special>></span>
|
|
<span class=keyword>struct</span> <span class=identifier>mem_fun_explicit</span><span class=special>;</span>
|
|
|
|
<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>
|
|
<b>implementation defined</b>
|
|
<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>
|
|
<b>implementation defined</b>
|
|
|
|
<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
|
|
|
|
<span class=special>}</span> <span class=comment>// namespace boost</span>
|
|
</pre></blockquote>
|
|
|
|
<h3><a name="const_mem_fun">Template class <code>const_mem_fun</code></a></h3>
|
|
|
|
<p>
|
|
<code>const_mem_fun</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
|
|
returning as key the result of invoking a given constant member function of a class.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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=keyword>struct</span> <span class=identifier>const_mem_fun</span>
|
|
<span class=special>{</span>
|
|
<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>
|
|
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<span class=special>};</span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
The <code>PtrToMemberFunction</code> template argument specifies the particular
|
|
<code>Type (Class::*PtrToMemberFunction)()const</code> pointer to the the constant
|
|
member function used in the extraction.
|
|
<code>const_mem_fun<Class,Type,PtrToMemberFunction></code> is a model of:
|
|
<ul>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>Class</code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>reference_wrapper<const Class></code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>reference_wrapper<Class></code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from any <a href="#chained_pointers">chained pointer</a>
|
|
to <code>const Class</code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from any <a href="#chained_pointers">chained pointer</a>
|
|
to <code>Class</code>.</li>
|
|
</ul>
|
|
</p>
|
|
|
|
<h4><code>const_mem_fun</code> members</h4>
|
|
|
|
<code>template<typename ChainedPtr> Type operator()(const ChainedPtr& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
|
|
type to <code>Type</code>.<br>
|
|
<b>Returns:</b> <code>(y.*PtrToMemberFunction)()</code>, where <code>y</code> is the
|
|
object chained-pointed to by <code>x</code>.
|
|
</blockquote>
|
|
|
|
<code>Type operator()(const Class& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> <code>(x.*PtrToMemberFunction)()</code>.
|
|
</blockquote>
|
|
|
|
<code>Type operator()(const reference_wrapper<const Class>& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> <code>(x.get().*PtrToMemberFunction)()</code>.
|
|
</blockquote>
|
|
|
|
<code>Type operator()(const reference_wrapper<Class>& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> <code>(x.get().*PtrToMemberFunction)()</code>.
|
|
</blockquote>
|
|
|
|
<h3><a name="mem_fun">Template class <code>mem_fun</code></a></h3>
|
|
|
|
<p>
|
|
<code>mem_fun</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
|
|
returning as key the result of invoking a given member function of a class.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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>struct</span> <span class=identifier>mem_fun</span>
|
|
<span class=special>{</span>
|
|
<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>
|
|
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<span class=special>};</span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
The <code>PtrToMemberFunction</code> template argument specifies the particular
|
|
<code>Type (Class::*PtrToMemberFunction)()</code> pointer to the the member
|
|
function used in the extraction.
|
|
<code>mem_fun<Class,Type,PtrToMemberFunction></code> is a model of:
|
|
<ul>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>reference_wrapper<Class></code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from any <a href="#chained_pointers">chained pointer</a>
|
|
to <code>Class</code>.</li>
|
|
</ul>
|
|
</p>
|
|
|
|
<h4><code>mem_fun</code> members</h4>
|
|
|
|
<code>template<typename ChainedPtr> Type operator()(const ChainedPtr& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
|
|
type to <code>Type</code>.<br>
|
|
<b>Returns:</b> <code>(y.*PtrToMemberFunction)()</code>, where <code>y</code> is the
|
|
object chained-pointed to by <code>x</code>.
|
|
</blockquote>
|
|
|
|
<code>Type operator()(Class& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> <code>(x.*PtrToMemberFunction)()</code>.
|
|
</blockquote>
|
|
|
|
<code>Type operator()(const reference_wrapper<Class>& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> <code>(x.get().*PtrToMemberFunction)()</code>.
|
|
</blockquote>
|
|
|
|
<h3><a name="const_mem_fun_explicit">Template class <code>const_mem_fun_explicit</code></a></h3>
|
|
|
|
<p>
|
|
MSVC++ 6.0 do not properly support pointers to constant member functions as non-type
|
|
template parameters, thus <a href="#const_mem_fun"><code>const_mem_fun</code></a> cannot be
|
|
used in this compiler. A simple workaround consists in specifying the <i>type</i> of
|
|
these pointers as an additional template parameter.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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=keyword>typename</span> <span class=identifier>PtrToMemberFunctionType</span><span class=special>,</span><span class=identifier>PtrToMemberFunctionType</span> <span class=identifier>PtrToMemberFunction</span>
|
|
<span class=special>></span>
|
|
<span class=keyword>struct</span> <span class=identifier>const_mem_fun_explicit</span>
|
|
<span class=special>{</span>
|
|
<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>
|
|
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<span class=special>};</span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
<code>const_mem_fun_explicit</code> provides the very same functionality as
|
|
its <code>const_mem_fun</code> analogous instantiation. For example, given the type
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<span class=keyword>struct</span> <span class=identifier>A</span>
|
|
<span class=special>{</span>
|
|
<span class=keyword>int</span> <span class=identifier>f</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
|
|
<span class=special>};</span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
the extractor <code>const_mem_fun<A,int,&A::f></code> can be replaced by
|
|
<code>const_mem_fun_explicit<A,int,int (A::*)()const,&A::f></code>.
|
|
</p>
|
|
|
|
<h3><a name="mem_fun_explicit">Template class <code>mem_fun_explicit</code></a></h3>
|
|
|
|
<p>
|
|
For analogy with <a href="#const_mem_fun_explicit"><code>const_mem_fun_explicit</code></a>,
|
|
a variation of <a href="#mem_fun"><code>mem_fun</code></a> is provided accepting
|
|
an additional parameter with the type of the pointer to non-constant member function
|
|
used for extraction.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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=keyword>typename</span> <span class=identifier>PtrToMemberFunctionType</span><span class=special>,</span><span class=identifier>PtrToMemberFunctionType</span> <span class=identifier>PtrToMemberFunction</span>
|
|
<span class=special>></span>
|
|
<span class=keyword>struct</span> <span class=identifier>mem_fun_explicit</span>
|
|
<span class=special>{</span>
|
|
<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>
|
|
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<span class=special>};</span>
|
|
</pre></blockquote>
|
|
|
|
<h3><a name="boost_multi_index_const_mem_fun">Macro
|
|
<code>BOOST_MULTI_INDEX_CONST_MEM_FUN</code></a></h3>
|
|
|
|
<blockquote><pre>
|
|
<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>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
Use this macro when writing cross-platform code selectively using
|
|
<code>const_mem_fun_explicit</code> in place of <code>const_mem_fun</code> for
|
|
compilers not supporting the latter. In the usual cases, the macro expands to
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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>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>Class</span><span class=special>::</span><span class=identifier>MemberFunName</span><span class=special>></span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
but it resolves to
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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>const_mem_fun_explicit</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>Type</span> <span class=special>(</span><span class=identifier>Class</span><span class=special>::*)()</span><span class=keyword>const</span><span class=special>,&</span><span class=identifier>Class</span><span class=special>::</span><span class=identifier>MemberFunName</span>
|
|
<span class=special>></span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
for MSVC++ 6.0 or lower.
|
|
</p>
|
|
|
|
|
|
<h3><a name="boost_multi_index_mem_fun">Macro
|
|
<code>BOOST_MULTI_INDEX_MEM_FUN</code></a></h3>
|
|
|
|
<blockquote><pre>
|
|
<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>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
By default, the macro expands to
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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>Class</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>MemberFunName</span><span class=special>></span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
but it resolves to
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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_explicit</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>Type</span> <span class=special>(</span><span class=identifier>Class</span><span class=special>::*)()</span><span class=special>,&</span><span class=identifier>Class</span><span class=special>::</span><span class=identifier>MemberFunName</span>
|
|
<span class=special>></span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
for MSVC++ 6.0 or lower.
|
|
</p>
|
|
|
|
<h2>
|
|
<a name="composite_key_synopsis">Header
|
|
<a href="../../../../boost/multi_index/composite_key.hpp">
|
|
<code>"boost/multi_index/composite_key.hpp"</code></a> synopsis</a></h2>
|
|
|
|
<blockquote><pre>
|
|
<span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
|
|
|
|
<span class=keyword>namespace</span> <span class=identifier>multi_index</span><span class=special>{</span>
|
|
|
|
<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>
|
|
<span class=keyword>struct</span> <span class=identifier>composite_key</span><span class=special>;</span>
|
|
|
|
<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>struct</span> <span class=identifier>composite_key_result</span><span class=special>;</span>
|
|
|
|
<span class=comment>// comparison for composite_key_result:</span>
|
|
|
|
<span class=comment>// <b>OP</b> is any of =,<,!=,>,>=,<=</span>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
|
|
<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>
|
|
<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>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><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>x</span><span class=special>,</span>
|
|
<span class=keyword>const</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>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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
|
|
<span class=keyword>const</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=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>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>
|
|
<span class=keyword>struct</span> <span class=identifier>composite_key_compare</span><span class=special>;</span>
|
|
|
|
<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKeyResult</span><span class=special>></span>
|
|
<span class=keyword>struct</span> <span class=identifier>composite_key_result_less</span><span class=special>;</span>
|
|
|
|
<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKeyResult</span><span class=special>></span>
|
|
<span class=keyword>struct</span> <span class=identifier>composite_key_result_greater</span><span class=special>;</span>
|
|
|
|
<span class=special>}</span> <span class=comment>// namespace boost::multi_index</span>
|
|
|
|
<span class=special>}</span> <span class=comment>// namespace boost</span>
|
|
|
|
<span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
|
|
|
|
<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>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>
|
|
|
|
<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>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>
|
|
|
|
<span class=special>}</span> <span class=comment>// namespace std</span>
|
|
</pre></blockquote>
|
|
|
|
<h3><a name="composite_key">Template class <code>composite_key</code></a></h3>
|
|
|
|
<p>
|
|
<code>composite_key</code> is a <a href="#key_extractors"><code>Key Extractor</code></a>
|
|
returning the combined value of several key extractors whose type is specified
|
|
at compile time. The returned object is of type
|
|
<a href="#composite_key_result">
|
|
<code>composite_key_result</code></a><code><composite_key></code>.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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>
|
|
<span class=keyword>struct</span> <span class=identifier>composite_key</span>
|
|
<span class=special>{</span>
|
|
<span class=keyword>typedef</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>
|
|
<span class=keyword>typedef</span> <span class=identifier>Value</span> <span class=identifier>value_type</span><span class=special>;</span>
|
|
<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>
|
|
|
|
<span class=identifier>composite_key</span><span class=special>(</span>
|
|
<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>
|
|
<span class=special>...</span>
|
|
<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>
|
|
|
|
<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>
|
|
|
|
<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>
|
|
<span class=identifier>key_extractor_tuple</span><span class=special>&</span> <span class=identifier>key_extractors</span><span class=special>()</span>
|
|
|
|
<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>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>
|
|
|
|
<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>
|
|
<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>
|
|
<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>
|
|
<span class=special>};</span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
<code>KeyFromvalue0</code>, ... , <code>KeyFromvaluen</code> are the types of
|
|
the key extractors combined into the composite key. Each of these types
|
|
must be a <a href="#key_extractors"><code>Key Extractor</code></a> from
|
|
<code>Value</code>. At least a key extractor must be provided. The maximum
|
|
number of key extractors of a <code>composite_key</code> instantiation is
|
|
implementation defined. <code>composite_key</code> internally stores an
|
|
object of every constituent key extractor type.
|
|
<code>composite_key<Value,KeyFromValue0,...,KeyFromValuen></code> is a model
|
|
of:
|
|
<ul>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>Value</code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>reference_wrapper<const Value></code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from <code>reference_wrapper<Value></code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from any <a href="#chained_pointers">chained pointer</a>
|
|
to <code>const Value</code>,</li>
|
|
<li><a href="#key_extractors"><code>Key Extractor</code></a>
|
|
from any <a href="#chained_pointers">chained pointer</a>
|
|
to <code>Value</code>.</li>
|
|
</ul>
|
|
</p>
|
|
|
|
<h4><code>composite_key</code> members</h4>
|
|
|
|
<code>composite_key(<br>
|
|
const KeyFromValue0& k0=KeyFromValue0(),<br>
|
|
...<br>
|
|
const KeyFromValuen& kn=KeyFromValuen());
|
|
</code>
|
|
|
|
<blockquote>
|
|
<b>Effects:</b> Constructs a <code>composite_key</code> that stores
|
|
copies of the key extractor objects supplied.
|
|
</blockquote>
|
|
|
|
<code>composite_key(const key_extractor_tuple& x);</code>
|
|
|
|
<blockquote>
|
|
<b>Effects:</b> Constructs a <code>composite_key</code> that stores
|
|
copies of the key extractor objects supplied in <code>x</code>.
|
|
</blockquote>
|
|
|
|
<code>const key_extractor_tuple& key_extractors()const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> a constant reference to a tuple holding the
|
|
key extractors internally stored by the <code>composite_key</code>.
|
|
</blockquote>
|
|
|
|
<code>key_extractor_tuple& key_extractors();</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> a reference to a tuple holding the
|
|
key extractors internally stored by the <code>composite_key</code>.
|
|
</blockquote>
|
|
|
|
<code>template<typename ChainedPtr><br>
|
|
result_type operator()(const ChainedPtr& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Requires:</b> <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a>
|
|
type to <code>result_type</code>.<br>
|
|
<b>Returns:</b> a <code>result_type</code> object dependent on
|
|
<code>*this</code> and <code>y</code>, where <code>y</code> is the
|
|
object chained-pointed to by <code>x</code>.
|
|
</blockquote>
|
|
|
|
<code>result_type operator()(const value_type& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> a <code>result_type</code> object dependent on
|
|
<code>*this</code> and <code>x</code>.
|
|
</blockquote>
|
|
|
|
<code>result_type operator()(const reference_wrapper<const value_type>& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> a <code>result_type</code> object dependent on
|
|
<code>*this</code> and <code>x.get()</code>.
|
|
</blockquote>
|
|
|
|
<code>result_type operator()(const reference_wrapper<value_type>& x)const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> a <code>result_type</code> object dependent on
|
|
<code>*this</code> and <code>x.get()</code>.
|
|
</blockquote>
|
|
|
|
<h3><a name="composite_key_result">Template class
|
|
<code>composite_key_result</code></a></h3>
|
|
|
|
<p>
|
|
This is an opaque type returned by <code>composite_key</code>
|
|
instantiations as their extracted key.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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>struct</span> <span class=identifier>composite_key_result</span>
|
|
<span class=special>{</span>
|
|
<b>no public interface available</b>
|
|
<span class=special>};</span>
|
|
|
|
<span class=comment>// comparison:</span>
|
|
|
|
<span class=comment>// <b>OP</b> is any of =,<,!=,>,>=,<=</span>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
|
|
<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>
|
|
<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>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><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>x</span><span class=special>,</span>
|
|
<span class=keyword>const</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>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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span> <b><i>OP</i></b><span class=special>(</span>
|
|
<span class=keyword>const</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=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>
|
|
</pre></blockquote>
|
|
|
|
<code>CompositeKey</code> is the <code>composite_key</code> instantiation to
|
|
which the <code>composite_key_result</code> type is associated. Objects of type
|
|
<code>composite_key_result</code> returned by a composite key must be always treated
|
|
as <i>temporary</i>, i.e. they should not be stored or copied.
|
|
<code>composite_key_result</code> is <i>not</i> guaranteed to be a model of
|
|
<a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">
|
|
<code>Default Constructible</code></a> or
|
|
<a href="http://www.sgi.com/tech/stl/Assignable.html"><code>Assignable</code></a>.
|
|
Every object of type <code>composite_key_result<CompositeKey></code> is
|
|
internally asociated to the <code>CompositeKey</code> from which it is returned
|
|
and the object of type <code>CompositeKey::result_type</code> to which the
|
|
composite key was applied.
|
|
</p>
|
|
|
|
<h4><a name="ckey_result_notation">Notation</a></h4>
|
|
|
|
<p>
|
|
Given an <code>x</code> of type <code>composite_key_result<CompositeKey></code>,
|
|
we use the following notation:
|
|
<ul>
|
|
<li><code>ck(x)</code> is the <code>CompositeKey</code> object associated to
|
|
<code>x</code>,</li>
|
|
<li><code>v(x)</code> is the object of type <code>CompositeKey::value_type</code>
|
|
associated to <code>x</code>,</li>
|
|
<li><code>k<sub>i</sub>(x) = ck(x).key_extractors().get<i>()</code>,
|
|
that is, is the <code>i</code>-th key extractor of <code>ck(x)</code>,</li>
|
|
<li><code>x<sub>i</sub> = k<sub>i</sub>(x)(v(x))</code>, that is, the
|
|
key extracted from <code>v(x)</code> by the <code>i</code>-th key extractor,</li>
|
|
<li><code>length(x)</code> is the number of key extractors of <code>ck(x)</code>.</li>
|
|
</ul>
|
|
Also, if <code>y</code> is a tuple of values, we define:
|
|
<ul>
|
|
<li><code>y<sub>i</sub>=y.get<i>()</code>,</li>
|
|
<li><code>length(y)</code> is the number of elements of <code>y</code>.</li>
|
|
</ul>
|
|
</p>
|
|
|
|
<h4>Comparison operators</h4>
|
|
|
|
<code>template<typename CompositeKey1,typename CompositeKey2><br>
|
|
bool operator==(<br>
|
|
const composite_key_result<CompositeKey1>& x,<br>
|
|
const composite_key_result<CompositeKey2>& y);<br>
|
|
template<typename CompositeKey,typename Value0,...,typename Valuen><br>
|
|
bool operator==(<br>
|
|
const composite_key_result<CompositeKey>& x,<br>
|
|
const tuple<Value0,...,Valuen>& y);<br>
|
|
template<typename Value0,...,typename Valuen,typename CompositeKey><br>
|
|
bool operator==(<br>
|
|
const tuple<Value0,...,Valuen>& x,<br>
|
|
const composite_key_result<CompositeKey>& y);
|
|
</code>
|
|
|
|
<blockquote>
|
|
<b>Requires:</b> <code>length(x)==length(y)</code>. The expression
|
|
<code>x<sub>i</sub>==y<sub>i</sub></code> is valid for all <code>i</code>
|
|
in <code>[0,length(x))</code>.</br>
|
|
<b>Returns:</b> <code>true</code> if and only if
|
|
<blockquote>
|
|
<code>x<sub>i</sub>==y<sub>i</sub></code> for all <code>i</code>
|
|
in <code>[0,length(x))</code>.
|
|
</blockquote>
|
|
<b>Complexity:</b> No more key extraction operations and comparisons
|
|
are performed than those necessary for the evaluation of the expression above,
|
|
starting at <code>i==0</code>. The evaluation is short-circuited as soon as
|
|
the result is determined to be <code>false</code>.
|
|
</blockquote>
|
|
|
|
<code>template<typename CompositeKey1,typename CompositeKey2><br>
|
|
bool operator<(<br>
|
|
const composite_key_result<CompositeKey1>& x,<br>
|
|
const composite_key_result<CompositeKey2>& y);<br>
|
|
template<typename CompositeKey,typename Value0,...,typename Valuen><br>
|
|
bool operator<(<br>
|
|
const composite_key_result<CompositeKey>& x,<br>
|
|
const tuple<Value0,...,Valuen>& y);<br>
|
|
template<typename Value0,...,typename Valuen,typename CompositeKey><br>
|
|
bool operator<(<br>
|
|
const tuple<Value0,...,Valuen>& x,<br>
|
|
const composite_key_result<CompositeKey>& y);
|
|
</code>
|
|
|
|
<blockquote>
|
|
<b>Requires:</b> The expressions
|
|
<code>x<sub>i</sub><y<sub>i</sub></code> and
|
|
<code>y<sub>i</sub><x<sub>i</sub></code> are valid for all <code>i</code>
|
|
in <code>[0,min(length(x),length(y)))</code>.</br>
|
|
<b>Returns:</b> <code>true</code> if and only if there exists some
|
|
<code>j</code> in the range <code>[0,min(length(x),length(y)))</code>
|
|
such that
|
|
<blockquote>
|
|
<code>!(x<sub>i</sub><y<sub>i</sub>) && !(y<sub>i</sub><x<sub>i</sub>)</code>
|
|
for all <code>i</code> in <code>[0,j)</code>,<br>
|
|
<code> x<sub>j</sub><y<sub>j</sub></code>.
|
|
</blockquote>
|
|
<b>Complexity:</b> No more key extraction operations and comparisons
|
|
are performed than those necessary for the evaluation of the expression above,
|
|
starting at <code>i==0</code>. The evaluation is short-circuited as soon as
|
|
the result is determined to be <code>false</code>.
|
|
</blockquote>
|
|
|
|
<code>template<typename CompositeKey1,typename CompositeKey2><br>
|
|
bool operator <b><i>OP</i></b>(<br>
|
|
const composite_key_result<CompositeKey1>& x,<br>
|
|
const composite_key_result<CompositeKey2>& y);<br>
|
|
template<typename CompositeKey,typename Value0,...,typename Valuen><br>
|
|
bool operator <b><i>OP</i></b>(<br>
|
|
const composite_key_result<CompositeKey>& x,<br>
|
|
const tuple<Value0,...,Valuen>& y);<br>
|
|
template<typename Value0,...,typename Valuen,typename CompositeKey><br>
|
|
bool operator <b><i>OP</i></b>(<br>
|
|
const tuple<Value0,...,Valuen>& x,<br>
|
|
const composite_key_result<CompositeKey>& y);
|
|
</code>
|
|
|
|
<p>
|
|
(<code><b><i>OP</i></b></code> is any of <code>!=</code>, <code>></code>,
|
|
<code>>=</code>, <code><=</code>.)
|
|
</p>
|
|
|
|
<blockquote>
|
|
<b>Requires:</b> The expressions given below are valid (for the particular
|
|
<code><b><i>OP</i></b></code> considered.)</br>
|
|
<b>Returns:</b> <code>true</code> if and only if
|
|
<blockquote>
|
|
<code>!(x==y)</code> (<code><b><i>OP</i></b></code> is <code>!=</code>),<br>
|
|
<code> y< x </code> (<code><b><i>OP</i></b></code> is <code>> </code>),<br>
|
|
<code>!(x< y)</code> (<code><b><i>OP</i></b></code> is <code>>=</code>),<br>
|
|
<code>!(y< x)</code> (<code><b><i>OP</i></b></code> is <code><=</code>).
|
|
</blockquote>
|
|
</blockquote>
|
|
|
|
<h3><a name="composite_key_compare">Template class
|
|
<code>composite_key_compare</code></a></h3>
|
|
|
|
<p>
|
|
<code>composite_key_compare</code> compares <code>composite_key_result</code>
|
|
instantiations between them and with tuples of values using an internally stored
|
|
collection of elementary comparison predicates.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<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>
|
|
<span class=keyword>struct</span> <span class=identifier>composite_key_compare</span>
|
|
<span class=special>{</span>
|
|
<span class=keyword>typedef</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>
|
|
|
|
<span class=identifier>composite_key_compare</span><span class=special>(</span>
|
|
<span class=keyword>const</span> <span class=identifier>Compare0</span><span class=special>&</span> <span class=identifier>co</span><span class=special>=</span><span class=identifier>Compare0</span><span class=special>(),</span>
|
|
<span class=special>...</span>
|
|
<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>
|
|
|
|
<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>
|
|
|
|
<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><span class=keyword>return</span> <span class=special>*</span><span class=keyword>this</span><span class=special>;}</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>return</span> <span class=special>*</span><span class=keyword>this</span><span class=special>;}</span>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
|
|
<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>
|
|
<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>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</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>x</span><span class=special>,</span>
|
|
<span class=keyword>const</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>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
|
|
<span class=keyword>const</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=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>
|
|
<span class=special>};</span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
<code>Compare0</code>, ... , <code>Compare0</code> are the types of the comparison
|
|
predicates stored by <code>composite_key_compare</code>. Each of these types
|
|
must be a <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">
|
|
<code>Binary Predicate</code></a>. At least a
|
|
comparison predicate must be provided. The maximum number of comparison predicates of
|
|
a <code>composite_key_compare</code> instantiation is implementation defined.
|
|
<code>composite_key_compare</code> is
|
|
<a href="http://www.sgi.com/tech/stl/Assignable.html"><code>Assignable</code></a>.
|
|
It is also
|
|
<a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">
|
|
<code>Default Constructible</code></a>
|
|
if each <code>Comparei</code> is
|
|
<a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">
|
|
<code>Default Constructible</code></a>.
|
|
</p>
|
|
|
|
<p>
|
|
Note that formally it is not required that the <code>Comparei</code> types
|
|
behave as comparison predicates in any definite way. However, the
|
|
semantics of <code>composite_key_compare</code> are well defined if this
|
|
is the case, as explained in the <a href="#ordering_semantics">ordering
|
|
semantics</a> section.
|
|
</p>
|
|
|
|
<h4>Notation</h4>
|
|
|
|
<p>
|
|
In what follows we use the same <a href="#ckey_result_notation">notation</a>
|
|
introduced for <code>composite_key_result</code>.
|
|
|
|
<h4><code>composite_key_compare</code> members</h4>
|
|
|
|
<code>composite_key_compare(<br>
|
|
const Compare0& c0=Compare0(),<br>
|
|
...<br>
|
|
const Comparen& kn=Comparen());
|
|
</code>
|
|
|
|
<blockquote>
|
|
<b>Effects:</b> Constructs a <code>composite_key_compare</code> that stores
|
|
copies of the comparison predicates supplied.
|
|
</blockquote>
|
|
|
|
<code>composite_key_compare(const key_comp_tuple& x);</code>
|
|
|
|
<blockquote>
|
|
<b>Effects:</b> Constructs a <code>composite_key_compare</code> that stores
|
|
copies of the comparison predicate objects supplied in <code>x</code>.
|
|
</blockquote>
|
|
|
|
<code>const key_comp_tuple& key_comps()const;</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> a constant reference to a tuple holding the
|
|
comparison predicate objects internally stored by the
|
|
<code>composite_key_compare</code>.
|
|
</blockquote>
|
|
|
|
<code>key_comp_tuple& key_comps();</code>
|
|
|
|
<blockquote>
|
|
<b>Returns:</b> a reference to a tuple holding the
|
|
comparison predicate objects internally stored by the
|
|
<code>composite_key_compare</code>.
|
|
</blockquote>
|
|
|
|
<code>
|
|
template<typename CompositeKey1,typename CompositeKey2><br>
|
|
bool operator()(<br>
|
|
const composite_key_result<CompositeKey1> & x,<br>
|
|
const composite_key_result<CompositeKey2> & y)const;<br>
|
|
template<typename CompositeKey,typename Value0,...,typename Valuen><br>
|
|
bool operator()(<br>
|
|
const composite_key_result<CompositeKey>& x,<br>
|
|
const tuple<Value0,...,Valuen>& y)const;<br>
|
|
template<typename Value0,...,typename Valuen,typename CompositeKey><br>
|
|
bool operator()(<br>
|
|
const tuple<Value0,...,Valuen>& x,<br>
|
|
const composite_key_result<CompositeKey>& y)const;<br>
|
|
</code>
|
|
|
|
<blockquote>
|
|
<b>Requires:</b> The expressions
|
|
<code>key_comps().get<i>()(x<sub>i</sub>,y<sub>i</sub>)</code> and
|
|
<code>key_comps().get<i>()(y<sub>i</sub>,x<sub>i</sub>)</code>
|
|
are valid for all <code>i</code>
|
|
in <code>[0,min(length(x),length(y)))</code>.</br>
|
|
<b>Returns:</b> <code>true</code> if and only if there exists some
|
|
<code>j</code> in the range <code>[0,min(length(x),length(y)))</code>
|
|
such that
|
|
<blockquote>
|
|
<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>
|
|
for all <code>i</code> in <code>[0,j)</code>,<br>
|
|
<code> key_comps().get<j>()(x<sub>j</sub>,y<sub>j</sub>)</code>.
|
|
</blockquote>
|
|
<b>Complexity:</b> No more key extraction operations and comparisons
|
|
are performed than those necessary for the evaluation of the expression above,
|
|
starting at <code>i==0</code>. The evaluation is short-circuited as soon as
|
|
the result is determined to be <code>false</code>.
|
|
</blockquote>
|
|
|
|
<h3><a name="composite_key_result_less">Template class
|
|
<code>composite_key_result_less</code></a></h3>
|
|
|
|
<p>
|
|
<code>composite_key_result</code> acts as a particularization of
|
|
<code>composite_key_compare</code> where all the comparison predicates supplied
|
|
are instantiations of <code>std::less</code>.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKeyResult</span><span class=special>></span>
|
|
<span class=keyword>struct</span> <span class=identifier>composite_key_result_less</span>
|
|
<span class=special>{</span>
|
|
<span class=keyword>typedef</span> <span class=identifier>CompositeKeyResult</span> <span class=identifier>first_argument_type</span><span class=special>;</span>
|
|
<span class=keyword>typedef</span> <span class=identifier>first_argument_type</span> <span class=identifier>second_argument_type</span><span class=special>;</span>
|
|
<span class=keyword>typedef</span> <span class=keyword>bool</span> <span class=identifier>result_type</span><span class=special>;</span>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
|
|
<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>
|
|
<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>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</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>x</span><span class=special>,</span>
|
|
<span class=keyword>const</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>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
|
|
<span class=keyword>const</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=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>
|
|
<span class=special>};</span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
<code>CompositeKeyResult</code> must be an instantiation of
|
|
<code>composite_key_result</code> for some type
|
|
<code>composite_key<KeyFromValue0,...,KeyFromValuen></code>.
|
|
<code>composite_key_result_less<CompositeKeyResult>::operator()</code> is
|
|
then equivalent to
|
|
<code>composite_key_compare<Compare0,...,Comparen>::operator()</code>, taking
|
|
<blockquote>
|
|
<code>Comparei = std::less<KeyFromValuei::result_type></code> for all
|
|
<code>i = 0,...,n</code>.
|
|
</blockquote>
|
|
</p>
|
|
|
|
<p>
|
|
In addition to the requirements on <code>Comparei</code> imposed by
|
|
<code>composite_key_compare</code>, each of these types must be
|
|
<a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">
|
|
<code>Default Constructible</code></a>. <code>composite_key_result_less</code>
|
|
is <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">
|
|
<code>Default Constructible</code></a> and
|
|
<a href="http://www.sgi.com/tech/stl/Assignable.html"><code>Assignable</code></a>.
|
|
</p>
|
|
|
|
<h3><a name="composite_key_result_greater">Template class
|
|
<code>composite_key_result_greater</code></a></h3>
|
|
|
|
<p>
|
|
<code>composite_key_result</code> acts as a particularization of
|
|
<code>composite_key_compare</code> where all the comparison predicates supplied
|
|
are instantiations of <code>std::greater</code>.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<span class=keyword>template</span><span class=special><</span><span class=keyword>typename</span> <span class=identifier>CompositeKeyResult</span><span class=special>></span>
|
|
<span class=keyword>struct</span> <span class=identifier>composite_key_result_greater</span>
|
|
<span class=special>{</span>
|
|
<span class=keyword>typedef</span> <span class=identifier>CompositeKeyResult</span> <span class=identifier>first_argument_type</span><span class=special>;</span>
|
|
<span class=keyword>typedef</span> <span class=identifier>first_argument_type</span> <span class=identifier>second_argument_type</span><span class=special>;</span>
|
|
<span class=keyword>typedef</span> <span class=keyword>bool</span> <span class=identifier>result_type</span><span class=special>;</span>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
|
|
<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>
|
|
<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>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</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>x</span><span class=special>,</span>
|
|
<span class=keyword>const</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>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
|
|
<span class=keyword>const</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=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>
|
|
<span class=special>};</span>
|
|
</pre></blockquote>
|
|
|
|
<p>
|
|
<code>CompositeKeyResult</code> must be an instantiation of
|
|
<code>composite_key_result</code> for some type
|
|
<code>composite_key<KeyFromValue0,...,KeyFromValuen></code>.
|
|
<code>composite_key_result_greater<CompositeKeyResult>::operator()</code> is
|
|
then equivalent to
|
|
<code>composite_key_compare<Compare0,...,Comparen>::operator()</code>, taking
|
|
<blockquote>
|
|
<code>Comparei = std::greater<KeyFromValuei::result_type></code> for all
|
|
<code>i = 0,...,n</code>.
|
|
</blockquote>
|
|
</p>
|
|
|
|
<p>
|
|
In addition to the requirements on <code>Comparei</code> imposed by
|
|
<code>composite_key_compare</code>, each of these types must be
|
|
<a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">
|
|
<code>Default Constructible</code></a>. <code>composite_key_result_greater</code>
|
|
is <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">
|
|
<code>Default Constructible</code></a> and
|
|
<a href="http://www.sgi.com/tech/stl/Assignable.html"><code>Assignable</code></a>.
|
|
</p>
|
|
|
|
<h3><a name="less_composite_key_result">Specialization of <code>std::less</code> for
|
|
<code>composite_key</code> results</a></h3>
|
|
|
|
<p>
|
|
<code>std::less<CompositeKeyResult></code>, for <code>CompositeKeyResult</code>
|
|
being an instantiation of <code>composite_key_result</code>, has the same interface
|
|
and functionality that <code>composite_key_result_less<CompositeKeyResult></code>.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
|
|
|
|
<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>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>
|
|
<span class=special>{</span>
|
|
<span class=keyword>typedef</span> <span class=identifier>CompositeKeyResult</span> <span class=identifier>first_argument_type</span><span class=special>;</span>
|
|
<span class=keyword>typedef</span> <span class=identifier>first_argument_type</span> <span class=identifier>second_argument_type</span><span class=special>;</span>
|
|
<span class=keyword>typedef</span> <span class=keyword>bool</span> <span class=identifier>result_type</span><span class=special>;</span>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
|
|
<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>
|
|
<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>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</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>x</span><span class=special>,</span>
|
|
<span class=keyword>const</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>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
|
|
<span class=keyword>const</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=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>
|
|
<span class=special>};</span>
|
|
|
|
<span class=special>}</span> <span class=comment>// namespace std</span>
|
|
</pre></blockquote>
|
|
|
|
<h3><a name="greater_composite_key_result">Specialization of <code>std::greater</code> for
|
|
<code>composite_key</code> results</a></h3>
|
|
|
|
<p>
|
|
<code>std::greater<CompositeKeyResult></code>, for <code>CompositeKeyResult</code>
|
|
being an instantiation of <code>composite_key_result</code>, has the same interface
|
|
and functionality that <code>composite_key_result_greater<CompositeKeyResult></code>.
|
|
</p>
|
|
|
|
<blockquote><pre>
|
|
<span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
|
|
|
|
<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>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>
|
|
<span class=special>{</span>
|
|
<span class=keyword>typedef</span> <span class=identifier>CompositeKeyResult</span> <span class=identifier>first_argument_type</span><span class=special>;</span>
|
|
<span class=keyword>typedef</span> <span class=identifier>first_argument_type</span> <span class=identifier>second_argument_type</span><span class=special>;</span>
|
|
<span class=keyword>typedef</span> <span class=keyword>bool</span> <span class=identifier>result_type</span><span class=special>;</span>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
|
|
<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>
|
|
<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>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</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>x</span><span class=special>,</span>
|
|
<span class=keyword>const</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>
|
|
|
|
<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>
|
|
<span class=keyword>bool</span> <span class=keyword>operator</span><span class=special>()(</span>
|
|
<span class=keyword>const</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=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>
|
|
<span class=special>};</span>
|
|
|
|
<span class=special>}</span> <span class=comment>// namespace std</span>
|
|
</pre></blockquote>
|
|
|
|
<h3><a name="ordering_semantics">Ordering semantics</a></h3>
|
|
|
|
<p>
|
|
Consider an instantiation of <code>composite_key_compare</code> with
|
|
types <code>Compare0</code>, ... , <code>Comparen</code> such that each
|
|
<code>Comparei</code> is a
|
|
<a href="http://www.sgi.com/tech/stl/StrictWeakOrdering.html"><code>Strict
|
|
Weak Ordering</code></a> on a certain type <code>Ti</code>. Then the following
|
|
properties hold.
|
|
</p>
|
|
|
|
<p>
|
|
Let <code>CompositeKey</code> be a type of the form
|
|
<code>composite_key<Value,KeyFromValue0,...,KeyFromValuej></code>,
|
|
with <code>j <= n</code>, such that
|
|
<blockquote>
|
|
<code>KeyFromValuei::result_type = Ti</code>, for all <code>i = 0,...,j</code>.
|
|
</blockquote>
|
|
Then, <code>composite_key_compare</code> is a
|
|
<a href="http://www.sgi.com/tech/stl/StrictWeakOrdering.html"><code>Strict
|
|
Weak Ordering</code></a> on elements of type
|
|
<code>composite_key_result<CompositeKey></code>, and the order induced
|
|
is lexicographical. Also, the following types are
|
|
<a href="ord_indices.html#set_operations"><code>Compatible Keys</code></a> of
|
|
<code>composite_key_compare</code> with respect to
|
|
<code>composite_key_result<CompositeKey></code>:
|
|
<blockquote>
|
|
<code>tuple<Q0,...,Qk></code>, <code>k <= n</code><br>
|
|
<code>composite_key_result<composite_key<K0,...,Kk> ></code>, with
|
|
<code>Ki::result_type = Qi</code> for all <code>i = 0,...,k</code>.
|
|
</blockquote>
|
|
provided that each <code>Qi</code> is either <code>Ti</code> or a
|
|
<a href="ord_indices.html#set_operations"><code>Compatible Key</code></a>
|
|
of <code>Comparei</code>. In this case, the comparison is done
|
|
lexicographically only on the first <code>1+min(j,k)</code> elements.
|
|
</p>
|
|
|
|
<p>
|
|
The rationale of this design is simple:
|
|
<code>composite_key_result</code>s are regarded as "virtual" tuples
|
|
with each element being the result of the corresponding elementary key
|
|
extractor. Accordingly, these objects and actual tuples are compared
|
|
lexicographically taking the minimum length of the operands considered.
|
|
</p>
|
|
|
|
<p>
|
|
Analogous properties hold for
|
|
<code>composite_key_result::operator<</code>. As for
|
|
<code>operator==</code>, the semantics is compatible with that of
|
|
less-than comparison, with the additional constraint that only objects
|
|
of the same length can be tested for equality. In this regard,
|
|
the equivalence classes induced by <code>x==y</code> are subsets
|
|
of those associated to <code>!(x<y)&&!(y<x)</code>.
|
|
</p>
|
|
|
|
<hr>
|
|
|
|
<div class="prev_link"><a href="seq_indices.html"><img src="../prev.gif" alt="sequenced indices" border="0"><br>
|
|
Sequenced indices
|
|
</a></div>
|
|
<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"><br>
|
|
Boost.MultiIndex reference
|
|
</a></div>
|
|
<div class="next_link"><a href="../compiler_specifics.html"><img src="../next.gif" alt="compiler specifics" border="0"><br>
|
|
Compiler specifics
|
|
</a></div><br clear="all" style="clear: all;">
|
|
|
|
<br>
|
|
|
|
<p>Revised May 7th 2004</p>
|
|
|
|
<p>Copyright © 2003-2004 Joaquín M López Muñoz.
|
|
Use, modification, and distribution are subject to the Boost Software
|
|
License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
|
|
LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
|
|
www.boost.org/LICENSE_1_0.txt</a>)
|
|
</p>
|
|
|
|
</body>
|
|
</html>
|