This commit was manufactured by cvs2svn to create tag

'Version_1_31_0'.

[SVN r22162]

doc/Jamfile.v2

@@ -1,16 +1,5 @@
-#   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-#   Distributed under 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)
 project boost/doc ;
 import boostbook : boostbook ;
 
-boostbook function-doc 
+boostbook function-doc : function.xml ;
-    : 
-    function.xml 
-    :
-        <xsl:param>boost.root=../../../..
-        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
-    ;
 

doc/faq.xml

@@ -1,11 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under 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)
-  -->
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 <section id="function.faq" last-revision="$Date$">
@@ -139,25 +132,6 @@ function objects with parameters that don't exactly match.</para>
       application a reference-counting allocator could be used.</para>
     </answer>
   </qandaentry>
-
-  <qandaentry>
-    <question><para>How much overhead does a call through <code><classname>boost::function</classname></code> incur?</para></question>
-    <answer>
-      <para>The cost of <code>boost::function</code> can be reasonably
-      consistently measured at around 20ns +/- 10 ns on a modern >2GHz
-      platform versus directly inlining the code.</para>
-
-      <para>However, the performance of your application may benefit
-      from or be disadvantaged by <code>boost::function</code>
-      depending on how your C++ optimiser optimises.  Similar to a
-      standard function pointer, differences of order of 10% have been
-      noted to the benefit or disadvantage of using
-      <code>boost::function</code> to call a function that contains a
-      tight loop depending on your compilation circumstances.</para>
-     
-      <para>[Answer provided by Matt Hurd. See <ulink url="http://article.gmane.org/gmane.comp.lib.boost.devel/33278"/>]</para>
-    </answer>
-  </qandaentry>
 </qandaset> 
 
 </section>

doc/function.xml

@@ -8,14 +8,13 @@
   <author>
     <firstname>Douglas</firstname>
     <surname>Gregor</surname>
-    <email>dgregor -at- cs.indiana.edu</email>
+     <email>gregod@cs.rpi.edu</email>
   </author>
 
   <copyright>
     <year>2001</year>
     <year>2002</year>
     <year>2003</year>
-    <year>2004</year>
     <holder>Douglas Gregor</holder>
   </copyright>
 

doc/history.xml

@@ -1,61 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under 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)
-  -->
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 <section id="function.history" last-revision="$Date$">
   <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.37.0</bold>: </para>
-    <itemizedlist spacing="compact">
-      <listitem><para>Improved the performance of Boost.Function's
-      swap() operation for large function objects. Original patch
-      contributed by Niels Dekker.</para></listitem>
-
-      <listitem><para>Added a new header &lt;boost/function/function_typeof.hpp&gt; that provides support for using the Boost.Typeof library on Boost.Function objects.</para></listitem>
-
-      <listitem><para>Added a new header &lt;boost/function/function_fwd.hpp&gt; that provides support for using the Boost.Typeof library on Boost.Function objects.</para></listitem>
-
-      <listitem><para>The <methodname alt="boost::function::target">target</methodname>()
-      function now respects the cv-qualifiers of function objects
-      stored by reference
-      (using <classname>boost::reference_wrapper</classname>), such
-      that a reference to a <code>const</code> function object cannot
-      be accessed as a reference to a non-<code>const</code> function
-      object.</para></listitem>
-    </itemizedlist>
-  </listitem>
-
-  <listitem><para><bold>Version 1.36.0</bold>: </para>
-    <itemizedlist spacing="compact">
-      <listitem><para>Boost.Function now implements allocator support
-      in the same way that is is provided in C++0x, based on C++
-      committee
-      proposal <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2308.html">N2308</ulink>. This
-      change removes the <computeroutput>Allocator</computeroutput>
-      template parameter of <classname>boost::function</classname> in
-      favor of a constructor that takes an argument. While this is a
-      backward-incompatible change, it is likely to affect only a few
-      users. This change to Function was contributed by Emil
-      Dotchevski, which also authored the corresponding C++ committee
-      proposal.</para></listitem>
-    </itemizedlist>
-  </listitem>
-
-  <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>
@@ -82,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/misc.xml

@@ -1,11 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under 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)
-  -->
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 <section id="function.misc" last-revision="$Date$">
@@ -24,7 +17,7 @@
 <para> And, of course, function pointers have several advantages over Boost.Function:
 
 <itemizedlist spacing="compact">
-    <listitem><para> Function pointers are smaller (the size of one pointer instead of four or more) </para></listitem>
+    <listitem><para> Function pointers are smaller (the size of one pointer instead of three) </para></listitem>
     <listitem><para> Function pointers are faster (Boost.Function may require two calls through function pointers) </para></listitem>
     <listitem><para> Function pointers are backward-compatible with C libraries.</para></listitem>
     <listitem><para> More readable error messages. </para></listitem>
@@ -37,12 +30,12 @@
 
 <section>
   <title>Function object wrapper size</title>
-  <para> Function object wrappers will be the size of a struct containing a member function pointer and two data pointers. The actual size can vary significantly depending on the underlying platform; on 32-bit Mac OS X with GCC, this amounts to 16 bytes, while it is 32 bytes Windows with Visual C++. Additionally, the function object target may be allocated on the heap, if it cannot be placed into the small-object buffer in the <code>boost::function</code> object.</para>
+<para> Function object wrappers will be the size of two function pointers plus one function pointer or data pointer (whichever is larger). On common 32-bit platforms, this amounts to 12 bytes per wrapper. Additionally, the function object target will be allocated on the heap.</para>
 </section>
 
 <section>
   <title>Copying efficiency</title>
-  <para> Copying function object wrappers may require allocating memory for a copy of the function object target. The default allocator may be replaced with a faster custom allocator or one may choose to allow the function object wrappers to only store function object targets by reference (using <computeroutput>ref</computeroutput>) if the cost of this cloning becomes prohibitive. Small function objects can be stored within the <code>boost::function</code> object itself, improving copying efficiency.</para>
+<para> Copying function object wrappers may require allocating memory for a copy of the function object target. The default allocator may be replaced with a faster custom allocator or one may choose to allow the function object wrappers to only store function object targets by reference (using <computeroutput>ref</computeroutput>) if the cost of this cloning becomes prohibitive.</para>
  </section>
 
 <section>

doc/reference.xml

@@ -1,11 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under 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)
-  -->
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 
@@ -86,49 +79,7 @@
     <method-group name="capacity">
       <method name="empty" cv="const">
         <type>bool</type>
-        <returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
+        <returns><simpara><code>true</code> if <code>this</code> has a target, and <code>false</code> otherwise.</simpara></returns>
-        <throws><simpara>Will not throw.</simpara></throws>
-      </method>
-    </method-group>
-
-    <method-group name="target access">
-      <overloaded-method name="target">
-        <signature>
-          <template> 
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>Functor*</type>
-        </signature>
-        <signature cv="const">
-          <template> 
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>const Functor*</type>
-        </signature>
-
-        <returns><simpara>If <code>this</code> stores a target of type
-        <code>Functor</code>, returns the address of the
-        target. Otherwise, returns the NULL
-        pointer.</simpara></returns>
-
-        <throws><simpara>Will not throw.</simpara></throws>
-      </overloaded-method>
-
-      <method name="contains" cv="const">
-        <template>
-          <template-type-parameter name="Functor"/>
-        </template>
-        <type>bool</type>
-        <parameter name="f">
-          <paramtype>const Functor&amp;</paramtype>
-        </parameter>
-        <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>
@@ -141,6 +92,9 @@
       <template-type-parameter name="T2"/>
       <template-varargs/>
       <template-type-parameter name="TN"/>
