// -*- C++ -*- /*************************************************************************** * * functional - global template functions * * $Id$ * *************************************************************************** * * Copyright (c) 1994 * Hewlett-Packard Company * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Hewlett-Packard Company makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. * *************************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed * with this work for additional information regarding copyright * ownership. The ASF licenses this file to you under the Apache * License, Version 2.0 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or * implied. See the License for the specific language governing * permissions and limitations under the License. * * Copyright 1994-2006 Rogue Wave Software. * **************************************************************************/ #ifndef _RWSTD_FUNCTIONAL_INCLUDED #define _RWSTD_FUNCTIONAL_INCLUDED #include #include _RWSTD_NAMESPACE (std) { // 20.3.2 - Arithmetic operations // 20.3.2, p2 template struct plus : binary_function<_TypeT, _TypeT, _TypeT> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x + __y; } }; // 20.3.2, p3 template struct minus : binary_function<_TypeT, _TypeT, _TypeT> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x - __y; } }; // 20.3.2, p4 template struct multiplies : binary_function<_TypeT, _TypeT, _TypeT> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x * __y; } }; // 20.3.2, p5 template struct divides : binary_function<_TypeT, _TypeT, _TypeT> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x / __y; } }; // 20.3.2, p6 template struct modulus : binary_function<_TypeT, _TypeT, _TypeT> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x % __y; } }; // 20.3.2, p7 template struct negate : unary_function<_TypeT, _TypeT> { _RWSTD_UNARY_FUNCTION_TYPES (_TypeT, _TypeT); result_type operator() (const argument_type &__x) const { return -__x; } }; // 20.3.3 - Comparisons // 20.3.3, p2 template struct equal_to : binary_function<_TypeT, _TypeT, bool> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x == __y; } }; // 20.3.3, p3 template struct not_equal_to : binary_function<_TypeT, _TypeT, bool> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x != __y; } }; // 20.3.3, p4 template struct greater : binary_function<_TypeT, _TypeT, bool> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x > __y; } }; // 20.3.3, p5 - defined in template struct less; // 20.3.3, p6 template struct greater_equal : binary_function<_TypeT, _TypeT, bool> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x >= __y; } }; // 20.3.3, p7 template struct less_equal : binary_function<_TypeT, _TypeT, bool> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x <= __y; } }; // 20.3.4 - Logical operations // 20.3.4, p2 template struct logical_and : binary_function<_TypeT, _TypeT, bool> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x && __y; } }; // 20.3.4, p3 template struct logical_or : binary_function<_TypeT, _TypeT, bool> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, bool); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x || __y; } }; // 20.3.4, p4 template struct logical_not : unary_function<_TypeT, bool> { _RWSTD_UNARY_FUNCTION_TYPES (_TypeT, bool); result_type operator() (const _TypeT &__x) const { return !__x; } }; // 20.3.5 - Negators // 20.3.5, p2 template class unary_negate : public unary_function<_TYPENAME _Predicate::argument_type, bool> { _Predicate _C_pred; public: _RWSTD_UNARY_FUNCTION_TYPES (_TYPENAME _Predicate::argument_type, bool); _EXPLICIT unary_negate (const _Predicate &__pred) : _C_pred (__pred) { } result_type operator() (const argument_type &__x) const { return !_C_pred (__x); } }; // 20.3.5, p3 template inline unary_negate<_Predicate> not1 (const _Predicate &__pred) { return unary_negate<_Predicate>(__pred); } // 20.3.5, p4 template class binary_negate : public binary_function<_TYPENAME _Predicate::first_argument_type, _TYPENAME _Predicate::second_argument_type, bool> { _Predicate _C_pred; public: _RWSTD_BINARY_FUNCTION_TYPES (_TYPENAME _Predicate::first_argument_type, _TYPENAME _Predicate::second_argument_type, bool); _EXPLICIT binary_negate (const _Predicate &__pred) : _C_pred (__pred) { } result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return !_C_pred (__x, __y); } }; // 20.3.5, p5 template inline binary_negate<_Predicate> not2 (const _Predicate &__pred) { return binary_negate<_Predicate>(__pred); } // 20.3.6 - Binders // 20.3.6.1 template class binder1st : public unary_function<_TYPENAME _Operation::second_argument_type, _TYPENAME _Operation::result_type> { protected: _Operation op; _TYPENAME _Operation::first_argument_type value; public: _RWSTD_UNARY_FUNCTION_TYPES (_TYPENAME _Operation::second_argument_type, _TYPENAME _Operation::result_type); binder1st (const _Operation &__oper, const _TYPENAME _Operation::first_argument_type &__x) : op (__oper), value (__x) { } result_type operator() (const argument_type &__y) const { return op (value, __y); } }; // 20.3.6.2 template inline binder1st<_Operation> bind1st (const _Operation &__oper, const _TypeT &__x) { typedef _TYPENAME _Operation::first_argument_type first_argument_type; return binder1st<_Operation>(__oper, first_argument_type (__x)); } // 20.3.6.3 template class binder2nd : public unary_function<_TYPENAME _Operation::first_argument_type, _TYPENAME _Operation::result_type> { protected: _Operation op; _TYPENAME _Operation::second_argument_type value; public: _RWSTD_UNARY_FUNCTION_TYPES (_TYPENAME _Operation::first_argument_type, _TYPENAME _Operation::result_type); binder2nd (const _Operation &__oper, const _TYPENAME _Operation::second_argument_type &__y) : op (__oper), value (__y) { } result_type operator() (const argument_type &__x) const { return op (__x, value); } }; // 20.3.6.4 template inline binder2nd<_Operation> bind2nd (const _Operation &__oper, const _TypeT &__x) { typedef _TYPENAME _Operation::second_argument_type second_argument_type; return binder2nd<_Operation>(__oper, second_argument_type (__x)); } // 20.3.7 - Adaptors for pointers to functions // 20.3.7, p2 template struct pointer_to_unary_function : unary_function<_Arg, _Result> { _RWSTD_UNARY_FUNCTION_TYPES (_Arg, _Result); _EXPLICIT pointer_to_unary_function (result_type (*__fun)(argument_type)) : _C_fn (__fun) {} result_type operator() (argument_type __x) const { return _C_fn (__x); } private: result_type (*_C_fn)(argument_type); }; // 20.3.7, p3 template inline pointer_to_unary_function<_Arg, _Result> ptr_fun (_Result (*__fun)(_Arg)) { return pointer_to_unary_function<_Arg, _Result>(__fun); } // 20.3.7, p4 template struct pointer_to_binary_function : binary_function<_Arg1, _Arg2, _Result> { _RWSTD_BINARY_FUNCTION_TYPES (_Arg1, _Arg2, _Result); _EXPLICIT pointer_to_binary_function (result_type (*__fun)(first_argument_type, second_argument_type)) : _C_fn (__fun) { } result_type operator() (first_argument_type __x, second_argument_type __y) const { return _C_fn (__x, __y); } private: result_type (*_C_fn)(first_argument_type, second_argument_type); }; // 20.3.7, p5 template inline pointer_to_binary_function<_Arg1, _Arg2, _Result> ptr_fun (_Result (*__fun)(_Arg1, _Arg2)) { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__fun); } // 20.3.8 - Adaptors for pointers to members // 20.3.8, p2 - adaptor for a non-const member function taking no arguments // operating on a pointer to a non-const object template struct mem_fun_t: unary_function<_TypeT*, _Result> { _RWSTD_UNARY_FUNCTION_TYPES (_TypeT*, _Result); _EXPLICIT mem_fun_t (result_type (_TypeT::*__fun)()) : _C_fn (__fun) { } result_type operator() (argument_type __x) const { return (__x->*_C_fn)(); } private: result_type (_TypeT::*_C_fn)(); }; // 20.3.8, p3 - adaptor for a non-const member function taking one argument // operating on a pointer to a non-const object template struct mem_fun1_t: binary_function<_TypeT*, _Arg, _Result> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT*, _Arg, _Result); _EXPLICIT mem_fun1_t (result_type (_TypeT::*__fun)(second_argument_type)) : _C_fn (__fun) { } result_type operator() (first_argument_type __x, second_argument_type __y) const { return (__x->*_C_fn)(__y); } private: result_type (_TypeT::*_C_fn)(second_argument_type); }; // 20.3.8, p4 template inline mem_fun_t<_Result, _TypeT> mem_fun (_Result (_TypeT::*__fun)()) { return mem_fun_t<_Result, _TypeT>(__fun); } template inline mem_fun1_t<_Result, _TypeT, _Arg> mem_fun (_Result (_TypeT::*__fun)(_Arg)) { return mem_fun1_t<_Result, _TypeT, _Arg>(__fun); } // 20.3.8, p5 - adaptor for a non-const member function taking no arguments // operating on a non-const object template struct mem_fun_ref_t: unary_function<_TypeT, _Result> { _RWSTD_UNARY_FUNCTION_TYPES (_TypeT, _Result); _EXPLICIT mem_fun_ref_t (result_type (_TypeT::*__fun)()) : _C_fn (__fun) { } result_type operator() (argument_type &__x) const { return (__x.*_C_fn)(); } private: result_type (_TypeT::*_C_fn)(); }; // 20.3.8, p6 - adaptor for a non-const member function taking one argument // operating on a non-const object template struct mem_fun1_ref_t : binary_function<_TypeT, _Arg, _Result> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _Arg, _Result); _EXPLICIT mem_fun1_ref_t (result_type (_TypeT::*__fun)(second_argument_type)) : _C_fn (__fun) { } result_type operator() (first_argument_type &__x, second_argument_type __y) const { return (__x.*_C_fn)(__y); } private: result_type (_TypeT::*_C_fn)(second_argument_type); }; // 20.3.8, p7 template inline mem_fun_ref_t<_Result, _TypeT> mem_fun_ref(_Result (_TypeT::*__fun)()) { return mem_fun_ref_t<_Result, _TypeT>(__fun); } template inline mem_fun1_ref_t<_Result, _TypeT, _Arg> mem_fun_ref(_Result (_TypeT::*__fun)(_Arg)) { return mem_fun1_ref_t<_Result, _TypeT, _Arg> (__fun); } // 20.3.8, p8 - adaptor for a const member function taking no arguments // operating on a const object template struct const_mem_fun_t: unary_function { _RWSTD_UNARY_FUNCTION_TYPES (const _TypeT*, _Result); _EXPLICIT const_mem_fun_t (result_type (_TypeT::*__fun)() const) : _C_fn (__fun) { } result_type operator() (argument_type __x) const { return (__x->*_C_fn)(); } private: result_type (_TypeT::*_C_fn)() const; }; // 20.3.8, p9 - adaptor for a const member function taking one argument // operating on a const object template struct const_mem_fun1_t: binary_function { _RWSTD_BINARY_FUNCTION_TYPES (const _TypeT*, _Arg, _Result); _EXPLICIT const_mem_fun1_t (result_type (_TypeT::*__fun)(second_argument_type) const) : _C_fn (__fun) { } result_type operator() (first_argument_type __x, second_argument_type __y) const { return (__x->*_C_fn)(__y); } private: result_type (_TypeT::*_C_fn)(second_argument_type) const; }; // 20.3.8, p10 template inline const_mem_fun_t<_Result, _TypeT> mem_fun (_Result (_TypeT::*__fun)() const) { return const_mem_fun_t<_Result, _TypeT>(__fun); } template inline const_mem_fun1_t<_Result, _TypeT, _Arg> mem_fun (_Result (_TypeT::*__fun)(_Arg) const) { return const_mem_fun1_t<_Result, _TypeT, _Arg>(__fun); } // 20.3.8, p11 - adaptor for a const member function taking no arguments // operating on a const reference to an object template struct const_mem_fun_ref_t: unary_function<_TypeT, _Result> { _RWSTD_UNARY_FUNCTION_TYPES (_TypeT, _Result); _EXPLICIT const_mem_fun_ref_t (result_type (_TypeT::*__fun)() const) : _C_fn (__fun) { } result_type operator() (const argument_type &__x) const { return (__x.*_C_fn)(); } private: result_type (_TypeT::*_C_fn)() const; }; // 20.3.8, p12 - adaptor for a const member function taking a single argument // operating on a const reference to an object template struct const_mem_fun1_ref_t : binary_function<_TypeT, _Arg, _Result> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _Arg, _Result); _EXPLICIT const_mem_fun1_ref_t (result_type (_TypeT::*__fun)(second_argument_type) const) : _C_fn (__fun) { } result_type operator() (const first_argument_type &__x, second_argument_type __y) const { return (__x.*_C_fn)(__y); } private: result_type (_TypeT::*_C_fn)(second_argument_type) const; }; // 20.3.8, p13 template inline const_mem_fun_ref_t<_Result, _TypeT> mem_fun_ref (_Result (_TypeT::*__fun)() const) { return const_mem_fun_ref_t<_Result, _TypeT>(__fun); } template inline const_mem_fun1_ref_t<_Result, _TypeT, _Arg> mem_fun_ref (_Result (_TypeT::*__fun)(_Arg) const) { return const_mem_fun1_ref_t<_Result, _TypeT, _Arg>(__fun); } } // namespace std _RWSTD_NAMESPACE (__rw) { // extension: returns the argument template struct identity : _STD::unary_function<_TypeT, _TypeT> { _RWSTD_UNARY_FUNCTION_TYPES (_TypeT, _TypeT); result_type operator() (const argument_type &__val) const { return __val; } }; // extension: returns the result of applying the unary plus operator to arg template struct unary_plus : _STD::unary_function<_TypeT, _TypeT> { _RWSTD_UNARY_FUNCTION_TYPES (_TypeT, _TypeT); result_type operator() (const argument_type &__val) const { return +__val; } }; // extension: returns the bitwise complement of the argument template struct bitwise_complement : _STD::unary_function<_TypeT, _TypeT> { _RWSTD_UNARY_FUNCTION_TYPES (_TypeT, _TypeT); result_type operator() (const argument_type &__val) const { return ~__val; } }; // extension: returns the bitwise or of the two arguments template struct bitwise_or : _STD::binary_function<_TypeT, _TypeT, _TypeT> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x | __y; } }; // extension: returns the bitwise and of the two arguments template struct bitwise_and : _STD::binary_function<_TypeT, _TypeT, _TypeT> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x & __y; } }; // extension: returns the exclusive or (XOR) of the two arguments template struct exclusive_or : _STD::binary_function<_TypeT, _TypeT, _TypeT> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x ^ __y; } }; // extension: returns the left argument shifted left by the right argument template struct shift_left : _STD::binary_function<_TypeT, _TypeT, _TypeT> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x << __y; } }; // extension: returns the left argument shifted right by the right argument template struct shift_right : _STD::binary_function<_TypeT, _TypeT, _TypeT> { _RWSTD_BINARY_FUNCTION_TYPES (_TypeT, _TypeT, _TypeT); result_type operator() (const first_argument_type &__x, const second_argument_type &__y) const { return __x >> __y; } }; } // namespace __rw #undef _RWSTD_UNARY_FUNCTION_TYPES #undef _RWSTD_BINARY_FUNCTION_TYPES #endif // _RWSTD_FUNCTIONAL_INCLUDED