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