+      <template-type-parameter name="Allocator">
+        <default><classname>std::allocator</classname>&lt;void&gt;</default>
+      </template-type-parameter>
     </template>
 
     <inherit access="public"><classname>function_base</classname></inherit>
@@ -157,6 +111,7 @@
     </description>
 
     <typedef name="result_type"><type>R</type></typedef>
+    <typedef name="allocator_type"><type>Allocator</type></typedef>
     <typedef name="argument_type">
       <type>T1</type><purpose>If N == 1</purpose>
     </typedef>
@@ -191,7 +146,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>
 
@@ -210,23 +165,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>
-    </constructor>
+      <throws><simpara>Will not throw when <code>f</code> is a stateless function object.</simpara></throws>
-
-    <constructor>
-      <template>
-        <template-type-parameter name="F"/>
-        <template-type-parameter name="Allocator"/>
-      </template>
-      <parameter name="f"><paramtype>F</paramtype></parameter>
-      <parameter name="alloc"><paramtype>Allocator</paramtype></parameter>
-      <requires><simpara>F is a function object Callable from <code>this</code>, Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw.</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>
-
-      <effects><simpara>If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory.</simpara></effects>
     </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>
 
@@ -234,7 +177,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">
@@ -242,18 +186,20 @@
         <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>
 
     <method-group name="capacity">
       <method name="empty" cv="const">
         <type>bool</type>
-        <returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
+        <returns><simpara><code>true</code> if <code>this</code> has a target, and <code>false</code> otherwise.</simpara></returns>
         <throws><simpara>Will not throw.</simpara></throws>
       </method>
 
@@ -270,49 +216,6 @@
       </method>
     </method-group>
 
-    <method-group name="target access">
-      <overloaded-method name="target">
-        <signature>
-          <template> 
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>Functor*</type>
-        </signature>
-        <signature cv="const">
-          <template> 
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>const Functor*</type>
-        </signature>
-
-        <returns><simpara>If <code>this</code> stores a target of type
-        <code>Functor</code>, returns the address of the
-        target. Otherwise, returns the NULL
-        pointer.</simpara></returns>
-
-        <throws><simpara>Will not throw.</simpara></throws>
-      </overloaded-method>
-
-      <method name="contains" cv="const">
-        <template>
-          <template-type-parameter name="Functor"/>
-        </template>
-        <type>bool</type>
-        <parameter name="f">
-          <paramtype>const Functor&amp;</paramtype>
-        </parameter>
-        <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">
       <method name="operator()" cv="const">
         <type>result_type</type>
@@ -322,7 +225,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>
 
@@ -333,204 +236,56 @@
           <template-type-parameter name="T2"/>
           <template-varargs/>
           <template-type-parameter name="TN"/>
+          <template-type-parameter name="Allocator"/>
         </template>
         <type>void</type>
-        <parameter name="f1"><paramtype><classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
+        <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&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>
 
-    <free-function-group name="comparison operators">
+    <free-function-group name="undefined operators">
-      <overloaded-function name="operator==">
+      <function name="operator==">
-        <signature>
+        <template>
-          <template>
+          <template-type-parameter name="T1"/>
-            <template-type-parameter name="T1"/>
+          <template-type-parameter name="T2"/>
-            <template-type-parameter name="T2"/>
+          <template-varargs/>
-            <template-varargs/>
+          <template-type-parameter name="TN"/>
-            <template-type-parameter name="TN"/>
+          <template-type-parameter name="Allocator1"/>
-            <template-type-parameter name="Functor"/>
+          <template-type-parameter name="U1"/>
-          </template>
+          <template-type-parameter name="U2"/>
-          <type>bool</type>
+          <template-varargs/>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
+          <template-type-parameter name="UN"/>
-          <parameter name="g"><paramtype>Functor</paramtype></parameter>
+          <template-type-parameter name="Allocator2"/>
-        </signature>
+        </template>
-        <signature>
+        <type>void</type>
-          <template>
+        <parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator1&gt;&amp;</paramtype></parameter>
-            <template-type-parameter name="T1"/>
+        <parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN, Allocator2&gt;&amp;</paramtype></parameter>
-            <template-type-parameter name="T2"/>
+        <notes><simpara>This function must be left undefined.</simpara></notes>
-            <template-varargs/>
+        <rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>==</code>. This undefined <code>void operator ==</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
-            <template-type-parameter name="TN"/>
+      </function>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="g"><paramtype>Functor</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
-        </signature>        
-        <signature>
-          <template>
-            <template-type-parameter name="T1"/>
-            <template-type-parameter name="T2"/>
-            <template-varargs/>
-            <template-type-parameter name="TN"/>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
-          <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
-        </signature>
-        <signature>
-          <template>
-            <template-type-parameter name="T1"/>
-            <template-type-parameter name="T2"/>
-            <template-varargs/>
-            <template-type-parameter name="TN"/>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
-        </signature>        
-        <signature>
-          <template>
-            <template-type-parameter name="T1"/>
-            <template-type-parameter name="T2"/>
-            <template-varargs/>
-            <template-type-parameter name="TN"/>
-            <template-type-parameter name="U1"/>
-            <template-type-parameter name="U2"/>
-            <template-varargs/>
-            <template-type-parameter name="UN"/>
-          </template>
-          <type>void</type>
-          <parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
-          <parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN&gt;&amp;</paramtype></parameter>
-        </signature>
 
