This commit was manufactured by cvs2svn to create tag

'Version_1_32_0'.

[SVN r26264]

doc/history.xml

@@ -5,14 +5,7 @@
   <title>History &amp; Compatibility Notes</title>
 
 <itemizedlist spacing="compact">
-
+  <listitem><para><emphasis role="bold">Version 1.30.0</emphasis>: </para> 
-  <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
       been removed from Boost.Function.</para></listitem>
@@ -39,7 +32,7 @@
       </itemizedlist>
   </listitem>
 
-  <listitem><para><bold>Version 1.29.0</bold>:
+  <listitem><para><emphasis role="bold">Version 1.29.0</emphasis>:
   Boost.Function has been partially redesigned to minimize the
   interface and make it cleaner. Several seldom- or never-used
   features of the older Boost.Function have been deprecated and will

doc/reference.xml

@@ -118,12 +118,6 @@
         <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>
 
@@ -188,7 +182,7 @@
     </struct>
 
     <constructor>
-      <postconditions><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></postconditions>
+      <postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
       <throws><simpara>Will not throw.</simpara></throws>
     </constructor>
 
@@ -207,10 +201,11 @@
       <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-&gt;<methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
+      <effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
 
     </destructor>
 
@@ -218,7 +213,8 @@
       <parameter name="f">
         <paramtype>const <classname>functionN</classname>&amp;</paramtype>
       </parameter>
-      <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>
+      <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>
     </copy-assignment>
 
     <method-group name="modifiers">
@@ -226,11 +222,13 @@
         <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>
 
@@ -288,13 +286,6 @@
         <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">
@@ -306,7 +297,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>
 
@@ -323,6 +314,7 @@
         <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>
 
@@ -597,7 +589,7 @@
     </struct>
 
     <constructor>
-      <postconditions><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></postconditions>
+      <postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
       <throws><simpara>Will not throw.</simpara></throws>
     </constructor>
 
@@ -624,26 +616,28 @@
       <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-&gt;<methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
+      <effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
 
     </destructor>
 
     <copy-assignment>
       <parameter name="f">
-        <paramtype>const <classname>function</classname>&amp;</paramtype>
+        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
       </parameter>
-      <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>
+      <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>
     </copy-assignment>
 
     <copy-assignment>
       <parameter name="f">
         <paramtype>const <classname>function</classname>&amp;</paramtype>
       </parameter>
-      <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>
+      <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. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></throws>
+      <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>
     </copy-assignment>
 
     <method-group name="modifiers">
@@ -651,6 +645,7 @@
         <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">
@@ -713,12 +708,6 @@
         <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">
@@ -730,7 +719,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>
 
@@ -744,6 +733,7 @@
         <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>
 

doc/tutorial.xml

@@ -329,8 +329,8 @@ exceptions during assignment or construction.
   or <code>!=</code> against any function object that can be stored
   within the wrapper. If the function object wrapper contains a
   function object of that type, it will be compared against the given
-  function object (which must be either be
+  function object (which must be
-  <conceptname>EqualityComparable</conceptname> or have an overloaded <functionname>boost::function_equal</functionname>). For instance:</para>
+  <conceptname>EqualityComparable</conceptname>). For instance:</para>
   
   <programlisting name="function.tutorial.compare">int compute_with_X(X*, int);
 

include/boost/function.hpp

@@ -10,8 +10,6 @@
 // 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>
 
@@ -24,7 +22,7 @@
 #include <boost/function/detail/prologue.hpp>
 
 // Visual Age C++ doesn't handle the file iteration well
-#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
+#if BOOST_WORKAROUND(__IBMCPP__, <= 600)
 #  if BOOST_FUNCTION_MAX_ARGS >= 0
 #    include <boost/function/function0.hpp>
 #  endif

include/boost/function/detail/prologue.hpp

@@ -11,7 +11,6 @@
 #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-2006. Use, modification and
+//  Copyright Douglas Gregor 2001-2004. 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/mpl/if.hpp>
+#include <boost/pending/ct_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,14 +30,6 @@
 #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) \
