// 20.3.7 adaptors pointers functions

/** @defgroup pointer_adaptors Adaptors for pointers to functions

 * @ingroup functors

 *

 *  The advantage of function objects over pointers to functions is that

 *  the objects in the standard library declare nested typedefs describing

 *  their argument and result types with uniform names (e.g., @c result_type

 *  from the base classes @c unary_function and @c binary_function).

 *  Sometimes those typedefs are required, not just optional.

 *

 *  Adaptors are provided to turn pointers to unary (single-argument) and

 *  binary (double-argument) functions into function objects.  The

 *  long-winded functor @c pointer_to_unary_function is constructed with a

 *  function pointer @c f, and its @c operator() called with argument @c x

 *  returns @c f(x).  The functor @c pointer_to_binary_function does the same

 *  thing, but with a double-argument @c f and @c operator().

 *

 *  The function @c ptr_fun takes a pointer-to-function @c f and constructs

 *  an instance of the appropriate functor.

 *

 *  @{

 */

/// One of the @link pointer_adaptors adaptors for function pointers@endlink.

template<typename _Arg, typename _Result>

class pointer_to_unary_function : public unary_function<_Arg, _Result>

{

protected:

    _Result (*_M_ptr)(_Arg);

public:

    pointer_to_unary_function() { }

    explicit

    pointer_to_unary_function(_Result (*__x)(_Arg))

    : _M_ptr(__x) { }

    _Result

    operator()(_Arg __x) const

    { return _M_ptr(__x); }

};

/// One of the @link pointer_adaptors adaptors for function pointers@endlink.

template<typename _Arg1, typename _Arg2, typename _Result>

class pointer_to_binary_function

        : public binary_function<_Arg1, _Arg2, _Result>

{

protected:

    _Result (*_M_ptr)(_Arg1, _Arg2);

public:

    pointer_to_binary_function() { }

    explicit

    pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))

    : _M_ptr(__x) { }

    _Result

    operator()(_Arg1 __x, _Arg2 __y) const

    { return _M_ptr(__x, __y); }

};

/// One of the @link pointer_adaptors adaptors for function pointers@endlink.

template<typename _Arg, typename _Result>

inline pointer_to_unary_function<_Arg, _Result>

ptr_fun(_Result (*__x)(_Arg))

{ return pointer_to_unary_function<_Arg, _Result>(__x); }

/// One of the @link pointer_adaptors adaptors for function pointers@endlink.

template<typename _Arg1, typename _Arg2, typename _Result>

inline pointer_to_binary_function<_Arg1, _Arg2, _Result>

ptr_fun(_Result (*__x)(_Arg1, _Arg2))

{ return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }

/**

 *  This is one of the @link functors functor base classes@endlink.

 */

template<typename _Arg, typename _Result>

struct unary_function

{

    /// @c argument_type is the type of the argument

    typedef _Arg    argument_type;

    /// @c result_type is the return type

    typedef _Result     result_type;

};

/**

 *  This is one of the @link functors functor base classes@endlink.

 */

template<typename _Arg1, typename _Arg2, typename _Result>

struct binary_function

{

    /// @c first_argument_type is the type of the first argument

    typedef _Arg1   first_argument_type;

    /// @c second_argument_type is the type of the second argument

    typedef _Arg2   second_argument_type;

    /// @c result_type is the return type

    typedef _Result     result_type;

};

// 20.3.8 adaptors pointers members

/** @defgroup memory_adaptors Adaptors for pointers to members

 * @ingroup functors

 *

 *  There are a total of 8 = 2^3 function objects in this family.

 *   (1) Member functions taking no arguments vs member functions taking

 *        one argument.

 *   (2) Call through pointer vs call through reference.

 *   (3) Const vs non-const member function.

 *

 *  All of this complexity is in the function objects themselves.  You can

 *   ignore it by using the helper function mem_fun and mem_fun_ref,

 *   which create whichever type of adaptor is appropriate.

 *

 *  @{

 */

/// One of the @link memory_adaptors adaptors for member

/// pointers@endlink.

template<typename _Ret, typename _Tp>

class mem_fun_t : public unary_function<_Tp*, _Ret>

{

public:

    explicit

    mem_fun_t(_Ret (_Tp::*__pf)())

    : _M_f(__pf) { }

    _Ret

    operator()(_Tp* __p) const

    { return (__p->*_M_f)(); }

private:

    _Ret (_Tp::*_M_f)();

};

/// One of the @link memory_adaptors adaptors for member

/// pointers@endlink.

template<typename _Ret, typename _Tp>

class mem_fun_ref_t : public unary_function<_Tp, _Ret>

{

public:

    explicit

    mem_fun_ref_t(_Ret (_Tp::*__pf)())

    : _M_f(__pf) { }

    _Ret

    operator()(_Tp& __r) const

    { return (__r.*_M_f)(); }

private:

    _Ret (_Tp::*_M_f)();

};

// Mem_fun adaptor helper functions.  There are only two:

// mem_fun and mem_fun_ref.

template<typename _Ret, typename _Tp>

inline mem_fun_t<_Ret, _Tp>

mem_fun(_Ret (_Tp::*__f)())

{ return mem_fun_t<_Ret, _Tp>(__f); }

template<typename _Ret, typename _Tp>

inline mem_fun_ref_t<_Ret, _Tp>

mem_fun_ref(_Ret (_Tp::*__f)())

{ return mem_fun_ref_t<_Ret, _Tp>(__f); }