-        <returns><simpara>True when <code>f</code> stores an object of
+      <function name="operator!=">
-        type <code>Functor</code> and one of the following conditions applies:
+        <template>
-          <itemizedlist>
+          <template-type-parameter name="T1"/>
-
+          <template-type-parameter name="T2"/>
-            <listitem><simpara><code>g</code> is of type
+          <template-varargs/>
-            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
+          <template-type-parameter name="TN"/>
-            and <code>f.target&lt;Functor&gt;() == g.<methodname
+          <template-type-parameter name="Allocator1"/>
-            alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
+          <template-type-parameter name="U1"/>
-
+          <template-type-parameter name="U2"/>
-            <listitem><simpara><code>g</code> is not of type
+          <template-varargs/>
-            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
+          <template-type-parameter name="UN"/>
-            and
+          <template-type-parameter name="Allocator2"/>
-            <code><functionname>function_equal</functionname>(*(f.target&lt;Functor&gt;()),
+        </template>
-            g)</code>.</simpara></listitem>
+        <type>void</type>
-
+        <parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator1&gt;&amp;</paramtype></parameter>
-          </itemizedlist>
+        <parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN, Allocator2&gt;&amp;</paramtype></parameter>
-          </simpara></returns>
+        <notes><simpara>This function must be left undefined.</simpara></notes>
-
+        <rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>!=</code>. This undefined <code>void operator !=</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
-        <notes><simpara><code><classname>functionN</classname></code>
+      </function>
-        objects are not
-        <conceptname>EqualityComparable</conceptname>.</simpara></notes>
-
-        <rationale><simpara>The <code>safe_bool</code> conversion
-        opens a loophole whereby two <code>functionN</code>
-        instances can be compared via <code>==</code>, although this
-        is not feasible to implement. The undefined <code>void
-        operator==</code> closes the loophole and ensures a
-        compile-time or link-time error.</simpara></rationale>
-      </overloaded-function>
-
-      <overloaded-function name="operator!=">
-        <signature>
-          <template>
-            <template-type-parameter name="T1"/>
-            <template-type-parameter name="T2"/>
-            <template-varargs/>
-            <template-type-parameter name="TN"/>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
-          <parameter name="g"><paramtype>Functor</paramtype></parameter>
-        </signature>
-        <signature>
-          <template>
-            <template-type-parameter name="T1"/>
-            <template-type-parameter name="T2"/>
-            <template-varargs/>
-            <template-type-parameter name="TN"/>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="g"><paramtype>Functor</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
-        </signature>        
-        <signature>
-          <template>
-            <template-type-parameter name="T1"/>
-            <template-type-parameter name="T2"/>
-            <template-varargs/>
-            <template-type-parameter name="TN"/>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
-          <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
-        </signature>
-        <signature>
-          <template>
-            <template-type-parameter name="T1"/>
-            <template-type-parameter name="T2"/>
-            <template-varargs/>
-            <template-type-parameter name="TN"/>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
-        </signature>        
-        <signature>
-          <template>
-            <template-type-parameter name="T1"/>
-            <template-type-parameter name="T2"/>
-            <template-varargs/>
-            <template-type-parameter name="TN"/>
-            <template-type-parameter name="U1"/>
-            <template-type-parameter name="U2"/>
-            <template-varargs/>
-            <template-type-parameter name="UN"/>
-          </template>
-          <type>void</type>
-          <parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
-          <parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN&gt;&amp;</paramtype></parameter>
-        </signature>
-
-        <returns><simpara>True when <code>f</code> does not store an
-        object of type <code>Functor</code> or it stores an object of
-        type <code>Functor</code> and one of the following conditions
-        applies:
-          <itemizedlist>
-
-            <listitem><simpara><code>g</code> is of type
-            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
-            and <code>f.target&lt;Functor&gt;() != g.<methodname
-            alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
-
-            <listitem><simpara><code>g</code> is not of type
-            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
-            and <code>!<functionname>function_equal</functionname>(*(f.target&lt;Functor&gt;()), g)</code>.</simpara></listitem>
-
-          </itemizedlist>
-          </simpara></returns>
-
-        <notes><simpara><code><classname>functionN</classname></code>
-        objects are not
-        <conceptname>EqualityComparable</conceptname>.</simpara></notes>
-
-        <rationale><simpara>The <code>safe_bool</code> conversion
-        opens a loophole whereby two <code>functionN</code>
-        instances can be compared via <code>!=</code>, although this
-        is not feasible to implement. The undefined <code>void
-        operator!=</code> closes the loophole and ensures a
-        compile-time or link-time error.</simpara></rationale>
-      </overloaded-function>
     </free-function-group>
   </class>
 
@@ -539,8 +294,11 @@
       <template-type-parameter name="Signature">
         <purpose>Function type R (T1, T2, ..., TN)</purpose>
       </template-type-parameter>
+      <template-type-parameter name="Allocator">
+        <default><classname>std::allocator</classname>&lt;void&gt;</default>
+      </template-type-parameter>
     </template>
-    <inherit access="public"><classname>functionN</classname>&lt;R, T1, T2, ..., TN&gt;</inherit>
+    <inherit access="public"><classname>functionN</classname>&lt;R, T1, T2, ..., TN, Allocator&gt;</inherit>
 
     <purpose>A generalized function pointer that can be used for
     callbacks or wrapping function objects.</purpose>
@@ -562,6 +320,7 @@
     </description>
 
     <typedef name="result_type"><type>R</type></typedef>
+    <typedef name="allocator_type"><type>Allocator</type></typedef>
     <typedef name="argument_type">
       <type>T1</type><purpose>If N == 1</purpose>
     </typedef>
@@ -596,7 +355,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>
 
@@ -623,39 +382,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>
-    </constructor>
+      <throws><simpara>Will not throw when <code>f</code> is a stateless function object.</simpara></throws>
-
-    <constructor>
-      <template>
-        <template-type-parameter name="F"/>
-        <template-type-parameter name="Allocator"/>
-      </template>
-      <parameter name="f"><paramtype>F</paramtype></parameter>
-      <parameter name="alloc"><paramtype>Allocator</paramtype></parameter>
-      <requires><simpara>F is a function object Callable from <code>this</code>, Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw.</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>
-
-      <effects><simpara>If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory.</simpara></effects>
     </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">
@@ -663,6 +411,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">
@@ -675,7 +424,7 @@
     <method-group name="capacity">
       <method name="empty" cv="const">
         <type>bool</type>
-        <returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
+        <returns><simpara><code>true</code> if <code>this</code> has a target, and <code>false</code> otherwise.</simpara></returns>
         <throws><simpara>Will not throw.</simpara></throws>
       </method>
 
@@ -692,47 +441,6 @@
       </method>
     </method-group>
 
-    <method-group name="target access">
-      <overloaded-method name="target">
-        <signature>
-          <template> 
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>Functor*</type>
-        </signature>
-        <signature cv="const">
-          <template> 
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>const Functor*</type>
-        </signature>
-
-        <returns><simpara>If <code>this</code> stores a target of type
-        <code>Functor</code>, returns the address of the
-        target. Otherwise, returns the NULL
-        pointer.</simpara></returns>
-        <throws><simpara>Will not throw.</simpara></throws>
-      </overloaded-method>
-
-      <method name="contains" cv="const">
-        <template>
-          <template-type-parameter name="Functor"/>
-        </template>
-        <type>bool</type>
-        <parameter name="f">
-          <paramtype>const Functor&amp;</paramtype>
-        </parameter>
-        <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">
       <method name="operator()" cv="const">
         <type>result_type</type>
@@ -742,7 +450,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>
 
@@ -750,189 +458,46 @@
       <function name="swap">
         <template>
           <template-type-parameter name="Signature"/>
+          <template-type-parameter name="Allocator"/>
         </template>
         <type>void</type>
-        <parameter name="f1"><paramtype><classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
+        <parameter name="f1"><paramtype><classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
-        <parameter name="f2"><paramtype><classname>function</classname>&lt;Signature&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>
 
-    <free-function-group name="comparison operators">
+    <free-function-group name="undefined operators">
-      <overloaded-function name="operator==">
+      <function name="operator==">
-        <signature>
+        <template>
-          <template>
+          <template-type-parameter name="Signature1"/>
-            <template-type-parameter name="Signature"/>
+          <template-type-parameter name="Allocator1"/>
-            <template-type-parameter name="Functor"/>
+          <template-type-parameter name="Signature2"/>
-          </template>
+          <template-type-parameter name="Allocator2"/>
-          <type>bool</type>
+        </template>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
+        <type>void</type>
-          <parameter name="g"><paramtype>Functor</paramtype></parameter>
+        <parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1, Allocator1&gt;&amp;</paramtype></parameter>
-        </signature>
+        <parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2, Allocator2&gt;&amp;</paramtype></parameter>
-        <signature>
+        <notes><simpara>This function must be left undefined.</simpara></notes>
-          <template>
+        <rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>==</code>. This undefined <code>void operator ==</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
-            <template-type-parameter name="Signature"/>
+      </function>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="g"><paramtype>Functor</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
-        </signature>        
-        <signature>
-          <template>
-            <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
-          <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
-        </signature>
-        <signature>
-          <template>
-            <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
-        </signature>        
-        <signature>
-          <template>
-            <template-type-parameter name="Signature1"/>
-            <template-type-parameter name="Signature2"/>
-          </template>
-          <type>void</type>
-          <parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1&gt;&amp;</paramtype></parameter>
-          <parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2&gt;&amp;</paramtype></parameter>
-        </signature>
 
