boost-react-native-bundle

<!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"> <link rel="start" href="../index.html"> <link rel="prev" href="rnd_indices.html"> <link rel="up" href="index.html"> <link rel="next" href="../compiler_specifics.html"> </head> <body> <h1><img src="../../../../boost.png" alt="boost.png (6897 bytes)" align= "middle" width="277" height="86">Boost.MultiIndex Key extraction reference</h1> <div class="prev_link"><a href="rnd_indices.html"><img src="../prev.gif" alt="random access indices" border="0"> Random access indices </a></div> <div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.MultiIndex reference" border="0"> Boost.MultiIndex reference </a></div> <div class="next_link"><a href="../compiler_specifics.html"><img src="../next.gif" alt="compiler specifics" border="0"> Compiler specifics </a></div> <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">Class template <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">Class template <code>member</code></a></li> <li><a href="#member_offset">Class template <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">Class template <code>const_mem_fun</code></a></li> <li><a href="#mem_fun">Class template <code>mem_fun</code></a></li> <li><a href="#const_mem_fun_explicit">Class templates <code>const_mem_fun_explicit</code> and <code>mem_fun_explicit</code></a></li> <li><a href="#boost_multi_index_const_mem_fun">Macros <code>BOOST_MULTI_INDEX_CONST_MEM_FUN</code> and <code>BOOST_MULTI_INDEX_MEM_FUN</code></a></li> </ul> </li> <li><a href="#global_fun_synopsis">Header <code>"boost/multi_index/global_fun.hpp"</code> synopsis</a> <ul> <li><a href="#global_fun">Class template <code>global_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">Class template <code>composite_key</code></a></li> <li><a href="#composite_key_result">Class template <code>composite_key_result</code></a></li> <li><a href="#ckey_result_equality">Equality</a> <ul> <li><a href="#composite_key_equal_to">Class template <code>composite_key_equal_to</code></a></li> <li><a href="#composite_key_result_equal_to">Class template <code>composite_key_result_equal_to</code></a></li> <li><a href="#equal_to_composite_key_result">Specialization of <code>std::equal_to</code> for <code>composite_key</code> results</a></li> </ul> </li> <li><a href="#ckey_result_comparison">Comparison</a> <ul> <li><a href="#composite_key_compare">Class template <code>composite_key_compare</code></a></li> <li><a href="#composite_key_result_less">Class template <code>composite_key_result_less</code></a></li> <li><a href="#composite_key_result_greater">Class template <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> </ul> </li> <li><a href="#ckey_result_hashing">Hashing</a> <ul> <li><a href="#composite_key_hash">Class template <code>composite_key_hash</code></a></li> <li><a href="#composite_key_result_hash">Class template <code>composite_key_result_hash</code></a></li> <li><a href="#hash_composite_key_result">Specialization of <code>boost::hash</code> for <code>composite_key</code> results</a></li> </ul> </li> <li><a href="#ckey_result_semantics">Semantics of <code>composite_key_result</code></a></li> </ul> </li> </ul> <h2><a name="key_extractors">Key Extractors</a></h2> Key extraction classes are used by <a href="indices.html#key_based_indices">key-based indices</a> to obtain the indexing keys from the elements of a <code>multi_index_container</code>. A <code>CopyConstructible</code> and <code>CopyAssignable</code> class <code>KeyFromValue</code> is said to be a key extractor from a type <code>Type</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>. Additionally, <code>KeyFromValue</code> is a read/write 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>. Boost.MultiIndex provides six 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>,</li> <li><a href="#mem_fun"><code>mem_fun</code></a>,</li> <li><a href="#global_fun"><code>global_fun</code></a> and</li> <li><a href="#composite_key"><code>composite_key</code></a>.</li> </ul> <h3><a name="chained_pointers">Chained pointers</a></h3> 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 chained pointers 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>*p</code> yields an object of type <code>Type&</code> or <code>boost::reference_wrapper<Type></code>, OR</li> <li><code>*p</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>. <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> #include <boost/multi_index/identity.hpp> #include <boost/multi_index/member.hpp> #include <boost/multi_index/mem_fun.hpp> #include <boost/multi_index/global_fun.hpp> #include <boost/multi_index/composite_key.hpp> </pre></blockquote> This header includes all the key extractors provided by Boost.MultiIndex. <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> namespace boost{ namespace multi_index{ template<typename T> struct identity; } // namespace boost::multi_index } // namespace boost </pre></blockquote> <h3><a name="identity">Class template <code>identity</code></a></h3> <code>identity</code> is a <a href="#key_extractors"><code>Key Extractor</code></a> that acts as a do-nothing identity functor. <blockquote><pre> template<typename Type> struct identity { typedef Type result_type; // only provided if const ChainedPtr& is not convertible to const Type& template<typename ChainedPtr> Type& operator()(const ChainedPtr& x)const; const Type& operator()(const Type& x)const; Type& operator()(Type& x)const; // only provided if Type is non-const // only provided if Type is non-const const Type& operator()(const reference_wrapper<const Type>& x)const; // only provided if Type is const Type& operator()( const reference_wrapper<typename remove_const<Type>::type>& x)const; Type& operator()(const reference_wrapper<Type>& x)const; }; </pre></blockquote> <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> <h4><code>identity</code> members</h4> <code>template<typename ChainedPtr> Type& operator()(const ChainedPtr& x)const;</code> <blockquote> Requires: <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a> type to <code>Type</code>. Returns: a reference to the object chained-pointed to by <code>x</code>. </blockquote> <code>const Type& operator()(const Type& x)const;</code> <blockquote> Returns: <code>x</code>. </blockquote> <code>Type& operator()(Type& x)const;</code> <blockquote> Returns: <code>x</code>. </blockquote> <code>const Type& operator()(const reference_wrapper<const Type>& x)const;</code> <blockquote> Returns: <code>x.get()</code>. </blockquote> <code>Type& operator()(const reference_wrapper<typename remove_const<Type>::type>& x)const;</code> <blockquote> Returns: <code>x.get()</code>. </blockquote> <code>Type& operator()(const reference_wrapper<Type>& x)const;</code> <blockquote> Returns: <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> namespace boost{ namespace multi_index{ template<class Class,typename Type,Type Class::*PtrToMember> struct member; template<class Class,typename Type,std::size_t OffsetOfMember> struct member_offset; // deprecated #define BOOST_MULTI_INDEX_MEMBER(Class,Type,MemberName) implementation defined } // namespace boost::multi_index } // namespace boost </pre></blockquote> <h3><a name="member">Class template <code>member</code></a></h3> <code>member</code> is a <a href="#key_extractors"><code>Key Extractor</code></a> aimed at accessing a given member of a class. <blockquote><pre> template<class Class,typename Type,Type Class::*PtrToMember> struct member { typedef Type result_type; // only provided if const ChainedPtr& is not convertible to const Class& template<typename ChainedPtr> Type& operator()(const ChainedPtr& x)const; const Type& operator()(const Class& x)const; Type& operator()(Class& x)const; // only provided if Type is non-const const Type& operator()(const reference_wrapper<const Class>& x)const; Type& operator()(const reference_wrapper<Class>& x)const; }; </pre></blockquote> 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>,</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> <h4><code>member</code> members</h4> <code>template<typename ChainedPtr> Type& operator()(const ChainedPtr& x)const;</code> <blockquote> Requires: <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a> type to <code>Type</code>. Returns: a reference to the object chained-pointed to by <code>x</code>. </blockquote> <code>const Type& operator()(const Class& x)const;</code> <blockquote> Returns: <code>x.*PtrToMember</code>. </blockquote> <code>Type& operator()(Class& x)const;</code> <blockquote> Returns: <code>x.*PtrToMember</code>. </blockquote> <code>const Type& operator()(const reference_wrapper<const Class>& x)const;</code> <blockquote> Returns: <code>x.get().*PtrToMember</code>. </blockquote> <code>Type& operator()(const reference_wrapper<Class>& x)const;</code> <blockquote> Returns: <code>x.get().*PtrToMember</code>. </blockquote> <h3><a name="member_offset">Class template <code>member_offset</code></a></h3> <code>member_offset</code> was designed to overcome limitations of some legacy compilers and its use is currently deprecated. Refer to a <a href="http://www.boost.org/doc/libs/1_54_0/libs/multi_index/doc/reference/key_extraction.html#member_offset">former version</a> of Boost.MultiIndex for further information. <h3><a name="boost_multi_index_member">Macro <code>BOOST_MULTI_INDEX_MEMBER</code></a></h3> <blockquote><pre> BOOST_MULTI_INDEX_MEMBER(Class,Type,MemberName) </pre></blockquote> This macro was designed as a portability mechanism for legacy compilers where <code>member</code> could not be supported. As such it is no longer needed in modern environments, though some users might still prefer it to plain <code>member</code> because it provides a slightly more concise syntax. <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> namespace boost{ namespace multi_index{ template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()const> struct const_mem_fun; template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()> struct mem_fun; template< class Class,typename Type, typename PtrToMemberFunctionType,PtrToMemberFunctionType PtrToMemberFunction > struct const_mem_fun_explicit; // deprecated template< class Class,typename Type, typename PtrToMemberFunctionType,PtrToMemberFunctionType PtrToMemberFunction > struct mem_fun_explicit; // deprecated #define BOOST_MULTI_INDEX_CONST_MEM_FUN(Class,Type,MemberFunName) \ implementation defined #define BOOST_MULTI_INDEX_MEM_FUN(Class,Type,MemberFunName) \ implementation defined } // namespace boost::multi_index } // namespace boost </pre></blockquote> <h3><a name="const_mem_fun">Class template <code>const_mem_fun</code></a></h3> <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. <blockquote><pre> template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()const> struct const_mem_fun { typedef typename remove_reference<Type>::type result_type; // only provided if const ChainedPtr& is not convertible to const Class& template<typename ChainedPtr> Type operator()(const ChainedPtr& x)const; Type operator()(const Class& x)const; Type operator()(const reference_wrapper<const Class>& x)const; Type operator()(const reference_wrapper<Class>& x)const; }; </pre></blockquote> 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> <h4><code>const_mem_fun</code> members</h4> <code>template<typename ChainedPtr> Type operator()(const ChainedPtr& x)const;</code> <blockquote> Requires: <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a> type to <code>Type</code>. Returns: <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> Returns: <code>(x.*PtrToMemberFunction)()</code>. </blockquote> <code>Type operator()(const reference_wrapper<const Class>& x)const;</code> <blockquote> Returns: <code>(x.get().*PtrToMemberFunction)()</code>. </blockquote> <code>Type operator()(const reference_wrapper<Class>& x)const;</code> <blockquote> Returns: <code>(x.get().*PtrToMemberFunction)()</code>. </blockquote> <h3><a name="mem_fun">Class template <code>mem_fun</code></a></h3> <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. <blockquote><pre> template<class Class,typename Type,Type (Class::*PtrToMemberFunction)()> struct mem_fun { typedef typename remove_reference<Type>::type result_type; // only provided if ChainedPtr& is not convertible to Class& template<typename ChainedPtr> Type operator()(const ChainedPtr& x)const; Type operator()(Class& x)const; Type operator()(const reference_wrapper<Class>& x)const; }; </pre></blockquote> 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> <h4><code>mem_fun</code> members</h4> <code>template<typename ChainedPtr> Type operator()(const ChainedPtr& x)const;</code> <blockquote> Requires: <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a> type to <code>Type</code>. Returns: <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> Returns: <code>(x.*PtrToMemberFunction)()</code>. </blockquote> <code>Type operator()(const reference_wrapper<Class>& x)const;</code> <blockquote> Returns: <code>(x.get().*PtrToMemberFunction)()</code>. </blockquote> <h3><a name="const_mem_fun_explicit">Class templates <code>const_mem_fun_explicit</code> and <code>mem_fun_explicit</code></a></h3> These extractors were provided as a workaround for MSVC++ 6.0 and are now deprecated. Refer to a <a href="http://www.boost.org/doc/libs/1_54_0/libs/multi_index/doc/reference/key_extraction.html#const_mem_fun_explicit">former version</a> of Boost.MultiIndex for further information. <h3><a name="boost_multi_index_const_mem_fun">Macros <code>BOOST_MULTI_INDEX_CONST_MEM_FUN</code> and <code>BOOST_MULTI_INDEX_MEM_FUN</code></a></h3> <blockquote><pre> BOOST_MULTI_INDEX_CONST_MEM_FUN(Class,Type,MemberFunName) BOOST_MULTI_INDEX_MEM_FUN(Class,Type,MemberFunName) </pre></blockquote> Portability macros for usage of <code>const_mem_fun</code> and <code>mem_fun</code>. Although no longer needed in modern compilers, some users might still decide to resort to them as they provide a slightly more concise syntax. <h2> <a name="global_fun_synopsis">Header <a href="../../../../boost/multi_index/global_fun.hpp"> <code>"boost/multi_index/global_fun.hpp"</code></a> synopsis</a></h2> <blockquote><pre> namespace boost{ namespace multi_index{ template<class Value,typename Type,Type (*PtrToFunction)(Value)> struct global_fun; } // namespace boost::multi_index } // namespace boost </pre></blockquote> <h3><a name="global_fun">Class template <code>global_fun</code></a></h3> <code>global_fun</code> is a <a href="#key_extractors"><code>Key Extractor</code></a> based on a given global or static member function accepting the base type as argument and returning the associated key. <blockquote><pre> template<class Value,typename Type,Type (*PtrToFunction)(Value)> struct global_fun { typedef typename remove_reference<Type>::type result_type; // Only provided under the following circumstances: // - If Value is a reference to a constant type, only provided // when const ChainedPtr& is not convertible to Value; // - if Value is a reference to a non-const type, only provided // when ChainedPtr& is not convertible to Value; // - else, only provided when const ChainedPtr& is not // convertible to const Value&. Type operator()(const ChainedPtr& x)const; // only provided if Value is a reference type Type operator()(Value x)const; // only provided if Value is not a reference type Type operator()(const Value& x)const; // only provided if Value is not a reference type Type operator()(const reference_wrapper<const Value>& x)const; // only provided if Value is a reference type Type operator()( const reference_wrapper< remove_reference<Value>::type>& x)const; // only provided if Value is not a reference type or is // a reference to a constant type Type operator()( const reference_wrapper< typename remove_const< typename remove_reference<Value>::type>::type>& x)const; }; </pre></blockquote> <code>PtrToFunction</code> specifies the particular function used to extract the key of type <code>Type</code> from some <code>BaseType</code>. <code>global_fun</code> supports the following function signatures: <ul> <li><code>Type f(BaseType)</code> (<code>Value</code> is <code>BaseType</code>),</li> <li><code>Type f(const BaseType&)</code> (<code>Value</code> is <code>const BaseType&</code>),</li> <li><code>Type f(BaseType&)</code> (<code>Value</code> is <code>BaseType&</code>).</li> </ul> <code>global_fun<Type,Value,PtrToFunction></code> is a model of: <ul> <li><a href="#key_extractors"><code>Key Extractor</code></a> from <code>reference_wrapper<BaseType></code>,</li> <li><a href="#key_extractors"><code>Key Extractor</code></a> from any <a href="#chained_pointers">chained pointer</a> to <code>BaseType</code>.</li> </ul> When <code>Value</code> is <code>BaseType</code> or <code>const BaseType&</code>, <code>global_fun<Type,Value,PtrToFunction></code> is also a model of: <ul> <li><a href="#key_extractors"><code>Key Extractor</code></a> from <code>BaseType</code>,</li> <li><a href="#key_extractors"><code>Key Extractor</code></a> from <code>reference_wrapper<const BaseType></code>,</li> <li><a href="#key_extractors"><code>Key Extractor</code></a> from any <a href="#chained_pointers">chained pointer</a> to <code>const BaseType</code>.</li> </ul> <h4><code>global_fun</code> members</h4> <code>template<typename ChainedPtr> Type operator()(const ChainedPtr& x)const;</code> <blockquote> Requires: <code>ChainedPtr</code> is a <a href="#chained_pointers">chained pointer</a> type to <code>Value</code>. Returns: <code>PtrToFunction)(y)</code>, where <code>y</code> is the object chained-pointed to by <code>x</code>. </blockquote> <code>Type operator()(Value x)const;</code> <blockquote> Returns: <code>PtrToFunction(x)</code>. </blockquote> <code>Type operator()(const Value& x)const;</code> <blockquote> Returns: <code>PtrToFunction(x)</code>. </blockquote> <code>Type operator()(const reference_wrapper<const Value>& x)const;</code> <blockquote> Returns: <code>PtrToFunction(x.get())</code>. </blockquote> <code> Type operator()(   const reference_wrapper<remove_reference<Value>::type>& x)const;</code> <blockquote> Returns: <code>PtrToFunction(x.get())</code>. </blockquote> <code>Type operator()(   const reference_wrapper<     typename remove_const<       typename remove_reference<Value>::type>::type>& x)const;</code> <blockquote> Returns: <code>PtrToFunction(x.get())</code>. </blockquote> <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> namespace boost{ namespace multi_index{ template<typename Value,typename KeyFromValue0,...,typename KeyFromValuen> struct composite_key; template<typename CompositeKey> struct composite_key_result; // comparison operators for composite_key_result: // OP is any of ==,<,!=,>,>=,<= template<typename CompositeKey1,typename CompositeKey2> bool operator OP( const composite_key_result&