137 lines
4.2 KiB
ReStructuredText
137 lines
4.2 KiB
ReStructuredText
++++++++++++++++++++++++++++++++++
|
|
|Boost| Pointer Container Library
|
|
++++++++++++++++++++++++++++++++++
|
|
|
|
.. |Boost| image:: boost.png
|
|
|
|
Indirected functions
|
|
--------------------
|
|
|
|
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.
|
|
|
|
When the container uses ``void*`` internally, we can use the
|
|
class ``void_ptr_indirect_fun``; otherwise we use the class
|
|
``indirect_fun``.
|
|
|
|
**Example:** ::
|
|
|
|
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 );
|
|
|
|
**See also:**
|
|
|
|
- `result_of <http://www.boost.org/libs/utility/utility.htm#result_of>`_
|
|
- `pointee <http://www.boost.org/libs/iterator/doc/pointee.html>`_
|
|
- `ptr_set <ptr_set.html>`_
|
|
- `ptr_multiset <ptr_multiset.html>`_
|
|
|
|
**Navigate**
|
|
|
|
- `home <ptr_container.html>`_
|
|
- `reference <reference.html>`_
|
|
|
|
**Remarks:**
|
|
|
|
The class ``indirect_fun`` will work with smart pointers such as `boost::shared_ptr<T> <http://www.boost.org/libs/smart_ptr/shared_ptr.htm>`_
|
|
because of the type traits ``pointee<T>::type`` from the header ``<boost/pointee.hpp>``.
|
|
|
|
**Synopsis:**
|
|
|
|
Since the definition of the predicates is somewhat trivial, only the
|
|
first operation is expanded inline.
|
|
|
|
::
|
|
|
|
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'
|
|
|
|
.. raw:: html
|
|
|
|
<hr>
|
|
|
|
:Copyright: Thorsten Ottosen 2004-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0 (see LICENSE_1_0.txt__).
|
|
|
|
__ http://www.boost.org/LICENSE_1_0.txt
|
|
|
|
|