-        <returns><simpara>True when <code>f</code> stores an object of
+      <function name="operator!=">
-        type <code>Functor</code> and one of the following conditions applies:
+        <template>
-          <itemizedlist>
+          <template-type-parameter name="Signature1"/>
-
+          <template-type-parameter name="Allocator1"/>
-            <listitem><simpara><code>g</code> is of type
+          <template-type-parameter name="Signature2"/>
-            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
+          <template-type-parameter name="Allocator2"/>
-            and <code>f.target&lt;Functor&gt;() == g.<methodname
+        </template>
-            alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
+        <type>void</type>
-
+        <parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1, Allocator1&gt;&amp;</paramtype></parameter>
-            <listitem><simpara><code>g</code> is not of type
+        <parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2, Allocator2&gt;&amp;</paramtype></parameter>
-            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
+        <notes><simpara>This function must be left undefined.</simpara></notes>
-            and <code><functionname>function_equals</functionname>(*(f.target&lt;Functor&gt;()), g)</code>.</simpara></listitem>
+        <rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>!=</code>. This undefined <code>void operator !=</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
-
+      </function>
-          </itemizedlist>
-          </simpara></returns>
-
-        <notes><simpara><code><classname>function</classname></code>
-        objects are not
-        <conceptname>EqualityComparable</conceptname>.</simpara></notes>
-
-        <rationale><simpara>The <code>safe_bool</code> conversion
-        opens a loophole whereby two <code>function</code>
-        instances can be compared via <code>==</code>, although this
-        is not feasible to implement. The undefined <code>void
-        operator==</code> closes the loophole and ensures a
-        compile-time or link-time error.</simpara></rationale>
-      </overloaded-function>
-
-      <overloaded-function name="operator!=">
-        <signature>
-          <template>
-            <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
-          <parameter name="g"><paramtype>Functor</paramtype></parameter>
-        </signature>
-        <signature>
-          <template>
-            <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="g"><paramtype>Functor</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
-        </signature>        
-        <signature>
-          <template>
-            <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
-          <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
-        </signature>
-        <signature>
-          <template>
-            <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Functor"/>
-          </template>
-          <type>bool</type>
-          <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
-        </signature>        
-        <signature>
-          <template>
-            <template-type-parameter name="Signature1"/>
-            <template-type-parameter name="Signature2"/>
-          </template>
-          <type>void</type>
-          <parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1&gt;&amp;</paramtype></parameter>
-          <parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2&gt;&amp;</paramtype></parameter>
-        </signature>
-
-        <returns><simpara>True when <code>f</code> does not store an
-        object of type <code>Functor</code> or it stores an object of
-        type <code>Functor</code> and one of the following conditions
-        applies:
-          <itemizedlist>
-
-            <listitem><simpara><code>g</code> is of type
-            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
-            and <code>f.target&lt;Functor&gt;() != g.<methodname
-            alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
-
-            <listitem><simpara><code>g</code> is not of type
-            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
-            and <code>!<functionname>function_equals</functionname>(*(f.target&lt;Functor&gt;()), g)</code>.</simpara></listitem>
-
-          </itemizedlist>
-          </simpara></returns>
-
-        <notes><simpara><code><classname>function</classname></code>
-        objects are not
-        <conceptname>EqualityComparable</conceptname>.</simpara></notes>
-
-        <rationale><simpara>The <code>safe_bool</code> conversion
-        opens a loophole whereby two <code>function</code>
-        instances can be compared via <code>!=</code>, although this
-        is not feasible to implement. The undefined <code>void
-        operator!=</code> closes the loophole and ensures a
-        compile-time or link-time error.</simpara></rationale>
-      </overloaded-function>
     </free-function-group>
   </class>
 </namespace>
 </header>
-
-<header name="boost/function_equal.hpp">
-  <namespace name="boost">
-  <function name="function_equal">
-    <template>
-      <template-type-parameter name="F"/>
-      <template-type-parameter name="G"/>
-    </template>
-    <type>bool</type>
-    <parameter name="f">
-      <paramtype>const F&amp;</paramtype>
-    </parameter>
-    <parameter name="g">
-      <paramtype>const G&amp;</paramtype>
-    </parameter>
-    <purpose><simpara>Compare two function objects for equality.</simpara></purpose>
-    <returns><simpara><code>f == g</code>.</simpara></returns>
-    <throws><simpara>Only if <code>f == g</code> throws.</simpara></throws>
-  </function>
-  </namespace>
-</header>
 </library-reference>

doc/tests.xml

@@ -1,11 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under 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)
-  -->
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 <testsuite id="function.testsuite" last-revision="$Date$">
@@ -33,12 +26,6 @@
     <if-fails><para>Either Boost.Lambda does not work on the platform, or Boost.Function cannot safely be applied without the use of <functionname>boost::unlambda</functionname>.</para></if-fails>
   </run-test>
 
-  <run-test filename="contains_test.cpp">
-    <purpose><para>Test the operation of the
-    <code><methodname>target</methodname></code> member function and the
-    equality operators.</para></purpose>
-  </run-test>
-
   <compile-fail-test filename="function_test_fail1.cpp">
     <purpose><para>Test the (incorrect!) use of comparisons between Boost.Function function objects.</para></purpose>
     <if-fails><para>Intuitive (but incorrect!) code may compile and will give meaningless results.</para></if-fails>

doc/tutorial.xml

@@ -1,11 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under 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)
-  -->
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 <section xmlns:xi="http://www.w3.org/2001/XInclude" id="function.tutorial"
@@ -35,12 +28,12 @@ form to use for your compiler.
         <row>
           <entry>
             <itemizedlist spacing="compact">
-              <listitem><simpara>GNU C++ 2.95.x, 3.0.x and later versions</simpara></listitem>
+              <listitem><simpara>GNU C++ 2.95.x, 3.0.x, 3.1.x</simpara></listitem>
               <listitem><simpara>Comeau C++ 4.2.45.2</simpara></listitem>
               <listitem><simpara>SGI MIPSpro 7.3.0</simpara></listitem>
               <listitem><simpara>Intel C++ 5.0, 6.0</simpara></listitem>
               <listitem><simpara>Compaq's cxx 6.2</simpara></listitem>
-	      <listitem><simpara>Microsoft Visual C++ 7.1 and later versions</simpara></listitem>
+	      <listitem><simpara>Microsoft Visual C++ 7.1</simpara></listitem>
             </itemizedlist>
           </entry>
           <entry>
@@ -255,17 +248,17 @@ f(&amp;x, 5);</programlisting>
         <row>
           <entry>
 <programlisting name="function.tutorial.std_bind.cxx98">  <classname>boost::function</classname>&lt;int (int)&gt; f;
-X x;
+  X x;
-f = std::bind1st(
+  f = std::bind1st(
-      std::mem_fun(&amp;X::foo), &amp;x);
+        std::mem_fun(&amp;X::foo), &amp;x);
-f(5); // Call x.foo(5)</programlisting>
+  f(5); // Call x.foo(5)</programlisting>
 </entry>
 <entry>
 <programlisting name="function.tutorial.std_bind.portable">  <classname alt="functionN">boost::function1</classname>&lt;int, int&gt; f;
