Pointer Container Library

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
• pointee
• ptr_set
• ptr_multiset

Navigate

• home
• reference

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>.

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'  

---

Copyright:	Thorsten Ottosen 2004-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0 (see LICENSE_1_0.txt).