#pragma once

#ifndef TCG_FUNCTION_TYPES_H

#define TCG_FUNCTION_TYPES_H

// tcg includes

#include "traits.h"

// STD includes

#include <functional></functional>

/*!

  \file     function_types.h

  \brief    This file contains some template class types useful to convert

  functions

            into functors  at compile-time <\I>, with minimal memory

  overhead.

*/

namespace tcg {

//************************************************************************************

//    Function Objects  definition

//************************************************************************************

template <typename f="" func="" func,=""></typename>

struct function;

//---------------------------------------------------------------------------

template <typename (*f)()="" ret="" ret,=""></typename>

struct function<ret (*)(),="" f=""> : public std::unary_function<void, ret=""> {</void,></ret>

  Ret operator()() const { return f(); }

};

//---------------------------------------------------------------------------

template <typename (*f)(arg)="" arg,="" ret="" ret,="" typename=""></typename>

struct function<ret (*)(arg),="" f=""> : public std::unary_function<arg, ret=""> {</arg,></ret>

  Ret operator()(Arg arg) const { return f(arg); }

};

//---------------------------------------------------------------------------

template <typename (*f)(arg1,="" arg1,="" arg2)="" arg2,="" ret="" ret,="" typename=""></typename>

struct function<ret (*)(arg1,="" arg2),="" f=""></ret>

    : public std::binary_function<arg1, arg2,="" ret=""> {</arg1,>

  Ret operator()(Arg1 arg1, Arg2 arg2) const { return f(arg1, arg2); }

};

//************************************************************************************

//    Member Function Objects  definition

//************************************************************************************

template <typename (c::*f)()="" c,="" ret="" ret,="" typename=""></typename>

struct function<ret (c::*)(),="" f=""> : public std::unary_function<c &,="" ret=""> {</c></ret>

  Ret operator()(C &c) const { return (c.*f)(); }

};

//---------------------------------------------------------------------------

template <typename (c::*f)()="" c,="" const="" ret="" ret,="" typename=""></typename>

struct function<ret (c::*)()="" const,="" f=""></ret>

    : public std::unary_function<const &,="" c="" ret=""> {</const>

  Ret operator()(const C &c) const { return (c.*f)(); }

};

//---------------------------------------------------------------------------

template <typename (c::*f)(arg)="" arg,="" c,="" ret="" ret,="" typename=""></typename>

struct function<ret (c::*)(arg),="" f=""></ret>

    : public std::binary_function<c &,="" arg,="" ret=""> {</c>

  Ret operator()(C &c, Arg arg) const { return (c.*f)(arg); }

};

//---------------------------------------------------------------------------

template <typename (c::*f)(arg)="" arg,="" c,="" const="" ret="" ret,="" typename=""></typename>

struct function<ret (c::*)(arg)="" const,="" f=""></ret>

    : public std::binary_function<const &,="" arg,="" c="" ret=""> {</const>

  Ret operator()(const C &c, Arg arg) const { return (c.*f)(arg); }

};

//************************************************************************************

//    Binder functors

//************************************************************************************

/*!

  \brief    Binary function object binder generalizing \p std::binder1st with

            an explicitly specifiable bound type.

  \note     Unlike std::binder1st, this binder accepts functors whose arguments

            are reference types.

  \sa       Helper function tcg::bind1st().

  \remark   This class currently adds an additional arguments copy.

            Be warned of this when using heavyweight argument types.

*/

template <class arg="typename" func,="" function_traits<func="" typename="">::arg1_type></class>

class binder1st

    : public std::unary_function<

          typename function_traits<func>::arg2_type,  // Forward function types</func>

          typename function_traits<func>::ret_type>   //</func>

{

public:

  binder1st(const Func &func, Arg arg1) : m_func(func), m_arg1(arg1) {}

  typename function_traits<func>::ret_type operator()(</func>

      typename function_traits<func>::arg2_type arg2)</func>

      const  // NOTE: Double copy

  {

    return m_func(m_arg1, arg2);

  }

protected:

  Func m_func;

  Arg m_arg1;

};

//---------------------------------------------------------------------------

template <class arg="typename" func,="" function_traits<func="" typename="">::arg2_type></class>

class binder2nd

    : public std::unary_function<typename function_traits<func="">::arg1_type,</typename>

                                 typename function_traits<func>::ret_type> {</func>

public:

  binder2nd(const Func &func, Arg arg2) : m_func(func), m_arg2(arg2) {}

  typename function_traits<func>::ret_type operator()(</func>

      typename function_traits<func>::arg1_type arg1) const {</func>

    return m_func(arg1, m_arg2);

  }

protected:

  Func m_func;

  Arg m_arg2;

};

//---------------------------------------------------------------------------

/*!

  \brief    Helper function for the creation of binder objects with automatic

            type deduction.

  \warning  Unlike std::bind1st, the bound argument type is the one declared

            by the function object. This is typically a commodity, but

            be aware of the subtle implications:

              \li Only parameters copied by value result in a copied

                  bound argument.

              \li Avoid temporaries as bound reference arguments.

  \sa       Class tcg::binder1st.

*/

template <typename arg="" func,="" typename=""></typename>

inline binder1st<func> bind1st(const Func &func, const Arg &arg1) {</func>

  return binder1st<func>(func, arg1);</func>

}

template <typename arg="" func,="" typename=""></typename>

inline binder1st<func> bind1st(const Func &func, Arg &arg1) {</func>

  return binder1st<func>(func, arg1);</func>

}

//---------------------------------------------------------------------------

template <typename arg="" func,="" typename=""></typename>

inline binder2nd<func> bind2nd(const Func &func, const Arg &arg2) {</func>

  return binder2nd<func>(func, arg2);</func>

}

template <typename arg="" func,="" typename=""></typename>

inline binder2nd<func> bind2nd(const Func &func, Arg &arg2) {</func>

  return binder2nd<func>(func, arg2);</func>

}

}  // namespace tcg

#endif  // TCG_FUNCTION_TYPES_H