williamr@2: // ------------------------------------------------------------------------------
williamr@2: // Copyright (c) 2000 Cadenza New Zealand Ltd
williamr@2: // Distributed under the Boost Software License, Version 1.0. (See accompany-
williamr@2: // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
williamr@2: // ------------------------------------------------------------------------------
williamr@2: // Boost functional.hpp header file
williamr@2: // See http://www.boost.org/libs/functional for documentation.
williamr@2: // ------------------------------------------------------------------------------
williamr@2: // $Id: functional.hpp,v 1.4.20.1 2006/12/02 14:17:26 andreas_huber69 Exp $
williamr@2: // ------------------------------------------------------------------------------
williamr@2: 
williamr@2: #ifndef BOOST_FUNCTIONAL_HPP
williamr@2: #define BOOST_FUNCTIONAL_HPP
williamr@2: 
williamr@2: #include <boost/config.hpp>
williamr@2: #include <boost/call_traits.hpp>
williamr@2: #include <functional>
williamr@2: 
williamr@2: namespace boost
williamr@2: {
williamr@2: #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     // The following traits classes allow us to avoid the need for ptr_fun
williamr@2:     // because the types of arguments and the result of a function can be 
williamr@2:     // deduced.
williamr@2:     //
williamr@2:     // In addition to the standard types defined in unary_function and 
williamr@2:     // binary_function, we add
williamr@2:     //
williamr@2:     // - function_type, the type of the function or function object itself.
williamr@2:     //
williamr@2:     // - param_type, the type that should be used for passing the function or
williamr@2:     //   function object as an argument.
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     namespace detail
williamr@2:     {
williamr@2:         template <class Operation>
williamr@2:         struct unary_traits_imp;
williamr@2:         
williamr@2:         template <class Operation>
williamr@2:         struct unary_traits_imp<Operation*>
williamr@2:         {
williamr@2:             typedef Operation                         function_type;
williamr@2:             typedef const function_type &             param_type;
williamr@2:             typedef typename Operation::result_type   result_type;
williamr@2:             typedef typename Operation::argument_type argument_type;
williamr@2:         };
williamr@2: 
williamr@2:         template <class R, class A>
williamr@2:         struct unary_traits_imp<R(*)(A)>
williamr@2:         {
williamr@2:             typedef R (*function_type)(A);
williamr@2:             typedef R (*param_type)(A);
williamr@2:             typedef R result_type;
williamr@2:             typedef A argument_type;
williamr@2:         };
williamr@2: 
williamr@2:         template <class Operation>
williamr@2:         struct binary_traits_imp;
williamr@2: 
williamr@2:         template <class Operation>
williamr@2:         struct binary_traits_imp<Operation*>
williamr@2:         {
williamr@2:             typedef Operation                                function_type;
williamr@2:             typedef const function_type &                    param_type;
williamr@2:             typedef typename Operation::result_type          result_type;
williamr@2:             typedef typename Operation::first_argument_type  first_argument_type;
williamr@2:             typedef typename Operation::second_argument_type second_argument_type;
williamr@2:         };
williamr@2:         
williamr@2:         template <class R, class A1, class A2>
williamr@2:         struct binary_traits_imp<R(*)(A1,A2)>
williamr@2:         {
williamr@2:             typedef R (*function_type)(A1,A2);
williamr@2:             typedef R (*param_type)(A1,A2);
williamr@2:             typedef R result_type;
williamr@2:             typedef A1 first_argument_type;
williamr@2:             typedef A2 second_argument_type;
williamr@2:         };
williamr@2:     } // namespace detail
williamr@2:     
williamr@2:     template <class Operation>
williamr@2:     struct unary_traits
williamr@2:     {
williamr@2:         typedef typename detail::unary_traits_imp<Operation*>::function_type function_type;
williamr@2:         typedef typename detail::unary_traits_imp<Operation*>::param_type    param_type;
williamr@2:         typedef typename detail::unary_traits_imp<Operation*>::result_type   result_type;
williamr@2:         typedef typename detail::unary_traits_imp<Operation*>::argument_type argument_type;
williamr@2:     }; 
williamr@2: 
williamr@2:     template <class R, class A>
williamr@2:     struct unary_traits<R(*)(A)>
williamr@2:     {
williamr@2:         typedef R (*function_type)(A);
williamr@2:         typedef R (*param_type)(A);
williamr@2:         typedef R result_type;
williamr@2:         typedef A argument_type;
williamr@2:     };
williamr@2: 
williamr@2:     template <class Operation>
williamr@2:     struct binary_traits
williamr@2:     {
williamr@2:         typedef typename detail::binary_traits_imp<Operation*>::function_type        function_type;
williamr@2:         typedef typename detail::binary_traits_imp<Operation*>::param_type           param_type;
williamr@2:         typedef typename detail::binary_traits_imp<Operation*>::result_type          result_type;
williamr@2:         typedef typename detail::binary_traits_imp<Operation*>::first_argument_type  first_argument_type;
williamr@2:         typedef typename detail::binary_traits_imp<Operation*>::second_argument_type second_argument_type;
williamr@2:     };
williamr@2:     
williamr@2:     template <class R, class A1, class A2>
williamr@2:     struct binary_traits<R(*)(A1,A2)>
williamr@2:     {
williamr@2:         typedef R (*function_type)(A1,A2);
williamr@2:         typedef R (*param_type)(A1,A2);
williamr@2:         typedef R result_type;
williamr@2:         typedef A1 first_argument_type;
williamr@2:         typedef A2 second_argument_type;
williamr@2:     };
williamr@2: #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     // If we have no partial specialisation available, decay to a situation
williamr@2:     // that is no worse than in the Standard, i.e., ptr_fun will be required.
williamr@2:     // --------------------------------------------------------------------------
williamr@2: 
williamr@2:     template <class Operation>
williamr@2:     struct unary_traits
williamr@2:     {
williamr@2:         typedef Operation                         function_type;
williamr@2:         typedef const Operation&                  param_type;
williamr@2:         typedef typename Operation::result_type   result_type;
williamr@2:         typedef typename Operation::argument_type argument_type;
williamr@2:     }; 
williamr@2:     
williamr@2:     template <class Operation>
williamr@2:     struct binary_traits
williamr@2:     {
williamr@2:         typedef Operation                                function_type;
williamr@2:         typedef const Operation &                        param_type;
williamr@2:         typedef typename Operation::result_type          result_type;
williamr@2:         typedef typename Operation::first_argument_type  first_argument_type;
williamr@2:         typedef typename Operation::second_argument_type second_argument_type;
williamr@2:     };    
williamr@2: #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
williamr@2:     
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     // unary_negate, not1
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     template <class Predicate>
williamr@2:     class unary_negate
williamr@2:         : public std::unary_function<typename unary_traits<Predicate>::argument_type,bool>
williamr@2:     {
williamr@2:       public:
williamr@2:         explicit unary_negate(typename unary_traits<Predicate>::param_type x)
williamr@2:             :
williamr@2:             pred(x)
williamr@2:         {}
williamr@2:         bool operator()(typename call_traits<typename unary_traits<Predicate>::argument_type>::param_type x) const
williamr@2:         {
williamr@2:             return !pred(x);
williamr@2:         }
williamr@2:       private:
williamr@2:         typename unary_traits<Predicate>::function_type pred;
williamr@2:     };
williamr@2: 
williamr@2:     template <class Predicate>
williamr@2:     unary_negate<Predicate> not1(const Predicate &pred)
williamr@2:     {
williamr@2:         // The cast is to placate Borland C++Builder in certain circumstances.
williamr@2:         // I don't think it should be necessary.
williamr@2:         return unary_negate<Predicate>((typename unary_traits<Predicate>::param_type)pred);
williamr@2:     }
williamr@2: 
williamr@2:     template <class Predicate>
williamr@2:     unary_negate<Predicate> not1(Predicate &pred)
williamr@2:     {
williamr@2:         return unary_negate<Predicate>(pred);
williamr@2:     }
williamr@2: 
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     // binary_negate, not2
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     template <class Predicate>
williamr@2:     class binary_negate
williamr@2:         : public std::binary_function<typename binary_traits<Predicate>::first_argument_type,
williamr@2:                                       typename binary_traits<Predicate>::second_argument_type,
williamr@2:                                       bool>
williamr@2:     {
williamr@2:       public:
williamr@2:         explicit binary_negate(typename binary_traits<Predicate>::param_type x)
williamr@2:             :
williamr@2:             pred(x)
williamr@2:         {}
williamr@2:         bool operator()(typename call_traits<typename binary_traits<Predicate>::first_argument_type>::param_type x,
williamr@2:                         typename call_traits<typename binary_traits<Predicate>::second_argument_type>::param_type y) const
williamr@2:         {
williamr@2:             return !pred(x,y);
williamr@2:         }
williamr@2:       private:
williamr@2:         typename binary_traits<Predicate>::function_type pred;
williamr@2:     };
williamr@2: 
williamr@2:     template <class Predicate>
williamr@2:     binary_negate<Predicate> not2(const Predicate &pred)
williamr@2:     {
williamr@2:         // The cast is to placate Borland C++Builder in certain circumstances.
williamr@2:         // I don't think it should be necessary.
williamr@2:         return binary_negate<Predicate>((typename binary_traits<Predicate>::param_type)pred);
williamr@2:     }
williamr@2: 
williamr@2:     template <class Predicate>
williamr@2:     binary_negate<Predicate> not2(Predicate &pred)
williamr@2:     {
williamr@2:         return binary_negate<Predicate>(pred);
williamr@2:     }
williamr@2:         
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     // binder1st, bind1st
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     template <class Operation>
williamr@2:     class binder1st
williamr@2:         : public std::unary_function<typename binary_traits<Operation>::second_argument_type,
williamr@2:                                      typename binary_traits<Operation>::result_type>
williamr@2:     {       
williamr@2:       public:
williamr@2:         binder1st(typename binary_traits<Operation>::param_type x,
williamr@2:                   typename call_traits<typename binary_traits<Operation>::first_argument_type>::param_type y)
williamr@2:             :
williamr@2:             op(x), value(y)
williamr@2:         {}
williamr@2:         
williamr@2:         typename binary_traits<Operation>::result_type
williamr@2:         operator()(typename call_traits<typename binary_traits<Operation>::second_argument_type>::param_type x) const
williamr@2:         {
williamr@2:             return op(value, x);
williamr@2:         }
williamr@2:         
williamr@2:       protected:
williamr@2:         typename binary_traits<Operation>::function_type op;
williamr@2:         typename binary_traits<Operation>::first_argument_type value;
williamr@2:     };
williamr@2: 
williamr@2:     template <class Operation>
williamr@2:     inline binder1st<Operation> bind1st(const Operation &op,
williamr@2:                                         typename call_traits<
williamr@2:                                                     typename binary_traits<Operation>::first_argument_type
williamr@2:                                         >::param_type x)
williamr@2:     {
williamr@2:         // The cast is to placate Borland C++Builder in certain circumstances.
williamr@2:         // I don't think it should be necessary.
williamr@2:         return binder1st<Operation>((typename binary_traits<Operation>::param_type)op, x);
williamr@2:     }
williamr@2: 
williamr@2:     template <class Operation>
williamr@2:     inline binder1st<Operation> bind1st(Operation &op,
williamr@2:                                         typename call_traits<
williamr@2:                                                     typename binary_traits<Operation>::first_argument_type
williamr@2:                                         >::param_type x)
williamr@2:     {
williamr@2:         return binder1st<Operation>(op, x);
williamr@2:     }
williamr@2: 
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     // binder2nd, bind2nd
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     template <class Operation>
williamr@2:     class binder2nd
williamr@2:         : public std::unary_function<typename binary_traits<Operation>::first_argument_type,
williamr@2:                                      typename binary_traits<Operation>::result_type>
williamr@2:     {
williamr@2:       public:
williamr@2:         binder2nd(typename binary_traits<Operation>::param_type x,
williamr@2:                   typename call_traits<typename binary_traits<Operation>::second_argument_type>::param_type y)
williamr@2:             :
williamr@2:             op(x), value(y)
williamr@2:         {}
williamr@2:         
williamr@2:         typename binary_traits<Operation>::result_type
williamr@2:         operator()(typename call_traits<typename binary_traits<Operation>::first_argument_type>::param_type x) const
williamr@2:         {
williamr@2:             return op(x, value);
williamr@2:         }               
williamr@2:         
williamr@2:       protected:
williamr@2:         typename binary_traits<Operation>::function_type op;
williamr@2:         typename binary_traits<Operation>::second_argument_type value;
williamr@2:     };
williamr@2: 
williamr@2:     template <class Operation>
williamr@2:     inline binder2nd<Operation> bind2nd(const Operation &op,
williamr@2:                                         typename call_traits<
williamr@2:                                                     typename binary_traits<Operation>::second_argument_type
williamr@2:                                         >::param_type x)
williamr@2:     {
williamr@2:         // The cast is to placate Borland C++Builder in certain circumstances.
williamr@2:         // I don't think it should be necessary.
williamr@2:         return binder2nd<Operation>((typename binary_traits<Operation>::param_type)op, x);
williamr@2:     }
williamr@2: 
williamr@2:     template <class Operation>
williamr@2:     inline binder2nd<Operation> bind2nd(Operation &op,
williamr@2:                                         typename call_traits<
williamr@2:                                                     typename binary_traits<Operation>::second_argument_type
williamr@2:                                         >::param_type x)
williamr@2:     {
williamr@2:         return binder2nd<Operation>(op, x);
williamr@2:     }
williamr@2: 
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     // mem_fun, etc
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     template <class S, class T>
williamr@2:     class mem_fun_t : public std::unary_function<T*, S>
williamr@2:     {
williamr@2:       public:
williamr@2:         explicit mem_fun_t(S (T::*p)())
williamr@2:             :
williamr@2:             ptr(p)
williamr@2:         {}
williamr@2:         S operator()(T* p) const
williamr@2:         {
williamr@2:             return (p->*ptr)();
williamr@2:         }
williamr@2:       private:
williamr@2:         S (T::*ptr)();
williamr@2:     };
williamr@2: 
williamr@2:     template <class S, class T, class A>
williamr@2:     class mem_fun1_t : public std::binary_function<T*, A, S>
williamr@2:     {
williamr@2:       public:   
williamr@2:         explicit mem_fun1_t(S (T::*p)(A))
williamr@2:             :
williamr@2:             ptr(p)
williamr@2:         {}
williamr@2:         S operator()(T* p, typename call_traits<A>::param_type x) const
williamr@2:         {
williamr@2:             return (p->*ptr)(x);
williamr@2:         }
williamr@2:       private:
williamr@2:         S (T::*ptr)(A);
williamr@2:     };
williamr@2: 
williamr@2:     template <class S, class T>
williamr@2:     class const_mem_fun_t : public std::unary_function<const T*, S>
williamr@2:     {
williamr@2:       public:
williamr@2:         explicit const_mem_fun_t(S (T::*p)() const)
williamr@2:             :
williamr@2:             ptr(p)
williamr@2:         {}
williamr@2:         S operator()(const T* p) const
williamr@2:         {
williamr@2:             return (p->*ptr)();
williamr@2:         }
williamr@2:       private:
williamr@2:         S (T::*ptr)() const;        
williamr@2:     };
williamr@2: 
williamr@2:     template <class S, class T, class A>
williamr@2:     class const_mem_fun1_t : public std::binary_function<const T*, A, S>
williamr@2:     {
williamr@2:       public:
williamr@2:         explicit const_mem_fun1_t(S (T::*p)(A) const)
williamr@2:             :
williamr@2:             ptr(p)
williamr@2:         {}
williamr@2:         S operator()(const T* p, typename call_traits<A>::param_type x) const
williamr@2:         {
williamr@2:             return (p->*ptr)(x);
williamr@2:         }
williamr@2:       private:
williamr@2:         S (T::*ptr)(A) const;
williamr@2:     };
williamr@2:     
williamr@2:     template<class S, class T>
williamr@2:     inline mem_fun_t<S,T> mem_fun(S (T::*f)())
williamr@2:     {
williamr@2:         return mem_fun_t<S,T>(f);
williamr@2:     }
williamr@2:     
williamr@2:     template<class S, class T, class A>
williamr@2:     inline mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A))
williamr@2:     {
williamr@2:         return mem_fun1_t<S,T,A>(f);
williamr@2:     }
williamr@2: 
williamr@2: #ifndef BOOST_NO_POINTER_TO_MEMBER_CONST
williamr@2:     template<class S, class T>
williamr@2:     inline const_mem_fun_t<S,T> mem_fun(S (T::*f)() const)
williamr@2:     {
williamr@2:         return const_mem_fun_t<S,T>(f);
williamr@2:     }
williamr@2:     
williamr@2:     template<class S, class T, class A>
williamr@2:     inline const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const)
williamr@2:     {
williamr@2:         return const_mem_fun1_t<S,T,A>(f);
williamr@2:     }
williamr@2: #endif // BOOST_NO_POINTER_TO_MEMBER_CONST
williamr@2: 
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     // mem_fun_ref, etc
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     template <class S, class T>
williamr@2:     class mem_fun_ref_t : public std::unary_function<T&, S>
williamr@2:     {
williamr@2:       public:
williamr@2:         explicit mem_fun_ref_t(S (T::*p)())
williamr@2:             :
williamr@2:             ptr(p)
williamr@2:         {}
williamr@2:         S operator()(T& p) const
williamr@2:         {
williamr@2:             return (p.*ptr)();
williamr@2:         }
williamr@2:       private:
williamr@2:         S (T::*ptr)();
williamr@2:     };
williamr@2: 
williamr@2:     template <class S, class T, class A>
williamr@2:     class mem_fun1_ref_t : public std::binary_function<T&, A, S>
williamr@2:     {
williamr@2:       public:
williamr@2:         explicit mem_fun1_ref_t(S (T::*p)(A))
williamr@2:             :
williamr@2:             ptr(p)
williamr@2:         {}
williamr@2:         S operator()(T& p, typename call_traits<A>::param_type x) const
williamr@2:         {
williamr@2:             return (p.*ptr)(x);
williamr@2:         }
williamr@2:       private:
williamr@2:         S (T::*ptr)(A);
williamr@2:     };
williamr@2:     
williamr@2:     template <class S, class T>
williamr@2:     class const_mem_fun_ref_t : public std::unary_function<const T&, S>
williamr@2:     {
williamr@2:       public:
williamr@2:         explicit const_mem_fun_ref_t(S (T::*p)() const)
williamr@2:             :
williamr@2:             ptr(p)
williamr@2:         {}
williamr@2:         
williamr@2:         S operator()(const T &p) const
williamr@2:         {
williamr@2:             return (p.*ptr)();
williamr@2:         }
williamr@2:       private:
williamr@2:         S (T::*ptr)() const;
williamr@2:     };
williamr@2: 
williamr@2:     template <class S, class T, class A>
williamr@2:     class const_mem_fun1_ref_t : public std::binary_function<const T&, A, S>
williamr@2:     {
williamr@2:       public:
williamr@2:         explicit const_mem_fun1_ref_t(S (T::*p)(A) const)
williamr@2:             :
williamr@2:             ptr(p)
williamr@2:         {}
williamr@2: 
williamr@2:         S operator()(const T& p, typename call_traits<A>::param_type x) const
williamr@2:         {
williamr@2:             return (p.*ptr)(x);
williamr@2:         }
williamr@2:       private:
williamr@2:         S (T::*ptr)(A) const;
williamr@2:     };
williamr@2:     
williamr@2:     template<class S, class T>
williamr@2:     inline mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)())
williamr@2:     {
williamr@2:         return mem_fun_ref_t<S,T>(f);
williamr@2:     }
williamr@2: 
williamr@2:     template<class S, class T, class A>
williamr@2:     inline mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A))
williamr@2:     {
williamr@2:         return mem_fun1_ref_t<S,T,A>(f);
williamr@2:     }
williamr@2: 
williamr@2: #ifndef BOOST_NO_POINTER_TO_MEMBER_CONST
williamr@2:     template<class S, class T>
williamr@2:     inline const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const)
williamr@2:     {
williamr@2:         return const_mem_fun_ref_t<S,T>(f);
williamr@2:     }
williamr@2: 
williamr@2:     template<class S, class T, class A>
williamr@2:     inline const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const)
williamr@2:     {
williamr@2:         return const_mem_fun1_ref_t<S,T,A>(f);
williamr@2:     }   
williamr@2: #endif // BOOST_NO_POINTER_TO_MEMBER_CONST
williamr@2: 
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     // ptr_fun
williamr@2:     // --------------------------------------------------------------------------
williamr@2:     template <class Arg, class Result>
williamr@2:     class pointer_to_unary_function : public std::unary_function<Arg,Result>
williamr@2:     {
williamr@2:       public:
williamr@2:         explicit pointer_to_unary_function(Result (*f)(Arg))
williamr@2:             :
williamr@2:             func(f)
williamr@2:         {}
williamr@2: 
williamr@2:         Result operator()(typename call_traits<Arg>::param_type x) const
williamr@2:         {
williamr@2:             return func(x);
williamr@2:         }
williamr@2:         
williamr@2:       private:
williamr@2:         Result (*func)(Arg);
williamr@2:     };
williamr@2: 
williamr@2:     template <class Arg, class Result>
williamr@2:     inline pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg))
williamr@2:     {
williamr@2:         return pointer_to_unary_function<Arg,Result>(f);
williamr@2:     }
williamr@2: 
williamr@2:     template <class Arg1, class Arg2, class Result>
williamr@2:     class pointer_to_binary_function : public std::binary_function<Arg1,Arg2,Result>
williamr@2:     {
williamr@2:       public:
williamr@2:         explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2))
williamr@2:             :
williamr@2:             func(f)
williamr@2:         {}
williamr@2:         
williamr@2:         Result operator()(typename call_traits<Arg1>::param_type x, typename call_traits<Arg2>::param_type y) const
williamr@2:         {
williamr@2:             return func(x,y);
williamr@2:         }
williamr@2:         
williamr@2:       private:
williamr@2:         Result (*func)(Arg1, Arg2);
williamr@2:     };
williamr@2: 
williamr@2:     template <class Arg1, class Arg2, class Result>
williamr@2:     inline pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1, Arg2))
williamr@2:     {
williamr@2:         return pointer_to_binary_function<Arg1,Arg2,Result>(f);
williamr@2:     }
williamr@2: } // namespace boost
williamr@2: 
williamr@2: #endif