-X x;
+  X x;
-f = std::bind1st(
+  f = std::bind1st(
-      std::mem_fun(&amp;X::foo), &amp;x);
+        std::mem_fun(&amp;X::foo), &amp;x);
-f(5); // Call x.foo(5)</programlisting>
+  f(5); // Call x.foo(5)</programlisting>
 </entry>
           </row>
         </tbody>
@@ -281,7 +274,7 @@ f(5); // Call x.foo(5)</programlisting>
 </section>
 
 <section>
-  <title>References to Function Objects</title> <para> In some cases it is
+  <title>References to Functions</title> <para> In some cases it is
   expensive (or semantically incorrect) to have Boost.Function clone a
   function object. In such cases, it is possible to request that
   Boost.Function keep only a reference to the actual function
@@ -300,18 +293,18 @@ f(5); // Call x.foo(5)</programlisting>
       <tbody>
         <row>
           <entry>
-<programlisting name="function.tutorial.ref.cxx98">stateful_type a_function_object;
+<programlisting name="function.tutorial.ref.cxx98">  stateful_type a_function_object;
-<classname>boost::function</classname>&lt;int (int)&gt; f;
+  <classname>boost::function</classname>&lt;int (int)&gt; f;
-f = <functionname>boost::ref</functionname>(a_function_object);
+  f = <functionname>boost::ref</functionname>(a_function_object);
 
-<classname>boost::function</classname>&lt;int (int)&gt; f2(f);</programlisting>
+  <classname>boost::function</classname>&lt;int (int)&gt; f2(f);</programlisting>
 </entry>
 <entry>
-<programlisting name="function.tutorial.ref.portable">stateful_type a_function_object;
+<programlisting name="function.tutorial.ref.portable">  stateful_type a_function_object;
-<classname alt="functionN">boost::function1</classname>&lt;int, int&gt; f;
+  <classname alt="functionN">boost::function1</classname>&lt;int, int&gt; f;
-f = <functionname>boost::ref</functionname>(a_function_object);
+  f = <functionname>boost::ref</functionname>(a_function_object);
 
-<classname alt="functionN">boost::function1</classname>&lt;int, int&gt; f2(f);</programlisting>
+  <classname alt="functionN">boost::function1</classname>&lt;int, int&gt; f2(f);</programlisting>
 </entry>
           </row>
         </tbody>
@@ -328,37 +321,5 @@ using references to function objects, Boost.Function will not throw
 exceptions during assignment or construction.
 </para>
 </section>
-
-<section>
-  <title>Comparing Boost.Function function objects</title>
-
-  <para>Function object wrappers can be compared via <code>==</code>
-  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
-  <conceptname>EqualityComparable</conceptname> or have an overloaded <functionname>boost::function_equal</functionname>). For instance:</para>
-  
-  <programlisting name="function.tutorial.compare">int compute_with_X(X*, int);
-
-f = &amp;X::foo;
-assert(f == &amp;X::foo);
-assert(&amp;compute_with_X != f);</programlisting>
-
-   <para>When comparing against an instance of
-   <code><classname>reference_wrapper</classname></code>, the address
-   of the object in the
-   <code><classname>reference_wrapper</classname></code> is compared
-   against the address of the object stored by the function object
-   wrapper:</para>
-
-  <programlisting name="function.tutorial.compare-ref">a_stateful_object so1, so2;
-f = <functionname>boost::ref</functionname>(so1);
-assert(f == <functionname>boost::ref</functionname>(so1));
-assert(f == so1); <emphasis>// Only if a_stateful_object is <conceptname>EqualityComparable</conceptname></emphasis>
-assert(f != <functionname>boost::ref</functionname>(so2));</programlisting>
-
-</section>
-
 </section>
 

example/bind1st.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library examples
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright Doug 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)

example/int_div.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library examples
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright Doug 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)

example/sum_avg.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library examples
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright Doug 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)

include/boost/function.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright Doug 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)
@@ -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>
 
@@ -23,8 +21,8 @@
 // in anything that may be included by function_template.hpp doesn't break
 #include <boost/function/detail/prologue.hpp>
 
-// Older Visual Age C++ version do not handle the file iteration well
+// Visual Age C++ doesn't handle the file iteration well
-#if BOOST_WORKAROUND(__IBMCPP__, >= 500) && BOOST_WORKAROUND(__IBMCPP__, < 800)
+#if BOOST_WORKAROUND(__IBMCPP__, <= 600)
 #  if BOOST_FUNCTION_MAX_ARGS >= 0
 #    include <boost/function/function0.hpp>
 #  endif

include/boost/function/detail/function_iterate.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2003. Use, modification and
+//  Copyright Doug Gregor 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)

include/boost/function/detail/gen_maybe_include.pl

@@ -2,7 +2,7 @@
 #
 # Boost.Function library
 #
-# Copyright (C) 2001-2003 Douglas Gregor (gregod@cs.rpi.edu)
+# Copyright (C) 2001-2003 Doug Gregor (gregod@cs.rpi.edu)
 #
 # Permission to copy, use, sell and distribute this software is granted
 # provided this copyright notice appears in all copies.

include/boost/function/detail/maybe_include.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2003. Use, modification and
+//  Copyright Doug Gregor 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)

include/boost/function/detail/prologue.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)
@@ -11,7 +11,6 @@
 #define BOOST_FUNCTION_PROLOGUE_HPP
 #  include <cassert>
 #  include <algorithm>
-#  include <boost/config/no_tr1/functional.hpp> // unary_function, binary_function
 #  include <boost/throw_exception.hpp>
 #  include <boost/config.hpp>
 #  include <boost/function/function_base.hpp>
@@ -22,5 +21,4 @@
 #  include <boost/preprocessor/cat.hpp>
 #  include <boost/preprocessor/repeat.hpp>
 #  include <boost/preprocessor/inc.hpp>
-#  include <boost/type_traits/is_void.hpp>
 #endif // BOOST_FUNCTION_PROLOGUE_HPP

include/boost/function/function0.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)

include/boost/function/function1.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)

include/boost/function/function10.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)

include/boost/function/function2.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)

include/boost/function/function3.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)

include/boost/function/function4.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)

include/boost/function/function5.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)

include/boost/function/function6.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)

include/boost/function/function7.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)

include/boost/function/function8.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)

include/boost/function/function9.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)

include/boost/function/function_fwd.hpp

