123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581 |
- // ------------------------------------------------------------------------------
- // 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
|