Branch for adding initializer list support (only in the unreleased gcc 4.4 at the moment).

[SVN r48931]

CMakeLists.txt

@@ -1,22 +0,0 @@
-#----------------------------------------------------------------------------
-# This file was automatically generated from the original CMakeLists.txt file
-# Add a variable to hold the headers for the library
-set (lib_headers
-    function.hpp
-    function
-)
-
-# Add a library target to the build system
-boost_library_project(
-  function
-  #  SRCDIRS 
-  TESTDIRS  test 
-  HEADERS ${lib_headers}
-  DOCDIRS  doc
-  #  DESCRIPTION 
-  MODULARIZED 
-  #  AUTHORS 
-  #  MAINTAINERS 
-)
-
-

doc/CMakeLists.txt

@@ -1,2 +0,0 @@
-boost_add_documentation(function.xml
-  faq.xml history.xml misc.xml reference.xml tests.xml tutorial.xml)

include/boost/function/function_base.hpp

@@ -42,7 +42,7 @@
 #endif       
 
 // Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
-#ifdef BOOST_NO_STD_TYPEINFO
+#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
 // Embedded VC++ does not have type_info in namespace std
 #  define BOOST_FUNCTION_STD_NS
 #else
@@ -193,8 +193,8 @@ namespace boost {
       struct reference_manager
       {
         static inline void
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
-               functor_manager_operation_type op)
+        get(const function_buffer& in_buffer, function_buffer& out_buffer, 
+            functor_manager_operation_type op)
         {
           switch (op) {
           case clone_functor_tag: 
@@ -396,14 +396,6 @@ namespace boost {
                   mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
         }
 
-        // For member pointers, we use the small-object optimization buffer.
-        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
-                functor_manager_operation_type op, member_ptr_tag)
-        {
-          manager(in_buffer, out_buffer, op, mpl::true_());
-        }
-
       public:
         /* Dispatch to an appropriate manager based on whether we have a
            function pointer or a function object pointer. */
@@ -597,6 +589,7 @@ namespace boost {
        */
       struct vtable_base
       {
+        vtable_base() : manager(0) { }
         void (*manager)(const function_buffer& in_buffer, 
                         function_buffer& out_buffer, 
                         functor_manager_operation_type op);

include/boost/function/function_template.hpp

@@ -53,20 +53,12 @@
   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
@@ -188,44 +180,6 @@ namespace boost {
         }
       };
 
-#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
@@ -289,190 +243,11 @@ namespace boost {
                        >::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.
+       * vtable for a specific boost::function instance.
        */
       template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-      struct BOOST_FUNCTION_VTABLE
+      struct BOOST_FUNCTION_VTABLE : vtable_base
       {
 #ifndef BOOST_NO_VOID_RETURNS
         typedef R         result_type;
@@ -484,6 +259,17 @@ namespace boost {
                                             BOOST_FUNCTION_COMMA
                                             BOOST_FUNCTION_TEMPLATE_ARGS);
 
+        template<typename F>
+        BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0)
+        {
+          init(f);
+        }
+        template<typename F,typename Allocator>
+        BOOST_FUNCTION_VTABLE(F f, Allocator) : vtable_base(), invoker(0)
+        {
+          init_a<Allocator>(f);
+        }
+
         template<typename F>
         bool assign_to(F f, function_buffer& functor)
         {
@@ -499,12 +285,52 @@ namespace boost {
 
         void clear(function_buffer& functor)
         {
-          if (base.manager)
-            base.manager(functor, functor, destroy_functor_tag);
+          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());
+        }
+        template<typename Allocator,typename F>
+        void init_a(F f)
+        {
+          typedef typename get_function_tag<F>::type tag;
+          init_a<Allocator>(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>::manage;
+        }
+        template<typename Allocator,typename FunctionPtr>
+        void init_a(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_a<FunctionPtr, Allocator>::manage;
+        }
+
         template<typename FunctionPtr>
         bool 
         assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
@@ -528,6 +354,23 @@ namespace boost {
 
         // 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 Allocator,typename MemberPtr>
+        void init_a(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_a<Allocator>(mem_fn(f));
+        }
+
         template<typename MemberPtr>
         bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
         {
@@ -557,6 +400,33 @@ namespace boost {
 #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>::manage;
+        }
+        template<typename Allocator,typename FunctionObj>
+        void init_a(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_a<FunctionObj, Allocator>::manage;
+        }
+
         // Assign to a function object using the small object optimization
         template<typename FunctionObj>
         void 
@@ -619,6 +489,27 @@ namespace boost {
         }
 
         // 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 Allocator,typename FunctionObj>
+        void 
+        init_a(const reference_wrapper<FunctionObj>& f, function_obj_ref_tag)
+        {
+          init(f,function_obj_ref_tag());
+        }
+
         template<typename FunctionObj>
         bool 
         assign_to(const reference_wrapper<FunctionObj>& f, 
@@ -642,7 +533,6 @@ namespace boost {
         }
 
       public:
-        vtable_base base;
         invoker_type invoker;
       };
     } // end namespace function
@@ -847,7 +737,7 @@ namespace boost {
     void clear()
     {
       if (vtable) {
-        reinterpret_cast<vtable_type*>(vtable)->clear(this->functor);
+        static_cast<vtable_type*>(vtable)->clear(this->functor);
         vtable = 0;
       }
     }
@@ -884,53 +774,15 @@ namespace boost {
     template<typename Functor>
     void assign_to(Functor f)
     {
-      using detail::function::vtable_base;
-
-      typedef typename detail::function::get_function_tag<Functor>::type tag;
-      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
-      typedef typename get_invoker::
-                         template apply<Functor, R BOOST_FUNCTION_COMMA 
-                        BOOST_FUNCTION_TEMPLATE_ARGS>
-        handler_type;
-      
-      typedef typename handler_type::invoker_type invoker_type;
-      typedef typename handler_type::manager_type manager_type;
-
-      // Note: it is extremely important that this initialization use
-      // static initialization. Otherwise, we will have a race
-      // condition here in multi-threaded code. See
-      // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
-      static vtable_type stored_vtable = 
-        { { &manager_type::manage }, &invoker_type::invoke };
-
-      if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable.base;
+      static vtable_type stored_vtable(f);
+      if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable;
       else vtable = 0;
     }
-
     template<typename Functor,typename Allocator>
     void assign_to_a(Functor f,Allocator a)
     {
-      using detail::function::vtable_base;
-
-      typedef typename detail::function::get_function_tag<Functor>::type tag;
-      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
-      typedef typename get_invoker::
-                         template apply_a<Functor, R BOOST_FUNCTION_COMMA 
-                         BOOST_FUNCTION_TEMPLATE_ARGS,
-                         Allocator>
-        handler_type;
-      
-      typedef typename handler_type::invoker_type invoker_type;
-      typedef typename handler_type::manager_type manager_type;
-
-      // Note: it is extremely important that this initialization use
-      // static initialization. Otherwise, we will have a race
-      // condition here in multi-threaded code. See
-      // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
-      static vtable_type stored_vtable =
-        { { &manager_type::manage }, &invoker_type::invoke };
-
-      if (stored_vtable.assign_to_a(f, functor, a)) vtable = &stored_vtable.base;
+      static vtable_type stored_vtable(f,a);
+      if (stored_vtable.assign_to_a(f, functor, a)) vtable = &stored_vtable;
       else vtable = 0;
     }
 
@@ -985,7 +837,7 @@ namespace boost {
     if (this->empty())
       boost::throw_exception(bad_function_call());
 
-    return reinterpret_cast<const vtable_type*>(vtable)->invoker
+    return static_cast<vtable_type*>(vtable)->invoker
              (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
   }
 #endif
@@ -1112,13 +964,10 @@ public:
 #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

test/CMakeLists.txt

@@ -1,20 +0,0 @@
-boost_test_run(lib_function_test function_test.cpp)
-boost_test_run(function_n_test)
-boost_test_run(allocator_test)
-boost_test_run(stateless_test)
-boost_test_run(lambda_test)
-boost_test_compile_fail(function_test_fail1)
-boost_test_compile_fail(function_test_fail2)
-boost_test_compile(function_30)
-boost_test_run(function_arith_cxx98)
-boost_test_run(function_arith_portable)
-boost_test_run(sum_avg_cxx98)
-boost_test_run(sum_avg_portable)
-boost_test_run(mem_fun_cxx98)
-boost_test_run(mem_fun_portable)
-boost_test_run(std_bind_cxx98)
-boost_test_run(std_bind_portable)
-boost_test_run(function_ref_cxx98)
-boost_test_run(function_ref_portable)
-boost_test_run(contains_test)
-boost_test_run(contains2_test)