// Boost.Function library

//  Copyright Douglas Gregor 2001-2006. Use, modification and

//  distribution is subject to the Boost Software License, Version

//  1.0. (See accompanying file LICENSE_1_0.txt or copy at

//  http://www.boost.org/LICENSE_1_0.txt)

// For more information, see http://www.boost.org

// Note: this header is a header template and must NOT have multiple-inclusion

// protection.

#include <boost/function/detail/prologue.hpp>

#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)

#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)

#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)

#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)

#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)

#define BOOST_FUNCTION_ARG_TYPE(J,I,D) \

  typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);

#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)

// Type of the default allocator

#ifndef BOOST_NO_STD_ALLOCATOR

#  define BOOST_FUNCTION_DEFAULT_ALLOCATOR std::allocator<function_base>

#else

#  define BOOST_FUNCTION_DEFAULT_ALLOCATOR int

#endif // BOOST_NO_STD_ALLOCATOR

// Comma if nonzero number of arguments

#if BOOST_FUNCTION_NUM_ARGS == 0

#  define BOOST_FUNCTION_COMMA

#else

#  define BOOST_FUNCTION_COMMA ,

#endif // BOOST_FUNCTION_NUM_ARGS > 0

// Class names used in this version of the code

#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_INVOKER \

  BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER \

  BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER \

  BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \

  BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_FUNCTION_REF_INVOKER \

  BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \

  BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \

  BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \

  BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \

  BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)

#ifndef BOOST_NO_VOID_RETURNS

#  define BOOST_FUNCTION_VOID_RETURN_TYPE void

#  define BOOST_FUNCTION_RETURN(X) X

#else

#  define BOOST_FUNCTION_VOID_RETURN_TYPE boost::detail::function::unusable

#  define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()

#endif

#ifdef BOOST_MSVC

#  pragma warning(push)

#  pragma warning(disable: 4127) // conditional expression is constant.

#endif

#ifdef BOOST_MSVC

#  pragma warning(push)

#  pragma warning(disable: 4127) // conditional expression is constant.

#endif

namespace boost {

  namespace detail {

    namespace function {

      template<

        typename FunctionPtr,

        typename R BOOST_FUNCTION_COMMA

        BOOST_FUNCTION_TEMPLATE_PARMS

        >

      struct BOOST_FUNCTION_FUNCTION_INVOKER

      {

        static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA

                        BOOST_FUNCTION_PARMS)

        {

          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);

          return f(BOOST_FUNCTION_ARGS);

        }

      };

      template<

        typename FunctionPtr,

        typename R BOOST_FUNCTION_COMMA

        BOOST_FUNCTION_TEMPLATE_PARMS

        >

      struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER

      {

        static BOOST_FUNCTION_VOID_RETURN_TYPE

        invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA

               BOOST_FUNCTION_PARMS)

        {

          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);

          BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));

        }

      };

      template<

        typename FunctionObj,

        typename R BOOST_FUNCTION_COMMA

        BOOST_FUNCTION_TEMPLATE_PARMS

      >

      struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER

      {

        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA

                        BOOST_FUNCTION_PARMS)

        {

          FunctionObj* f;

          if (function_allows_small_object_optimization<FunctionObj>::value)

            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);

          else

            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);

          return (*f)(BOOST_FUNCTION_ARGS);

        }

      };

      template<

        typename FunctionObj,

        typename R BOOST_FUNCTION_COMMA

        BOOST_FUNCTION_TEMPLATE_PARMS

      >

      struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER

      {

        static BOOST_FUNCTION_VOID_RETURN_TYPE

        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA

               BOOST_FUNCTION_PARMS)

        {

          FunctionObj* f;

          if (function_allows_small_object_optimization<FunctionObj>::value)

            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);

          else

            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);

          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));

        }

      };

      template<

        typename FunctionObj,

        typename R BOOST_FUNCTION_COMMA

        BOOST_FUNCTION_TEMPLATE_PARMS

      >

      struct BOOST_FUNCTION_FUNCTION_REF_INVOKER

      {

        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA

                        BOOST_FUNCTION_PARMS)

        {

          FunctionObj* f = 

            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);

          return (*f)(BOOST_FUNCTION_ARGS);

        }

      };

      template<

        typename FunctionObj,

        typename R BOOST_FUNCTION_COMMA

        BOOST_FUNCTION_TEMPLATE_PARMS

      >

      struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER

      {

        static BOOST_FUNCTION_VOID_RETURN_TYPE

        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA

               BOOST_FUNCTION_PARMS)

        {

          FunctionObj* f = 

            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);

          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));

        }

      };

      template<

        typename FunctionPtr,

        typename R BOOST_FUNCTION_COMMA

        BOOST_FUNCTION_TEMPLATE_PARMS

      >

      struct BOOST_FUNCTION_GET_FUNCTION_INVOKER

      {

        typedef typename mpl::if_c<(is_void<R>::value),

                            BOOST_FUNCTION_VOID_FUNCTION_INVOKER<

                            FunctionPtr,

                            R BOOST_FUNCTION_COMMA

                            BOOST_FUNCTION_TEMPLATE_ARGS

                          >,

                          BOOST_FUNCTION_FUNCTION_INVOKER<

                            FunctionPtr,

                            R BOOST_FUNCTION_COMMA

                            BOOST_FUNCTION_TEMPLATE_ARGS

                          >

                       >::type type;

      };

      template<

        typename FunctionObj,

        typename R BOOST_FUNCTION_COMMA

        BOOST_FUNCTION_TEMPLATE_PARMS

       >

      struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER

      {

        typedef typename mpl::if_c<(is_void<R>::value),

                            BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<

                            FunctionObj,

                            R BOOST_FUNCTION_COMMA

                            BOOST_FUNCTION_TEMPLATE_ARGS

                          >,

                          BOOST_FUNCTION_FUNCTION_OBJ_INVOKER<

                            FunctionObj,

                            R BOOST_FUNCTION_COMMA

                            BOOST_FUNCTION_TEMPLATE_ARGS

                          >

                       >::type type;

      };

      template<

        typename FunctionObj,

        typename R BOOST_FUNCTION_COMMA

        BOOST_FUNCTION_TEMPLATE_PARMS

       >

      struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER

      {

        typedef typename mpl::if_c<(is_void<R>::value),

                            BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<

                            FunctionObj,

                            R BOOST_FUNCTION_COMMA

                            BOOST_FUNCTION_TEMPLATE_ARGS

                          >,

                          BOOST_FUNCTION_FUNCTION_REF_INVOKER<

                            FunctionObj,

                            R BOOST_FUNCTION_COMMA

                            BOOST_FUNCTION_TEMPLATE_ARGS

                          >

                       >::type type;

      };

      /**

       * vtable for a specific boost::function instance.

       */

      template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,

               typename Allocator>

      struct BOOST_FUNCTION_VTABLE : vtable_base

      {

#ifndef BOOST_NO_VOID_RETURNS

        typedef R         result_type;

#else

        typedef typename function_return_type<R>::type result_type;

#endif // BOOST_NO_VOID_RETURNS

        typedef result_type (*invoker_type)(function_buffer&

                                            BOOST_FUNCTION_COMMA

                                            BOOST_FUNCTION_TEMPLATE_ARGS);

        template<typename F>

        BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0)

        {

          init(f);

        }

        template<typename F>

        bool assign_to(F f, function_buffer& functor)

        {

          typedef typename get_function_tag<F>::type tag;

          return assign_to(f, functor, tag());

        }

        void clear(function_buffer& functor)

        {

          if (manager)

            manager(functor, functor, destroy_functor_tag);

        }

      private:

        template<typename F>

        void init(F f)

        {

          typedef typename get_function_tag<F>::type tag;

          init(f, tag());

        }

        // Function pointers

        template<typename FunctionPtr>

        void init(FunctionPtr /*f*/, function_ptr_tag)

        {

          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<

                             FunctionPtr,

                             R BOOST_FUNCTION_COMMA

                             BOOST_FUNCTION_TEMPLATE_ARGS

                           >::type

            actual_invoker_type;

          invoker = &actual_invoker_type::invoke;

          manager = &functor_manager<FunctionPtr, Allocator>::manage;

        }

        template<typename FunctionPtr>

        bool 

        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)

        {

          this->clear(functor);

          if (f) {

            // should be a reinterpret cast, but some compilers insist

            // on giving cv-qualifiers to free functions

            functor.func_ptr = (void (*)())(f);

            return true;

          } else {

            return false;

          }

        }

        // Member pointers

#if BOOST_FUNCTION_NUM_ARGS > 0

        template<typename MemberPtr>

        void init(MemberPtr f, member_ptr_tag)

        {

          // DPG TBD: Add explicit support for member function

          // objects, so we invoke through mem_fn() but we retain the

          // right target_type() values.

          this->init(mem_fn(f));

        }

        template<typename MemberPtr>

        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)

        {

          // DPG TBD: Add explicit support for member function

          // objects, so we invoke through mem_fn() but we retain the

          // right target_type() values.

          if (f) {

            this->assign_to(mem_fn(f), functor);

            return true;

          } else {

            return false;

          }

        }

