mirror of
https://github.com/boostorg/ptr_container.git
synced 2026-02-23 16:02:10 +00:00
127 lines
4.8 KiB
HTML
127 lines
4.8 KiB
HTML
<?xml version="1.0" encoding="utf-8" ?>
|
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
|
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
|
|
<head>
|
|
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
|
<meta name="generator" content="Docutils 0.3.7: http://docutils.sourceforge.net/" />
|
|
<title>Indirected functions</title>
|
|
<link rel="stylesheet" href="default.css" type="text/css" />
|
|
</head>
|
|
<body>
|
|
<div class="document" id="indirected-functions">
|
|
<h1 class="title">Indirected functions</h1>
|
|
<p>It is quite common that we have two pointers and what to compare the
|
|
pointed to objects. Also, we have usually already defined how
|
|
to compare the objects. So to avoid some tedious boiler-plate code
|
|
this library defines predicates that apply an indirection before comparing.</p>
|
|
<p>When the container uses <tt class="docutils literal"><span class="pre">void*</span></tt> internally, we can use the
|
|
class <tt class="docutils literal"><span class="pre">void_ptr_indirect_fun</span></tt>; otherwise we use the class
|
|
<tt class="docutils literal"><span class="pre">indirect_fun</span></tt>.</p>
|
|
<p><strong>Example:</strong></p>
|
|
<pre class="literal-block">
|
|
std::string* bar = new std::string("bar");
|
|
std::string* foo = new std::string("foo");
|
|
BOOST_ASSERT( indirect_fun< std::less<std::string> >()( bar, foo ) == true );
|
|
BOOST_ASSERT( make_indirect_fun( std::less<std::string>() )( foo, bar ) == false );
|
|
|
|
void* vptr1 = ptr1;
|
|
void* vptr2 = ptr2;
|
|
void_ptr_indirect_fun< std::less<std::string>, std::string> cast_fun;
|
|
BOOST_CHECK( cast_fun( vptr1, vptr2 ) == true );
|
|
</pre>
|
|
<p><strong>See also:</strong></p>
|
|
<ul class="simple">
|
|
<li><a class="reference" href="http://www.boost.org/libs/utility/utility.htm#result_of">result_of</a></li>
|
|
<li><a class="reference" href="http://www.boost.org/libs/iterator/doc/pointee.html">pointee</a></li>
|
|
<li><a class="reference" href="ptr_set.html">ptr_set</a></li>
|
|
<li><a class="reference" href="ptr_multiset.html">ptr_multiset</a></li>
|
|
</ul>
|
|
<p><strong>Navigate</strong></p>
|
|
<ul class="simple">
|
|
<li><a class="reference" href="ptr_container.html">home</a></li>
|
|
<li><a class="reference" href="reference.html">reference</a></li>
|
|
</ul>
|
|
<p><strong>Remarks:</strong></p>
|
|
<p>The class <tt class="docutils literal"><span class="pre">indirect_fun</span></tt> will work with smart pointers such as <a class="reference" href="http://www.boost.org/libs/smart_ptr/shared_ptr.htm">boost::shared_ptr<T></a>
|
|
because of the type traits <tt class="docutils literal"><span class="pre">pointee<T>::type</span></tt> from the header <tt class="docutils literal"><span class="pre"><boost/pointee.hpp></span></tt>.</p>
|
|
<p><strong>Synopsis:</strong></p>
|
|
<p>Since the definition of the predicates is somewhat trivial, only the
|
|
first operation is expanded inline.</p>
|
|
<pre class="literal-block">
|
|
namespace boost
|
|
{
|
|
|
|
template< class Fun >
|
|
struct indirect_fun
|
|
{
|
|
indirect_fun() : fun(Fun())
|
|
{ }
|
|
|
|
indirect_fun( Fun f ) : fun(f)
|
|
{ }
|
|
|
|
template< class T >
|
|
typename result_of< Fun( typename pointee<T>::type ) >::type
|
|
operator()( const T& r ) const
|
|
{
|
|
return fun( *r );
|
|
}
|
|
|
|
template< class T, class U >
|
|
typename result_of< Fun( typename pointee<T>::type,
|
|
typename pointee<U>::type ) >::type
|
|
operator()( const T& r, const U& r2 ) const
|
|
{
|
|
return fun( *r, *r2 );
|
|
}
|
|
|
|
private:
|
|
Fun fun;
|
|
};
|
|
|
|
template< class Fun >
|
|
inline indirect_fun<Fun> make_indirect_fun( Fun f )
|
|
{
|
|
return indirect_fun<Fun>( f );
|
|
}
|
|
|
|
|
|
|
|
template< class Fun, class Arg1, class Arg2 = Arg1 >
|
|
struct void_ptr_indirect_fun
|
|
{
|
|
void_ptr_indirect_fun() : fun(Fun())
|
|
{ }
|
|
|
|
void_ptr_indirect_fun( Fun f ) : fun(f)
|
|
{ }
|
|
|
|
typename result_of< Fun( Arg1 ) >::type
|
|
operator()( const void* r ) const
|
|
{
|
|
return fun( * static_cast<const Arg1*>( r ) );
|
|
}
|
|
|
|
typename result_of< Fun( Arg1, Arg2 ) >::type
|
|
operator()( const void* l, const void* r ) const
|
|
{
|
|
return fun( * static_cast<const Arg1*>( l ), * static_cast<const Arg2*>( r ) );
|
|
}
|
|
|
|
private:
|
|
Fun fun;
|
|
};
|
|
|
|
template< class Fun, class Arg >
|
|
inline void_ptr_indirect_fun<Fun,Arg>
|
|
make_void_ptr_indirect_fun( Fun f )
|
|
{
|
|
return void_ptr_indirect_fun<Fun,Arg>( f );
|
|
}
|
|
|
|
} // namespace 'boost'
|
|
</pre>
|
|
</div>
|
|
</body>
|
|
</html>
|