Created a branch from trunk

[SVN r38959]

doc/history.xml

@@ -5,6 +5,13 @@
   <title>History &amp; Compatibility Notes</title>
 
 <itemizedlist spacing="compact">
+
+  <listitem><para><bold>Version 1.34.0</bold>: </para> 
+    <itemizedlist spacing="compact">
+      <listitem><para>Boost.Function now implements a small buffer optimization, which can drastically improve the performance when copying or construction Boost.Function objects storing small function objects. For instance, <code>bind(&amp;X:foo, &amp;x, _1, _2)</code> requires no heap allocation when placed into a Boost.Function object. Note that some exception-safety guarantees have changed: assignment provides the basic exception guarantee and <code>swap()</code> may throw.</para></listitem>
+    </itemizedlist>
+  </listitem>
+
   <listitem><para><bold>Version 1.30.0</bold>: </para> 
     <itemizedlist spacing="compact">
       <listitem><para>All features deprecated in version 1.29.0 have

doc/reference.xml

@@ -118,6 +118,12 @@
         <returns><simpara><code>true</code> if <code>this-&gt;<methodname>target</methodname>&lt;Functor&gt;()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this-&gt;target&lt;Functor&gt;()), f)</code></simpara></returns>
  
       </method>
+
+      <method name="target_type" cv="const">
+        <type>const std::type_info&amp;</type>
+        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
     </method-group>
   </class>
 
@@ -182,7 +188,7 @@
     </struct>
 
     <constructor>
-      <postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
+      <postconditions><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></postconditions>
       <throws><simpara>Will not throw.</simpara></throws>
     </constructor>
 
@@ -201,11 +207,10 @@
       <parameter name="f"><paramtype>F</paramtype></parameter>
       <requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
       <postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-&gt;<methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
-      <throws><simpara>Will not throw when <code>f</code> is a stateless function object.</simpara></throws>
     </constructor>
 
     <destructor>
-      <effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
+      <effects><simpara>If <code>!this-&gt;<methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
 
     </destructor>
 
@@ -213,8 +218,7 @@
       <parameter name="f">
         <paramtype>const <classname>functionN</classname>&amp;</paramtype>
       </parameter>
-      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
-      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object.</simpara></throws>
+      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
     </copy-assignment>
 
     <method-group name="modifiers">
@@ -222,13 +226,11 @@
         <type>void</type>
         <parameter name="f"><paramtype>const <classname>functionN</classname>&amp;</paramtype></parameter>
         <effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
-        <throws><simpara>Will not throw.</simpara></throws>
       </method>
 
       <method name="clear">
         <type>void</type>
         <postconditions><simpara>this-&gt;<methodname>empty</methodname>()</simpara></postconditions>
-        <throws><simpara>Will not throw.</simpara></throws>
       </method>
     </method-group>
 
@@ -286,6 +288,13 @@
         <returns><simpara><code>true</code> if <code>this-&gt;<methodname>target</methodname>&lt;Functor&gt;()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this-&gt;target&lt;Functor&gt;()), f)</code></simpara></returns>
  
       </method>
+
+      <method name="target_type" cv="const">
+        <type>const std::type_info&amp;</type>
+        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+
     </method-group>
 
     <method-group name="invocation">
@@ -297,7 +306,7 @@
         <parameter name="aN"><paramtype>argN_type</paramtype></parameter>
         <effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
         <returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
-        <throws><simpara><code><classname>bad_function_call</classname></code> if <code>!this-&gt;<methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
+        <throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-&gt;<methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
       </method>
     </method-group>
 
@@ -314,7 +323,6 @@
         <parameter name="f1"><paramtype><classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
         <parameter name="f2"><paramtype><classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
         <effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
-        <throws><simpara>Will not throw.</simpara></throws>
       </function>
     </free-function-group>
 
@@ -589,7 +597,7 @@
     </struct>
 
     <constructor>
-      <postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
+      <postconditions><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></postconditions>
       <throws><simpara>Will not throw.</simpara></throws>
     </constructor>
 
@@ -616,28 +624,26 @@
       <parameter name="f"><paramtype>F</paramtype></parameter>
       <requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
       <postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-&gt;<methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
-      <throws><simpara>Will not throw when <code>f</code> is a stateless function object.</simpara></throws>
     </constructor>
 
     <destructor>
-      <effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
+      <effects><simpara>If <code>!this-&gt;<methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
 
     </destructor>
 
     <copy-assignment>
       <parameter name="f">
-        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
+        <paramtype>const <classname>function</classname>&amp;</paramtype>
       </parameter>
-      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code></simpara></postconditions>
-      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object.</simpara></throws>
+      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
     </copy-assignment>
 
     <copy-assignment>
       <parameter name="f">
         <paramtype>const <classname>function</classname>&amp;</paramtype>
       </parameter>
-      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code></simpara></postconditions>
-      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object.</simpara></throws>
+      <postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
+      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></throws>
     </copy-assignment>
 
     <method-group name="modifiers">
@@ -645,7 +651,6 @@
         <type>void</type>
         <parameter name="f"><paramtype>const <classname>function</classname>&amp;</paramtype></parameter>
         <effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
-        <throws><simpara>Will not throw.</simpara></throws>
       </method>
 
       <method name="clear">
@@ -708,6 +713,12 @@
         <returns><simpara><code>true</code> if <code>this-&gt;<methodname>target</methodname>&lt;Functor&gt;()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this-&gt;target&lt;Functor&gt;()), f)</code></simpara></returns>
  
       </method>
+
+      <method name="target_type" cv="const">
+        <type>const std::type_info&amp;</type>
+        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
     </method-group>
 
     <method-group name="invocation">
@@ -719,7 +730,7 @@
         <parameter name="aN"><paramtype>argN_type</paramtype></parameter>
         <effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
         <returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
-        <throws><simpara><code><classname>bad_function_call</classname></code> if <code>!this-&gt;<methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
+        <throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-&gt;<methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
       </method>
     </method-group>
 
