// Boost.Function library

//  Copyright Douglas Gregor 2001-2006

//  Copyright Emil Dotchevski 2007

//  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>

#if defined(BOOST_MSVC)

#   pragma warning( push )

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

#endif       

#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)

// 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_MEMBER_INVOKER \

  BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \

  BOOST_JOIN(function_void_mem_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_GET_MEMBER_INVOKER \

  BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)

#define BOOST_FUNCTION_GET_INVOKER \

  BOOST_JOIN(get_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

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));

        }

      };

#if BOOST_FUNCTION_NUM_ARGS > 0

      /* Handle invocation of member pointers. */

      template<

        typename MemberPtr,

        typename R BOOST_FUNCTION_COMMA

        BOOST_FUNCTION_TEMPLATE_PARMS

      >

      struct BOOST_FUNCTION_MEMBER_INVOKER

      {

        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA

                        BOOST_FUNCTION_PARMS)

        {

          MemberPtr* f = 

            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);

          return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);

        }

      };

      template<

        typename MemberPtr,

        typename R BOOST_FUNCTION_COMMA

        BOOST_FUNCTION_TEMPLATE_PARMS

      >

      struct BOOST_FUNCTION_VOID_MEMBER_INVOKER

      {

        static BOOST_FUNCTION_VOID_RETURN_TYPE

        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA

               BOOST_FUNCTION_PARMS)

        {

          MemberPtr* f = 

            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);

          BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));

        }

      };

#endif

      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;

      };

#if BOOST_FUNCTION_NUM_ARGS > 0

      /* Retrieve the appropriate invoker for a member pointer.  */

      template<

        typename MemberPtr,

        typename R BOOST_FUNCTION_COMMA

        BOOST_FUNCTION_TEMPLATE_PARMS

       >

      struct BOOST_FUNCTION_GET_MEMBER_INVOKER

      {

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

                            BOOST_FUNCTION_VOID_MEMBER_INVOKER<

                            MemberPtr,

                            R BOOST_FUNCTION_COMMA

                            BOOST_FUNCTION_TEMPLATE_ARGS

                          >,

                          BOOST_FUNCTION_MEMBER_INVOKER<

                            MemberPtr,

                            R BOOST_FUNCTION_COMMA

                            BOOST_FUNCTION_TEMPLATE_ARGS

                          >

                       >::type type;

      };

#endif

      /* Given the tag returned by get_function_tag, retrieve the

         actual invoker that will be used for the given function

         object. 

         Each specialization contains an "apply" nested class template

         that accepts the function object, return type, function

         argument types, and allocator. The resulting "apply" class

         contains two typedefs, "invoker_type" and "manager_type",

         which correspond to the invoker and manager types. */

      template<typename Tag>

      struct BOOST_FUNCTION_GET_INVOKER { };

      /* Retrieve the invoker for a function pointer. */

      template<>

      struct BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>

      {

        template<typename FunctionPtr,

                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>

        struct apply

        {

          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<

                             FunctionPtr,

                             R BOOST_FUNCTION_COMMA

                             BOOST_FUNCTION_TEMPLATE_ARGS

                           >::type

            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;

        };

        template<typename FunctionPtr,

                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,

                 typename Allocator>

        struct apply_a

        {

          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<

                             FunctionPtr,

                             R BOOST_FUNCTION_COMMA

                             BOOST_FUNCTION_TEMPLATE_ARGS

                           >::type

            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;

        };

      };

#if BOOST_FUNCTION_NUM_ARGS > 0

      /* Retrieve the invoker for a member pointer. */

      template<>

      struct BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>

      {

        template<typename MemberPtr,

                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>

        struct apply

        {

          typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<

                             MemberPtr,

                             R BOOST_FUNCTION_COMMA

                             BOOST_FUNCTION_TEMPLATE_ARGS

                           >::type

            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;

        };

        template<typename MemberPtr,

                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,

                 typename Allocator>

        struct apply_a

        {

          typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<

                             MemberPtr,

                             R BOOST_FUNCTION_COMMA

                             BOOST_FUNCTION_TEMPLATE_ARGS

                           >::type

            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;

        };

      };

#endif

      /* Retrieve the invoker for a function object. */

      template<>

      struct BOOST_FUNCTION_GET_INVOKER<function_obj_tag>

      {

        template<typename FunctionObj,

                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>

        struct apply

        {

          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<

                             FunctionObj,

                             R BOOST_FUNCTION_COMMA

                             BOOST_FUNCTION_TEMPLATE_ARGS

                           >::type

            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;

        };

        template<typename FunctionObj,

                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,

                 typename Allocator>

        struct apply_a

        {

          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<

                             FunctionObj,

                             R BOOST_FUNCTION_COMMA

                             BOOST_FUNCTION_TEMPLATE_ARGS

                           >::type

            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;

        };

      };

      /* Retrieve the invoker for a reference to a function object. */

      template<>

      struct BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>

      {

        template<typename RefWrapper,

                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>

        struct apply

        {

          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<

                             typename RefWrapper::type,

                             R BOOST_FUNCTION_COMMA

                             BOOST_FUNCTION_TEMPLATE_ARGS

                           >::type

            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;

        };

        template<typename RefWrapper,

                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,

                 typename Allocator>

        struct apply_a

        {

          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<

                             typename RefWrapper::type,

                             R BOOST_FUNCTION_COMMA

                             BOOST_FUNCTION_TEMPLATE_ARGS

                           >::type

            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;

        };

      };

      /**

       * vtable for a specific boost::function instance. This

       * structure must be an aggregate so that we can use static

       * initialization in boost::function's assign_to and assign_to_a

       * members. It therefore cannot have any constructors,

       * destructors, base classes, etc.

       */

      template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>

      struct BOOST_FUNCTION_VTABLE

      {

#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>

        bool assign_to(F f, function_buffer& functor)

        {

          typedef typename get_function_tag<F>::type tag;

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

        }

        template<typename F,typename Allocator>

        bool assign_to_a(F f, function_buffer& functor, Allocator a)

        {

          typedef typename get_function_tag<F>::type tag;

          return assign_to_a(f, functor, a, tag());

        }

        void clear(function_buffer& functor)

        {

          if (base.manager)

            base.manager(functor, functor, destroy_functor_tag);

        }

      private:

        // Function pointers

        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;

          }

        }

        template<typename FunctionPtr,typename Allocator>

        bool 

        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)

        {

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

        }