passenger 6.0.14 → 6.0.27

data/src/cxx_supportlib/vendor-modified/boost/function/function_template.hpp

@@ -1,3 +1,6 @@
+#ifndef BOOST_FUNCTION_FUNCTION_TEMPLATE_HPP_INCLUDED
+#define BOOST_FUNCTION_FUNCTION_TEMPLATE_HPP_INCLUDED
+
 // Boost.Function library
 
 //  Copyright Douglas Gregor 2001-2006
@@ -8,125 +11,64 @@
 
 // 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>
+#include <boost/function/function_base.hpp>
 #include <boost/core/no_exceptions_support.hpp>
+#include <boost/mem_fn.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/config.hpp>
+#include <algorithm>
+#include <cassert>
+#include <type_traits>
 
 #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)
-
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-#   define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
-#else
-#   define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
-#   define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
-#endif
-
-#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
+        typename R,
+        typename... T
         >
-      struct BOOST_FUNCTION_FUNCTION_INVOKER
+      struct function_invoker
       {
-        static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_PARMS)
+        static R invoke(function_buffer& function_ptr,
+                        T... a)
         {
           FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
-          return f(BOOST_FUNCTION_ARGS);
+          return f(static_cast<T&&>(a)...);
         }
       };
 
       template<
         typename FunctionPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R,
+        typename... T
         >
-      struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+      struct void_function_invoker
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
+        static void
+        invoke(function_buffer& function_ptr,
+               T... a)
 
         {
           FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
-          BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
+          f(static_cast<T&&>(a)...);
         }
       };
 
       template<
         typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R,
+        typename... T
       >
-      struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+      struct function_obj_invoker
       {
-        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_PARMS)
+        static R invoke(function_buffer& function_obj_ptr,
+                        T... a)
 
         {
           FunctionObj* f;
@@ -134,20 +76,20 @@ namespace boost {
             f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
           else
             f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
-          return (*f)(BOOST_FUNCTION_ARGS);
+          return (*f)(static_cast<T&&>(a)...);
         }
       };
 
       template<
         typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R,
+        typename... T
       >
-      struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+      struct void_function_obj_invoker
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
+        static void
+        invoke(function_buffer& function_obj_ptr,
+               T... a)
 
         {
           FunctionObj* f;
@@ -155,194 +97,190 @@ namespace boost {
             f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
           else
             f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
-          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
+          (*f)(static_cast<T&&>(a)...);
         }
       };
 
       template<
         typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R,
+        typename... T
       >
-      struct BOOST_FUNCTION_FUNCTION_REF_INVOKER
+      struct function_ref_invoker
       {
-        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_PARMS)
+        static R invoke(function_buffer& function_obj_ptr,
+                        T... a)
 
         {
           FunctionObj* f =
             reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
-          return (*f)(BOOST_FUNCTION_ARGS);
+          return (*f)(static_cast<T&&>(a)...);
         }
       };
 
       template<
         typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R,
+        typename... T
       >
-      struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+      struct void_function_ref_invoker
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
+        static void
+        invoke(function_buffer& function_obj_ptr,
+               T... a)
 
         {
           FunctionObj* f =
             reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
-          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
+          (*f)(static_cast<T&&>(a)...);
         }
       };
 
-#if BOOST_FUNCTION_NUM_ARGS > 0
       /* Handle invocation of member pointers. */
       template<
         typename MemberPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R,
+        typename... T
       >
-      struct BOOST_FUNCTION_MEMBER_INVOKER
+      struct member_invoker
       {
-        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_PARMS)
+        static R invoke(function_buffer& function_obj_ptr,
+                        T... a)
 
         {
           MemberPtr* f =
             reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
-          return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
+          return boost::mem_fn(*f)(static_cast<T&&>(a)...);
         }
       };
 
       template<
         typename MemberPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R,
+        typename... T
       >