@@ -1,70 +0,0 @@
-// Boost.Function library
-//  Copyright (C) Douglas Gregor 2008
-//
-//  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
-#ifndef BOOST_FUNCTION_FWD_HPP
-#define BOOST_FUNCTION_FWD_HPP
-#include <boost/config.hpp>
-
-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
-// Work around a compiler bug.
-// boost::python::objects::function has to be seen by the compiler before the
-// boost::function class template.
-namespace boost { namespace python { namespace objects {
-  class function;
-}}}
-#endif
-
-#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
- || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
- || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
-#  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
-#endif
-
-namespace boost {
-  class bad_function_call;
-
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-  // Preferred syntax
-  template<typename Signature> class function;
-
-  template<typename Signature>
-  inline void swap(function<Signature>& f1, function<Signature>& f2)
-  {
-    f1.swap(f2);
-  }
-#endif // have partial specialization
-
-  // Portable syntax
-  template<typename R> class function0;
-  template<typename R, typename T1> class function1;
-  template<typename R, typename T1, typename T2> class function2;
-  template<typename R, typename T1, typename T2, typename T3> class function3;
-  template<typename R, typename T1, typename T2, typename T3, typename T4> 
-    class function4;
-  template<typename R, typename T1, typename T2, typename T3, typename T4,
-           typename T5> 
-    class function5;
-  template<typename R, typename T1, typename T2, typename T3, typename T4,
-           typename T5, typename T6> 
-    class function6;
-  template<typename R, typename T1, typename T2, typename T3, typename T4,
-           typename T5, typename T6, typename T7> 
-    class function7;
-  template<typename R, typename T1, typename T2, typename T3, typename T4,
-           typename T5, typename T6, typename T7, typename T8> 
-    class function8;
-  template<typename R, typename T1, typename T2, typename T3, typename T4,
-           typename T5, typename T6, typename T7, typename T8, typename T9> 
-    class function9;
-  template<typename R, typename T1, typename T2, typename T3, typename T4,
-           typename T5, typename T6, typename T7, typename T8, typename T9,
-           typename T10> 
-    class function10;
-}
-
-#endif

include/boost/function/function_typeof.hpp

@@ -1,45 +0,0 @@
-// Boost.Function library - Typeof support
-//  Copyright (C) Douglas Gregor 2008
-//
-//  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
-#ifndef BOOST_FUNCTION_TYPEOF_HPP
-#define BOOST_FUNCTION_TYPEOF_HPP
-#include <boost/function/function_fwd.hpp>
-#include <boost/typeof/typeof.hpp>
-
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-BOOST_TYPEOF_REGISTER_TYPE(boost::bad_function_call)
-
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function, (typename))
-#endif
-
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function0, (typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function1, (typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function2, (typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function3, 
-  (typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function4, 
-  (typename)(typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function5, 
-  (typename)(typename)(typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function6, 
-  (typename)(typename)(typename)(typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function7, 
-  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
-  (typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function8, 
-  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
-  (typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function9, 
-  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
-  (typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function10, 
-  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
-  (typename)(typename)(typename)(typename))
-#endif

include/boost/function/gen_function_N.pl

@@ -2,7 +2,7 @@
 #
 # Boost.Function library
 #
-# Copyright Douglas Gregor 2001-2003. Use, modification and
+# Copyright Doug 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)

include/boost/function_equal.hpp

@@ -1,28 +0,0 @@
-//  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)
-
-// For more information, see http://www.boost.org
-#ifndef BOOST_FUNCTION_EQUAL_HPP
-#define BOOST_FUNCTION_EQUAL_HPP
-
-namespace boost {
-
-template<typename F, typename G>
-  bool function_equal_impl(const F& f, const G& g, long)
-  { return f == g; }
-
-// 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); }
-
-} // end namespace boost
-
-#endif // BOOST_FUNCTION_EQUAL_HPP

index.html

@@ -1,20 +1,9 @@
 <html>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under 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)
-  -->
 <head>
 <meta http-equiv="refresh" content="0; URL=../../doc/html/function.html">
 </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>© Copyright Beman Dawes, 2001</p>
-<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
-file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
-at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
 </body>
-</html>
+</html>

test/Jamfile

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

test/Jamfile.v2

@@ -1,6 +1,6 @@
 # Function library
 
-# Copyright Douglas Gregor 2001-2003. Use, modification and
+# Copyright Doug 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)
@@ -8,7 +8,6 @@
 # For more information, see http://www.boost.org/
 
 project
-    : requirements <toolset>msvc:<asynch-exceptions>on
     : source-location $(BOOST_ROOT)
     ;
 
@@ -54,14 +53,6 @@ import testing ;
   [ run libs/function/test/function_ref_cxx98.cpp :  :  :  :  ]
 
   [ run libs/function/test/function_ref_portable.cpp :  :  :  :  ]
-  
-  [ run libs/function/test/contains_test.cpp : : : : ]
-   
-  [ run libs/function/test/contains2_test.cpp : : : : ]
-   
-  [ run libs/function/test/nothrow_swap.cpp :  :  :  :  ]
-
-  [ compile libs/function/test/function_typeof_test.cpp ]
  ;
 }
-      
+      

test/allocator_test.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright Doug 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)
@@ -27,14 +27,6 @@ struct counting_allocator : public std::allocator<T>
     typedef counting_allocator<U> other;
   };
 
-  counting_allocator()
-  {
-  }
-
-  template<typename U>
-  counting_allocator( counting_allocator<U> )
-  {
-  }
 
   T* allocate(std::size_t n)
   {
@@ -49,25 +41,9 @@ struct counting_allocator : public std::allocator<T>
   }
 };
 
-struct enable_small_object_optimization
-{
-};
-
-struct disable_small_object_optimization
-{
-  int unused_state_data[32];
-};
-
-template <typename base>
-struct plus_int: base
-{
-  int operator()(int x, int y) const { return x + y; }
-};
-
 static int do_minus(int x, int y) { return x-y; }
 
-template <typename base>
+struct DoNothing
-struct DoNothing: base
 {
   void operator()() const {}
 };
@@ -77,61 +53,29 @@ static void do_nothing() {}
 int
 test_main(int, char*[])
 {
-  function2<int, int, int> f;
+  function2<int, int, int, counting_allocator<int> > f;
-  f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<int>() );
+  f = plus<int>();
-  f.clear();
-  BOOST_CHECK(alloc_count == 1);
-  BOOST_CHECK(dealloc_count == 1);
-  alloc_count = 0;
-  dealloc_count = 0;
-  f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
-  f.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
-  f.assign( plus_int<disable_small_object_optimization>(), std::allocator<int>() );
-  f.clear();
-  f.assign( plus_int<enable_small_object_optimization>(), std::allocator<int>() );
   f.clear();
+  BOOST_TEST(alloc_count == 1);
+  BOOST_TEST(dealloc_count == 1);
 
   alloc_count = 0;
   dealloc_count = 0;
-  f.assign( &do_minus, counting_allocator<int>() );
+  f = &do_minus;
-  f.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
-  f.assign( &do_minus, std::allocator<int>() );
   f.clear();
 
-  function0<void> fv;
+  function0<void, counting_allocator<int> > fv;
   alloc_count = 0;
   dealloc_count = 0;
-  fv.assign( DoNothing<disable_small_object_optimization>(), counting_allocator<int>() );
+  fv = DoNothing();
-  fv.clear();
-  BOOST_CHECK(alloc_count == 1);
-  BOOST_CHECK(dealloc_count == 1);
-  alloc_count = 0;
-  dealloc_count = 0;
-  fv.assign( DoNothing<enable_small_object_optimization>(), counting_allocator<int>() );
-  fv.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
-  fv.assign( DoNothing<disable_small_object_optimization>(), std::allocator<int>() );
-  fv.clear();
-  fv.assign( DoNothing<enable_small_object_optimization>(), std::allocator<int>() );
   fv.clear();
+  BOOST_TEST(alloc_count == 1);
+  BOOST_TEST(dealloc_count == 1);
 
   alloc_count = 0;
   dealloc_count = 0;
-  fv.assign( &do_nothing, counting_allocator<int>() );
+  fv = &do_nothing;
   fv.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
-  fv.assign( &do_nothing, std::allocator<int>() );
-  fv.clear();
-  
-  function0<void> fv2;
-  fv.assign(&do_nothing, std::allocator<int>() );
-  fv2.assign(fv, std::allocator<int>() );
 
   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

@@ -1,235 +0,0 @@
-// Boost.Function library
-
-//  Copyright Douglas Gregor 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)
-
-#include <boost/test/minimal.hpp>
-#include <boost/function.hpp>
-#include <boost/ref.hpp>
-
-static int forty_two() { return 42; }
-
-struct Seventeen
-{
-  int operator()() const { return 17; }
-};
-
-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; }
-
-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_CHECK(!f.target<Seventeen>());
-
-  f = Seventeen();
-  BOOST_CHECK(!f.target<int (*)()>());
-  BOOST_CHECK(f.target<Seventeen>());
-
-  Seventeen this_seventeen;
-  f = boost::ref(this_seventeen);
-  BOOST_CHECK(!f.target<int (*)()>());
-  BOOST_CHECK(f.target<Seventeen>());
-  BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);
-
-  const Seventeen const_seventeen = this_seventeen;
-  f = boost::ref(const_seventeen);
-  BOOST_CHECK(!f.target<int (*)()>());
-  BOOST_CHECK(f.target<const Seventeen>());
-  BOOST_CHECK(f.target<const Seventeen>() == &const_seventeen);
-  BOOST_CHECK(f.target<const volatile Seventeen>());
-  BOOST_CHECK(!f.target<Seventeen>());
-  BOOST_CHECK(!f.target<volatile Seventeen>());
-}
-
-static void equal_test()
-{
-  boost::function0<int> f;
-
-  f = &forty_two;
-  BOOST_CHECK(f == &forty_two);
-  BOOST_CHECK(f != ReturnInt(17));
-#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-  BOOST_CHECK(&forty_two == f);
-  BOOST_CHECK(ReturnInt(17) != f);
-#endif
-
-  BOOST_CHECK(f.contains(&forty_two));
-
-  f = ReturnInt(17);
-  BOOST_CHECK(f != &forty_two);
-  BOOST_CHECK(f == ReturnInt(17));
-  BOOST_CHECK(f != ReturnInt(16));
-#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-  BOOST_CHECK(&forty_two != f);
-  BOOST_CHECK(ReturnInt(17) == f);
-  BOOST_CHECK(ReturnInt(16) != f);
-#endif
-
-  BOOST_CHECK(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_CHECK(g != ReturnInt(17));
-#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-  BOOST_CHECK(&forty_two == g);
-  BOOST_CHECK(ReturnInt(17) != g);
-#  endif
-
-  g = ReturnInt(17);
-  BOOST_CHECK(g != &forty_two);
-  BOOST_CHECK(g == ReturnInt(17));
-  BOOST_CHECK(g != ReturnInt(16));
-#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-  BOOST_CHECK(&forty_two != g);
-  BOOST_CHECK(ReturnInt(17) == g);
-  BOOST_CHECK(ReturnInt(16) != g);
-#  endif
-#endif
-}
-
-static void ref_equal_test()
-{
-  {
-    ReturnInt ri(17);
-    boost::function0<int> f = boost::ref(ri);
-
-    // References and values are equal
-    BOOST_CHECK(f == boost::ref(ri));
-    BOOST_CHECK(f == ri);
-    BOOST_CHECK(boost::ref(ri) == f);
-    BOOST_CHECK(!(f != boost::ref(ri)));
-    BOOST_CHECK(!(f != ri));
-    BOOST_CHECK(!(boost::ref(ri) != f));
-#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-    BOOST_CHECK(ri == f);
-    BOOST_CHECK(!(ri != f));
-#endif
-
-    // Values equal, references inequal
-    ReturnInt ri2(17);
-    BOOST_CHECK(f == ri2);
-    BOOST_CHECK(f != boost::ref(ri2));
-    BOOST_CHECK(boost::ref(ri2) != f);
-    BOOST_CHECK(!(f != ri2));
-    BOOST_CHECK(!(f == boost::ref(ri2)));
-    BOOST_CHECK(!(boost::ref(ri2) == f));
-#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-    BOOST_CHECK(ri2 == f);
-    BOOST_CHECK(!(ri2 != f));
-#endif 
-  }
-
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-  {
-    ReturnInt ri(17);
-    boost::function<int(void)> f = boost::ref(ri);
-
-    // References and values are equal
-    BOOST_CHECK(f == boost::ref(ri));
-    BOOST_CHECK(f == ri);
-    BOOST_CHECK(boost::ref(ri) == f);
-    BOOST_CHECK(!(f != boost::ref(ri)));
-    BOOST_CHECK(!(f != ri));
-    BOOST_CHECK(!(boost::ref(ri) != f));
-#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-    BOOST_CHECK(ri == f);
-    BOOST_CHECK(!(ri != f));
-#  endif
-
-    // Values equal, references inequal
-    ReturnInt ri2(17);
-    BOOST_CHECK(f == ri2);
-    BOOST_CHECK(f != boost::ref(ri2));
-    BOOST_CHECK(boost::ref(ri2) != f);
-    BOOST_CHECK(!(f != ri2));
-    BOOST_CHECK(!(f == boost::ref(ri2)));
-    BOOST_CHECK(!(boost::ref(ri2) == f));
-#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
-    BOOST_CHECK(ri2 == f);
-    BOOST_CHECK(!(ri2 != f));
-#  endif
-  }
-#endif
-}
-
-int test_main(int, char*[])
-{
-  target_test();
-  equal_test();
-  ref_equal_test();
-
-  return 0;
-}

test/function_30.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)

test/function_n_test.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright Doug 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)
@@ -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,61 +629,13 @@ 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");
   }
 }
 