@@ -733,7 +744,6 @@
         <parameter name="f1"><paramtype><classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
         <parameter name="f2"><paramtype><classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
         <effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
-        <throws><simpara>Will not throw.</simpara></throws>
       </function>
     </free-function-group>
 

include/boost/function.hpp

@@ -10,6 +10,8 @@
 // William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
 // design of this library.
 
+#include <functional> // unary_function, binary_function
+
 #include <boost/preprocessor/iterate.hpp>
 #include <boost/detail/workaround.hpp>
 

include/boost/function/detail/prologue.hpp

@@ -11,6 +11,7 @@
 #define BOOST_FUNCTION_PROLOGUE_HPP
 #  include <cassert>
 #  include <algorithm>
+#  include <functional> // unary_function, binary_function
 #  include <boost/throw_exception.hpp>
 #  include <boost/config.hpp>
 #  include <boost/function/function_base.hpp>

include/boost/function/function_base.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2004. Use, modification and
+//  Copyright Douglas Gregor 2001-2006. Use, modification and
 //  distribution is subject to the Boost Software License, Version
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
@@ -19,10 +19,10 @@
 #include <boost/assert.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/composite_traits.hpp>
-#include <boost/type_traits/is_stateless.hpp>
 #include <boost/ref.hpp>
-#include <boost/pending/ct_if.hpp>
+#include <boost/mpl/if.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/type_traits/alignment_of.hpp>
 #ifndef BOOST_NO_SFINAE
 #  include "boost/utility/enable_if.hpp"
 #else
@@ -30,6 +30,14 @@
 #endif
 #include <boost/function_equal.hpp>
 
+// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
+#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
+// Embedded VC++ does not have type_info in namespace std
+#  define BOOST_FUNCTION_STD_NS
+#else
+#  define BOOST_FUNCTION_STD_NS std
+#endif
+
 // Borrowed from Boost.Python library: determines the cases where we
 // need to use std::type_info::name to compare instead of operator==.
 # if (defined(__GNUC__) && __GNUC__ >= 3) \
