//  IBM_PROLOG_BEGIN_TAG
//  This is an automatically generated prolog.
//
//  $Source: src/include/functional $
//
//  IBM CONFIDENTIAL
//
//  COPYRIGHT International Business Machines Corp. 2011
//
//  p1
//
//  Object Code Only (OCO) source materials
//  Licensed Internal Code Source Materials
//  IBM HostBoot Licensed Internal Code
//
//  The source code for this program is not published or other-
//  wise divested of its trade secrets, irrespective of what has
//  been deposited with the U.S. Copyright Office.
//
//  Origin: 30
//
//  IBM_PROLOG_END
#ifndef _FUNCTIONAL_H
#define _FUNCTIONAL_H

// See C++ spec

namespace std
{
    template<typename A1, typename A2, typename R>
        struct binary_function
        {
            typedef A1 first_argument_type;   ///< type of the first argument
            typedef A2 second_argument_type;  ///< type of the second argument
            typedef R result_type;            ///< type of the return type
        };

    template<typename A, typename R>
        struct unary_function
        {
            typedef A argument_type;
            typedef R result_type;
        };

    /**
     * less template
     */
    template<typename T>
        struct less : public binary_function<T, T, bool>
    {
        /**
         * operator()
         * @param[in] x first object
         * @param[in] y second object
         * @return true if x < y otherwise false
         */
        bool operator()(const T& x, const T& y) const
        {
            return x < y;
        }
    };

    template<typename T>
        struct greater : public binary_function<T, T, bool>
    {
        /**
         * operator()
         * @param[in] x first object
         * @param[in] y second object
         * @return true if x > y otherwise false
         */
        bool operator()(const T& x, const T& y) const
            { return x > y; }
    };

// --------------- mem_fun templates --------------- //

    template<typename Result, typename X>
        struct mem_fun_t : public unary_function<X*, Result>
    {
        explicit mem_fun_t(Result (X::*f)()) : func(f) {}
        Result operator()(X* x) const { return (x->*func)(); }

        private:
            Result (X::*func)();
    };

    template<typename Result, typename X>
        struct const_mem_fun_t : public unary_function<X*, Result>
    {
        explicit const_mem_fun_t(Result (X::*f)() const) : func(f) {}
        Result operator()(const X* x) const { return (x->*func)(); }

        private:
            Result (X::*func)() const;
    };
        
    template<typename Result, typename X>
    mem_fun_t<Result, X> mem_fun(Result (X::*f)())
    {
        return mem_fun_t<Result, X>(f);
    }

    template<typename Result, typename X>
    const_mem_fun_t<Result, X> mem_fun(Result (X::*f)() const)
    {
        return const_mem_fun_t<Result, X>(f);
    }

// --------------- mem_fun1 templates --------------- //

    template<typename Result, typename X, typename Arg>
        struct mem_fun1_t : public binary_function<X*, Arg, Result>
    {
        explicit mem_fun1_t(Result (X::*f)(Arg)) : func(f) {}
        Result operator()(X* x, Arg a) const { return (x->*func)(a); }

        private:
            Result (X::*func)(Arg);
    };

    template<typename Result, typename X, typename Arg>
        struct const_mem_fun1_t : public binary_function<X*, Arg, Result>
    {
        explicit const_mem_fun1_t(Result (X::*f)(Arg) const) : func(f) {}
        Result operator()(const X* x, Arg a) const { return (x->*func)(a); }

        private:
            Result (X::*func)(Arg) const;
    };

    template<typename Result, typename X, typename Arg>
    mem_fun1_t<Result, X, Arg> mem_fun(Result (X::*f)(Arg))
    {
        return mem_fun1_t<Result, X, Arg>(f);
    }

    template<typename Result, typename X, typename Arg>
    const_mem_fun1_t<Result, X, Arg> mem_fun(Result (X::*f)(Arg) const)
    {
        return const_mem_fun1_t<Result, X, Arg>(f);
    }

// --------------- mem_fun_ref templates --------------- //

    template<typename Result, typename X>
        struct mem_fun_ref_t : public unary_function<X, Result>
    {
        explicit mem_fun_ref_t(Result (X::*f)()) : func(f) {}
        Result operator()(X& x) const { return (x.*func)(); }