-      struct BOOST_FUNCTION_VOID_MEMBER_INVOKER
+      struct void_member_invoker
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
+        static void
+        invoke(function_buffer& function_obj_ptr,
+               T... a)
 
         {
           MemberPtr* f =
             reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
-          BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
+          boost::mem_fn(*f)(static_cast<T&&>(a)...);
         }
       };
-#endif
 
       template<
         typename FunctionPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R,
+        typename... T
       >
-      struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
+      struct get_function_invoker
       {
-        typedef typename conditional<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
+        typedef typename std::conditional<std::is_void<R>::value,
+                            void_function_invoker<
                             FunctionPtr,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R,
+                            T...
                           >,
-                          BOOST_FUNCTION_FUNCTION_INVOKER<
+                          function_invoker<
                             FunctionPtr,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R,
+                            T...
                           >
                        >::type type;
       };
 
       template<
         typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R,
+        typename... T
        >
-      struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+      struct get_function_obj_invoker
       {
-        typedef typename conditional<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
+        typedef typename std::conditional<std::is_void<R>::value,
+                            void_function_obj_invoker<
                             FunctionObj,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R,
+                            T...
                           >,
-                          BOOST_FUNCTION_FUNCTION_OBJ_INVOKER<
+                          function_obj_invoker<
                             FunctionObj,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R,
+                            T...
                           >
                        >::type type;
       };
 
       template<
         typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
+        typename R,
+        typename... T
        >