@@ -67,23 +59,15 @@ namespace boost { namespace python { namespace objects {
 
 #if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
  || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
- || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+ || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
 #  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
 #endif
 
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
-#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
   typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
                         (::boost::is_integral<Functor>::value)>::value), \
                        Type>::type
-#else
+
-// BCC doesn't recognize this depends on a template argument and complains
-// about the use of 'typename'
-#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
-      ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
-                   (::boost::is_integral<Functor>::value)>::value), \
-                       Type>::type
-#endif
 
 #if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
 namespace boost {
@@ -113,36 +97,42 @@ inline void swap(function<Signature, Allocator>& f1,
 namespace boost {
   namespace detail {
     namespace function {
-      class X;
-
       /**
-       * A buffer used to store small function objects in
+       * A union of a function pointer and a void pointer. This is necessary
-       * boost::function. It is a union containing function pointers,
+       * because 5.2.10/6 allows reinterpret_cast<> to safely cast between
-       * object pointers, and a structure that resembles a bound
+       * function pointer types and 5.2.9/10 allows static_cast<> to safely
-       * member function pointer.
+       * 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),
-      union function_buffer
+       * so function requires a union of the two. */
+      union any_pointer
       {
-        // 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)();
-        // For function pointers of all kinds
+        char data[1];
-        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
@@ -171,8 +161,7 @@ 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
@@ -180,77 +169,55 @@ 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 mpl::if_c<(is_pointer<F>::value),
+        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_member_pointer<F>::value),
+        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_reference_wrapper<F>::value),
+        typedef typename ct_if<(is_reference_wrapper<F>::value),
                              function_obj_ref_tag,
                              ptr_or_obj_or_mem_tag>::type or_ref_tag;
 
       public:
-        typedef or_ref_tag type;
+        typedef typename ct_if<(is_stateless<F>::value),
+                            stateless_function_obj_tag,
+                            or_ref_tag>::type 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 reference_manager
+      struct trivial_manager
       {
-        static inline void
+        static inline any_pointer
-        get(const function_buffer& in_buffer, function_buffer& out_buffer, 
+        get(any_pointer f, functor_manager_operation_type op)
-            functor_manager_operation_type op)
         {
           switch (op) {
-          case clone_functor_tag: 
+          case clone_functor_tag: return f;
-            out_buffer.obj_ptr = in_buffer.obj_ptr;
-            return;
 
           case destroy_functor_tag:
-            out_buffer.obj_ptr = 0;
+            return make_any_pointer(reinterpret_cast<void*>(0));
-            return;
 
           case check_functor_type_tag:
             {
-              // DPG TBD: Since we're only storing a pointer, it's
+              std::type_info* t = static_cast<std::type_info*>(f.obj_ptr);
-              // possible that the user could ask for a base class or
+              return BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(F), *t)?
-              // derived class. Is that okay?
+                f
-              const BOOST_FUNCTION_STD_NS::type_info& check_type = 
+                : make_any_pointer(reinterpret_cast<void*>(0));
-                *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;
 
-          case get_functor_type_tag:
+          // Clears up a warning with GCC 3.2.3
-            out_buffer.const_obj_ptr = &typeid(F);
+          return make_any_pointer(reinterpret_cast<void*>(0));
-            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))));
       };
 
       /**
@@ -264,50 +231,23 @@ namespace boost {
         typedef Functor functor_type;
 
         // For function pointers, the manager is trivial
-        static inline void
+        static inline any_pointer
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+        manager(any_pointer function_ptr,
-                functor_manager_operation_type op, function_ptr_tag)
+                functor_manager_operation_type op,
+                function_ptr_tag)
         {
           if (op == clone_functor_tag)
-            out_buffer.func_ptr = in_buffer.func_ptr;
+            return function_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;
+            return make_any_pointer(static_cast<void (*)()>(0));
-          }
         }
 
-        // Function objects that fit in the small-object buffer.
+        // For function object pointers, we clone the pointer to each
-        static inline void
+        // function has its own version.
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+        static inline any_pointer
-                functor_manager_operation_type op, mpl::true_)
+        manager(any_pointer function_obj_ptr,
-        {
+                functor_manager_operation_type op,
-          if (op == clone_functor_tag) {
+                function_obj_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
@@ -322,10 +262,8 @@ namespace boost {
 #  endif // BOOST_NO_STD_ALLOCATOR
 
           if (op == clone_functor_tag) {
-            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
+            functor_type* f =
-            // can't do the static_cast that we should do.
+              static_cast<functor_type*>(function_obj_ptr.obj_ptr);
-            const functor_type* f =
-              (const functor_type*)(in_buffer.obj_ptr);
 
             // Clone the functor
 #  ifndef BOOST_NO_STD_ALLOCATOR
@@ -337,11 +275,12 @@ namespace boost {
 #  else
             functor_type* new_f = new functor_type(*f);
 #  endif // BOOST_NO_STD_ALLOCATOR
-            out_buffer.obj_ptr = new_f;
+            return make_any_pointer(static_cast<void*>(new_f));
-          } else if (op == destroy_functor_tag) {
+          }
+          else {
             /* Cast from the void pointer to the functor pointer type */
             functor_type* f =
-              static_cast<functor_type*>(out_buffer.obj_ptr);
+              reinterpret_cast<functor_type*>(function_obj_ptr.obj_ptr);
 
 #  ifndef BOOST_NO_STD_ALLOCATOR
             /* Cast from the functor pointer type to the allocator's pointer
@@ -354,44 +293,26 @@ namespace boost {
 #  else
             delete f;
 #  endif // BOOST_NO_STD_ALLOCATOR
-            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
+            return make_any_pointer(static_cast<void*>(0));
-        // 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 inline void
+        static any_pointer
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
+        manage(any_pointer functor_ptr, functor_manager_operation_type op)
-               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;
-          switch (op) {
+            return manager(functor_ptr, op, tag_type());
-          case get_functor_type_tag:
-            out_buffer.const_obj_ptr = &typeid(functor_type);
-            return;
-
-          default:
-            manager(in_buffer, out_buffer, op, tag_type());
-            return;
           }
         }
       };
@@ -457,18 +378,6 @@ 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
 
@@ -481,61 +390,48 @@ namespace boost {
 class function_base
 {
 public:
-  function_base() : vtable(0) { }
+  function_base() : manager(0)
-
-  /** 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);
+    functor.obj_ptr = 0;
-
-    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);
   }
 
+  // Is this function empty?
+  bool empty() const { return !manager; }
+
   template<typename Functor>
     Functor* target()
     {
-      if (!vtable) return 0;
+      if (!manager) return 0;
 
-      detail::function::function_buffer type_result;
+      detail::function::any_pointer result =
-      type_result.const_obj_ptr = &typeid(Functor);
+        manager(detail::function::make_any_pointer(&typeid(Functor)),
-      vtable->manager(functor, type_result, 
                 detail::function::check_functor_type_tag);
-      return static_cast<Functor*>(type_result.obj_ptr);
+      if (!result.obj_ptr) return 0;
+      else {
+        typedef typename detail::function::get_function_tag<Functor>::type tag;
+        return get_functor_pointer<Functor>(tag(), 0);
+      }
     }
 
   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 (!vtable) return 0;
+      if (!manager) return 0;
 
-      detail::function::function_buffer type_result;
+      detail::function::any_pointer result =
-      type_result.const_obj_ptr = &typeid(Functor);
+        manager(detail::function::make_any_pointer(&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
+      if (!result.obj_ptr) return 0;
-      // can't do the static_cast that we should do.
+      else {
-      return (const Functor*)(type_result.obj_ptr);
+        typedef typename detail::function::get_function_tag<Functor>::type tag;
+        return get_functor_pointer<Functor>(tag(), 0);
+      }
     }
 
   template<typename F>
     bool contains(const F& f) const
     {
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+      if (const F* fp = this->template target<F>()) {
-      if (const F* fp = this->target( (F*)0 ))
-#else
-      if (const F* fp = this->template target<F>())
-#endif
-      {
         return function_equal(*fp, f);
       } else {
         return false;
@@ -566,8 +462,28 @@ public:
 #endif
 
 public: // should be protected, but GCC 2.95.3 will fail to allow access
-  detail::function::vtable_base* vtable;
+  detail::function::any_pointer (*manager)(
-  mutable detail::function::function_buffer functor;
+    detail::function::any_pointer,
+    detail::function::functor_manager_operation_type);
+  detail::function::any_pointer functor;
+
+private:
+  template<typename Functor>
+    Functor* get_functor_pointer(detail::function::function_ptr_tag, int)
+    { return reinterpret_cast<Functor*>(&functor.func_ptr); }
+
+  template<typename Functor, typename Tag>
+    Functor* get_functor_pointer(Tag, long)
+    { return static_cast<Functor*>(functor.obj_ptr); }
+
+  template<typename Functor>
+    const Functor*
+    get_functor_pointer(detail::function::function_ptr_tag, int) const
+    { return reinterpret_cast<const Functor*>(&functor.func_ptr); }
+
+  template<typename Functor, typename Tag>
+    const Functor* get_functor_pointer(Tag, long) const
+    { return static_cast<const Functor*>(functor.const_obj_ptr); }
 };
 
 /**

include/boost/function/function_template.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2006. Use, modification and
+//  Copyright Douglas Gregor 2001-2003. 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(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+  typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(arg, BOOST_PP_CAT(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,25 +50,16 @@
   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 \
+#define BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER \
-  BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+  BOOST_JOIN(stateless_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
+#define BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER \
-  BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+  BOOST_JOIN(stateless_void_function_obj_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 \
+#define BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER \
-  BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+  BOOST_JOIN(get_stateless_function_obj_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 {
@@ -80,7 +71,7 @@ namespace boost {
         >
       struct BOOST_FUNCTION_FUNCTION_INVOKER
       {
-        static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
+        static R invoke(any_pointer function_ptr BOOST_FUNCTION_COMMA
                         BOOST_FUNCTION_PARMS)
         {
           FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
@@ -95,13 +86,13 @@ namespace boost {
         >
       struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
+        static unusable invoke(any_pointer function_ptr BOOST_FUNCTION_COMMA
-        invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
                                BOOST_FUNCTION_PARMS)
 
         {
           FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
-          BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
+          f(BOOST_FUNCTION_ARGS);
+          return unusable();
         }
       };
 
@@ -112,15 +103,11 @@ namespace boost {
       >
       struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
       {
-        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
+        static R invoke(any_pointer function_obj_ptr BOOST_FUNCTION_COMMA
                         BOOST_FUNCTION_PARMS)
 
         {
-          FunctionObj* f;
+          FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
-          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);
         }
       };
@@ -132,17 +119,14 @@ namespace boost {
       >
       struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
+        static unusable invoke(any_pointer function_obj_ptr
-        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
+                               BOOST_FUNCTION_COMMA
                                BOOST_FUNCTION_PARMS)
 
         {
-          FunctionObj* f;
+          FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
-          if (function_allows_small_object_optimization<FunctionObj>::value)
+          (*f)(BOOST_FUNCTION_ARGS);
-            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          return unusable();
-          else
-            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
-          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
         }
       };
 
@@ -151,15 +135,12 @@ namespace boost {
         typename R BOOST_FUNCTION_COMMA
         BOOST_FUNCTION_TEMPLATE_PARMS
       >
-      struct BOOST_FUNCTION_FUNCTION_REF_INVOKER
+      struct BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER
       {
-        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
+        static R invoke(any_pointer BOOST_FUNCTION_COMMA BOOST_FUNCTION_PARMS)
-                        BOOST_FUNCTION_PARMS)
-
         {
-          FunctionObj* f = 
+          FunctionObj f = FunctionObj();
-            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return f(BOOST_FUNCTION_ARGS);
-          return (*f)(BOOST_FUNCTION_ARGS);
         }
       };
 
@@ -168,16 +149,15 @@ namespace boost {
         typename R BOOST_FUNCTION_COMMA
         BOOST_FUNCTION_TEMPLATE_PARMS
       >
-      struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+      struct BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER
       {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
+        static unusable invoke(any_pointer BOOST_FUNCTION_COMMA
-        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
                                BOOST_FUNCTION_PARMS)
 
         {
-          FunctionObj* f = 
+          FunctionObj f = FunctionObj();
-            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          f(BOOST_FUNCTION_ARGS);
-          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
+          return unusable();
         }
       };
 
@@ -188,7 +168,7 @@ namespace boost {
       >
       struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
       {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename ct_if<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
                             FunctionPtr,
                             R BOOST_FUNCTION_COMMA
@@ -209,7 +189,7 @@ namespace boost {
        >
       struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
       {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename ct_if<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
                             FunctionObj,
                             R BOOST_FUNCTION_COMMA
@@ -228,15 +208,15 @@ namespace boost {
         typename R BOOST_FUNCTION_COMMA
         BOOST_FUNCTION_TEMPLATE_PARMS
        >
-      struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+      struct BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER
       {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename ct_if<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
+                            BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER<
                             FunctionObj,
                             R BOOST_FUNCTION_COMMA
                             BOOST_FUNCTION_TEMPLATE_ARGS
                           >,
-                          BOOST_FUNCTION_FUNCTION_REF_INVOKER<
+                          BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER<
                             FunctionObj,
                             R BOOST_FUNCTION_COMMA
                             BOOST_FUNCTION_TEMPLATE_ARGS
@@ -244,199 +224,6 @@ 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
 
@@ -446,31 +233,12 @@ 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
+    typedef typename detail::function::function_return_type<R>::type
-    typedef R         result_type;
+      internal_result_type;
-#else
-    typedef  typename boost::detail::function::function_return_type<R>::type
-      result_type;
-#endif // BOOST_NO_VOID_RETURNS
 
   private:
-    typedef boost::detail::function::BOOST_FUNCTION_VTABLE<
-              R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator>
-      vtable_type;
-
     struct clear_type {};
 
   public:
@@ -480,7 +248,7 @@ namespace boost {
     template<typename Args>
     struct sig
     {
-      typedef result_type type;
+      typedef internal_result_type type;
     };
 
 #if BOOST_FUNCTION_NUM_ARGS == 1
@@ -493,10 +261,16 @@ namespace boost {
     BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);
     BOOST_FUNCTION_ARG_TYPES
 
+#ifndef BOOST_NO_VOID_RETURNS
+    typedef R         result_type;
+#else
+    typedef internal_result_type result_type;
+#endif // BOOST_NO_VOID_RETURNS
     typedef Allocator allocator_type;
     typedef BOOST_FUNCTION_FUNCTION self_type;
 
-    BOOST_FUNCTION_FUNCTION() : function_base() { }
+    BOOST_FUNCTION_FUNCTION() : function_base()
+                              , invoker(0) {}
 
     // MSVC chokes if the following two constructors are collapsed into
     // one with a default parameter.
@@ -504,33 +278,36 @@ namespace boost {
     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
 #ifndef BOOST_NO_SFINAE
                             ,typename enable_if_c<
-                            (boost::type_traits::ice_not<
+                            (::boost::type_traits::ice_not<
                              (is_integral<Functor>::value)>::value),
                                         int>::type = 0
 #endif // BOOST_NO_SFINAE
                             ) :
-      function_base()
+      function_base(),
+      invoker(0)
     {
       this->assign_to(f);
     }
 
 #ifndef BOOST_NO_SFINAE
-    BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
+    BOOST_FUNCTION_FUNCTION(clear_type*) : function_base(), invoker(0) {}
 #else
-    BOOST_FUNCTION_FUNCTION(int zero) : function_base()
+    BOOST_FUNCTION_FUNCTION(int zero) : function_base(), invoker(0)
     {
       BOOST_ASSERT(zero == 0);
     }
 #endif
 
-    BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base()
+    BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) :
+      function_base(),
+      invoker(0)
     {
       this->assign_to_own(f);
     }
 
     ~BOOST_FUNCTION_FUNCTION() { clear(); }
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
     // MSVC 6.0 and prior require all definitions to be inline, but
     // these definitions can become very costly.
     result_type operator()(BOOST_FUNCTION_PARMS) const
@@ -538,8 +315,15 @@ namespace boost {
       if (this->empty())
         boost::throw_exception(bad_function_call());
 
-      return static_cast<vtable_type*>(vtable)->invoker
+      internal_result_type result = invoker(this->functor
-               (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
+                                            BOOST_FUNCTION_COMMA
+                                            BOOST_FUNCTION_ARGS);
+
+#ifndef BOOST_NO_VOID_RETURNS
+      return static_cast<result_type>(result);
+#else
+      return result;
+#endif // BOOST_NO_VOID_RETURNS
     }
 #else
     result_type operator()(BOOST_FUNCTION_PARMS) const;
@@ -553,7 +337,7 @@ namespace boost {
     template<typename Functor>
 #ifndef BOOST_NO_SFINAE
     typename enable_if_c<
-               (boost::type_traits::ice_not<
+               (::boost::type_traits::ice_not<
                  (is_integral<Functor>::value)>::value),
                BOOST_FUNCTION_FUNCTION&>::type
 #else
@@ -561,13 +345,7 @@ namespace boost {
 #endif
     operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
     {
-      this->clear();
+      self_type(f).swap(*this);
-      try {
-        this->assign_to(f);
-      } catch (...) {
-        vtable = 0;
-        throw;
-      }
       return *this;
     }
 
@@ -592,13 +370,7 @@ namespace boost {
       if (&f == this)
         return *this;
 
-      this->clear();
+      self_type(f).swap(*this);
-      try {
-        this->assign_to_own(f);
-      } catch (...) {
-        vtable = 0;
-        throw;
-      }
       return *this;
     }
 
@@ -607,18 +379,21 @@ namespace boost {
       if (&other == this)
         return;
 
-      BOOST_FUNCTION_FUNCTION tmp = *this;
+      std::swap(this->manager, other.manager);
-      *this = other;
+      std::swap(this->functor, other.functor);
-      other = tmp;
+      std::swap(invoker, other.invoker);
     }
 
     // Clear out a target, if there is one
     void clear()
     {
-      if (vtable) {
+      if (this->manager) {
-        static_cast<vtable_type*>(vtable)->clear(this->functor);
+        function_base::functor =
-        vtable = 0;
+          this->manager(this->functor, detail::function::destroy_functor_tag);
       }
+
+      this->manager = 0;
+      invoker = 0;
     }
 
 #if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG)
@@ -644,19 +419,131 @@ namespace boost {
     void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)
     {
       if (!f.empty()) {
-        this->vtable = f.vtable;
+        invoker = f.invoker;
-        f.vtable->manager(f.functor, this->functor,
+        this->manager = f.manager;
-                          boost::detail::function::clone_functor_tag);
+        this->functor =
+          f.manager(f.functor, detail::function::clone_functor_tag);
       }
     }
 
     template<typename Functor>
     void assign_to(Functor f)
     {
-      static vtable_type stored_vtable(f);
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
-      if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable;
+      this->assign_to(f, tag());
-      else vtable = 0;
     }
+
+    template<typename FunctionPtr>
+    void assign_to(FunctionPtr f, detail::function::function_ptr_tag)
+    {
+      clear();
+
+      if (f) {
+        typedef typename 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 =
+          &detail::function::functor_manager<FunctionPtr, Allocator>::manage;
+        this->functor =
+          this->manager(detail::function::make_any_pointer(
+                            // should be a reinterpret cast, but some compilers
+                            // insist on giving cv-qualifiers to free functions
+                            (void (*)())(f)
+                          ),
+                          detail::function::clone_functor_tag);
+      }
+    }
+
+#if BOOST_FUNCTION_NUM_ARGS > 0
+    template<typename MemberPtr>
+    void assign_to(MemberPtr f, 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, detail::function::function_obj_tag)
+    {
+      if (!detail::function::has_empty_target(addressof(f))) {
+        typedef
+          typename 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 = &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 =
+          detail::function::make_any_pointer(static_cast<void*>(new_f));
+      }
+    }
+
+    template<typename FunctionObj>
+    void assign_to(const reference_wrapper<FunctionObj>& f,
+                   detail::function::function_obj_ref_tag)
+    {
+      if (!detail::function::has_empty_target(f.get_pointer())) {
+        typedef
+          typename 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 = &detail::function::trivial_manager<FunctionObj>::get;
+        this->functor =
+          this->manager(
+            detail::function::make_any_pointer(
+              const_cast<FunctionObj*>(f.get_pointer())),
+            detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename FunctionObj>
+    void assign_to(FunctionObj, detail::function::stateless_function_obj_tag)
+    {
+      typedef
+          typename 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 = &detail::function::trivial_manager<FunctionObj>::get;
+      this->functor = detail::function::make_any_pointer(this);
+    }
+
+    typedef internal_result_type (*invoker_type)(detail::function::any_pointer
+                                                 BOOST_FUNCTION_COMMA
+                                                 BOOST_FUNCTION_TEMPLATE_ARGS);
+
+    invoker_type invoker;
   };
 
   template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
@@ -675,7 +562,7 @@ namespace boost {
     f1.swap(f2);
   }
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
   template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
            typename Allocator>
   typename BOOST_FUNCTION_FUNCTION<
@@ -689,8 +576,15 @@ namespace boost {
       if (this->empty())
         boost::throw_exception(bad_function_call());
 
-    return static_cast<vtable_type*>(vtable)->invoker
+      internal_result_type result = invoker(this->functor
-             (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
+                                            BOOST_FUNCTION_COMMA
+                                            BOOST_FUNCTION_ARGS);
+
+#  ifndef BOOST_NO_VOID_RETURNS
+      return static_cast<result_type>(result);
+#  else
+      return result;
+#  endif // BOOST_NO_VOID_RETURNS
     }
 #endif
 
@@ -746,7 +640,7 @@ public:
   function(Functor f
 #ifndef BOOST_NO_SFINAE
            ,typename enable_if_c<
-                            (boost::type_traits::ice_not<
+                            (::boost::type_traits::ice_not<
                           (is_integral<Functor>::value)>::value),
                        int>::type = 0
 #endif
@@ -772,7 +666,7 @@ public:
   template<typename Functor>
 #ifndef BOOST_NO_SFINAE
   typename enable_if_c<
-                            (boost::type_traits::ice_not<
+                            (::boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       self_type&>::type
 #else
@@ -805,7 +699,6 @@ public:
 } // end namespace boost
 
 // Cleanup after ourselves...
-#undef BOOST_FUNCTION_VTABLE
 #undef BOOST_FUNCTION_DEFAULT_ALLOCATOR
 #undef BOOST_FUNCTION_COMMA
 #undef BOOST_FUNCTION_FUNCTION
@@ -813,11 +706,11 @@ public:
 #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_STATELESS_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_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_STATELESS_FUNCTION_OBJ_INVOKER
 #undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
 #undef BOOST_FUNCTION_TEMPLATE_PARMS
 #undef BOOST_FUNCTION_TEMPLATE_ARGS
@@ -826,5 +719,3 @@ public:
 #undef BOOST_FUNCTION_ARGS
 #undef BOOST_FUNCTION_ARG_TYPE
 #undef BOOST_FUNCTION_ARG_TYPES
-#undef BOOST_FUNCTION_VOID_RETURN_TYPE
-#undef BOOST_FUNCTION_RETURN

include/boost/function_equal.hpp

@@ -1,9 +1,6 @@
-//  Copyright Douglas Gregor 2004.
+//  Copyright Douglas Gregor 2004. Use, modification and
-//  Copyright 2005 Peter Dimov
+//  distribution is subject to the Boost Software License, Version
-
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  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
@@ -12,16 +9,15 @@
 
 namespace boost {
 
-template<typename F, typename G>
+namespace detail {
+  template<typename F, typename G>
     bool function_equal_impl(const F& f, const G& g, long)
     { return f == g; }
-
+} // end namespace boost::function
-// function_equal_impl needs to be unqualified to pick
-// user overloads on two-phase compilers
 
 template<typename F, typename G>
   bool function_equal(const F& f, const G& g)
-  { return function_equal_impl(f, g, 0); }
+  { return ::boost::detail::function_equal_impl(f, g, 0); }
 
 } // end namespace boost
 

index.html

@@ -4,10 +4,6 @@
 </head>
 <body>
 Automatic redirection failed, please go to
-<a href="../../doc/html/function.html">../../doc/html/function.html</a> &nbsp;<hr>
+<a href="../../doc/html/function.html">../../doc/html/function.html</a>
-<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>

test/Jamfile

@@ -0,0 +1,67 @@
+# 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 : : : : ]
+ ;
+}
+      

test/Jamfile.v2

@@ -56,8 +56,6 @@ import testing ;
   
   [ run libs/function/test/contains_test.cpp : : : : ]
    
-  [ run libs/function/test/contains2_test.cpp : : : : ]
-   
  ;
 }
       

test/allocator_test.cpp

@@ -41,20 +41,11 @@ struct counting_allocator : public std::allocator<T>
   }
 };
 
-struct plus_int
-{
-  int operator()(int x, int y) const { return x + y; }
-
-  int unused_state_data[32];
-};
-
 static int do_minus(int x, int y) { return x-y; }
 
 struct DoNothing
 {
   void operator()() const {}
-
-  int unused_state_data[32];
 };
 
 static void do_nothing() {}
@@ -63,32 +54,28 @@ int
 test_main(int, char*[])
 {
   function2<int, int, int, counting_allocator<int> > f;
-  f = plus_int();
+  f = plus<int>();
   f.clear();
-  BOOST_CHECK(alloc_count == 1);
+  BOOST_TEST(alloc_count == 1);
-  BOOST_CHECK(dealloc_count == 1);
+  BOOST_TEST(dealloc_count == 1);
 
   alloc_count = 0;
   dealloc_count = 0;
   f = &do_minus;
   f.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
 
   function0<void, counting_allocator<int> > fv;
   alloc_count = 0;
   dealloc_count = 0;
   fv = DoNothing();
   fv.clear();
-  BOOST_CHECK(alloc_count == 1);
+  BOOST_TEST(alloc_count == 1);
-  BOOST_CHECK(dealloc_count == 1);
+  BOOST_TEST(dealloc_count == 1);
 
   alloc_count = 0;
   dealloc_count = 0;
   fv = &do_nothing;
   fv.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
 
   return 0;
 }

test/contains2_test.cpp

@@ -1,88 +0,0 @@
-// Boost.Function library
-
-//  Copyright Douglas Gregor 2004.
-//  Copyright 2005 Peter Dimov
-
-//  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)
-
-#include <boost/function.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-static int forty_two()
-{
-    return 42;
-}
-
-struct Seventeen
-{
-    int operator()() const
-    {
-        return 17;
-    }
-};
-
-bool operator==(const Seventeen&, const Seventeen&)
-{
-    return true;
-}
-
-struct ReturnInt
-{
-    explicit ReturnInt(int value) : value(value)
-    {
-    }
-
-    int operator()() const
-    {
-        return value;
-    }
-
-    int value;
-};
-
-bool operator==(const ReturnInt& x, const ReturnInt& y)
-{
-    return x.value == y.value;
-}
-
-bool operator!=(const ReturnInt& x, const ReturnInt& y)
-{
-    return x.value != y.value;
-}
-
-int main()
-{
-    boost::function0<int> fn;
-
-    fn = &forty_two;
-
-    BOOST_TEST( fn() == 42 );
-
-    BOOST_TEST( fn.contains(&forty_two) );
-    BOOST_TEST( !fn.contains( Seventeen() ) );
-    BOOST_TEST( !fn.contains( ReturnInt(0) ) );
-    BOOST_TEST( !fn.contains( ReturnInt(12) ) );
-
-    fn = Seventeen();
-
-    BOOST_TEST( fn() == 17 );
-
-    BOOST_TEST( !fn.contains( &forty_two ) );
-    BOOST_TEST( fn.contains( Seventeen() ) );
-    BOOST_TEST( !fn.contains( ReturnInt(0) ) );
-    BOOST_TEST( !fn.contains( ReturnInt(12) ) );
-
-    fn = ReturnInt(12);
-
-    BOOST_TEST( fn() == 12 );
-
-    BOOST_TEST( !fn.contains( &forty_two ) );
-    BOOST_TEST( !fn.contains( Seventeen() ) );
-    BOOST_TEST( !fn.contains( ReturnInt(0) ) );
-    BOOST_TEST( fn.contains( ReturnInt(12) ) );
-
-    return boost::report_errors();
-}

test/contains_test.cpp

@@ -31,63 +31,23 @@ bool operator==(const ReturnInt& x, const ReturnInt& y)
 bool operator!=(const ReturnInt& x, const ReturnInt& y)
 { return x.value != y.value; }
 
-namespace contain_test {
-
-struct ReturnIntFE
-{
-  explicit ReturnIntFE(int value) : value(value) {}
-
-  int operator()() const { return value; }
-
-  int value;
-};
-
-}
-
-#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-
-namespace contain_test {
-# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-bool function_equal(const ReturnIntFE& x, const ReturnIntFE& y)
-{ return x.value == y.value; }
-# else
-bool function_equal_impl(const ReturnIntFE& x, const ReturnIntFE& y, int)
-{ return x.value == y.value; }
-# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-}
-#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-namespace boost {
-# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-bool 
-function_equal(const contain_test::ReturnIntFE& x, 
-               const contain_test::ReturnIntFE& y)
-{ return x.value == y.value; }
-# else
-bool 
-function_equal_impl(const contain_test::ReturnIntFE& x, 
-                    const contain_test::ReturnIntFE& y, int)
-{ return x.value == y.value; }
-# endif
-}
-#endif
-
 static void target_test()
 {
   boost::function0<int> f;
 
   f = &forty_two;
-  BOOST_CHECK(*f.target<int (*)()>() == &forty_two);
+  BOOST_TEST(*f.target<int (*)()>() == &forty_two);
-  BOOST_CHECK(!f.target<Seventeen>());
+  BOOST_TEST(!f.target<Seventeen>());
 
   f = Seventeen();
-  BOOST_CHECK(!f.target<int (*)()>());
+  BOOST_TEST(!f.target<int (*)()>());
-  BOOST_CHECK(f.target<Seventeen>());
+  BOOST_TEST(f.target<Seventeen>());
 
   Seventeen this_seventeen;
   f = boost::ref(this_seventeen);
-  BOOST_CHECK(!f.target<int (*)()>());
+  BOOST_TEST(!f.target<int (*)()>());
-  BOOST_CHECK(f.target<Seventeen>());
+  BOOST_TEST(f.target<Seventeen>());
-  BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);
+  BOOST_TEST(f.target<Seventeen>() == &this_seventeen);
 }
 
 static void equal_test()
@@ -95,58 +55,46 @@ static void equal_test()
   boost::function0<int> f;
 
   f = &forty_two;
-  BOOST_CHECK(f == &forty_two);
+  BOOST_TEST(f == &forty_two);
-  BOOST_CHECK(f != ReturnInt(17));
+  BOOST_TEST(f != ReturnInt(17));
 #if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-  BOOST_CHECK(&forty_two == f);
+  BOOST_TEST(&forty_two == f);
-  BOOST_CHECK(ReturnInt(17) != f);
+  BOOST_TEST(ReturnInt(17) != f);
 #endif
 
-  BOOST_CHECK(f.contains(&forty_two));
+  BOOST_TEST(f.contains(&forty_two));
 
   f = ReturnInt(17);
-  BOOST_CHECK(f != &forty_two);
+  BOOST_TEST(f != &forty_two);
-  BOOST_CHECK(f == ReturnInt(17));
+  BOOST_TEST(f == ReturnInt(17));
-  BOOST_CHECK(f != ReturnInt(16));
+  BOOST_TEST(f != ReturnInt(16));
 #if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-  BOOST_CHECK(&forty_two != f);
+  BOOST_TEST(&forty_two != f);
-  BOOST_CHECK(ReturnInt(17) == f);
+  BOOST_TEST(ReturnInt(17) == f);
-  BOOST_CHECK(ReturnInt(16) != f);
+  BOOST_TEST(ReturnInt(16) != f);
 #endif
 
-  BOOST_CHECK(f.contains(ReturnInt(17)));
+  BOOST_TEST(f.contains(ReturnInt(17)));
-
-  f = contain_test::ReturnIntFE(17);
-  BOOST_CHECK(f != &forty_two);
-  BOOST_CHECK(f == contain_test::ReturnIntFE(17));
-  BOOST_CHECK(f != contain_test::ReturnIntFE(16));
-#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-  BOOST_CHECK(&forty_two != f);
-  BOOST_CHECK(contain_test::ReturnIntFE(17) == f);
-  BOOST_CHECK(contain_test::ReturnIntFE(16) != f);
-#endif
-
-  BOOST_CHECK(f.contains(contain_test::ReturnIntFE(17)));
 
 #if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
   boost::function<int(void)> g;
 
   g = &forty_two;
-  BOOST_CHECK(g == &forty_two);
+  BOOST_TEST(g == &forty_two);
-  BOOST_CHECK(g != ReturnInt(17));
+  BOOST_TEST(g != ReturnInt(17));
 #  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-  BOOST_CHECK(&forty_two == g);
+  BOOST_TEST(&forty_two == g);
-  BOOST_CHECK(ReturnInt(17) != g);
+  BOOST_TEST(ReturnInt(17) != g);
 #  endif
 
   g = ReturnInt(17);
-  BOOST_CHECK(g != &forty_two);
+  BOOST_TEST(g != &forty_two);
-  BOOST_CHECK(g == ReturnInt(17));
+  BOOST_TEST(g == ReturnInt(17));
-  BOOST_CHECK(g != ReturnInt(16));
+  BOOST_TEST(g != ReturnInt(16));
 #  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-  BOOST_CHECK(&forty_two != g);
+  BOOST_TEST(&forty_two != g);
-  BOOST_CHECK(ReturnInt(17) == g);
+  BOOST_TEST(ReturnInt(17) == g);
-  BOOST_CHECK(ReturnInt(16) != g);
+  BOOST_TEST(ReturnInt(16) != g);
 #  endif
 #endif
 }
@@ -158,28 +106,28 @@ static void ref_equal_test()
     boost::function0<int> f = boost::ref(ri);
 
     // References and values are equal
-    BOOST_CHECK(f == boost::ref(ri));
+    BOOST_TEST(f == boost::ref(ri));
-    BOOST_CHECK(f == ri);
+    BOOST_TEST(f == ri);
-    BOOST_CHECK(boost::ref(ri) == f);
+    BOOST_TEST(boost::ref(ri) == f);
-    BOOST_CHECK(!(f != boost::ref(ri)));
+    BOOST_TEST(!(f != boost::ref(ri)));
-    BOOST_CHECK(!(f != ri));
+    BOOST_TEST(!(f != ri));
-    BOOST_CHECK(!(boost::ref(ri) != f));
+    BOOST_TEST(!(boost::ref(ri) != f));
 #if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-    BOOST_CHECK(ri == f);
+    BOOST_TEST(ri == f);
-    BOOST_CHECK(!(ri != f));
+    BOOST_TEST(!(ri != f));
 #endif
 
     // Values equal, references inequal
     ReturnInt ri2(17);
-    BOOST_CHECK(f == ri2);
+    BOOST_TEST(f == ri2);
-    BOOST_CHECK(f != boost::ref(ri2));
+    BOOST_TEST(f != boost::ref(ri2));
-    BOOST_CHECK(boost::ref(ri2) != f);
+    BOOST_TEST(boost::ref(ri2) != f);
-    BOOST_CHECK(!(f != ri2));
+    BOOST_TEST(!(f != ri2));
-    BOOST_CHECK(!(f == boost::ref(ri2)));
+    BOOST_TEST(!(f == boost::ref(ri2)));
-    BOOST_CHECK(!(boost::ref(ri2) == f));
+    BOOST_TEST(!(boost::ref(ri2) == f));
 #if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-    BOOST_CHECK(ri2 == f);
+    BOOST_TEST(ri2 == f);
-    BOOST_CHECK(!(ri2 != f));
+    BOOST_TEST(!(ri2 != f));
 #endif 
   }
 
@@ -189,28 +137,28 @@ static void ref_equal_test()
     boost::function<int(void)> f = boost::ref(ri);
 
     // References and values are equal
-    BOOST_CHECK(f == boost::ref(ri));
+    BOOST_TEST(f == boost::ref(ri));
-    BOOST_CHECK(f == ri);
+    BOOST_TEST(f == ri);
-    BOOST_CHECK(boost::ref(ri) == f);
+    BOOST_TEST(boost::ref(ri) == f);
-    BOOST_CHECK(!(f != boost::ref(ri)));
+    BOOST_TEST(!(f != boost::ref(ri)));
-    BOOST_CHECK(!(f != ri));
+    BOOST_TEST(!(f != ri));
-    BOOST_CHECK(!(boost::ref(ri) != f));
+    BOOST_TEST(!(boost::ref(ri) != f));
 #  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-    BOOST_CHECK(ri == f);
+    BOOST_TEST(ri == f);
-    BOOST_CHECK(!(ri != f));
+    BOOST_TEST(!(ri != f));
 #  endif
 
     // Values equal, references inequal
     ReturnInt ri2(17);
-    BOOST_CHECK(f == ri2);
+    BOOST_TEST(f == ri2);
-    BOOST_CHECK(f != boost::ref(ri2));
+    BOOST_TEST(f != boost::ref(ri2));
-    BOOST_CHECK(boost::ref(ri2) != f);
+    BOOST_TEST(boost::ref(ri2) != f);
-    BOOST_CHECK(!(f != ri2));
+    BOOST_TEST(!(f != ri2));
-    BOOST_CHECK(!(f == boost::ref(ri2)));
+    BOOST_TEST(!(f == boost::ref(ri2)));
-    BOOST_CHECK(!(boost::ref(ri2) == f));
+    BOOST_TEST(!(boost::ref(ri2) == f));
 #  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-    BOOST_CHECK(ri2 == f);
+    BOOST_TEST(ri2 == f);
-    BOOST_CHECK(!(ri2 != f));
+    BOOST_TEST(!(ri2 != f));
 #  endif
   }
 #endif

test/function_n_test.cpp

@@ -56,30 +56,30 @@ test_zero_args()
 
   // Default construction
   func_void_type v1;
-  BOOST_CHECK(v1.empty());
+  BOOST_TEST(v1.empty());
 
   // Assignment to an empty function
   v1 = five;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
 
   // Invocation of a function
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear() method
   v1.clear();
-  BOOST_CHECK(!v1);
+  BOOST_TEST(!v1);
 
   // Assignment to an empty function
   v1 = three;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
 
   // Invocation and self-assignment
   global_int = 0;
   v1 = v1;
   v1();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
   v1 = five;
@@ -88,61 +88,61 @@ test_zero_args()
   global_int = 0;
   v1 = (v1);
   v1();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear
   v1 = 0;
-  BOOST_CHECK(v1.empty());
+  BOOST_TEST(v1.empty());
 
   // Assignment to an empty function from a free function
   v1 = &write_five;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v1 = &write_three;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment
   v1 = five;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v1 = write_three;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Construction from another function (that is empty)
   v1.clear();
   func_void_type v2(v1);
-  BOOST_CHECK(!v2? true : false);
+  BOOST_TEST(!v2? true : false);
 
   // Assignment to an empty function
   v2 = three;
-  BOOST_CHECK(!v2.empty());
+  BOOST_TEST(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
   v2 = (five);
@@ -150,86 +150,86 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   v2.clear();
-  BOOST_CHECK(v2.empty());
+  BOOST_TEST(v2.empty());
 
   // Assignment to an empty function from a free function
   v2 = (&write_five);
-  BOOST_CHECK(v2? true : false);
+  BOOST_TEST(v2? true : false);
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v2 = &write_three;
-  BOOST_CHECK(!v2.empty());
+  BOOST_TEST(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Swapping
   v1 = five;
   swap(v1, v2);
   v2();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
   v1();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
   swap(v1, v2);
   v1.clear();
 
   // Assignment
   v2 = five;
-  BOOST_CHECK(!v2.empty());
+  BOOST_TEST(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v2 = &write_three;
-  BOOST_CHECK(!v2.empty());
+  BOOST_TEST(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a function from an empty function
   v2 = v1;
-  BOOST_CHECK(v2.empty());
+  BOOST_TEST(v2.empty());
 
   // Assignment to a function from a function with a functor
   v1 = three;
   v2 = v1;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
-  BOOST_CHECK(!v2.empty());
+  BOOST_TEST(!v2.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assign to a function from a function with a function
   v2 = &write_five;
   v1 = v2;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
-  BOOST_CHECK(!v2.empty());
+  BOOST_TEST(!v2.empty());
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Construct a function given another function containing a function
   func_void_type v3(v1);
@@ -237,20 +237,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v3();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear() method
   v3.clear();
-  BOOST_CHECK(!v3? true : false);
+  BOOST_TEST(!v3? true : false);
 
   // Assignment to an empty function
   v3 = three;
-  BOOST_CHECK(!v3.empty());
+  BOOST_TEST(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
   v3 = five;
@@ -258,38 +258,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v3();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear()
   v3.clear();
-  BOOST_CHECK(v3.empty());
+  BOOST_TEST(v3.empty());
 
   // Assignment to an empty function from a free function
   v3 = &write_five;
-  BOOST_CHECK(!v3.empty());
+  BOOST_TEST(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v3 = &write_three;
-  BOOST_CHECK(!v3.empty());
+  BOOST_TEST(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment
   v3 = five;
-  BOOST_CHECK(!v3.empty());
+  BOOST_TEST(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Construction of a function from a function containing a functor
   func_void_type v4(v3);
@@ -297,20 +297,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v4();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear() method
   v4.clear();
-  BOOST_CHECK(v4.empty());
+  BOOST_TEST(v4.empty());
 
   // Assignment to an empty function
   v4 = three;
-  BOOST_CHECK(!v4.empty());
+  BOOST_TEST(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
   v4 = five;
@@ -318,38 +318,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v4();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear()
   v4.clear();
-  BOOST_CHECK(v4.empty());
+  BOOST_TEST(v4.empty());
 
   // Assignment to an empty function from a free function
   v4 = &write_five;
-  BOOST_CHECK(!v4.empty());
+  BOOST_TEST(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v4 = &write_three;
-  BOOST_CHECK(!v4.empty());
+  BOOST_TEST(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment
   v4 = five;
-  BOOST_CHECK(!v4.empty());
+  BOOST_TEST(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Construction of a function from a functor
   func_void_type v5(five);
@@ -357,20 +357,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v5();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear() method
   v5.clear();
-  BOOST_CHECK(v5.empty());
+  BOOST_TEST(v5.empty());
 
   // Assignment to an empty function
   v5 = three;
-  BOOST_CHECK(!v5.empty());
+  BOOST_TEST(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
   v5 = five;
@@ -378,38 +378,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v5();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear()
   v5.clear();
-  BOOST_CHECK(v5.empty());
+  BOOST_TEST(v5.empty());
 
   // Assignment to an empty function from a free function
   v5 = &write_five;
-  BOOST_CHECK(!v5.empty());
+  BOOST_TEST(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v5 = &write_three;
-  BOOST_CHECK(!v5.empty());
+  BOOST_TEST(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment
   v5 = five;
-  BOOST_CHECK(!v5.empty());
+  BOOST_TEST(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Construction of a function from a function
   func_void_type v6(&write_five);
@@ -417,20 +417,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v6();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear() method
   v6.clear();
-  BOOST_CHECK(v6.empty());
+  BOOST_TEST(v6.empty());
 
   // Assignment to an empty function
   v6 = three;
-  BOOST_CHECK(!v6.empty());
+  BOOST_TEST(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
   v6 = five;
@@ -438,38 +438,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v6();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear()
   v6.clear();
-  BOOST_CHECK(v6.empty());
+  BOOST_TEST(v6.empty());
 
   // Assignment to an empty function from a free function
   v6 = &write_five;
-  BOOST_CHECK(!v6.empty());
+  BOOST_TEST(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v6 = &write_three;
-  BOOST_CHECK(!v6.empty());
+  BOOST_TEST(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment
   v6 = five;
-  BOOST_CHECK(!v6.empty());
+  BOOST_TEST(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Const vs. non-const
   // Initialization for Borland C++ 5.5
@@ -479,19 +479,19 @@ test_zero_args()
 
   global_int = 0;
   v7();
-  BOOST_CHECK(global_int == 2);
+  BOOST_TEST(global_int == 2);
 
   global_int = 0;
   v8();
-  BOOST_CHECK(global_int == 2);
+  BOOST_TEST(global_int == 2);
 
   // Test construction from 0 and comparison to 0
   func_void_type v9(0);
-  BOOST_CHECK(v9 == 0);
+  BOOST_TEST(v9 == 0);
 # if !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540 || defined(BOOST_STRICT_CONFIG)
-  BOOST_CHECK(0 == v9);
+  BOOST_TEST(0 == v9);
 #else
-  BOOST_CHECK(v9.empty());
+  BOOST_TEST(v9.empty());
 #endif
 
   // Test return values
@@ -501,31 +501,31 @@ test_zero_args()
   generate_three_obj gen_three = generate_three_obj();
   func_int_type i0(gen_five);
 
-  BOOST_CHECK(i0() == 5);
+  BOOST_TEST(i0() == 5);
   i0 = gen_three;
-  BOOST_CHECK(i0() == 3);
+  BOOST_TEST(i0() == 3);
   i0 = &generate_five;
-  BOOST_CHECK(i0() == 5);
+  BOOST_TEST(i0() == 5);
   i0 = &generate_three;
-  BOOST_CHECK(i0() == 3);
+  BOOST_TEST(i0() == 3);
-  BOOST_CHECK(i0? true : false);
+  BOOST_TEST(i0? true : false);
   i0.clear();
-  BOOST_CHECK(!i0? true : false);
+  BOOST_TEST(!i0? true : false);
 
   // Test return values with compatible types
   typedef function0<long> func_long_type;
   func_long_type i1(gen_five);
 
-  BOOST_CHECK(i1() == 5);
+  BOOST_TEST(i1() == 5);
   i1 = gen_three;
-  BOOST_CHECK(i1() == 3);
+  BOOST_TEST(i1() == 3);
   i1 = &generate_five;
-  BOOST_CHECK(i1() == 5);
+  BOOST_TEST(i1() == 5);
   i1 = &generate_three;
-  BOOST_CHECK(i1() == 3);
+  BOOST_TEST(i1() == 3);
-  BOOST_CHECK(i1? true : false);
+  BOOST_TEST(i1? true : false);
   i1.clear();
-  BOOST_CHECK(!i1? true : false);
+  BOOST_TEST(!i1? true : false);
 }
 
 static void
@@ -534,45 +534,45 @@ test_one_arg()
   negate<int> neg = negate<int>(); // Initialization for Borland C++ 5.5
 
   function1<int, int> f1(neg);
-  BOOST_CHECK(f1(5) == -5);
+  BOOST_TEST(f1(5) == -5);
 
   function1<string, string> id(&identity_str);
-  BOOST_CHECK(id("str") == "str");
+  BOOST_TEST(id("str") == "str");
 
   function1<std::string, const char*> id2(&identity_str);
-  BOOST_CHECK(id2("foo") == "foo");
+  BOOST_TEST(id2("foo") == "foo");
 
   add_to_obj add_to(5);
   function1<int, int> f2(add_to);
-  BOOST_CHECK(f2(3) == 8);
+  BOOST_TEST(f2(3) == 8);
 
   const function1<int, int> cf2(add_to);
-  BOOST_CHECK(cf2(3) == 8);
+  BOOST_TEST(cf2(3) == 8);
 }
 
 static void
 test_two_args()
 {
   function2<string, const string&, const string&> cat(&string_cat);
-  BOOST_CHECK(cat("str", "ing") == "string");
+  BOOST_TEST(cat("str", "ing") == "string");
 
   function2<int, short, short> sum(&sum_ints);
-  BOOST_CHECK(sum(2, 3) == 5);
+  BOOST_TEST(sum(2, 3) == 5);
 }
 
 static void
 test_emptiness()
 {
   function0<float> f1;
-  BOOST_CHECK(f1.empty());
+  BOOST_TEST(f1.empty());
 
   function0<float> f2;
   f2 = f1;
-  BOOST_CHECK(f2.empty());
+  BOOST_TEST(f2.empty());
 
   function0<double> f3;
   f3 = f2;
-  BOOST_CHECK(f3.empty());
+  BOOST_TEST(f3.empty());
 }
 
 struct X {
@@ -593,18 +593,18 @@ test_member_functions()
   X one(1);
   X five(5);
 
-  BOOST_CHECK(f1(&one) == 2);
+  BOOST_TEST(f1(&one) == 2);
-  BOOST_CHECK(f1(&five) == 10);
+  BOOST_TEST(f1(&five) == 10);
 
   boost::function1<int, X*> f1_2;
   f1_2 = &X::twice;
 
-  BOOST_CHECK(f1_2(&one) == 2);
+  BOOST_TEST(f1_2(&one) == 2);
-  BOOST_CHECK(f1_2(&five) == 10);
+  BOOST_TEST(f1_2(&five) == 10);
 
   boost::function2<int, X&, int> f2(&X::plus);
-  BOOST_CHECK(f2(one, 3) == 4);
+  BOOST_TEST(f2(one, 3) == 4);
-  BOOST_CHECK(f2(five, 4) == 9);
+  BOOST_TEST(f2(five, 4) == 9);
 }
 
 struct add_with_throw_on_copy {
@@ -629,7 +629,7 @@ test_ref()
   add_with_throw_on_copy atc;
   try {
     boost::function2<int, int, int> f(ref(atc));
-    BOOST_CHECK(f(1, 3) == 4);
+    BOOST_TEST(f(1, 3) == 4);
   }
   catch(std::runtime_error e) {
     BOOST_ERROR("Nonthrowing constructor threw an exception");

test/function_test.cpp

@@ -10,6 +10,7 @@
 #include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
 #include <functional>
+#include <cassert>
 #include <string>
 #include <utility>
 
@@ -55,30 +56,30 @@ test_zero_args()
 
   // Default construction
   func_void_type v1;
-  BOOST_CHECK(v1.empty());
+  BOOST_TEST(v1.empty());
 
   // Assignment to an empty function
   v1 = five;
-  BOOST_CHECK(v1 != 0);
+  BOOST_TEST(v1 != 0);
 
   // Invocation of a function
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear() method
   v1.clear();
-  BOOST_CHECK(v1 == 0);
+  BOOST_TEST(v1 == 0);
 
   // Assignment to an empty function
   v1 = three;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
 
   // Invocation and self-assignment
   global_int = 0;
   v1 = v1;
   v1();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
   v1 = five;
@@ -87,61 +88,61 @@ test_zero_args()
   global_int = 0;
   v1 = (v1);
   v1();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear
   v1 = 0;
-  BOOST_CHECK(0 == v1);
+  BOOST_TEST(0 == v1);
 
   // Assignment to an empty function from a free function
   v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
-  BOOST_CHECK(0 != v1);
+  BOOST_TEST(0 != v1);
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment
   v1 = five;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v1 = &write_three;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Construction from another function (that is empty)
   v1.clear();
   func_void_type v2(v1);
-  BOOST_CHECK(!v2? true : false);
+  BOOST_TEST(!v2? true : false);
 
   // Assignment to an empty function
   v2 = three;
-  BOOST_CHECK(!v2.empty());
+  BOOST_TEST(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
   v2 = (five);
@@ -149,86 +150,86 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   v2.clear();
-  BOOST_CHECK(v2.empty());
+  BOOST_TEST(v2.empty());
 
   // Assignment to an empty function from a free function
   v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
-  BOOST_CHECK(v2? true : false);
+  BOOST_TEST(v2? true : false);
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
-  BOOST_CHECK(!v2.empty());
+  BOOST_TEST(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Swapping
   v1 = five;
   swap(v1, v2);
   v2();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
   v1();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
   swap(v1, v2);
   v1.clear();
 
   // Assignment
   v2 = five;
-  BOOST_CHECK(!v2.empty());
+  BOOST_TEST(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v2 = &write_three;
-  BOOST_CHECK(!v2.empty());
+  BOOST_TEST(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a function from an empty function
   v2 = v1;
-  BOOST_CHECK(v2.empty());
+  BOOST_TEST(v2.empty());
 
   // Assignment to a function from a function with a functor
   v1 = three;
   v2 = v1;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
-  BOOST_CHECK(!v2.empty());
+  BOOST_TEST(!v2.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assign to a function from a function with a function
   v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
   v1 = v2;
-  BOOST_CHECK(!v1.empty());
+  BOOST_TEST(!v1.empty());
-  BOOST_CHECK(!v2.empty());
+  BOOST_TEST(!v2.empty());
   global_int = 0;
   v1();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
   global_int = 0;
   v2();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Construct a function given another function containing a function
   func_void_type v3(v1);
@@ -236,20 +237,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v3();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear() method
   v3.clear();
-  BOOST_CHECK(!v3? true : false);
+  BOOST_TEST(!v3? true : false);
 
   // Assignment to an empty function
   v3 = three;
-  BOOST_CHECK(!v3.empty());
+  BOOST_TEST(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
   v3 = five;
@@ -257,38 +258,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v3();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear()
   v3.clear();
-  BOOST_CHECK(v3.empty());
+  BOOST_TEST(v3.empty());
 
   // Assignment to an empty function from a free function
   v3 = &write_five;
-  BOOST_CHECK(!v3.empty());
+  BOOST_TEST(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v3 = &write_three;
-  BOOST_CHECK(!v3.empty());
+  BOOST_TEST(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment
   v3 = five;
-  BOOST_CHECK(!v3.empty());
+  BOOST_TEST(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Construction of a function from a function containing a functor
   func_void_type v4(v3);
@@ -296,20 +297,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v4();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear() method
   v4.clear();
-  BOOST_CHECK(v4.empty());
+  BOOST_TEST(v4.empty());
 
   // Assignment to an empty function
   v4 = three;
-  BOOST_CHECK(!v4.empty());
+  BOOST_TEST(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
   v4 = five;
@@ -317,38 +318,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v4();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear()
   v4.clear();
-  BOOST_CHECK(v4.empty());
+  BOOST_TEST(v4.empty());
 
   // Assignment to an empty function from a free function
   v4 = &write_five;
-  BOOST_CHECK(!v4.empty());
+  BOOST_TEST(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v4 = &write_three;
-  BOOST_CHECK(!v4.empty());
+  BOOST_TEST(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment
   v4 = five;
-  BOOST_CHECK(!v4.empty());
+  BOOST_TEST(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Construction of a function from a functor
   func_void_type v5(five);
@@ -356,20 +357,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v5();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear() method
   v5.clear();
-  BOOST_CHECK(v5.empty());
+  BOOST_TEST(v5.empty());
 
   // Assignment to an empty function
   v5 = three;
-  BOOST_CHECK(!v5.empty());
+  BOOST_TEST(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
   v5 = five;
@@ -377,38 +378,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v5();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear()
   v5.clear();
-  BOOST_CHECK(v5.empty());
+  BOOST_TEST(v5.empty());
 
   // Assignment to an empty function from a free function
   v5 = &write_five;
-  BOOST_CHECK(!v5.empty());
+  BOOST_TEST(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v5 = &write_three;
-  BOOST_CHECK(!v5.empty());
+  BOOST_TEST(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment
   v5 = five;
-  BOOST_CHECK(!v5.empty());
+  BOOST_TEST(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Construction of a function from a function
   func_void_type v6(&write_five);
@@ -416,20 +417,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v6();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear() method
   v6.clear();
-  BOOST_CHECK(v6.empty());
+  BOOST_TEST(v6.empty());
 
   // Assignment to an empty function
   v6 = three;
-  BOOST_CHECK(!v6.empty());
+  BOOST_TEST(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
   v6 = five;
@@ -437,38 +438,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v6();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // clear()
   v6.clear();
-  BOOST_CHECK(v6.empty());
+  BOOST_TEST(v6.empty());
 
   // Assignment to an empty function from a free function
   v6 = &write_five;
-  BOOST_CHECK(!v6.empty());
+  BOOST_TEST(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v6 = &write_three;
-  BOOST_CHECK(!v6.empty());
+  BOOST_TEST(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_CHECK(global_int == 3);
+  BOOST_TEST(global_int == 3);
 
   // Assignment
   v6 = five;
-  BOOST_CHECK(!v6.empty());
+  BOOST_TEST(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_CHECK(global_int == 5);
+  BOOST_TEST(global_int == 5);
 
   // Const vs. non-const
   write_const_1_nonconst_2 one_or_two;
@@ -477,16 +478,16 @@ test_zero_args()
 
   global_int = 0;
   v7();
-  BOOST_CHECK(global_int == 2);
+  BOOST_TEST(global_int == 2);
 
   global_int = 0;
   v8();
-  BOOST_CHECK(global_int == 2);
+  BOOST_TEST(global_int == 2);
 
   // Test construction from 0 and comparison to 0
   func_void_type v9(0);
-  BOOST_CHECK(v9 == 0);
+  BOOST_TEST(v9 == 0);
-  BOOST_CHECK(0 == v9);
+  BOOST_TEST(0 == v9);
 
   // Test return values
   typedef function<int ()> func_int_type;
@@ -495,31 +496,31 @@ test_zero_args()
 
   func_int_type i0(gen_five);
 
-  BOOST_CHECK(i0() == 5);
+  BOOST_TEST(i0() == 5);
   i0 = gen_three;
-  BOOST_CHECK(i0() == 3);
+  BOOST_TEST(i0() == 3);
   i0 = &generate_five;
-  BOOST_CHECK(i0() == 5);
+  BOOST_TEST(i0() == 5);
   i0 = &generate_three;
-  BOOST_CHECK(i0() == 3);
+  BOOST_TEST(i0() == 3);
-  BOOST_CHECK(i0? true : false);
+  BOOST_TEST(i0? true : false);
   i0.clear();
-  BOOST_CHECK(!i0? true : false);
+  BOOST_TEST(!i0? true : false);
 
   // Test return values with compatible types
   typedef function<long ()> func_long_type;
   func_long_type i1(gen_five);
 
-  BOOST_CHECK(i1() == 5);
+  BOOST_TEST(i1() == 5);
   i1 = gen_three;
-  BOOST_CHECK(i1() == 3);
+  BOOST_TEST(i1() == 3);
   i1 = &generate_five;
-  BOOST_CHECK(i1() == 5);
+  BOOST_TEST(i1() == 5);
   i1 = &generate_three;
-  BOOST_CHECK(i1() == 3);
+  BOOST_TEST(i1() == 3);
-  BOOST_CHECK(i1? true : false);
+  BOOST_TEST(i1? true : false);
   i1.clear();
-  BOOST_CHECK(!i1? true : false);
+  BOOST_TEST(!i1? true : false);
 }
 
 static void
@@ -528,45 +529,45 @@ test_one_arg()
   negate<int> neg;
 
   function<int (int)> f1(neg);
-  BOOST_CHECK(f1(5) == -5);
+  BOOST_TEST(f1(5) == -5);
 
   function<string (string)> id(&identity_str);
-  BOOST_CHECK(id("str") == "str");
+  BOOST_TEST(id("str") == "str");
 
   function<string (const char*)> id2(&identity_str);
-  BOOST_CHECK(id2("foo") == "foo");
+  BOOST_TEST(id2("foo") == "foo");
 
   add_to_obj add_to(5);
   function<int (int)> f2(add_to);
-  BOOST_CHECK(f2(3) == 8);
+  BOOST_TEST(f2(3) == 8);
 
   const function<int (int)> cf2(add_to);
-  BOOST_CHECK(cf2(3) == 8);
+  BOOST_TEST(cf2(3) == 8);
 }
 
 static void
 test_two_args()
 {
   function<string (const string&, const string&)> cat(&string_cat);
-  BOOST_CHECK(cat("str", "ing") == "string");
+  BOOST_TEST(cat("str", "ing") == "string");
 
   function<int (short, short)> sum(&sum_ints);
-  BOOST_CHECK(sum(2, 3) == 5);
+  BOOST_TEST(sum(2, 3) == 5);
 }
 
 static void
 test_emptiness()
 {
   function<float ()> f1;
-  BOOST_CHECK(f1.empty());
+  BOOST_TEST(f1.empty());
 
   function<float ()> f2;
   f2 = f1;
-  BOOST_CHECK(f2.empty());
+  BOOST_TEST(f2.empty());
 
   function<double ()> f3;
   f3 = f2;
-  BOOST_CHECK(f3.empty());
+  BOOST_TEST(f3.empty());
 }
 
 struct X {
@@ -586,18 +587,18 @@ test_member_functions()
   X one(1);
   X five(5);
 
-  BOOST_CHECK(f1(&one) == 2);
+  BOOST_TEST(f1(&one) == 2);
-  BOOST_CHECK(f1(&five) == 10);
+  BOOST_TEST(f1(&five) == 10);
 
   boost::function<int (X*)> f1_2;
   f1_2 = &X::twice;
 
-  BOOST_CHECK(f1_2(&one) == 2);
+  BOOST_TEST(f1_2(&one) == 2);
-  BOOST_CHECK(f1_2(&five) == 10);
+  BOOST_TEST(f1_2(&five) == 10);
 
   boost::function<int (X&, int)> f2(&X::plus);
-  BOOST_CHECK(f2(one, 3) == 4);
+  BOOST_TEST(f2(one, 3) == 4);
-  BOOST_CHECK(f2(five, 4) == 9);
+  BOOST_TEST(f2(five, 4) == 9);
 }
 
 struct add_with_throw_on_copy {
@@ -622,19 +623,83 @@ test_ref()
   add_with_throw_on_copy atc;
   try {
     boost::function<int (int, int)> f(ref(atc));
-    BOOST_CHECK(f(1, 3) == 4);
+    BOOST_TEST(f(1, 3) == 4);
   }
   catch(runtime_error e) {
     BOOST_ERROR("Nonthrowing constructor threw an exception");
   }
 }
 
+static int alloc_count = 0;
+static int dealloc_count = 0;
+
+template<typename T>
+struct counting_allocator : public allocator<T>
+{
+  template<typename U>
+  struct rebind
+  {
+    typedef counting_allocator<U> other;
+  };
+
+
+  T* allocate(size_t n)
+  {
+    alloc_count++;
+    return allocator<T>::allocate(n);
+  }
+
+  void deallocate(T* p, size_t n)
+  {
+    dealloc_count++;
+    allocator<T>::deallocate(p, n);
+  }
+};
+
+static int do_minus(int x, int y) { return x-y; }
+
+struct DoNothing
+{
+  void operator()() const {}
+};
+
+static void do_nothing() {}
+
+static void test_allocator()
+{
+#ifndef BOOST_NO_STD_ALLOCATOR
+  boost::function<int (int, int), counting_allocator<int> > f;
+  f = plus<int>();
+  f.clear();
+  BOOST_TEST(alloc_count == 1);
+  BOOST_TEST(dealloc_count == 1);
+
+  alloc_count = 0;
+  dealloc_count = 0;
+  f = &do_minus;
+  f.clear();
+
+  boost::function<void (), counting_allocator<int> > fv;
+  alloc_count = 0;
+  dealloc_count = 0;
+  fv = DoNothing();
+  fv.clear();
+  BOOST_TEST(alloc_count == 1);
+  BOOST_TEST(dealloc_count == 1);
+
+  alloc_count = 0;
+  dealloc_count = 0;
+  fv = &do_nothing;
+  fv.clear();
+#endif // ndef BOOST_NO_STD_ALLOCATOR
+}
+
 static void test_exception()
 {
   boost::function<int (int, int)> f;
   try {
     f(5, 4);
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   catch(boost::bad_function_call) {
     // okay
@@ -652,12 +717,12 @@ static void test_implicit()
 
 static void test_call_obj(boost::function<int (int, int)> f)
 {
-  BOOST_CHECK(!f.empty());
+  assert(!f.empty());
 }
 
 static void test_call_cref(const boost::function<int (int, int)>& f)
 {
-  BOOST_CHECK(!f.empty());
+  assert(!f.empty());
 }
 
 static void test_call()
@@ -674,6 +739,7 @@ int test_main(int, char* [])
   test_emptiness();
   test_member_functions();
   test_ref();
+  test_allocator();
   test_exception();
   test_implicit();
   test_call();

test/function_test_fail1.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright (C) Douglas Gregor 2001-2005. Use, modification and
+//  Copyright Douglas Gregor 2001-2003. 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_ERROR("This should not have compiled.");
+  BOOST_CRITICAL_ERROR("This should not have compiled.");
 
   return 0;
 }

test/function_test_fail2.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright (C) Douglas Gregor 2001-2005. Use, modification and
+//  Copyright Douglas Gregor 2001-2003. 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_ERROR("This should not have compiled.");
+  BOOST_CRITICAL_ERROR("This should not have compiled.");
 
   return 0;
 }

test/stateless_test.cpp

@@ -14,21 +14,23 @@
 struct stateless_integer_add {
   int operator()(int x, int y) const { return x+y; }
 
-  void* operator new(std::size_t)
+  void* operator new(std::size_t, stateless_integer_add*)
   {
     throw std::runtime_error("Cannot allocate a stateless_integer_add");
   }
 
-  void* operator new(std::size_t, void* p)
+  void operator delete(void*, stateless_integer_add*) throw()
-  {
-    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;