// -*- C++ -*-
/***************************************************************************
 *
 * functional - global template functions
 *
 * $Id: //stdlib/dev/include/functional#20 $
 *
 ***************************************************************************
 *
 * 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.
 *
 ***************************************************************************
 *
 * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave
 * Software division. Licensed 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.
 * 
 **************************************************************************/

#ifndef _RWSTD_FUNCTIONAL_INCLUDED
#define _RWSTD_FUNCTIONAL_INCLUDED


#include <rw/_funcbase.h>
#include <rw/_defs.h>


_RWSTD_NAMESPACE (std) { 


// 20.3.2 - Arithmetic operations

// 20.3.2, p2
template <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <rw/_funcbase.h>
template <class _TypeT>
struct less;


// 20.3.3, p6
template <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 _Predicate>
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 <class _Predicate>
inline unary_negate<_Predicate> not1 (const _Predicate &__pred)
{
    return unary_negate<_Predicate>(__pred);
}


// 20.3.5, p4
template <class _Predicate>
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 <class _Predicate>
inline binary_negate<_Predicate> not2 (const _Predicate &__pred)
{
    return binary_negate<_Predicate>(__pred);
}


// 20.3.6 - Binders

// 20.3.6.1
template <class _Operation>
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 <class _Operation, class _TypeT>
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 _Operation>
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 <class _Operation, class _TypeT>
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 <class _Arg, class _Result>
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 <class _Arg, class _Result>
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 <class _Arg1, class _Arg2, class _Result>
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 <class _Arg1, class _Arg2, class _Result>
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 <class _Result, class _TypeT>
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 <class _Result, class _TypeT, class _Arg>
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 <class _Result, class _TypeT>
inline mem_fun_t<_Result, _TypeT> mem_fun (_Result (_TypeT::*__fun)())
{
    return mem_fun_t<_Result, _TypeT>(__fun);
}


template <class _Result, class _TypeT, class _Arg>
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 <class _Result, class _TypeT>
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 <class _Result, class _TypeT, class _Arg>
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 <class _Result, class _TypeT>
inline mem_fun_ref_t<_Result, _TypeT>
mem_fun_ref(_Result (_TypeT::*__fun)())
{
    return mem_fun_ref_t<_Result, _TypeT>(__fun);
}


template <class _Result, class _TypeT, class _Arg>
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 <class _Result, class _TypeT>
struct const_mem_fun_t: unary_function<const _TypeT*, _Result>
{
    _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 <class _Result, class _TypeT, class _Arg>
struct const_mem_fun1_t: binary_function<const _TypeT*, _Arg, _Result>
{
    _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 <class _Result, class _TypeT>
inline const_mem_fun_t<_Result, _TypeT>
mem_fun (_Result (_TypeT::*__fun)() const)
{
    return const_mem_fun_t<_Result, _TypeT>(__fun);
}


template <class _Result, class _TypeT, class _Arg>
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 <class _Result, class _TypeT>
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 <class _Result, class _TypeT, class _Arg>
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 <class _Result, class _TypeT>
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 <class _Result, class _TypeT, class _Arg>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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 <class _TypeT>
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