        private:
            Result (X::*func)();
    };

    template<typename Result, typename X>
        struct const_mem_fun_ref_t : public unary_function<X, Result>
    {
        explicit const_mem_fun_ref_t(Result (X::*f)() const) : func(f) {}
        Result operator()(const X& x) const { return (x.*func)(); }

        private:
            Result (X::*func)() const;
    };
        
    template<typename Result, typename X>
    mem_fun_ref_t<Result, X> mem_fun_ref(Result (X::*f)())
    {
        return mem_fun_ref_t<Result, X>(f);
    }

    template<typename Result, typename X>
    const_mem_fun_ref_t<Result, X> mem_fun_ref(Result (X::*f)() const)
    {
        return const_mem_fun_ref_t<Result, X>(f);
    }

// --------------- mem_fun1_ref templates --------------- //

    template<typename Result, typename X, typename Arg>
        struct mem_fun1_ref_t : public binary_function<X, Arg, Result>
    {
        explicit mem_fun1_ref_t(Result (X::*f)(Arg)) : func(f) {}
        Result operator()(X& x, Arg a) const { return (x.*func)(a); }

        private:
            Result (X::*func)(Arg);
    };

    template<typename Result, typename X, typename Arg>
        struct const_mem_fun1_ref_t : public binary_function<X, Arg, Result>
    {
        explicit const_mem_fun1_ref_t(Result (X::*f)(Arg) const) : func(f) {}
        Result operator()(const X& x, Arg a) const { return (x.*func)(a); }

        private:
            Result (X::*func)(Arg) const;
    };

    template<typename Result, typename X, typename Arg>
    mem_fun1_ref_t<Result, X, Arg> mem_fun_ref(Result (X::*f)(Arg))
    {
        return mem_fun1_ref_t<Result, X, Arg>(f);
    }

    template<typename Result, typename X, typename Arg>
    const_mem_fun1_ref_t<Result, X, Arg> mem_fun_ref(Result (X::*f)(Arg) const)
    {
        return const_mem_fun1_ref_t<Result, X, Arg>(f);
    }

// --------------- bind1st templates --------------- //

    template<typename AdaptableBinaryFunction>
    struct binder1st : 
        public unary_function<
                    typename AdaptableBinaryFunction::second_argument_type, 
                    typename AdaptableBinaryFunction::result_type
               >
    {
        binder1st(const AdaptableBinaryFunction& F,
                  typename AdaptableBinaryFunction::first_argument_type c) :
            func(F), arg(c) {}

        typename AdaptableBinaryFunction::result_type 
            operator()(const typename 
                       AdaptableBinaryFunction::second_argument_type& x) const
        { 
            return func(arg, x);
        }

        private:
            AdaptableBinaryFunction func;
            typename AdaptableBinaryFunction::first_argument_type arg;
    };

    template<typename AdaptableBinaryFunction, typename T>
    binder1st<AdaptableBinaryFunction>
        bind1st(const AdaptableBinaryFunction& F,
                const T& c)
    {
        return binder1st<AdaptableBinaryFunction>(F, 
                    typename AdaptableBinaryFunction::first_argument_type(c));
    };

// --------------- bind2nd templates --------------- //

    template<typename AdaptableBinaryFunction>
    struct binder2nd : 
        public unary_function<
                    typename AdaptableBinaryFunction::first_argument_type, 
                    typename AdaptableBinaryFunction::result_type
               >
    {
        binder2nd(const AdaptableBinaryFunction& F,
                  typename AdaptableBinaryFunction::second_argument_type c) :
            func(F), arg(c) {}

        typename AdaptableBinaryFunction::result_type 
            operator()(const typename 
                       AdaptableBinaryFunction::first_argument_type& x) const
        { 
            return func(x, arg);
        }

        private:
            AdaptableBinaryFunction func;
            typename AdaptableBinaryFunction::second_argument_type arg;
    };

    template<typename AdaptableBinaryFunction, typename T>
    binder2nd<AdaptableBinaryFunction>
        bind2nd(const AdaptableBinaryFunction& F,
                const T& c)
    {
        return binder2nd<AdaptableBinaryFunction>(F, 
                    typename AdaptableBinaryFunction::second_argument_type(c));
    };


};
#endif
/* vim: set filetype=cpp : */