It is quite common to have two pointers and what to compare the pointed to objects. Also, having defined how to compare the objects to avoid some tedious boiler-plate code this library defines predicates that apply an indirection before comparing.
When the container uses void* internally, use the class void_ptr_indirect_fun; otherwise 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 );
Remarks:
The class indirect_fun will work with smart pointers such as boost::shared_ptr<T> because of the type traits pointee<T>::type from the header <boost/pointee.hpp>.
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'
|
©Thorsten Ottosen 2004-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0 (see http://www.boost.org/LICENSE_1_0.txt). |
|
|---|