-static unsigned construction_count = 0;
-static unsigned destruction_count = 0;
-
-struct MySmallFunctor {
-  MySmallFunctor() { ++construction_count; }
-  MySmallFunctor(const MySmallFunctor &) { ++construction_count; }
-  ~MySmallFunctor() { ++destruction_count; }
-  int operator()() { return 0; }
- };
-
-struct MyLargeFunctor {
-  MyLargeFunctor() { ++construction_count; }
-  MyLargeFunctor(const MyLargeFunctor &) { ++construction_count; }
-  ~MyLargeFunctor() { ++destruction_count; }
-  int operator()() { return 0; }
-
-  float data[128];
- };
-
-void test_construct_destroy_count()
-{
-  {
-    boost::function0<int> f;
-    boost::function0<int> g;
-    f = MySmallFunctor();
-    g = MySmallFunctor();
-    f.swap(g);
-  }
-
-  // MySmallFunctor objects should be constructed as many times as
-  // they are destroyed.
-  BOOST_CHECK(construction_count == destruction_count);
- 
-  construction_count = 0;
-  destruction_count = 0;
-  {
-    boost::function0<int> f;
-    boost::function0<int> g;
-    f = MyLargeFunctor();
-    g = MyLargeFunctor();
-    f.swap(g);
-   }
-
-   // MyLargeFunctor objects should be constructed as many times as
-   // they are destroyed.
-   BOOST_CHECK(construction_count == destruction_count);
-}
-
 int test_main(int, char* [])
 {
   test_zero_args();
@@ -692,6 +644,5 @@ int test_main(int, char* [])
   test_emptiness();
   test_member_functions();
   test_ref();
-  test_construct_destroy_count();
   return 0;
 }