@@ -59,7 +67,7 @@ namespace boost { namespace python { namespace objects {
 
 #if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
  || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
- || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+ || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
 #  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
 #endif
 
@@ -105,42 +113,36 @@ inline void swap(function<Signature, Allocator>& f1,
 namespace boost {
   namespace detail {
     namespace function {
+      class X;
+
       /**
-       * A union of a function pointer and a void pointer. This is necessary
-       * because 5.2.10/6 allows reinterpret_cast<> to safely cast between
-       * function pointer types and 5.2.9/10 allows static_cast<> to safely
-       * cast between a void pointer and an object pointer. But it is not legal
-       * to cast between a function pointer and a void* (in either direction),
-       * so function requires a union of the two. */
-      union any_pointer
+       * A buffer used to store small function objects in
+       * boost::function. It is a union containing function pointers,
+       * object pointers, and a structure that resembles a bound
+       * member function pointer.
+       */
+      union function_buffer
       {
+        // For pointers to function objects
         void* obj_ptr;
+
+        // For pointers to std::type_info objects
+        // (get_functor_type_tag, check_functor_type_tag).
         const void* const_obj_ptr;
-        void (*func_ptr)();
-        char data[1];
+
+        // For function pointers of all kinds
+        mutable void (*func_ptr)();
+
+        // For bound member pointers
+        struct bound_memfunc_ptr_t {
+          void (X::*memfunc_ptr)(int);
+          void* obj_ptr;
+        } bound_memfunc_ptr;
+
+        // To relax aliasing constraints
+        mutable char data;
       };
 
-      inline any_pointer make_any_pointer(void* o)
-      {
-        any_pointer p;
-        p.obj_ptr = o;
-        return p;
-      }
-
-      inline any_pointer make_any_pointer(const void* o)
-      {
-        any_pointer p;
-        p.const_obj_ptr = o;
-        return p;
-      }
-
-      inline any_pointer make_any_pointer(void (*f)())
-      {
-        any_pointer p;
-        p.func_ptr = f;
-        return p;
-      }
-
       /**
        * The unusable class is a placeholder for unused function arguments
        * It is also completely unusable except that it constructable from
@@ -169,7 +171,8 @@ namespace boost {
       enum functor_manager_operation_type {
         clone_functor_tag,
         destroy_functor_tag,
-        check_functor_type_tag
+        check_functor_type_tag,
+        get_functor_type_tag
       };
 
       // Tags used to decide between different types of functions
@@ -177,57 +180,79 @@ namespace boost {
       struct function_obj_tag {};
       struct member_ptr_tag {};
       struct function_obj_ref_tag {};
-      struct stateless_function_obj_tag {};
 
       template<typename F>
       class get_function_tag
       {
-        typedef typename ct_if<(is_pointer<F>::value),
-                            function_ptr_tag,
-                            function_obj_tag>::type ptr_or_obj_tag;
+        typedef typename mpl::if_c<(is_pointer<F>::value),
+                                   function_ptr_tag,
+                                   function_obj_tag>::type ptr_or_obj_tag;
 
-        typedef typename ct_if<(is_member_pointer<F>::value),
-                            member_ptr_tag,
-                            ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
+        typedef typename mpl::if_c<(is_member_pointer<F>::value),
+                                   member_ptr_tag,
+                                   ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
 
-        typedef typename ct_if<(is_reference_wrapper<F>::value),
-                             function_obj_ref_tag,
-                             ptr_or_obj_or_mem_tag>::type or_ref_tag;
+        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
+                                   function_obj_ref_tag,
+                                   ptr_or_obj_or_mem_tag>::type or_ref_tag;
 
       public:
-        typedef typename ct_if<(is_stateless<F>::value),
-                            stateless_function_obj_tag,
-                            or_ref_tag>::type type;
+        typedef or_ref_tag type;
       };
 
       // The trivial manager does nothing but return the same pointer (if we
       // are cloning) or return the null pointer (if we are deleting).
       template<typename F>
-      struct trivial_manager
+      struct reference_manager
       {
-        static inline any_pointer
-        get(any_pointer f, functor_manager_operation_type op)
+        static inline void
+        get(const function_buffer& in_buffer, function_buffer& out_buffer, 
+            functor_manager_operation_type op)
         {
           switch (op) {
-          case clone_functor_tag: return f;
+          case clone_functor_tag: 
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
+            return;
 
           case destroy_functor_tag:
-            return make_any_pointer(reinterpret_cast<void*>(0));
+            out_buffer.obj_ptr = 0;
+            return;
 
           case check_functor_type_tag:
             {
-              std::type_info* t = static_cast<std::type_info*>(f.obj_ptr);
-              return BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(F), *t)?
-                f
-                : make_any_pointer(reinterpret_cast<void*>(0));
+              // DPG TBD: Since we're only storing a pointer, it's
+              // possible that the user could ask for a base class or
+              // derived class. Is that okay?
+              const BOOST_FUNCTION_STD_NS::type_info& check_type = 
+                *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
+                out_buffer.obj_ptr = in_buffer.obj_ptr;
+              else
+                out_buffer.obj_ptr = 0;
             }
-          }
+            return;
 
-          // Clears up a warning with GCC 3.2.3
-          return make_any_pointer(reinterpret_cast<void*>(0));
+          case get_functor_type_tag:
+            out_buffer.const_obj_ptr = &typeid(F);
+            return;
+          }
         }
       };
 
+      /**
+       * Determine if boost::function can use the small-object
+       * optimization with the function object type F.
+       */
+      template<typename F>
+      struct function_allows_small_object_optimization
+      {
+        BOOST_STATIC_CONSTANT
+          (bool, 
+           value = ((sizeof(F) <= sizeof(function_buffer) &&
+                     (alignment_of<function_buffer>::value 
+                      % alignment_of<F>::value == 0))));
+      };
+
       /**
        * The functor_manager class contains a static function "manage" which
        * can clone or destroy the given function/function object pointer.
@@ -239,30 +264,57 @@ namespace boost {
         typedef Functor functor_type;
 
         // For function pointers, the manager is trivial
-        static inline any_pointer
-        manager(any_pointer function_ptr,
-                functor_manager_operation_type op,
-                function_ptr_tag)
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, function_ptr_tag)
         {
           if (op == clone_functor_tag)
-            return function_ptr;
-          else
-            return make_any_pointer(static_cast<void (*)()>(0));
+            out_buffer.func_ptr = in_buffer.func_ptr;
+          else if (op == destroy_functor_tag)
+            out_buffer.func_ptr = 0;
+          else /* op == check_functor_type_tag */ {
+            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
+              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+              out_buffer.obj_ptr = &in_buffer.func_ptr;
+            else
+              out_buffer.obj_ptr = 0;
+          }
         }
 
-        // For function object pointers, we clone the pointer to each
-        // function has its own version.
-        static inline any_pointer
-        manager(any_pointer function_obj_ptr,
-                functor_manager_operation_type op,
-                function_obj_tag)
+        // Function objects that fit in the small-object buffer.
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, mpl::true_)
+        {
+          if (op == clone_functor_tag) {
+            const functor_type* in_functor = 
+              reinterpret_cast<const functor_type*>(&in_buffer.data);
+            new ((void*)&out_buffer.data) functor_type(*in_functor);
+          } else if (op == destroy_functor_tag) {
+            // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
+            reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
+          } else /* op == check_functor_type_tag */ {
+            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
+              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+              out_buffer.obj_ptr = &in_buffer.data;
+            else
+              out_buffer.obj_ptr = 0;
+          }
+        }
+        
+        // Function objects that require heap allocation
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, mpl::false_)
         {
 #ifndef BOOST_NO_STD_ALLOCATOR
-        typedef typename Allocator::template rebind<functor_type>::other
-          allocator_type;
-        typedef typename allocator_type::pointer pointer_type;
+          typedef typename Allocator::template rebind<functor_type>::other
+            allocator_type;
+          typedef typename allocator_type::pointer pointer_type;
 #else
-        typedef functor_type* pointer_type;
+          typedef functor_type* pointer_type;
 #endif // BOOST_NO_STD_ALLOCATOR
 
 #  ifndef BOOST_NO_STD_ALLOCATOR
@@ -270,8 +322,10 @@ namespace boost {
 #  endif // BOOST_NO_STD_ALLOCATOR
 
           if (op == clone_functor_tag) {
-            functor_type* f =
-              static_cast<functor_type*>(function_obj_ptr.obj_ptr);
+            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
+            // can't do the static_cast that we should do.
+            const functor_type* f =
+              (const functor_type*)(in_buffer.obj_ptr);
 
             // Clone the functor
 #  ifndef BOOST_NO_STD_ALLOCATOR
@@ -283,12 +337,11 @@ namespace boost {
 #  else
             functor_type* new_f = new functor_type(*f);
 #  endif // BOOST_NO_STD_ALLOCATOR
-            return make_any_pointer(static_cast<void*>(new_f));
-          }
-          else {
+            out_buffer.obj_ptr = new_f;
+          } else if (op == destroy_functor_tag) {
             /* Cast from the void pointer to the functor pointer type */
             functor_type* f =
-              reinterpret_cast<functor_type*>(function_obj_ptr.obj_ptr);
+              static_cast<functor_type*>(out_buffer.obj_ptr);
 
 #  ifndef BOOST_NO_STD_ALLOCATOR
             /* Cast from the functor pointer type to the allocator's pointer
@@ -301,26 +354,44 @@ namespace boost {
 #  else
             delete f;
 #  endif // BOOST_NO_STD_ALLOCATOR
-
-            return make_any_pointer(static_cast<void*>(0));
+            out_buffer.obj_ptr = 0;
+          } else /* op == check_functor_type_tag */ {
+            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
+              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+              out_buffer.obj_ptr = in_buffer.obj_ptr;
+            else
+              out_buffer.obj_ptr = 0;
           }
         }
+
+        // For function objects, we determine whether the function
+        // object can use the small-object optimization buffer or
+        // whether we need to allocate it on the heap.
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, function_obj_tag)
+        {
+          manager(in_buffer, out_buffer, op,
+                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+        }
+
       public:
         /* Dispatch to an appropriate manager based on whether we have a
            function pointer or a function object pointer. */
-        static any_pointer
-        manage(any_pointer functor_ptr, functor_manager_operation_type op)
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
+               functor_manager_operation_type op)
         {
-          if (op == check_functor_type_tag) {
-            std::type_info* type =
-              static_cast<std::type_info*>(functor_ptr.obj_ptr);
-            return (BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(Functor), *type)?
-                    functor_ptr
-                    : make_any_pointer(reinterpret_cast<void*>(0)));
-          }
-          else {
-            typedef typename get_function_tag<functor_type>::type tag_type;
-            return manager(functor_ptr, op, tag_type());
+          typedef typename get_function_tag<functor_type>::type tag_type;
+          switch (op) {
+          case get_functor_type_tag:
+            out_buffer.const_obj_ptr = &typeid(functor_type);
+            return;
+
+          default:
+            manager(in_buffer, out_buffer, op, tag_type());
+            return;
           }
         }
       };
@@ -386,6 +457,18 @@ namespace boost {
           else return true;
         }
 #endif // BOOST_NO_SFINAE
+
+      /**
+       * Stores the "manager" portion of the vtable for a
+       * boost::function object.
+       */
+      struct vtable_base
+      {
+        vtable_base() : manager(0) { }
+        void (*manager)(const function_buffer& in_buffer, 
+                        function_buffer& out_buffer, 
+                        functor_manager_operation_type op);
+      };
     } // end namespace function
   } // end namespace detail
 
@@ -398,62 +481,61 @@ namespace boost {
 class function_base
 {
 public:
-  function_base() : manager(0)
-  {
-    functor.obj_ptr = 0;
-  }
+  function_base() : vtable(0) { }
 
-  // Is this function empty?
-  bool empty() const { return !manager; }
+  /** Determine if the function is empty (i.e., has no target). */
+  bool empty() const { return !vtable; }
+
+  /** Retrieve the type of the stored function object, or typeid(void)
+      if this is empty. */
+  const BOOST_FUNCTION_STD_NS::type_info& target_type() const
+  {
+    if (!vtable) return typeid(void);
+
+    detail::function::function_buffer type;
+    vtable->manager(functor, type, detail::function::get_functor_type_tag);
+    return *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(type.const_obj_ptr);
+  }
 
   template<typename Functor>
     Functor* target()
     {
-      if (!manager) return 0;
+      if (!vtable) return 0;
 
-      detail::function::any_pointer result =
-        manager(detail::function::make_any_pointer(&typeid(Functor)),
-                detail::function::check_functor_type_tag);
-      if (!result.obj_ptr) return 0;
-      else {
-        typedef typename detail::function::get_function_tag<Functor>::type tag;
-        return get_functor_pointer<Functor>(tag(), 0);
-      }
+      detail::function::function_buffer type_result;
+      type_result.const_obj_ptr = &typeid(Functor);
+      vtable->manager(functor, type_result, 
+                      detail::function::check_functor_type_tag);
+      return static_cast<Functor*>(type_result.obj_ptr);
     }
 
   template<typename Functor>
-
 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
     const Functor* target( Functor * = 0 ) const
 #else
     const Functor* target() const
 #endif
     {
-      if (!manager) return 0;
+      if (!vtable) return 0;
 
-      detail::function::any_pointer result =
-        manager(detail::function::make_any_pointer(&typeid(Functor)),
-                detail::function::check_functor_type_tag);
-      if (!result.obj_ptr) return 0;
-      else {
-        typedef typename detail::function::get_function_tag<Functor>::type tag;
-
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        return get_functor_pointer(tag(), 0, (Functor*)0);
-#else
-        return get_functor_pointer<Functor>(tag(), 0);
-#endif
-      }
+      detail::function::function_buffer type_result;
+      type_result.const_obj_ptr = &typeid(Functor);
+      vtable->manager(functor, type_result, 
+                      detail::function::check_functor_type_tag);
+      // GCC 2.95.3 gets the CV qualifiers wrong here, so we
+      // can't do the static_cast that we should do.
+      return (const Functor*)(type_result.obj_ptr);
     }
 
   template<typename F>
     bool contains(const F& f) const
     {
 #if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-      if (const F* fp = this->target( (F*)0 )) {
+      if (const F* fp = this->target( (F*)0 ))
 #else
-      if (const F* fp = this->template target<F>()) {
+      if (const F* fp = this->template target<F>())
 #endif
+      {
         return function_equal(*fp, f);
       } else {
         return false;
@@ -484,44 +566,8 @@ public:
 #endif
 
 public: // should be protected, but GCC 2.95.3 will fail to allow access
-  detail::function::any_pointer (*manager)(
-    detail::function::any_pointer,
-    detail::function::functor_manager_operation_type);
-  detail::function::any_pointer functor;
-
-private:
-  template<typename Functor>
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    Functor* get_functor_pointer(detail::function::function_ptr_tag, int, Functor * = 0)
-#else
-    Functor* get_functor_pointer(detail::function::function_ptr_tag, int)
-#endif
-    { return reinterpret_cast<Functor*>(&functor.func_ptr); }
-
-  template<typename Functor, typename Tag>
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    Functor* get_functor_pointer(Tag, long, Functor * = 0)
-#else
-    Functor* get_functor_pointer(Tag, long)
-#endif
-    { return static_cast<Functor*>(functor.obj_ptr); }
-
-  template<typename Functor>
-    const Functor*
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    get_functor_pointer(detail::function::function_ptr_tag, int, Functor * = 0) const
-#else
-    get_functor_pointer(detail::function::function_ptr_tag, int) const
-#endif
-    { return reinterpret_cast<const Functor*>(&functor.func_ptr); }
-
-  template<typename Functor, typename Tag>
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    const Functor* get_functor_pointer(Tag, long, Functor * = 0) const
-#else
-    const Functor* get_functor_pointer(Tag, long) const
-#endif
-    { return static_cast<const Functor*>(functor.const_obj_ptr); }
+  detail::function::vtable_base* vtable;
+  mutable detail::function::function_buffer functor;
 };
 
 /**

include/boost/function/function_template.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright Douglas Gregor 2001-2006. Use, modification and
 //  distribution is subject to the Boost Software License, Version
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
@@ -22,7 +22,7 @@
 #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(arg, BOOST_PP_CAT(BOOST_PP_INC(I),_type));
+  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)
 
@@ -50,16 +50,17 @@
   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_STATELESS_FUNCTION_OBJ_INVOKER \
-  BOOST_JOIN(stateless_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER \
-  BOOST_JOIN(stateless_void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_REF_INVOKER \
+  BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
+  BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
 #define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
   BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
 #define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
   BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER \
-  BOOST_JOIN(get_stateless_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
+  BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
 
 #ifndef BOOST_NO_VOID_RETURNS
 #  define BOOST_FUNCTION_VOID_RETURN_TYPE void
@@ -79,7 +80,7 @@ namespace boost {
         >
       struct BOOST_FUNCTION_FUNCTION_INVOKER
       {
-        static R invoke(any_pointer function_ptr BOOST_FUNCTION_COMMA
+        static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
                         BOOST_FUNCTION_PARMS)
         {
           FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
@@ -95,7 +96,7 @@ namespace boost {
       struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
       {
         static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(any_pointer function_ptr BOOST_FUNCTION_COMMA
+        invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
                BOOST_FUNCTION_PARMS)
 
         {
@@ -111,11 +112,15 @@ namespace boost {
       >
       struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
       {
-        static R invoke(any_pointer function_obj_ptr BOOST_FUNCTION_COMMA
+        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
                         BOOST_FUNCTION_PARMS)
 
         {
-          FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
+          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);
         }
       };
@@ -128,11 +133,15 @@ namespace boost {
       struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
       {
         static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(any_pointer function_obj_ptr BOOST_FUNCTION_COMMA
+        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
                BOOST_FUNCTION_PARMS)
 
         {
-          FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
+          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));
         }
       };
@@ -142,12 +151,15 @@ namespace boost {
         typename R BOOST_FUNCTION_COMMA
         BOOST_FUNCTION_TEMPLATE_PARMS
       >
-      struct BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER
+      struct BOOST_FUNCTION_FUNCTION_REF_INVOKER
       {
-        static R invoke(any_pointer BOOST_FUNCTION_COMMA BOOST_FUNCTION_PARMS)
+        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
+                        BOOST_FUNCTION_PARMS)
+
         {
-          FunctionObj f = FunctionObj();
-          return f(BOOST_FUNCTION_ARGS);
+          FunctionObj* f = 
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)(BOOST_FUNCTION_ARGS);
         }
       };
 
@@ -156,14 +168,16 @@ namespace boost {
         typename R BOOST_FUNCTION_COMMA
         BOOST_FUNCTION_TEMPLATE_PARMS
       >
-      struct BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER
+      struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
       {
         static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(any_pointer BOOST_FUNCTION_COMMA BOOST_FUNCTION_PARMS)
+        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
+               BOOST_FUNCTION_PARMS)
 
         {
-          FunctionObj f = FunctionObj();
-          BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
+          FunctionObj* f = 
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
         }
       };
 
@@ -174,7 +188,7 @@ namespace boost {
       >
       struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
       {
-        typedef typename ct_if<(is_void<R>::value),
+        typedef typename mpl::if_c<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
                             FunctionPtr,
                             R BOOST_FUNCTION_COMMA
@@ -195,7 +209,7 @@ namespace boost {
        >
       struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
       {
-        typedef typename ct_if<(is_void<R>::value),
+        typedef typename mpl::if_c<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
                             FunctionObj,
                             R BOOST_FUNCTION_COMMA
@@ -214,15 +228,15 @@ namespace boost {
         typename R BOOST_FUNCTION_COMMA
         BOOST_FUNCTION_TEMPLATE_PARMS
        >
-      struct BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER
+      struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
       {
-        typedef typename ct_if<(is_void<R>::value),
-                            BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_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_STATELESS_FUNCTION_OBJ_INVOKER<
+                          BOOST_FUNCTION_FUNCTION_REF_INVOKER<
                             FunctionObj,
                             R BOOST_FUNCTION_COMMA
                             BOOST_FUNCTION_TEMPLATE_ARGS
@@ -230,6 +244,199 @@ namespace boost {
                        >::type type;
       };
 
+      /**
+       * vtable for a specific boost::function instance.
+       */
+      template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+               typename Allocator>
+      struct BOOST_FUNCTION_VTABLE : vtable_base
+      {
+#ifndef BOOST_NO_VOID_RETURNS
+        typedef R         result_type;
+#else
+        typedef typename function_return_type<R>::type result_type;
+#endif // BOOST_NO_VOID_RETURNS
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                            BOOST_FUNCTION_COMMA
+                                            BOOST_FUNCTION_TEMPLATE_ARGS);
+
+        template<typename F>
+        BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0)
+        {
+          init(f);
+        }
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor)
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+
+        void clear(function_buffer& functor)
+        {
+          if (manager)
+            manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+        template<typename F>
+        void init(F f)
+        {
+          typedef typename get_function_tag<F>::type tag;
+          init(f, tag());
+        }
+
+        // Function pointers
+        template<typename FunctionPtr>
+        void init(FunctionPtr /*f*/, function_ptr_tag)
+        {
+          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+                             FunctionPtr,
+                             R BOOST_FUNCTION_COMMA
+                             BOOST_FUNCTION_TEMPLATE_ARGS
+                           >::type
+            actual_invoker_type;
+
+          invoker = &actual_invoker_type::invoke;
+          manager = &functor_manager<FunctionPtr, Allocator>::manage;
+        }
+
+        template<typename FunctionPtr>
+        bool 
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
+        {
+          this->clear(functor);
+          if (f) {
+            // should be a reinterpret cast, but some compilers insist
+            // on giving cv-qualifiers to free functions
+            functor.func_ptr = (void (*)())(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+        // Member pointers
+#if BOOST_FUNCTION_NUM_ARGS > 0
+        template<typename MemberPtr>
+        void init(MemberPtr f, member_ptr_tag)
+        {
+          // DPG TBD: Add explicit support for member function
+          // objects, so we invoke through mem_fn() but we retain the
+          // right target_type() values.
+          this->init(mem_fn(f));
+        }
+
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
+        {
+          // DPG TBD: Add explicit support for member function
+          // objects, so we invoke through mem_fn() but we retain the
+          // right target_type() values.
+          if (f) {
+            this->assign_to(mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+#endif // BOOST_FUNCTION_NUM_ARGS > 0
+
+        // Function objects
+        template<typename FunctionObj>
+        void init(FunctionObj /*f*/, function_obj_tag)
+        {
+          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+                             FunctionObj,
+                             R BOOST_FUNCTION_COMMA
+                             BOOST_FUNCTION_TEMPLATE_ARGS
+                           >::type
+            actual_invoker_type;
+
+          invoker = &actual_invoker_type::invoke;
+          manager = &functor_manager<FunctionObj, Allocator>::manage;
+        }
+
+        // Assign to a function object using the small object optimization
+        template<typename FunctionObj>
+        void 
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
+        {
+          new ((void*)&functor.data) FunctionObj(f);
+        }
+
+        // Assign to a function object allocated on the heap.
+        template<typename FunctionObj>
+        void 
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
+        {
+#ifndef BOOST_NO_STD_ALLOCATOR
+          typedef typename Allocator::template rebind<FunctionObj>::other
+            allocator_type;
+          typedef typename allocator_type::pointer pointer_type;
+
+          allocator_type allocator;
+          pointer_type copy = allocator.allocate(1);
+          allocator.construct(copy, f);
+
+          // Get back to the original pointer type
+          functor.obj_ptr = static_cast<FunctionObj*>(copy);
+#  else
+          functor.obj_ptr = new FunctionObj(f);
+#  endif // BOOST_NO_STD_ALLOCATOR
+        }
+
+        template<typename FunctionObj>
+        bool 
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor, 
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+        // Reference to a function object
+        template<typename FunctionObj>
+        void 
+        init(const reference_wrapper<FunctionObj>& /*f*/, function_obj_ref_tag)
+        {
+          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
+                             FunctionObj,
+                             R BOOST_FUNCTION_COMMA
+                             BOOST_FUNCTION_TEMPLATE_ARGS
+                           >::type
+            actual_invoker_type;
+
+          invoker = &actual_invoker_type::invoke;
+          manager = &reference_manager<FunctionObj>::get;
+        }
+
+        template<typename FunctionObj>
+        bool 
+        assign_to(const reference_wrapper<FunctionObj>& f, 
+                  function_buffer& functor, function_obj_ref_tag)
+        {
+          if (!boost::detail::function::has_empty_target(f.get_pointer())) {
+            // DPG TBD: We might need to detect constness of
+            // FunctionObj to assign into obj_ptr or const_obj_ptr to
+            // be truly legit, but no platform in existence makes
+            // const void* different from void*.
+            functor.const_obj_ptr = f.get_pointer();
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+      public:
+        invoker_type invoker;
+      };
     } // end namespace function
   } // end namespace detail
 
@@ -239,6 +446,17 @@ namespace boost {
     typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR
   >
   class BOOST_FUNCTION_FUNCTION : public function_base
+
+#if BOOST_FUNCTION_NUM_ARGS == 1
+
+    , public std::unary_function<T0,R>
+
+#elif BOOST_FUNCTION_NUM_ARGS == 2
+
+    , public std::binary_function<T0,T1,R>
+
+#endif
+
   {
   public:
 #ifndef BOOST_NO_VOID_RETURNS
@@ -249,6 +467,10 @@ namespace boost {
 #endif // BOOST_NO_VOID_RETURNS
 
   private:
+    typedef boost::detail::function::BOOST_FUNCTION_VTABLE<
+              R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator>
+      vtable_type;
+
     struct clear_type {};
 
   public:
@@ -274,8 +496,7 @@ namespace boost {
     typedef Allocator allocator_type;
     typedef BOOST_FUNCTION_FUNCTION self_type;
 
-    BOOST_FUNCTION_FUNCTION() : function_base()
-                              , invoker(0) {}
+    BOOST_FUNCTION_FUNCTION() : function_base() { }
 
     // MSVC chokes if the following two constructors are collapsed into
     // one with a default parameter.
@@ -288,24 +509,21 @@ namespace boost {
                                         int>::type = 0
 #endif // BOOST_NO_SFINAE
                             ) :
-      function_base(),
-      invoker(0)
+      function_base()
     {
       this->assign_to(f);
     }
 
 #ifndef BOOST_NO_SFINAE
-    BOOST_FUNCTION_FUNCTION(clear_type*) : function_base(), invoker(0) {}
+    BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
 #else
-    BOOST_FUNCTION_FUNCTION(int zero) : function_base(), invoker(0)
+    BOOST_FUNCTION_FUNCTION(int zero) : function_base()
     {
       BOOST_ASSERT(zero == 0);
     }
 #endif
 
-    BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) :
-      function_base(),
-      invoker(0)
+    BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base()
     {
       this->assign_to_own(f);
     }
@@ -320,7 +538,8 @@ namespace boost {
       if (this->empty())
         boost::throw_exception(bad_function_call());
 
-      return invoker(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
+      return static_cast<vtable_type*>(vtable)->invoker
+               (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
     }
 #else
     result_type operator()(BOOST_FUNCTION_PARMS) const;
@@ -342,7 +561,13 @@ namespace boost {
 #endif
     operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
     {
-      self_type(f).swap(*this);
+      this->clear();
+      try {
+        this->assign_to(f);
+      } catch (...) {
+        vtable = 0;
+        throw;
+      }
       return *this;
     }
 
@@ -367,7 +592,13 @@ namespace boost {
       if (&f == this)
         return *this;
 
-      self_type(f).swap(*this);
+      this->clear();
+      try {
+        this->assign_to_own(f);
+      } catch (...) {
+        vtable = 0;
+        throw;
+      }
       return *this;
     }
 
@@ -376,22 +607,18 @@ namespace boost {
       if (&other == this)
         return;
 
-      std::swap(this->manager, other.manager);
-      std::swap(this->functor, other.functor);
-      std::swap(invoker, other.invoker);
+      BOOST_FUNCTION_FUNCTION tmp = *this;
+      *this = other;
+      other = tmp;
     }
 
     // Clear out a target, if there is one
     void clear()
     {
-      if (this->manager) {
-        function_base::functor =
-          this->manager(this->functor, 
-                        boost::detail::function::destroy_functor_tag);
+      if (vtable) {
+        static_cast<vtable_type*>(vtable)->clear(this->functor);
+        vtable = 0;
       }
-
-      this->manager = 0;
-      invoker = 0;
     }
 
 #if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG)
@@ -417,131 +644,19 @@ namespace boost {
     void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)
     {
       if (!f.empty()) {
-        invoker = f.invoker;
-        this->manager = f.manager;
-        this->functor =
-          f.manager(f.functor, boost::detail::function::clone_functor_tag);
+        this->vtable = f.vtable;
+        f.vtable->manager(f.functor, this->functor,
+                          boost::detail::function::clone_functor_tag);
       }
     }
 
     template<typename Functor>
     void assign_to(Functor f)
     {
-      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
-      this->assign_to(f, tag());
+      static vtable_type stored_vtable(f);
+      if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable;
+      else vtable = 0;
     }
-
-    template<typename FunctionPtr>
-    void assign_to(FunctionPtr f, boost::detail::function::function_ptr_tag)
-    {
-      clear();
-
-      if (f) {
-        typedef typename boost::detail::function::BOOST_FUNCTION_GET_FUNCTION_INVOKER<
-                           FunctionPtr,
-                           R BOOST_FUNCTION_COMMA
-                           BOOST_FUNCTION_TEMPLATE_ARGS
-                         >::type
-          actual_invoker_type;
-
-        invoker = &actual_invoker_type::invoke;
-        this->manager =
-          &boost::detail::function::functor_manager<FunctionPtr, Allocator>::manage;
-        this->functor =
-          this->manager(boost::detail::function::make_any_pointer(
-                            // should be a reinterpret cast, but some compilers
-                            // insist on giving cv-qualifiers to free functions
-                            (void (*)())(f)
-                          ),
-                          boost::detail::function::clone_functor_tag);
-      }
-    }
-
-#if BOOST_FUNCTION_NUM_ARGS > 0
-    template<typename MemberPtr>
-    void assign_to(MemberPtr f, boost::detail::function::member_ptr_tag)
-    {
-      this->assign_to(mem_fn(f));
-    }
-#endif // BOOST_FUNCTION_NUM_ARGS > 0
-
-    template<typename FunctionObj>
-    void assign_to(FunctionObj f, boost::detail::function::function_obj_tag)
-    {
-      if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
-        typedef
-          typename boost::detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
-                                       FunctionObj,
-                                       R BOOST_FUNCTION_COMMA
-                                       BOOST_FUNCTION_TEMPLATE_ARGS
-                                     >::type
-          actual_invoker_type;
-
-        invoker = &actual_invoker_type::invoke;
-        this->manager = &boost::detail::function::functor_manager<
-                                    FunctionObj, Allocator>::manage;
-#ifndef BOOST_NO_STD_ALLOCATOR
-        typedef typename Allocator::template rebind<FunctionObj>::other
-          rebound_allocator_type;
-        typedef typename rebound_allocator_type::pointer pointer_type;
-        rebound_allocator_type allocator;
-        pointer_type copy = allocator.allocate(1);
-        allocator.construct(copy, f);
-
-        // Get back to the original pointer type
-        FunctionObj* new_f = static_cast<FunctionObj*>(copy);
-#else
-        FunctionObj* new_f = new FunctionObj(f);
-#endif // BOOST_NO_STD_ALLOCATOR
-        this->functor =
-          boost::detail::function::make_any_pointer(static_cast<void*>(new_f));
-      }
-    }
-
-    template<typename FunctionObj>
-    void assign_to(const reference_wrapper<FunctionObj>& f,
-                   boost::detail::function::function_obj_ref_tag)
-    {
-      if (!boost::detail::function::has_empty_target(f.get_pointer())) {
-        typedef
-          typename boost::detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
-                                       FunctionObj,
-                                       R BOOST_FUNCTION_COMMA
-                                       BOOST_FUNCTION_TEMPLATE_ARGS
-                                     >::type
-          actual_invoker_type;
-
-        invoker = &actual_invoker_type::invoke;
-        this->manager = &boost::detail::function::trivial_manager<FunctionObj>::get;
-        this->functor =
-          this->manager(
-            boost::detail::function::make_any_pointer(
-              const_cast<FunctionObj*>(f.get_pointer())),
-            boost::detail::function::clone_functor_tag);
-      }
-    }
-
-    template<typename FunctionObj>
-    void assign_to(FunctionObj, boost::detail::function::stateless_function_obj_tag)
-    {
-      typedef
-          typename boost::detail::function::
-                     BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER<
-                       FunctionObj,
-                       R BOOST_FUNCTION_COMMA
-                       BOOST_FUNCTION_TEMPLATE_ARGS
-                     >::type
-          actual_invoker_type;
-      invoker = &actual_invoker_type::invoke;
-      this->manager = &boost::detail::function::trivial_manager<FunctionObj>::get;
-      this->functor = boost::detail::function::make_any_pointer(this);
-    }
-
-    typedef result_type (*invoker_type)(boost::detail::function::any_pointer
-                                        BOOST_FUNCTION_COMMA
-                                        BOOST_FUNCTION_TEMPLATE_ARGS);
-
-    invoker_type invoker;
   };
 
   template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
@@ -564,7 +679,7 @@ namespace boost {
   template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
            typename Allocator>
   typename BOOST_FUNCTION_FUNCTION<
-      R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, 
+      R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
       Allocator>::result_type
    BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
 
@@ -573,8 +688,9 @@ namespace boost {
   {
     if (this->empty())
       boost::throw_exception(bad_function_call());
-    
-    return invoker(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
+
+    return static_cast<vtable_type*>(vtable)->invoker
+             (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
   }
 #endif
 
@@ -689,6 +805,7 @@ public:
 } // end namespace boost
 
 // Cleanup after ourselves...
+#undef BOOST_FUNCTION_VTABLE
 #undef BOOST_FUNCTION_DEFAULT_ALLOCATOR
 #undef BOOST_FUNCTION_COMMA
 #undef BOOST_FUNCTION_FUNCTION
@@ -696,11 +813,11 @@ public:
 #undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
 #undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
 #undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
 #undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
 #undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
 #undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
 #undef BOOST_FUNCTION_TEMPLATE_PARMS
 #undef BOOST_FUNCTION_TEMPLATE_ARGS

index.html

@@ -4,6 +4,10 @@
 </head>
 <body>
 Automatic redirection failed, please go to
-<a href="../../doc/html/function.html">../../doc/html/function.html</a>
+<a href="../../doc/html/function.html">../../doc/html/function.html</a> &nbsp;<hr>
+<p><EFBFBD> Copyright Beman Dawes, 2001</p>
+<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
+file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
+at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
 </body>
-</html>
+</html>

test/Jamfile

@@ -1,68 +0,0 @@
-# Function library
-
-# Copyright (C) 2001-2003 Douglas Gregor
-
-# 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/
-
-
-# Testing Jamfile autogenerated from XML source
-subproject libs/function/test ;
-
-# bring in rules for testing
-SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
-include testing.jam ;
-
-# Make tests run by default.
-DEPENDS all : test ;
-
-{
-  # look in BOOST_ROOT for sources first, just in this Jamfile
-  local SEARCH_SOURCE = $(BOOST_ROOT) $(SEARCH_SOURCE) ;
-
-  test-suite function
-    : 
-  [ run libs/function/test/function_test.cpp :  :  :  : lib_function_test ]
-
-  [ run libs/function/test/function_n_test.cpp :  :  :  :  ]
-
-  [ run libs/function/test/allocator_test.cpp :  :  :  :  ]
-
-  [ run libs/function/test/stateless_test.cpp :  :  :  :  ]
-
-  [ run libs/function/test/lambda_test.cpp :  :  :  :  ]
-
-  [ compile-fail libs/function/test/function_test_fail1.cpp :  :  :  :  ]
-
-  [ compile-fail libs/function/test/function_test_fail2.cpp :  :  :  :  ]
-
-  [ compile libs/function/test/function_30.cpp :  :  :  :  ] 
-
-  [ run libs/function/test/function_arith_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_arith_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/sum_avg_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/sum_avg_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/mem_fun_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/mem_fun_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/std_bind_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/std_bind_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_ref_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_ref_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/contains_test.cpp : : : : ]
-
-  [ run libs/function/test/contains2_test.cpp : : : : ]
- ;
-}

test/allocator_test.cpp

@@ -45,7 +45,7 @@ struct plus_int
 {
   int operator()(int x, int y) const { return x + y; }
 
-  int unused_state_data;
+  int unused_state_data[32];
 };
 
 static int do_minus(int x, int y) { return x-y; }
@@ -54,7 +54,7 @@ struct DoNothing
 {
   void operator()() const {}
 
-  int unused_state_data;
+  int unused_state_data[32];
 };
 
 static void do_nothing() {}

test/function_test.cpp

@@ -10,7 +10,6 @@
 #include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
 #include <functional>
-#include <cassert>
 #include <string>
 #include <utility>
 
@@ -653,12 +652,12 @@ static void test_implicit()
 
 static void test_call_obj(boost::function<int (int, int)> f)
 {
-  assert(!f.empty());
+  BOOST_CHECK(!f.empty());
 }
 
 static void test_call_cref(const boost::function<int (int, int)>& f)
 {
-  assert(!f.empty());
+  BOOST_CHECK(!f.empty());
 }
 
 static void test_call()

test/function_test_fail1.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright (C) Douglas Gregor 2001-2005. 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)
@@ -22,7 +22,7 @@ test_main(int, char*[])
   if (f1 == f2) {
   }
 
-  BOOST_CRITICAL_ERROR("This should not have compiled.");
+  BOOST_ERROR("This should not have compiled.");
 
   return 0;
 }

test/function_test_fail2.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright (C) Douglas Gregor 2001-2005. 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)
@@ -21,7 +21,7 @@ test_main(int, char*[])
   function0<int> f1;
   f1 = bad_fn;
 
-  BOOST_CRITICAL_ERROR("This should not have compiled.");
+  BOOST_ERROR("This should not have compiled.");
 
   return 0;
 }

test/stateless_test.cpp

@@ -14,23 +14,21 @@
 struct stateless_integer_add {
   int operator()(int x, int y) const { return x+y; }
 
-  void* operator new(std::size_t, stateless_integer_add*)
+  void* operator new(std::size_t)
   {
     throw std::runtime_error("Cannot allocate a stateless_integer_add");
   }
 
-  void operator delete(void*, stateless_integer_add*) throw()
+  void* operator new(std::size_t, void* p)
+  {
+    return p;
+  }
+
+  void operator delete(void*) throw()
   {
   }
 };
 
-namespace boost {
-  template<>
-  struct is_stateless<stateless_integer_add> {
-    BOOST_STATIC_CONSTANT(bool, value = true);
-  };
-}
-
 int test_main(int, char*[])
 {
   boost::function2<int, int, int> f;