-      struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+      struct get_function_ref_invoker
       {
-        typedef typename conditional<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
+        typedef typename std::conditional<std::is_void<R>::value,
+                            void_function_ref_invoker<
                             FunctionObj,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R,
+                            T...
                           >,
-                          BOOST_FUNCTION_FUNCTION_REF_INVOKER<
+                          function_ref_invoker<
                             FunctionObj,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R,
+                            T...
                           >
                        >::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
+        typename R,
+        typename... T
        >
-      struct BOOST_FUNCTION_GET_MEMBER_INVOKER
+      struct get_member_invoker
       {
-        typedef typename conditional<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_MEMBER_INVOKER<
+        typedef typename std::conditional<std::is_void<R>::value,
+                            void_member_invoker<
                             MemberPtr,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R,
+                            T...
                           >,
-                          BOOST_FUNCTION_MEMBER_INVOKER<
+                          member_invoker<
                             MemberPtr,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
+                            R,
+                            T...
                           >
                        >::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
+         Each specialization contains an "apply_" nested class template
          that accepts the function object, return type, function
-         argument types, and allocator. The resulting "apply" class
+         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 { };
+      struct get_invoker { };
 
       /* Retrieve the invoker for a function pointer. */
       template<>
-      struct BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
+      struct get_invoker<function_ptr_tag>
       {
         template<typename FunctionPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-        struct apply
+                 typename R, typename... T>
+        struct apply_
         {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+          typedef typename get_function_invoker<
                              FunctionPtr,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R,
+                             T...
                            >::type
             invoker_type;
 
@@ -350,13 +288,13 @@ namespace boost {
         };
 
         template<typename FunctionPtr, typename Allocator,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R, typename... T>
         struct apply_a
         {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+          typedef typename get_function_invoker<
                              FunctionPtr,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R,
+                             T...
                            >::type
             invoker_type;
 
@@ -364,19 +302,18 @@ namespace boost {
         };
       };
 
-#if BOOST_FUNCTION_NUM_ARGS > 0
       /* Retrieve the invoker for a member pointer. */
       template<>
-      struct BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
+      struct get_invoker<member_ptr_tag>
       {
         template<typename MemberPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-        struct apply
+                 typename R, typename... T>
+        struct apply_
         {
-          typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
+          typedef typename get_member_invoker<
                              MemberPtr,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R,
+                             T...
                            >::type
             invoker_type;
 
@@ -384,33 +321,32 @@ namespace boost {
         };
 
         template<typename MemberPtr, typename Allocator,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R, typename... T>
         struct apply_a
         {
-          typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
+          typedef typename get_member_invoker<
                              MemberPtr,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R,
+                             T...
                            >::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>
+      struct get_invoker<function_obj_tag>
       {
         template<typename FunctionObj,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-        struct apply
+                 typename R, typename... T>
+        struct apply_
         {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+          typedef typename get_function_obj_invoker<
                              FunctionObj,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R,
+                             T...
                            >::type
             invoker_type;
 
@@ -418,13 +354,13 @@ namespace boost {
         };
 
         template<typename FunctionObj, typename Allocator,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R, typename... T>
         struct apply_a
         {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+          typedef typename get_function_obj_invoker<
                              FunctionObj,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R,
+                             T...
                            >::type
             invoker_type;
 
@@ -434,16 +370,16 @@ namespace boost {
 
       /* Retrieve the invoker for a reference to a function object. */
       template<>
-      struct BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
+      struct get_invoker<function_obj_ref_tag>
       {
         template<typename RefWrapper,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-        struct apply
+                 typename R, typename... T>
+        struct apply_
         {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
+          typedef typename get_function_ref_invoker<
                              typename RefWrapper::type,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R,
+                             T...
                            >::type
             invoker_type;
 
@@ -451,13 +387,13 @@ namespace boost {
         };
 
         template<typename RefWrapper, typename Allocator,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R, typename... T>
         struct apply_a
         {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
+          typedef typename get_function_ref_invoker<
                              typename RefWrapper::type,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
+                             R,
+                             T...
                            >::type
             invoker_type;
 
@@ -473,36 +409,40 @@ namespace boost {
        * 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
+      template<typename R, typename... T>
+      struct basic_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);
+                                           ,
+                                            T...);
 
         template<typename F>
         bool assign_to(F f, function_buffer& functor) const
         {
           typedef typename get_function_tag<F>::type tag;
-          return assign_to(f, functor, tag());
+          return assign_to(std::move(f), functor, tag());
         }
         template<typename F,typename Allocator>
         bool assign_to_a(F f, function_buffer& functor, Allocator a) const
         {
           typedef typename get_function_tag<F>::type tag;
-          return assign_to_a(f, functor, a, tag());
+          return assign_to_a(std::move(f), functor, a, tag());
         }
 
         void clear(function_buffer& functor) const
         {
+#if defined(BOOST_GCC) && (__GNUC__ >= 11)
+# pragma GCC diagnostic push
+// False positive in GCC 11/12 for empty function objects
+# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
           if (base.manager)
             base.manager(functor, functor, destroy_functor_tag);
+#if defined(BOOST_GCC) && (__GNUC__ >= 11)
+# pragma GCC diagnostic pop
+#endif
         }
 
       private:
@@ -513,8 +453,6 @@ namespace boost {
         {
           this->clear(functor);
           if (f) {
-            // should be a reinterpret cast, but some compilers insist
-            // on giving cv-qualifiers to free functions
             functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
             return true;
           } else {
@@ -525,11 +463,10 @@ namespace boost {
         bool
         assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
         {
-          return assign_to(f,functor,function_ptr_tag());
+          return assign_to(std::move(f),functor,function_ptr_tag());
         }
 
         // Member pointers
-#if BOOST_FUNCTION_NUM_ARGS > 0
         template<typename MemberPtr>
         bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
         {
@@ -556,50 +493,42 @@ namespace boost {
             return false;
           }
         }
-#endif // BOOST_FUNCTION_NUM_ARGS > 0
 
         // Function objects
         // Assign to a function object using the small object optimization
         template<typename FunctionObj>
         void
-        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        assign_functor(FunctionObj f, function_buffer& functor, std::true_type) const
         {
-          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(std::move(f));
         }
         template<typename FunctionObj,typename Allocator>
         void
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, std::true_type) const
         {
-          assign_functor(f,functor,true_type());
+          assign_functor(std::move(f),functor,std::true_type());
         }
 
         // Assign to a function object allocated on the heap.
         template<typename FunctionObj>
         void
-        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        assign_functor(FunctionObj f, function_buffer& functor, std::false_type) const
         {
-          functor.members.obj_ptr = new FunctionObj(f);
+          functor.members.obj_ptr = new FunctionObj(std::move(f));
         }
         template<typename FunctionObj,typename Allocator>
         void
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, std::false_type) const
         {
           typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-          typedef typename Allocator::template rebind<functor_wrapper_type>::other
-            wrapper_allocator_type;
-          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
-#else
+
           using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
           using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
-#endif
+
           wrapper_allocator_type wrapper_allocator(a);
           wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
-#else
           std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
-#endif
+
           functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
           functor.members.obj_ptr = new_f;
         }
@@ -609,8 +538,8 @@ namespace boost {
         assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
         {
           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
-            assign_functor(f, functor,
-                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            assign_functor(std::move(f), functor,
+                           std::integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
             return true;
           } else {
             return false;
@@ -621,8 +550,8 @@ namespace boost {
         assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
         {
           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
-            assign_functor_a(f, functor, a,
-                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            assign_functor_a(std::move(f), functor, a,
+                           std::integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
             return true;
           } else {
             return false;
@@ -636,8 +565,8 @@ namespace boost {
                   function_buffer& functor, function_obj_ref_tag) const
         {
           functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
-          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
-          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          functor.members.obj_ref.is_const_qualified = std::is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = std::is_volatile<FunctionObj>::value;
           return true;
         }
         template<typename FunctionObj,typename Allocator>
@@ -652,26 +581,146 @@ namespace boost {
         vtable_base base;
         invoker_type invoker;
       };
+
+      template <typename... T>
+      struct variadic_function_base
+      {};
+
+      template <typename T1>
+      struct variadic_function_base<T1>
+      {
+        typedef T1 argument_type;
+        typedef T1 arg1_type;
+      };
+
+      template <typename T1, typename T2>
+      struct variadic_function_base<T1, T2>
+      {
+        typedef T1 first_argument_type;
+        typedef T2 second_argument_type;
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+      };
+
+      template <typename T1, typename T2, typename T3>
+      struct variadic_function_base<T1, T2, T3>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4>
+      struct variadic_function_base<T1, T2, T3, T4>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4, typename T5>
+      struct variadic_function_base<T1, T2, T3, T4, T5>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+        typedef T5 arg5_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+      struct variadic_function_base<T1, T2, T3, T4, T5, T6>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+        typedef T5 arg5_type;
+        typedef T6 arg6_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+      struct variadic_function_base<T1, T2, T3, T4, T5, T6, T7>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+        typedef T5 arg5_type;
+        typedef T6 arg6_type;
+        typedef T7 arg7_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+      struct variadic_function_base<T1, T2, T3, T4, T5, T6, T7, T8>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+        typedef T5 arg5_type;
+        typedef T6 arg6_type;
+        typedef T7 arg7_type;
+        typedef T8 arg8_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+      struct variadic_function_base<T1, T2, T3, T4, T5, T6, T7, T8, T9>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+        typedef T5 arg5_type;
+        typedef T6 arg6_type;
+        typedef T7 arg7_type;
+        typedef T8 arg8_type;
+        typedef T9 arg9_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+      struct variadic_function_base<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+        typedef T5 arg5_type;
+        typedef T6 arg6_type;
+        typedef T7 arg7_type;
+        typedef T8 arg8_type;
+        typedef T9 arg9_type;
+        typedef T10 arg10_type;
+      };
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+
+      template<class T> struct is_trivially_copyable: std::integral_constant<bool,
+        __has_trivial_copy(T) && __has_trivial_assign(T) && __has_trivial_destructor(T)> {};
+
+#else
+
+      using std::is_trivially_copyable;
+
+#endif
+
     } // end namespace function
   } // end namespace detail
 
   template<
-    typename R BOOST_FUNCTION_COMMA
-    BOOST_FUNCTION_TEMPLATE_PARMS
+    typename R,
+    typename... T
   >
-  class BOOST_FUNCTION_FUNCTION : public function_base
+  class function_n : public function_base
+                                , public detail::function::variadic_function_base<T...>
   {
   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>
+    typedef boost::detail::function::basic_vtable<
+              R, T...>
       vtable_type;
 
     vtable_type* get_vtable() const {
@@ -682,8 +731,6 @@ namespace boost {
     struct clear_type {};
 
   public:
-    BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS);
-
     // add signature for boost::lambda
     template<typename Args>
     struct sig
@@ -691,93 +738,68 @@ namespace boost {
       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
+    BOOST_STATIC_CONSTANT(int, arity = sizeof...(T));
 
-    typedef BOOST_FUNCTION_FUNCTION self_type;
+    typedef function_n self_type;
 
-    BOOST_DEFAULTED_FUNCTION(BOOST_FUNCTION_FUNCTION(), : function_base() {})
+    BOOST_DEFAULTED_FUNCTION(function_n(), : 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 boost::enable_if_<
-                             !(is_integral<Functor>::value),
+    function_n(Functor f
+                            ,typename std::enable_if<
+                             !std::is_integral<Functor>::value,
                                         int>::type = 0
-#endif // BOOST_NO_SFINAE
                             ) :
       function_base()
     {
-      this->assign_to(f);
+      this->assign_to(std::move(f));
     }
     template<typename Functor,typename Allocator>
-    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
-#ifndef BOOST_NO_SFINAE
-                            ,typename boost::enable_if_<
-                              !(is_integral<Functor>::value),
+    function_n(Functor f, Allocator a
+                            ,typename std::enable_if<
+                              !std::is_integral<Functor>::value,
                                         int>::type = 0
-#endif // BOOST_NO_SFINAE
                             ) :
       function_base()
     {
-      this->assign_to_a(f,a);
+      this->assign_to_a(std::move(f),a);
     }
 
-#ifndef BOOST_NO_SFINAE
-    BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
-#else
-    BOOST_FUNCTION_FUNCTION(int zero) : function_base()
-    {
-      BOOST_ASSERT(zero == 0);
-    }
-#endif
+    function_n(clear_type*) : function_base() { }
 
-    BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base()
+    function_n(const function_n& f) : function_base()
     {
       this->assign_to_own(f);
     }
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    BOOST_FUNCTION_FUNCTION(BOOST_FUNCTION_FUNCTION&& f) : function_base()
+    function_n(function_n&& f) : function_base()
     {
       this->move_assign(f);
     }
-#endif
 
-    ~BOOST_FUNCTION_FUNCTION() { clear(); }
+    ~function_n() { clear(); }
 
-    result_type operator()(BOOST_FUNCTION_PARMS) const
+    result_type operator()(T... a) const
     {
       if (this->empty())
         boost::throw_exception(bad_function_call());
 
       return get_vtable()->invoker
-               (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
+               (this->functor, static_cast<T&&>(a)...);
     }
 
-    // The distinction between when to use BOOST_FUNCTION_FUNCTION and
+    // The distinction between when to use function_n and
     // when to use self_type is obnoxious. MSVC cannot handle self_type as
     // the return type of these assignment operators, but Borland C++ cannot
-    // handle BOOST_FUNCTION_FUNCTION as the type of the temporary to
+    // handle function_n as the type of the temporary to
     // construct.
     template<typename Functor>
-#ifndef BOOST_NO_SFINAE
-    typename boost::enable_if_<
-                  !(is_integral<Functor>::value),
-               BOOST_FUNCTION_FUNCTION&>::type
-#else
-    BOOST_FUNCTION_FUNCTION&
-#endif
-    operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
+    typename std::enable_if<
+                  !std::is_integral<Functor>::value,
+               function_n&>::type
+    operator=(Functor f)
     {
       this->clear();
       BOOST_TRY  {
@@ -790,7 +812,7 @@ namespace boost {
       return *this;
     }
     template<typename Functor,typename Allocator>
-    void assign(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a)
+    void assign(Functor f, Allocator a)
     {
       this->clear();
       BOOST_TRY{
@@ -802,23 +824,14 @@ namespace boost {
       BOOST_CATCH_END
     }
 
-#ifndef BOOST_NO_SFINAE
-    BOOST_FUNCTION_FUNCTION& operator=(clear_type*)
+    function_n& operator=(clear_type*)
     {
       this->clear();
       return *this;
     }
-#else
-    BOOST_FUNCTION_FUNCTION& operator=(int zero)
-    {
-      BOOST_ASSERT(zero == 0);
-      this->clear();
-      return *this;
-    }
-#endif
 
-    // Assignment from another BOOST_FUNCTION_FUNCTION
-    BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
+    // Assignment from another function_n
+    function_n& operator=(const function_n& f)
     {
       if (&f == this)
         return *this;
@@ -834,9 +847,8 @@ namespace boost {
       return *this;
     }
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    // Move assignment from another BOOST_FUNCTION_FUNCTION
-    BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f)
+    // Move assignment from another function_n
+    function_n& operator=(function_n&& f)
     {
       if (&f == this)
         return *this;
@@ -851,14 +863,13 @@ namespace boost {
       BOOST_CATCH_END
       return *this;
     }
-#endif
 
-    void swap(BOOST_FUNCTION_FUNCTION& other)
+    void swap(function_n& other)
     {
       if (&other == this)
         return;
 
-      BOOST_FUNCTION_FUNCTION tmp;
+      function_n tmp;
       tmp.move_assign(*this);
       this->move_assign(other);
       other.move_assign(tmp);
@@ -874,27 +885,10 @@ namespace boost {
       }
     }
 
-#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG)
-    // Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it
-    operator bool () const { return !this->empty(); }
-#else
-  private:
-    struct dummy {
-      void nonnull() {}
-    };
-
-    typedef void (dummy::*safe_bool)();
-
-  public:
-    operator safe_bool () const
-      { return (this->empty())? 0 : &dummy::nonnull; }
-
-    bool operator!() const
-      { return this->empty(); }
-#endif
+    explicit operator bool () const { return !this->empty(); }
 
   private:
-    void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)
+    void assign_to_own(const function_n& f)
     {
       if (!f.empty()) {
         this->vtable = f.vtable;
@@ -906,6 +900,10 @@ namespace boost {
             // This warning is technically correct, but we don't want to pay the price for initializing
             // just to silence a warning: https://github.com/boostorg/function/issues/27
 #           pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#           if (BOOST_GCC >= 110000)
+              // GCC 11.3, 12 emit a different warning: https://github.com/boostorg/function/issues/42
+#             pragma GCC diagnostic ignored "-Wuninitialized"
+#           endif
 #         endif
           std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
 #         if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
@@ -923,10 +921,10 @@ namespace boost {
       using boost::detail::function::vtable_base;
 
       typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
-      typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+      typedef boost::detail::function::get_invoker<tag> get_invoker;
       typedef typename get_invoker::
-                         template apply<Functor, R BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_TEMPLATE_ARGS>
+                         template apply_<Functor, R,
+                        T...>
         handler_type;
 
       typedef typename handler_type::invoker_type invoker_type;
@@ -939,11 +937,10 @@ namespace boost {
       static const vtable_type stored_vtable =
         { { &manager_type::manage }, &invoker_type::invoke };
 
-      if (stored_vtable.assign_to(f, functor)) {
+      if (stored_vtable.assign_to(std::move(f), functor)) {
         std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
         // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
-        if (boost::has_trivial_copy_constructor<Functor>::value &&
-            boost::has_trivial_destructor<Functor>::value &&
+        if (boost::detail::function::is_trivially_copyable<Functor>::value &&
             boost::detail::function::function_allows_small_object_optimization<Functor>::value)
           value |= static_cast<std::size_t>(0x01);
         vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
@@ -957,10 +954,10 @@ namespace boost {
       using boost::detail::function::vtable_base;
 
       typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
-      typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+      typedef boost::detail::function::get_invoker<tag> get_invoker;
       typedef typename get_invoker::
-                         template apply_a<Functor, Allocator, R BOOST_FUNCTION_COMMA
-                         BOOST_FUNCTION_TEMPLATE_ARGS>
+                         template apply_a<Functor, Allocator, R,
+                         T...>
         handler_type;
 
       typedef typename handler_type::invoker_type invoker_type;
@@ -973,11 +970,10 @@ namespace boost {
       static const vtable_type stored_vtable =
         { { &manager_type::manage }, &invoker_type::invoke };
 
-      if (stored_vtable.assign_to_a(f, functor, a)) {
+      if (stored_vtable.assign_to_a(std::move(f), functor, a)) {
         std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
         // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
-        if (boost::has_trivial_copy_constructor<Functor>::value &&
-            boost::has_trivial_destructor<Functor>::value &&
+        if (boost::detail::function::is_trivially_copyable<Functor>::value &&
             boost::detail::function::function_allows_small_object_optimization<Functor>::value)
           value |= static_cast<std::size_t>(0x01);
         vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
@@ -988,7 +984,7 @@ namespace boost {
     // Moves the value from the specified argument to *this. If the argument
     // has its function object allocated on the heap, move_assign will pass
     // its buffer to *this, and set the argument's buffer pointer to NULL.
-    void move_assign(BOOST_FUNCTION_FUNCTION& f)
+    void move_assign(function_n& f)
     {
       if (&f == this)
         return;
@@ -1004,14 +1000,26 @@ namespace boost {
               // This warning is technically correct, but we don't want to pay the price for initializing
               // just to silence a warning: https://github.com/boostorg/function/issues/27
 #             pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#             if (BOOST_GCC >= 120000)
+                // GCC 12 emits a different warning: https://github.com/boostorg/function/issues/42
+#               pragma GCC diagnostic ignored "-Wuninitialized"
+#             endif
 #           endif
             std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
 #           if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
 #             pragma GCC diagnostic pop
 #           endif
           } else
+#if defined(BOOST_GCC) && (__GNUC__ >= 11)
+# pragma GCC diagnostic push
+// False positive in GCC 11/12 for empty function objects (function_n_test.cpp:673)
+# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
             get_vtable()->base.manager(f.functor, this->functor,
                                      boost::detail::function::move_functor_tag);
+#if defined(BOOST_GCC) && (__GNUC__ >= 11)
+# pragma GCC diagnostic pop
+#endif
           f.vtable = 0;
         } else {
           clear();
@@ -1024,49 +1032,41 @@ namespace boost {
     }
   };
 
-  template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-  inline void swap(BOOST_FUNCTION_FUNCTION<
-                     R BOOST_FUNCTION_COMMA
-                     BOOST_FUNCTION_TEMPLATE_ARGS
+  template<typename R, typename... T>
+  inline void swap(function_n<
+                     R,
+                     T...
                    >& f1,
-                   BOOST_FUNCTION_FUNCTION<
-                     R BOOST_FUNCTION_COMMA
-                     BOOST_FUNCTION_TEMPLATE_ARGS
+                   function_n<
+                     R,
+                     T...
                    >& f2)
   {
     f1.swap(f2);
   }
 
 // Poison comparisons between boost::function objects of the same type.
-template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-  void operator==(const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS>&,
-                  const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS>&);
-template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-  void operator!=(const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS>&,
-                  const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS>& );
-
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-
-#if BOOST_FUNCTION_NUM_ARGS == 0
-#define BOOST_FUNCTION_PARTIAL_SPEC R (void)
-#else
-#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
-#endif
-
-template<typename R BOOST_FUNCTION_COMMA
-         BOOST_FUNCTION_TEMPLATE_PARMS>
-class function<BOOST_FUNCTION_PARTIAL_SPEC>
-  : public BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
+template<typename R, typename... T>
+  void operator==(const function_n<
+                          R,
+                          T...>&,
+                  const function_n<
+                          R,
+                          T...>&);
+template<typename R, typename... T>
+  void operator!=(const function_n<
+                          R,
+                          T...>&,
+                  const function_n<
+                          R,
+                          T...>& );
+
+template<typename R,
+         typename... T>
+class function<R (T...)>
+  : public function_n<R, T...>
 {
-  typedef BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS> base_type;
+  typedef function_n<R, T...> base_type;
   typedef function self_type;
 
   struct clear_type {};
@@ -1077,40 +1077,32 @@ public:
 
   template<typename Functor>
   function(Functor f
-#ifndef BOOST_NO_SFINAE
-           ,typename boost::enable_if_<
-                          !(is_integral<Functor>::value),
+           ,typename std::enable_if<
+                          !std::is_integral<Functor>::value,
                        int>::type = 0
-#endif
            ) :
-    base_type(f)
+    base_type(std::move(f))
   {
   }
   template<typename Functor,typename Allocator>
   function(Functor f, Allocator a
-#ifndef BOOST_NO_SFINAE
-           ,typename boost::enable_if_<
-                           !(is_integral<Functor>::value),
+           ,typename std::enable_if<
+                           !std::is_integral<Functor>::value,
                        int>::type = 0
-#endif
            ) :
-    base_type(f,a)
+    base_type(std::move(f),a)
   {
   }
 
-#ifndef BOOST_NO_SFINAE
   function(clear_type*) : base_type() {}
-#endif
 
   function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
 
   function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
   // Move constructors
   function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
   function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
-#endif
 
   self_type& operator=(const self_type& f)
   {
@@ -1118,35 +1110,27 @@ public:
     return *this;
   }
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
   self_type& operator=(self_type&& f)
   {
     self_type(static_cast<self_type&&>(f)).swap(*this);
     return *this;
   }
-#endif
 
   template<typename Functor>
-#ifndef BOOST_NO_SFINAE
-  typename boost::enable_if_<
-                         !(is_integral<Functor>::value),
+  typename std::enable_if<
+                         !std::is_integral<Functor>::value,
                       self_type&>::type
-#else
-  self_type&
-#endif
   operator=(Functor f)
   {
     self_type(f).swap(*this);
     return *this;
   }
 
-#ifndef BOOST_NO_SFINAE
   self_type& operator=(clear_type*)
   {
     this->clear();
     return *this;
   }
-#endif
 
   self_type& operator=(const base_type& f)
   {
@@ -1154,50 +1138,42 @@ public:
     return *this;
   }
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
   self_type& operator=(base_type&& f)
   {
     self_type(static_cast<base_type&&>(f)).swap(*this);
     return *this;
   }
-#endif
 };
 
-#undef BOOST_FUNCTION_PARTIAL_SPEC
-#endif // have partial specialization
-
 } // end namespace boost
 
-// Cleanup after ourselves...
-#undef BOOST_FUNCTION_VTABLE
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
-#undef BOOST_FUNCTION_MEMBER_INVOKER
-#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
-#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_INVOKER
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_PARM
-#ifdef BOOST_FUNCTION_ARG
-#   undef BOOST_FUNCTION_ARG
-#endif
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_ARG_TYPE
-#undef BOOST_FUNCTION_ARG_TYPES
-#undef BOOST_FUNCTION_VOID_RETURN_TYPE
-#undef BOOST_FUNCTION_RETURN
-
 #if defined(BOOST_MSVC)
 #   pragma warning( pop )
 #endif
+
+// Resolve C++20 issue with fn == bind(...)
+// https://github.com/boostorg/function/issues/45
+
+namespace boost
+{
+
+namespace _bi
+{
+
+template<class R, class F, class L> class bind_t;
+
+} // namespace _bi
+
+template<class S, class R, class F, class L> bool operator==( function<S> const& f, _bi::bind_t<R, F, L> const& b )
+{
+    return f.contains( b );
+}
+
+template<class S, class R, class F, class L> bool operator!=( function<S> const& f, _bi::bind_t<R, F, L> const& b )
+{
+    return !f.contains( b );
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_FUNCTION_FUNCTION_TEMPLATE_HPP_INCLUDED