test/function_test.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright Doug 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)
@@ -10,11 +10,12 @@
 #include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
 #include <functional>
+#include <cassert>
 #include <string>
 #include <utility>
 
-using boost::function;
+using namespace boost;
-using std::string;
+using namespace std;
 
 int global_int;
 
@@ -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,78 +496,78 @@ 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
 test_one_arg()
 {
-  std::negate<int> neg;
+  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 {
@@ -607,12 +608,12 @@ struct add_with_throw_on_copy {
 
   add_with_throw_on_copy(const add_with_throw_on_copy&)
   {
-    throw std::runtime_error("But this CAN'T throw");
+    throw runtime_error("But this CAN'T throw");
   }
 
   add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
   {
-    throw std::runtime_error("But this CAN'T throw");
+    throw runtime_error("But this CAN'T throw");
   }
 };
 
@@ -621,44 +622,84 @@ test_ref()
 {
   add_with_throw_on_copy atc;
   try {
-    boost::function<int (int, int)> f(boost::ref(atc));
+    boost::function<int (int, int)> f(ref(atc));
-    BOOST_CHECK(f(1, 3) == 4);
+    BOOST_TEST(f(1, 3) == 4);
   }
-  catch(std::runtime_error e) {
+  catch(runtime_error e) {
     BOOST_ERROR("Nonthrowing constructor threw an exception");
   }
 }
 
-static void dummy() {}
+static int alloc_count = 0;
+static int dealloc_count = 0;
 
-static void test_empty_ref()
+template<typename T>
+struct counting_allocator : public allocator<T>
 {
-  boost::function<void()> f1;
+  template<typename U>
-  boost::function<void()> f2(boost::ref(f1));
+  struct rebind
+  {
+    typedef counting_allocator<U> other;
+  };
 
-  try {
-    f2();
-    BOOST_ERROR("Exception didn't throw for reference to empty function.");
-  }
-  catch(std::runtime_error e) {}
 
-  f1 = dummy;
+  T* allocate(size_t n)
+  {
+    alloc_count++;
+    return allocator<T>::allocate(n);
+  }
 
-  try {
+  void deallocate(T* p, size_t n)
-    f2();
+  {
-  }
+    dealloc_count++;
-  catch(std::runtime_error e) {
+    allocator<T>::deallocate(p, n);
-    BOOST_ERROR("Error calling referenced function.");
   }
+};
+
+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
@@ -676,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()
@@ -698,7 +739,7 @@ int test_main(int, char* [])
   test_emptiness();
   test_member_functions();
   test_ref();
-  test_empty_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 Doug 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 Doug 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/function_typeof_test.cpp

@@ -1,18 +0,0 @@
-// Boost.Function library
-
-//  Copyright Douglas Gregor 2008. 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
-#include <boost/function/function_typeof.hpp>
-#include <boost/function.hpp>
-#include <boost/typeof/typeof.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/static_assert.hpp>
-
-void f(boost::function0<void> f, boost::function0<void> g)
-{
-  BOOST_STATIC_ASSERT((boost::is_same<boost::function0<void>, BOOST_TYPEOF(f = g)>::value));
-}

test/lambda_test.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  Copyright Doug Gregor 2002-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)
@@ -15,21 +15,21 @@
 #include <boost/lambda/bind.hpp>
 #include <boost/function.hpp>
 
+using namespace std;
+using namespace boost;
+using namespace boost::lambda;
+
 static unsigned
 func_impl(int arg1, bool arg2, double arg3)
 {
-  using namespace std;
   return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
 }
 
 int test_main(int, char*[])
 {
-  using boost::function;
-  using namespace boost::lambda;
-
   function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
-  function <unsigned(double)>       f2 = boost::lambda::bind(f1, false, _1);
+  function <unsigned(double)>       f2 = bind(f1, false, _1);
-  function <unsigned()>             f3 = boost::lambda::bind(f2, 4.0);
+  function <unsigned()>             f3 = bind(f2, 4.0);
 
   f3();
 

test/mem_fun_cxx98.cpp

@@ -10,28 +10,22 @@
 
     
 #include <boost/function.hpp>
-#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <functional>
 
 struct X {
   int foo(int);
-  std::ostream& foo2(std::ostream&) const;
 };
 int X::foo(int x) { return -x; }
-std::ostream& X::foo2(std::ostream& x) const { return x; }
 
 int main()
 {
     boost::function<int (X*, int)> f;
-    boost::function<std::ostream& (X*, std::ostream&)> f2;
 
-    f = &X::foo;
+f = &X::foo;
-    f2 = &X::foo2;
+  
+X x;
+f(&x, 5);
 
-    X x;
+    return 0;
-    BOOST_TEST(f(&x, 5) == -5);
-    BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout);
-
-    return ::boost::report_errors();
 }

test/mem_fun_portable.cpp

@@ -10,28 +10,22 @@
 
     
 #include <boost/function.hpp>
-#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <functional>
 
 struct X {
   int foo(int);
-  std::ostream& foo2(std::ostream&) const;
 };
 int X::foo(int x) { return -x; }
-std::ostream& X::foo2(std::ostream& x) const { return x; }
 
 int main()
 {
     boost::function2<int, X*, int> f;
-    boost::function2<std::ostream&, X*, std::ostream&> f2;
 
-    f = &X::foo;
+f = &X::foo;
-    f2 = &X::foo2;
+  
+X x;
+f(&x, 5);
 
-    X x;
+    return 0;
-    BOOST_TEST(f(&x, 5) == -5);
-    BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout);
-
-    return ::boost::report_errors();
 }

test/nothrow_swap.cpp

@@ -1,60 +0,0 @@
-// Boost.Function library
-
-//  Copyright Douglas Gregor 2008. 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
-
-#include <boost/test/minimal.hpp>
-#include <boost/function.hpp>
-
-struct tried_to_copy { };
-
-struct MaybeThrowOnCopy {
-  MaybeThrowOnCopy(int value = 0) : value(value) { }
-
-  MaybeThrowOnCopy(const MaybeThrowOnCopy& other) : value(other.value) {
-    if (throwOnCopy)
-      throw tried_to_copy();
-  }
-
-  MaybeThrowOnCopy& operator=(const MaybeThrowOnCopy& other) {
-    if (throwOnCopy)
-      throw tried_to_copy();
-    value = other.value;
-    return *this;
-  }
-
-  int operator()() { return value; }
-
-  int value;
-
-  // Make sure that this function object doesn't trigger the
-  // small-object optimization in Function.
-  float padding[100];
-
-  static bool throwOnCopy;
-};
-
-bool MaybeThrowOnCopy::throwOnCopy = false;
-
-int test_main(int, char* [])
-{
-  boost::function0<int> f;
-  boost::function0<int> g;
-
-  MaybeThrowOnCopy::throwOnCopy = false;
-  f = MaybeThrowOnCopy(1);
-  g = MaybeThrowOnCopy(2);
-  BOOST_CHECK(f() == 1);
-  BOOST_CHECK(g() == 2);
-
-  MaybeThrowOnCopy::throwOnCopy = true;
-  f.swap(g);
-  BOOST_CHECK(f() == 2);
-  BOOST_CHECK(g() == 1);
-  
-  return 0;
-}

test/stateless_test.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright Doug 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)
@@ -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;