#endif // BOOST_FUNCTION_NUM_ARGS > 0

        // Function objects

        template<typename FunctionObj>

        void init(FunctionObj /*f*/, function_obj_tag)

        {

          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<

                             FunctionObj,

                             R BOOST_FUNCTION_COMMA

                             BOOST_FUNCTION_TEMPLATE_ARGS

                           >::type

            actual_invoker_type;

          invoker = &actual_invoker_type::invoke;

          manager = &functor_manager<FunctionObj, Allocator>::manage;

        }

        // Assign to a function object using the small object optimization

        template<typename FunctionObj>

        void 

        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)

        {

          new ((void*)&functor.data) FunctionObj(f);

        }

        // Assign to a function object allocated on the heap.

        template<typename FunctionObj>

        void 

        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)

        {

#ifndef BOOST_NO_STD_ALLOCATOR

          typedef typename Allocator::template rebind<FunctionObj>::other

            allocator_type;

          typedef typename allocator_type::pointer pointer_type;

          allocator_type allocator;

          pointer_type copy = allocator.allocate(1);

          allocator.construct(copy, f);

          // Get back to the original pointer type

          functor.obj_ptr = static_cast<FunctionObj*>(copy);

#  else

          functor.obj_ptr = new FunctionObj(f);

#  endif // BOOST_NO_STD_ALLOCATOR

        }

        template<typename FunctionObj>

        bool 

        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)

        {

          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {

            assign_functor(f, functor, 

                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());

            return true;

          } else {

            return false;

          }

        }

        // Reference to a function object

        template<typename FunctionObj>

        void 

        init(const reference_wrapper<FunctionObj>& /*f*/, function_obj_ref_tag)

        {

          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<

                             FunctionObj,

                             R BOOST_FUNCTION_COMMA

                             BOOST_FUNCTION_TEMPLATE_ARGS

                           >::type

            actual_invoker_type;

          invoker = &actual_invoker_type::invoke;

          manager = &reference_manager<FunctionObj>::get;

        }

        template<typename FunctionObj>

        bool 

        assign_to(const reference_wrapper<FunctionObj>& f, 

                  function_buffer& functor, function_obj_ref_tag)

        {

          if (!boost::detail::function::has_empty_target(f.get_pointer())) {

            // DPG TBD: We might need to detect constness of

            // FunctionObj to assign into obj_ptr or const_obj_ptr to

            // be truly legit, but no platform in existence makes

            // const void* different from void*.

            functor.const_obj_ptr = f.get_pointer();

            return true;

          } else {

            return false;

          }

        }

      public:

        invoker_type invoker;

      };

    } // end namespace function

  } // end namespace detail

  template<

    typename R BOOST_FUNCTION_COMMA

    BOOST_FUNCTION_TEMPLATE_PARMS,

    typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR

  >

  class BOOST_FUNCTION_FUNCTION : public function_base

  {

  public:

#ifndef BOOST_NO_VOID_RETURNS

    typedef R         result_type;

#else

    typedef  typename boost::detail::function::function_return_type<R>::type

      result_type;

#endif // BOOST_NO_VOID_RETURNS

  private:

    typedef boost::detail::function::BOOST_FUNCTION_VTABLE<

              R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator>

      vtable_type;

    struct clear_type {};

  public:

    BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS);

    // add signature for boost::lambda

    template<typename Args>

    struct sig

    {

      typedef result_type type;

    };

#if BOOST_FUNCTION_NUM_ARGS == 1

    typedef T0 argument_type;

#elif BOOST_FUNCTION_NUM_ARGS == 2

    typedef T0 first_argument_type;

    typedef T1 second_argument_type;

#endif

    BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);

    BOOST_FUNCTION_ARG_TYPES

    typedef Allocator allocator_type;

    typedef BOOST_FUNCTION_FUNCTION self_type;

    BOOST_FUNCTION_FUNCTION() : function_base() { }

    // MSVC chokes if the following two constructors are collapsed into

    // one with a default parameter.

    template<typename Functor>

    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f

#ifndef BOOST_NO_SFINAE

                            ,typename enable_if_c<

                            (boost::type_traits::ice_not<

                             (is_integral<Functor>::value)>::value),

                                        int>::type = 0

#endif // BOOST_NO_SFINAE

                            ) :

      function_base()

    {

      this->assign_to(f);

    }

#ifndef BOOST_NO_SFINAE

    BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }

#else

    BOOST_FUNCTION_FUNCTION(int zero) : function_base()

    {

      BOOST_ASSERT(zero == 0);

    }

#endif

    BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base()

    {

      this->assign_to_own(f);

    }