merged from trunk

[SVN r49607]

CMakeLists.txt

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

doc/CMakeLists.txt

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

doc/Jamfile.v2

@@ -1,3 +1,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)
 project boost/doc ;
 import boostbook : boostbook ;
 

doc/faq.xml

@@ -1,4 +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.faq" last-revision="$Date$">

doc/history.xml

@@ -1,11 +1,61 @@
 <?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>
@@ -32,7 +82,7 @@
       </itemizedlist>
   </listitem>
 
-  <listitem><para><emphasis role="bold">Version 1.29.0</emphasis>:
+  <listitem><para><bold>Version 1.29.0</bold>:
   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,4 +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.misc" last-revision="$Date$">
@@ -17,7 +24,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 three) </para></listitem>
+    <listitem><para> Function pointers are smaller (the size of one pointer instead of four or more) </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>
@@ -30,12 +37,12 @@
 
 <section>
   <title>Function object wrapper size</title>
-<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>
+  <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>
 </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.</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. Small function objects can be stored within the <code>boost::function</code> object itself, improving copying efficiency.</para>
  </section>
 
 <section>

doc/reference.xml

@@ -1,4 +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">
 
@@ -118,6 +125,12 @@
         <returns><simpara><code>true</code> if <code>this-&gt;<methodname>target</methodname>&lt;Functor&gt;()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this-&gt;target&lt;Functor&gt;()), f)</code></simpara></returns>
  
       </method>
+
+      <method name="target_type" cv="const">
+        <type>const std::type_info&amp;</type>
+        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
     </method-group>
   </class>
 
@@ -128,9 +141,6 @@
       <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>
@@ -147,7 +157,6 @@
     </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>
@@ -182,7 +191,7 @@
     </struct>
 
     <constructor>
-      <postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
+      <postconditions><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></postconditions>
       <throws><simpara>Will not throw.</simpara></throws>
     </constructor>
 
@@ -201,11 +210,23 @@
       <parameter name="f"><paramtype>F</paramtype></parameter>
       <requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
       <postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-&gt;<methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
-      <throws><simpara>Will not throw when <code>f</code> is a stateless function object.</simpara></throws>
+    </constructor>
+
+    <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-><methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
+      <effects><simpara>If <code>!this-&gt;<methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
 
     </destructor>
 
@@ -213,8 +234,7 @@
       <parameter name="f">
         <paramtype>const <classname>functionN</classname>&amp;</paramtype>
       </parameter>
-      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
-      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object.</simpara></throws>
+      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
     </copy-assignment>
 
     <method-group name="modifiers">
@@ -222,13 +242,11 @@
         <type>void</type>
         <parameter name="f"><paramtype>const <classname>functionN</classname>&amp;</paramtype></parameter>
         <effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
-        <throws><simpara>Will not throw.</simpara></throws>
       </method>
 
       <method name="clear">
         <type>void</type>
         <postconditions><simpara>this-&gt;<methodname>empty</methodname>()</simpara></postconditions>
-        <throws><simpara>Will not throw.</simpara></throws>
       </method>
     </method-group>
 
@@ -286,6 +304,13 @@
         <returns><simpara><code>true</code> if <code>this-&gt;<methodname>target</methodname>&lt;Functor&gt;()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this-&gt;target&lt;Functor&gt;()), f)</code></simpara></returns>
  
       </method>
+
+      <method name="target_type" cv="const">
+        <type>const std::type_info&amp;</type>
+        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+
     </method-group>
 
     <method-group name="invocation">
@@ -297,7 +322,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>
 
@@ -308,13 +333,11 @@
           <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, Allocator&gt;&amp;</paramtype></parameter>
-        <parameter name="f2"><paramtype><classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+        <parameter name="f1"><paramtype><classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
+        <parameter name="f2"><paramtype><classname>functionN</classname>&lt;T1, T2, ..., TN&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>
 
@@ -326,11 +349,10 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+          <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>
@@ -339,12 +361,11 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <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, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
         </signature>        
         <signature>
           <template>
@@ -352,11 +373,10 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+          <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>
@@ -365,12 +385,11 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <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, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
         </signature>        
         <signature>
           <template>
@@ -378,16 +397,14 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator1"/>
             <template-type-parameter name="U1"/>
             <template-type-parameter name="U2"/>
             <template-varargs/>
             <template-type-parameter name="UN"/>
-            <template-type-parameter name="Allocator2"/>
           </template>
           <type>void</type>
-          <parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator1&gt;&amp;</paramtype></parameter>
-          <parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN, Allocator2&gt;&amp;</paramtype></parameter>
+          <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
@@ -427,11 +444,10 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+          <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>
@@ -440,12 +456,11 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <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, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
         </signature>        
         <signature>
           <template>
@@ -453,11 +468,10 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+          <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>
@@ -466,12 +480,11 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <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, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
         </signature>        
         <signature>
           <template>
@@ -479,16 +492,14 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator1"/>
             <template-type-parameter name="U1"/>
             <template-type-parameter name="U2"/>
             <template-varargs/>
             <template-type-parameter name="UN"/>
-            <template-type-parameter name="Allocator2"/>
           </template>
           <type>void</type>
-          <parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator1&gt;&amp;</paramtype></parameter>
-          <parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN, Allocator2&gt;&amp;</paramtype></parameter>
+          <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
@@ -528,11 +539,8 @@
       <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, Allocator&gt;</inherit>
+    <inherit access="public"><classname>functionN</classname>&lt;R, T1, T2, ..., TN&gt;</inherit>
 
     <purpose>A generalized function pointer that can be used for
     callbacks or wrapping function objects.</purpose>
@@ -554,7 +562,6 @@
     </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>
@@ -589,7 +596,7 @@
     </struct>
 
     <constructor>
-      <postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
+      <postconditions><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></postconditions>
       <throws><simpara>Will not throw.</simpara></throws>
     </constructor>
 
@@ -616,28 +623,39 @@
       <parameter name="f"><paramtype>F</paramtype></parameter>
       <requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
       <postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-&gt;<methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
-      <throws><simpara>Will not throw when <code>f</code> is a stateless function object.</simpara></throws>
+    </constructor>
+
+    <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-><methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
+      <effects><simpara>If <code>!this-&gt;<methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
 
     </destructor>
 
     <copy-assignment>
       <parameter name="f">
-        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
+        <paramtype>const <classname>function</classname>&amp;</paramtype>
       </parameter>
-      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code></simpara></postconditions>
-      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object.</simpara></throws>
+      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
     </copy-assignment>
 
     <copy-assignment>
       <parameter name="f">
         <paramtype>const <classname>function</classname>&amp;</paramtype>
       </parameter>
-      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code></simpara></postconditions>
-      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object.</simpara></throws>
+      <postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
+      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></throws>
     </copy-assignment>
 
     <method-group name="modifiers">
@@ -645,7 +663,6 @@
         <type>void</type>
         <parameter name="f"><paramtype>const <classname>function</classname>&amp;</paramtype></parameter>
         <effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
-        <throws><simpara>Will not throw.</simpara></throws>
       </method>
 
       <method name="clear">
@@ -708,6 +725,12 @@
         <returns><simpara><code>true</code> if <code>this-&gt;<methodname>target</methodname>&lt;Functor&gt;()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this-&gt;target&lt;Functor&gt;()), f)</code></simpara></returns>
  
       </method>
+
+      <method name="target_type" cv="const">
+        <type>const std::type_info&amp;</type>
+        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
     </method-group>
 
     <method-group name="invocation">
@@ -719,7 +742,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>
 
@@ -727,13 +750,11 @@
       <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, Allocator&gt;&amp;</paramtype></parameter>
-        <parameter name="f2"><paramtype><classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+        <parameter name="f1"><paramtype><classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
+        <parameter name="f2"><paramtype><classname>function</classname>&lt;Signature&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>
 
@@ -742,53 +763,47 @@
         <signature>
           <template>
             <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+          <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="Allocator"/>
             <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, Allocator&gt;&amp;</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="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+          <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="Allocator"/>
             <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, Allocator&gt;&amp;</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="Allocator1"/>
             <template-type-parameter name="Signature2"/>
-            <template-type-parameter name="Allocator2"/>
           </template>
           <type>void</type>
-          <parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1, Allocator1&gt;&amp;</paramtype></parameter>
-          <parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2, Allocator2&gt;&amp;</paramtype></parameter>
+          <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
@@ -823,53 +838,47 @@
         <signature>
           <template>
             <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+          <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="Allocator"/>
             <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, Allocator&gt;&amp;</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="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+          <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="Allocator"/>
             <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, Allocator&gt;&amp;</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="Allocator1"/>
             <template-type-parameter name="Signature2"/>
-            <template-type-parameter name="Allocator2"/>
           </template>
           <type>void</type>
-          <parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1, Allocator1&gt;&amp;</paramtype></parameter>
-          <parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2, Allocator2&gt;&amp;</paramtype></parameter>
+          <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

doc/tests.xml

@@ -1,4 +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">
 <testsuite id="function.testsuite" last-revision="$Date$">

doc/tutorial.xml

@@ -1,4 +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 xmlns:xi="http://www.w3.org/2001/XInclude" id="function.tutorial"
@@ -329,8 +336,8 @@ exceptions during assignment or construction.
   or <code>!=</code> against any function object that can be stored
   within the wrapper. If the function object wrapper contains a
   function object of that type, it will be compared against the given
-  function object (which must be
-  <conceptname>EqualityComparable</conceptname>). For instance:</para>
+  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);
 

include/boost/function.hpp

@@ -0,0 +1,66 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org/libs/function
+
+// 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>
+
+#ifndef BOOST_FUNCTION_MAX_ARGS
+#  define BOOST_FUNCTION_MAX_ARGS 10
+#endif // BOOST_FUNCTION_MAX_ARGS
+
+// Include the prologue here so that the use of file-level iteration
+// in anything that may be included by function_template.hpp doesn't break
+#include <boost/function/detail/prologue.hpp>
+
+// Visual Age C++ doesn't handle the file iteration well
+#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
+#  if BOOST_FUNCTION_MAX_ARGS >= 0
+#    include <boost/function/function0.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 1
+#    include <boost/function/function1.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 2
+#    include <boost/function/function2.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 3
+#    include <boost/function/function3.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 4
+#    include <boost/function/function4.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 5
+#    include <boost/function/function5.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 6
+#    include <boost/function/function6.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 7
+#    include <boost/function/function7.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 8
+#    include <boost/function/function8.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 9
+#    include <boost/function/function9.hpp>
+#  endif
+#  if BOOST_FUNCTION_MAX_ARGS >= 10
+#    include <boost/function/function10.hpp>
+#  endif
+#else
+// What is the '3' for?
+#  define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_FUNCTION_MAX_ARGS,<boost/function/detail/function_iterate.hpp>))
+#  include BOOST_PP_ITERATE()
+#  undef BOOST_PP_ITERATION_PARAMS_1
+#endif

include/boost/function/detail/function_iterate.hpp

@@ -0,0 +1,16 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+#if !defined(BOOST_PP_IS_ITERATING)
+# error Boost.Function - do not include this file!
+#endif
+
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS
+

include/boost/function/detail/gen_maybe_include.pl

@@ -0,0 +1,37 @@
+#!/usr/bin/perl -w
+#
+# Boost.Function library
+#
+# Copyright (C) 2001-2003 Douglas Gregor (gregod@cs.rpi.edu)
+#
+# Permission to copy, use, sell and distribute this software is granted
+# provided this copyright notice appears in all copies.
+# Permission to modify the code and to distribute modified code is granted
+# provided this copyright notice appears in all copies, and a notice
+# that the code was modified is included with the copyright notice.
+#
+# This software is provided "as is" without express or implied warranty,
+# and with no claim as to its suitability for any purpose.
+#
+# For more information, see http://www.boost.org
+use English;
+
+$max_args = $ARGV[0];
+
+open (OUT, ">maybe_include.hpp") or die("Cannot write to maybe_include.hpp");
+for($on_arg = 0; $on_arg <= $max_args; ++$on_arg) {
+    if ($on_arg == 0) {
+	print OUT "#if";
+    }
+    else {
+	print OUT "#elif";
+    }
+    print OUT " BOOST_FUNCTION_NUM_ARGS == $on_arg\n";
+    print OUT "#  ifndef BOOST_FUNCTION_$on_arg\n";
+    print OUT "#    define BOOST_FUNCTION_$on_arg\n";
+    print OUT "#    include <boost/function/function_template.hpp>\n";
+    print OUT "#  endif\n";
+}
+print OUT "#else\n";
+print OUT "#  error Cannot handle Boost.Function objects that accept more than $max_args arguments!\n";
+print OUT "#endif\n";

include/boost/function/detail/maybe_include.hpp

@@ -0,0 +1,267 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#if BOOST_FUNCTION_NUM_ARGS == 0
+#  ifndef BOOST_FUNCTION_0
+#    define BOOST_FUNCTION_0
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 1
+#  ifndef BOOST_FUNCTION_1
+#    define BOOST_FUNCTION_1
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 2
+#  ifndef BOOST_FUNCTION_2
+#    define BOOST_FUNCTION_2
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 3
+#  ifndef BOOST_FUNCTION_3
+#    define BOOST_FUNCTION_3
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 4
+#  ifndef BOOST_FUNCTION_4
+#    define BOOST_FUNCTION_4
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 5
+#  ifndef BOOST_FUNCTION_5
+#    define BOOST_FUNCTION_5
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 6
+#  ifndef BOOST_FUNCTION_6
+#    define BOOST_FUNCTION_6
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 7
+#  ifndef BOOST_FUNCTION_7
+#    define BOOST_FUNCTION_7
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 8
+#  ifndef BOOST_FUNCTION_8
+#    define BOOST_FUNCTION_8
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 9
+#  ifndef BOOST_FUNCTION_9
+#    define BOOST_FUNCTION_9
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 10
+#  ifndef BOOST_FUNCTION_10
+#    define BOOST_FUNCTION_10
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 11
+#  ifndef BOOST_FUNCTION_11
+#    define BOOST_FUNCTION_11
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 12
+#  ifndef BOOST_FUNCTION_12
+#    define BOOST_FUNCTION_12
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 13
+#  ifndef BOOST_FUNCTION_13
+#    define BOOST_FUNCTION_13
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 14
+#  ifndef BOOST_FUNCTION_14
+#    define BOOST_FUNCTION_14
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 15
+#  ifndef BOOST_FUNCTION_15
+#    define BOOST_FUNCTION_15
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 16
+#  ifndef BOOST_FUNCTION_16
+#    define BOOST_FUNCTION_16
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 17
+#  ifndef BOOST_FUNCTION_17
+#    define BOOST_FUNCTION_17
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 18
+#  ifndef BOOST_FUNCTION_18
+#    define BOOST_FUNCTION_18
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 19
+#  ifndef BOOST_FUNCTION_19
+#    define BOOST_FUNCTION_19
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 20
+#  ifndef BOOST_FUNCTION_20
+#    define BOOST_FUNCTION_20
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 21
+#  ifndef BOOST_FUNCTION_21
+#    define BOOST_FUNCTION_21
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 22
+#  ifndef BOOST_FUNCTION_22
+#    define BOOST_FUNCTION_22
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 23
+#  ifndef BOOST_FUNCTION_23
+#    define BOOST_FUNCTION_23
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 24
+#  ifndef BOOST_FUNCTION_24
+#    define BOOST_FUNCTION_24
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 25
+#  ifndef BOOST_FUNCTION_25
+#    define BOOST_FUNCTION_25
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 26
+#  ifndef BOOST_FUNCTION_26
+#    define BOOST_FUNCTION_26
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 27
+#  ifndef BOOST_FUNCTION_27
+#    define BOOST_FUNCTION_27
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 28
+#  ifndef BOOST_FUNCTION_28
+#    define BOOST_FUNCTION_28
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 29
+#  ifndef BOOST_FUNCTION_29
+#    define BOOST_FUNCTION_29
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 30
+#  ifndef BOOST_FUNCTION_30
+#    define BOOST_FUNCTION_30
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 31
+#  ifndef BOOST_FUNCTION_31
+#    define BOOST_FUNCTION_31
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 32
+#  ifndef BOOST_FUNCTION_32
+#    define BOOST_FUNCTION_32
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 33
+#  ifndef BOOST_FUNCTION_33
+#    define BOOST_FUNCTION_33
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 34
+#  ifndef BOOST_FUNCTION_34
+#    define BOOST_FUNCTION_34
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 35
+#  ifndef BOOST_FUNCTION_35
+#    define BOOST_FUNCTION_35
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 36
+#  ifndef BOOST_FUNCTION_36
+#    define BOOST_FUNCTION_36
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 37
+#  ifndef BOOST_FUNCTION_37
+#    define BOOST_FUNCTION_37
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 38
+#  ifndef BOOST_FUNCTION_38
+#    define BOOST_FUNCTION_38
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 39
+#  ifndef BOOST_FUNCTION_39
+#    define BOOST_FUNCTION_39
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 40
+#  ifndef BOOST_FUNCTION_40
+#    define BOOST_FUNCTION_40
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 41
+#  ifndef BOOST_FUNCTION_41
+#    define BOOST_FUNCTION_41
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 42
+#  ifndef BOOST_FUNCTION_42
+#    define BOOST_FUNCTION_42
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 43
+#  ifndef BOOST_FUNCTION_43
+#    define BOOST_FUNCTION_43
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 44
+#  ifndef BOOST_FUNCTION_44
+#    define BOOST_FUNCTION_44
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 45
+#  ifndef BOOST_FUNCTION_45
+#    define BOOST_FUNCTION_45
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 46
+#  ifndef BOOST_FUNCTION_46
+#    define BOOST_FUNCTION_46
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 47
+#  ifndef BOOST_FUNCTION_47
+#    define BOOST_FUNCTION_47
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 48
+#  ifndef BOOST_FUNCTION_48
+#    define BOOST_FUNCTION_48
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 49
+#  ifndef BOOST_FUNCTION_49
+#    define BOOST_FUNCTION_49
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 50
+#  ifndef BOOST_FUNCTION_50
+#    define BOOST_FUNCTION_50
+#    include <boost/function/function_template.hpp>
+#  endif
+#else
+#  error Cannot handle Boost.Function objects that accept more than 50 arguments!
+#endif

include/boost/function/detail/prologue.hpp

@@ -0,0 +1,26 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#ifndef BOOST_FUNCTION_PROLOGUE_HPP
+#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>
+#  include <boost/mem_fn.hpp>
+#  include <boost/type_traits/is_integral.hpp>
+#  include <boost/preprocessor/enum.hpp>
+#  include <boost/preprocessor/enum_params.hpp>
+#  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

@@ -0,0 +1,12 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#define BOOST_FUNCTION_NUM_ARGS 0
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS

include/boost/function/function1.hpp

@@ -0,0 +1,12 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#define BOOST_FUNCTION_NUM_ARGS 1
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS

include/boost/function/function10.hpp

@@ -0,0 +1,12 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#define BOOST_FUNCTION_NUM_ARGS 10
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS

include/boost/function/function2.hpp

@@ -0,0 +1,12 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#define BOOST_FUNCTION_NUM_ARGS 2
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS

include/boost/function/function3.hpp

@@ -0,0 +1,12 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#define BOOST_FUNCTION_NUM_ARGS 3
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS

include/boost/function/function4.hpp

@@ -0,0 +1,12 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#define BOOST_FUNCTION_NUM_ARGS 4
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS

include/boost/function/function5.hpp

@@ -0,0 +1,12 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#define BOOST_FUNCTION_NUM_ARGS 5
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS

include/boost/function/function6.hpp

@@ -0,0 +1,12 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#define BOOST_FUNCTION_NUM_ARGS 6
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS

include/boost/function/function7.hpp

@@ -0,0 +1,12 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#define BOOST_FUNCTION_NUM_ARGS 7
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS

include/boost/function/function8.hpp

@@ -0,0 +1,12 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#define BOOST_FUNCTION_NUM_ARGS 8
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS

include/boost/function/function9.hpp

@@ -0,0 +1,12 @@
+// Boost.Function library
+
+//  Copyright Douglas 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)
+
+// For more information, see http://www.boost.org
+
+#define BOOST_FUNCTION_NUM_ARGS 9
+#include <boost/function/detail/maybe_include.hpp>
+#undef BOOST_FUNCTION_NUM_ARGS

include/boost/function/function_base.hpp

@@ -0,0 +1,880 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2001-2006
+//  Copyright Emil Dotchevski 2007
+//  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_BASE_HEADER
+#define BOOST_FUNCTION_BASE_HEADER
+
+#include <stdexcept>
+#include <string>
+#include <memory>
+#include <new>
+#include <typeinfo>
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_volatile.hpp>
+#include <boost/type_traits/composite_traits.hpp>
+#include <boost/type_traits/ice.hpp>
+#include <boost/ref.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#ifndef BOOST_NO_SFINAE
+#  include "boost/utility/enable_if.hpp"
+#else
+#  include "boost/mpl/bool.hpp"
+#endif
+#include <boost/function_equal.hpp>
+#include <boost/function/function_fwd.hpp>
+
+#if defined(BOOST_MSVC)
+#   pragma warning( push )
+#   pragma warning( disable : 4793 ) // complaint about native code generation
+#   pragma warning( disable : 4127 ) // "conditional expression is constant"
+#endif       
+
+// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
+#ifdef BOOST_NO_STD_TYPEINFO
+// Embedded VC++ does not have type_info in namespace std
+#  define BOOST_FUNCTION_STD_NS
+#else
+#  define BOOST_FUNCTION_STD_NS std
+#endif
+
+// Borrowed from Boost.Python library: determines the cases where we
+// need to use std::type_info::name to compare instead of operator==.
+# if (defined(__GNUC__) && __GNUC__ >= 3) \
+ || defined(_AIX) \
+ || (   defined(__sgi) && defined(__host_mips))
+#  include <cstring>
+#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
+     (std::strcmp((X).name(),(Y).name()) == 0)
+# else
+#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
+#endif
+
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
+#  define BOOST_FUNCTION_TARGET_FIX(x) x
+#else
+#  define BOOST_FUNCTION_TARGET_FIX(x)
+#endif // not MSVC
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
+#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
+      typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
+                            (::boost::is_integral<Functor>::value)>::value), \
+                           Type>::type
+#else
+// BCC doesn't recognize this depends on a template argument and complains
+// about the use of 'typename'
+#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
+      ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
+                   (::boost::is_integral<Functor>::value)>::value), \
+                       Type>::type
+#endif
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      class X;
+
+      /**
+       * A buffer used to store small function objects in
+       * boost::function. It is a union containing function pointers,
+       * object pointers, and a structure that resembles a bound
+       * member function pointer.
+       */
+      union function_buffer
+      {
+        // For pointers to function objects
+        mutable void* obj_ptr;
+
+        // For pointers to std::type_info objects
+        struct type_t {
+          // (get_functor_type_tag, check_functor_type_tag).
+          const BOOST_FUNCTION_STD_NS::type_info* type;
+
+          // Whether the type is const-qualified.
+          bool const_qualified;
+          // Whether the type is volatile-qualified.
+          bool volatile_qualified;
+        } type;
+
+        // For function pointers of all kinds
+        mutable void (*func_ptr)();
+
+        // For bound member pointers
+        struct bound_memfunc_ptr_t {
+          void (X::*memfunc_ptr)(int);
+          void* obj_ptr;
+        } bound_memfunc_ptr;
+
+        // For references to function objects. We explicitly keep
+        // track of the cv-qualifiers on the object referenced.
+        struct obj_ref_t {
+          mutable void* obj_ptr;
+          bool is_const_qualified;
+          bool is_volatile_qualified;
+        } obj_ref;
+
+        // To relax aliasing constraints
+        mutable char data;
+      };
+
+      /**
+       * The unusable class is a placeholder for unused function arguments
+       * It is also completely unusable except that it constructable from
+       * anything. This helps compilers without partial specialization to
+       * handle Boost.Function objects returning void.
+       */
+      struct unusable
+      {
+        unusable() {}
+        template<typename T> unusable(const T&) {}
+      };
+
+      /* Determine the return type. This supports compilers that do not support
+       * void returns or partial specialization by silently changing the return
+       * type to "unusable".
+       */
+      template<typename T> struct function_return_type { typedef T type; };
+
+      template<>
+      struct function_return_type<void>
+      {
+        typedef unusable type;
+      };
+
+      // The operation type to perform on the given functor/function pointer
+      enum functor_manager_operation_type {
+        clone_functor_tag,
+        move_functor_tag,
+        destroy_functor_tag,
+        check_functor_type_tag,
+        get_functor_type_tag
+      };
+
+      // Tags used to decide between different types of functions
+      struct function_ptr_tag {};
+      struct function_obj_tag {};
+      struct member_ptr_tag {};
+      struct function_obj_ref_tag {};
+
+      template<typename F>
+      class get_function_tag
+      {
+        typedef typename mpl::if_c<(is_pointer<F>::value),
+                                   function_ptr_tag,
+                                   function_obj_tag>::type ptr_or_obj_tag;
+
+        typedef typename mpl::if_c<(is_member_pointer<F>::value),
+                                   member_ptr_tag,
+                                   ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
+
+        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
+                                   function_obj_ref_tag,
+                                   ptr_or_obj_or_mem_tag>::type or_ref_tag;
+
+      public:
+        typedef or_ref_tag type;
+      };
+
+      // The trivial manager does nothing but return the same pointer (if we
+      // are cloning) or return the null pointer (if we are deleting).
+      template<typename F>
+      struct reference_manager
+      {
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
+               functor_manager_operation_type op)
+        {
+          switch (op) {
+          case clone_functor_tag: 
+            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
+            return;
+
+          case move_functor_tag:
+            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
+            in_buffer.obj_ref.obj_ptr = 0;
+            return;
+
+          case destroy_functor_tag:
+            out_buffer.obj_ref.obj_ptr = 0;
+            return;
+
+          case check_functor_type_tag:
+            {
+              const BOOST_FUNCTION_STD_NS::type_info& check_type 
+                = *out_buffer.type.type;
+
+              // Check whether we have the same type. We can add
+              // cv-qualifiers, but we can't take them away.
+              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F))
+                  && (!in_buffer.obj_ref.is_const_qualified 
+                      || out_buffer.type.const_qualified)
+                  && (!in_buffer.obj_ref.is_volatile_qualified
+                      || out_buffer.type.volatile_qualified))
+                out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
+              else
+                out_buffer.obj_ptr = 0;
+            }
+            return;
+
+          case get_functor_type_tag:
+            out_buffer.type.type = &typeid(F);
+            out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
+            out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
+            return;
+          }
+        }
+      };
+
+      /**
+       * Determine if boost::function can use the small-object
+       * optimization with the function object type F.
+       */
+      template<typename F>
+      struct function_allows_small_object_optimization
+      {
+        BOOST_STATIC_CONSTANT
+          (bool, 
+           value = ((sizeof(F) <= sizeof(function_buffer) &&
+                     (alignment_of<function_buffer>::value 
+                      % alignment_of<F>::value == 0))));
+      };
+
+      template <typename F,typename A>
+      struct functor_wrapper: public F, public A
+      {
+        functor_wrapper( F f, A a ):
+          F(f),
+          A(a)
+        {
+        }
+      };
+
+      /**
+       * The functor_manager class contains a static function "manage" which
+       * can clone or destroy the given function/function object pointer.
+       */
+      template<typename Functor>
+      struct functor_manager_common
+      {
+        typedef Functor functor_type;
+
+        // Function pointers
+        static inline void
+        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op)
+        {
+          if (op == clone_functor_tag)
+            out_buffer.func_ptr = in_buffer.func_ptr;
+          else if (op == move_functor_tag) {
+            out_buffer.func_ptr = in_buffer.func_ptr;
+            in_buffer.func_ptr = 0;
+          } else if (op == destroy_functor_tag)
+            out_buffer.func_ptr = 0;
+          else if (op == check_functor_type_tag) {
+            const BOOST_FUNCTION_STD_NS::type_info& check_type 
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+              out_buffer.obj_ptr = &in_buffer.func_ptr;
+            else
+              out_buffer.obj_ptr = 0;
+          } else /* op == get_functor_type_tag */ {
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+          }
+        }
+
+        // Function objects that fit in the small-object buffer.
+        static inline void
+        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op)
+        {
+          if (op == clone_functor_tag || op == move_functor_tag) {
+            const functor_type* in_functor = 
+              reinterpret_cast<const functor_type*>(&in_buffer.data);
+            new ((void*)&out_buffer.data) functor_type(*in_functor);
+
+            if (op == move_functor_tag) {
+              reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor();
+            }
+          } else if (op == destroy_functor_tag) {
+            // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
+            reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
+          } else if (op == check_functor_type_tag) {
+            const BOOST_FUNCTION_STD_NS::type_info& check_type 
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+              out_buffer.obj_ptr = &in_buffer.data;
+            else
+              out_buffer.obj_ptr = 0;
+          } else /* op == get_functor_type_tag */ {
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;            
+          }
+        }
+      };
+
+      template<typename Functor>
+      struct functor_manager
+      {
+      private:
+        typedef Functor functor_type;
+
+        // Function pointers
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, function_ptr_tag)
+        {
+          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
+        }
+
+        // Function objects that fit in the small-object buffer.
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, mpl::true_)
+        {
+          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
+        }
+        
+        // Function objects that require heap allocation
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, mpl::false_)
+        {
+          if (op == clone_functor_tag) {
+            // Clone the functor
+            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
+            // can't do the static_cast that we should do.
+            const functor_type* f =
+              (const functor_type*)(in_buffer.obj_ptr);
+            functor_type* new_f = new functor_type(*f);
+            out_buffer.obj_ptr = new_f;
+          } else if (op == move_functor_tag) {
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
+            in_buffer.obj_ptr = 0;
+          } else if (op == destroy_functor_tag) {
+            /* Cast from the void pointer to the functor pointer type */
+            functor_type* f =
+              static_cast<functor_type*>(out_buffer.obj_ptr);
+            delete f;
+            out_buffer.obj_ptr = 0;
+          } else if (op == check_functor_type_tag) {
+            const BOOST_FUNCTION_STD_NS::type_info& check_type
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+              out_buffer.obj_ptr = in_buffer.obj_ptr;
+            else
+              out_buffer.obj_ptr = 0;
+          } else /* op == get_functor_type_tag */ {
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+          }
+        }
+
+        // For function objects, we determine whether the function
+        // object can use the small-object optimization buffer or
+        // whether we need to allocate it on the heap.
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, function_obj_tag)
+        {
+          manager(in_buffer, out_buffer, op,
+                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+        }
+
+        // For member pointers, we use the small-object optimization buffer.
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, member_ptr_tag)
+        {
+          manager(in_buffer, out_buffer, op, mpl::true_());
+        }
+
+      public:
+        /* Dispatch to an appropriate manager based on whether we have a
+           function pointer or a function object pointer. */
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
+               functor_manager_operation_type op)
+        {
+          typedef typename get_function_tag<functor_type>::type tag_type;
+          switch (op) {
+          case get_functor_type_tag:
+            out_buffer.type.type = &typeid(functor_type);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+            return;
+
+          default:
+            manager(in_buffer, out_buffer, op, tag_type());
+            return;
+          }
+        }
+      };
+
+      template<typename Functor, typename Allocator>
+      struct functor_manager_a
+      {
+      private:
+        typedef Functor functor_type;
+
+        // Function pointers
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, function_ptr_tag)
+        {
+          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
+        }
+
+        // Function objects that fit in the small-object buffer.
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, mpl::true_)
+        {
+          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
+        }
+        
+        // Function objects that require heap allocation
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, mpl::false_)
+        {
+          typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+
+          if (op == clone_functor_tag) {
+            // Clone the functor
+            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
+            // can't do the static_cast that we should do.
+            const functor_wrapper_type* f =
+              (const functor_wrapper_type*)(in_buffer.obj_ptr);
+            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
+            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+            wrapper_allocator.construct(copy, *f);
+
+            // Get back to the original pointer type
+            functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+            out_buffer.obj_ptr = new_f;
+          } else if (op == move_functor_tag) {
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
+            in_buffer.obj_ptr = 0;
+          } else if (op == destroy_functor_tag) {
+            /* Cast from the void pointer to the functor_wrapper_type */
+            functor_wrapper_type* victim =
+              static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
+            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
+            wrapper_allocator.destroy(victim);
+            wrapper_allocator.deallocate(victim,1);
+            out_buffer.obj_ptr = 0;
+          } else if (op == check_functor_type_tag) {
+            const BOOST_FUNCTION_STD_NS::type_info& check_type 
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+              out_buffer.obj_ptr = in_buffer.obj_ptr;
+            else
+              out_buffer.obj_ptr = 0;
+          } else /* op == get_functor_type_tag */ {
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+          }
+        }
+
+        // For function objects, we determine whether the function
+        // object can use the small-object optimization buffer or
+        // whether we need to allocate it on the heap.
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, function_obj_tag)
+        {
+          manager(in_buffer, out_buffer, op,
+                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+        }
+
+      public:
+        /* Dispatch to an appropriate manager based on whether we have a
+           function pointer or a function object pointer. */
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
+               functor_manager_operation_type op)
+        {
+          typedef typename get_function_tag<functor_type>::type tag_type;
+          switch (op) {
+          case get_functor_type_tag:
+            out_buffer.type.type = &typeid(functor_type);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+            return;
+
+          default:
+            manager(in_buffer, out_buffer, op, tag_type());
+            return;
+          }
+        }
+      };
+
+      // A type that is only used for comparisons against zero
+      struct useless_clear_type {};
+
+#ifdef BOOST_NO_SFINAE
+      // These routines perform comparisons between a Boost.Function
+      // object and an arbitrary function object (when the last
+      // parameter is mpl::bool_<false>) or against zero (when the
+      // last parameter is mpl::bool_<true>). They are only necessary
+      // for compilers that don't support SFINAE.
+      template<typename Function, typename Functor>
+        bool
+        compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
+        { return f.empty(); }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_not_equal(const Function& f, const Functor&, int,
+                          mpl::bool_<true>)
+        { return !f.empty(); }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_equal(const Function& f, const Functor& g, long,
+                      mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return function_equal(*fp, g);
+          else return false;
+        }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_equal(const Function& f, const reference_wrapper<Functor>& g,
+                      int, mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return fp == g.get_pointer();
+          else return false;
+        }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_not_equal(const Function& f, const Functor& g, long,
+                          mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return !function_equal(*fp, g);
+          else return true;
+        }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_not_equal(const Function& f,
+                          const reference_wrapper<Functor>& g, int,
+                          mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return fp != g.get_pointer();
+          else return true;
+        }
+#endif // BOOST_NO_SFINAE
+
+      /**
+       * Stores the "manager" portion of the vtable for a
+       * boost::function object.
+       */
+      struct vtable_base
+      {
+        void (*manager)(const function_buffer& in_buffer, 
+                        function_buffer& out_buffer, 
+                        functor_manager_operation_type op);
+      };
+    } // end namespace function
+  } // end namespace detail
+
+/**
+ * The function_base class contains the basic elements needed for the
+ * function1, function2, function3, etc. classes. It is common to all
+ * functions (and as such can be used to tell if we have one of the
+ * functionN objects).
+ */
+class function_base
+{
+public:
+  function_base() : vtable(0) { }
+
+  /** Determine if the function is empty (i.e., has no target). */
+  bool empty() const { return !vtable; }
+
+  /** Retrieve the type of the stored function object, or typeid(void)
+      if this is empty. */
+  const BOOST_FUNCTION_STD_NS::type_info& target_type() const
+  {
+    if (!vtable) return typeid(void);
+
+    detail::function::function_buffer type;
+    vtable->manager(functor, type, detail::function::get_functor_type_tag);
+    return *type.type.type;
+  }
+
+  template<typename Functor>
+    Functor* target()
+    {
+      if (!vtable) return 0;
+
+      detail::function::function_buffer type_result;
+      type_result.type.type = &typeid(Functor);
+      type_result.type.const_qualified = is_const<Functor>::value;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
+      vtable->manager(functor, type_result, 
+                      detail::function::check_functor_type_tag);
+      return static_cast<Functor*>(type_result.obj_ptr);
+    }
+
+  template<typename Functor>
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+    const Functor* target( Functor * = 0 ) const
+#else
+    const Functor* target() const
+#endif
+    {
+      if (!vtable) return 0;
+
+      detail::function::function_buffer type_result;
+      type_result.type.type = &typeid(Functor);
+      type_result.type.const_qualified = true;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
+      vtable->manager(functor, type_result, 
+                      detail::function::check_functor_type_tag);
+      // GCC 2.95.3 gets the CV qualifiers wrong here, so we
+      // can't do the static_cast that we should do.
+      return (const Functor*)(type_result.obj_ptr);
+    }
+
+  template<typename F>
+    bool contains(const F& f) const
+    {
+#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+      if (const F* fp = this->target( (F*)0 ))
+#else
+      if (const F* fp = this->template target<F>())
+#endif
+      {
+        return function_equal(*fp, f);
+      } else {
+        return false;
+      }
+    }
+
+#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
+  // GCC 3.3 and newer cannot copy with the global operator==, due to
+  // problems with instantiation of function return types before it
+  // has been verified that the argument types match up.
+  template<typename Functor>
+    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+    operator==(Functor g) const
+    {
+      if (const Functor* fp = target<Functor>())
+        return function_equal(*fp, g);
+      else return false;
+    }
+
+  template<typename Functor>
+    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+    operator!=(Functor g) const
+    {
+      if (const Functor* fp = target<Functor>())
+        return !function_equal(*fp, g);
+      else return true;
+    }
+#endif
+
+public: // should be protected, but GCC 2.95.3 will fail to allow access
+  detail::function::vtable_base* vtable;
+  mutable detail::function::function_buffer functor;
+};
+
+/**
+ * The bad_function_call exception class is thrown when a boost::function
+ * object is invoked
+ */
+class bad_function_call : public std::runtime_error
+{
+public:
+  bad_function_call() : std::runtime_error("call to empty boost::function") {}
+};
+
+#ifndef BOOST_NO_SFINAE
+inline bool operator==(const function_base& f,
+                       detail::function::useless_clear_type*)
+{
+  return f.empty();
+}
+
+inline bool operator!=(const function_base& f,
+                       detail::function::useless_clear_type*)
+{
+  return !f.empty();
+}
+
+inline bool operator==(detail::function::useless_clear_type*,
+                       const function_base& f)
+{
+  return f.empty();
+}
+
+inline bool operator!=(detail::function::useless_clear_type*,
+                       const function_base& f)
+{
+  return !f.empty();
+}
+#endif
+
+#ifdef BOOST_NO_SFINAE
+// Comparisons between boost::function objects and arbitrary function objects
+template<typename Functor>
+  inline bool operator==(const function_base& f, Functor g)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_equal(f, g, 0, integral());
+  }
+
+template<typename Functor>
+  inline bool operator==(Functor g, const function_base& f)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_equal(f, g, 0, integral());
+  }
+
+template<typename Functor>
+  inline bool operator!=(const function_base& f, Functor g)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_not_equal(f, g, 0, integral());
+  }
+
+template<typename Functor>
+  inline bool operator!=(Functor g, const function_base& f)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_not_equal(f, g, 0, integral());
+  }
+#else
+
+#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
+// Comparisons between boost::function objects and arbitrary function
+// objects. GCC 3.3 and before has an obnoxious bug that prevents this
+// from working.
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator==(const function_base& f, Functor g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return function_equal(*fp, g);
+    else return false;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator==(Functor g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return function_equal(g, *fp);
+    else return false;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator!=(const function_base& f, Functor g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return !function_equal(*fp, g);
+    else return true;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator!=(Functor g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return !function_equal(g, *fp);
+    else return true;
+  }
+#  endif
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator==(const function_base& f, reference_wrapper<Functor> g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return fp == g.get_pointer();
+    else return false;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator==(reference_wrapper<Functor> g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return g.get_pointer() == fp;
+    else return false;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator!=(const function_base& f, reference_wrapper<Functor> g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return fp != g.get_pointer();
+    else return true;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator!=(reference_wrapper<Functor> g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return g.get_pointer() != fp;
+    else return true;
+  }
+
+#endif // Compiler supporting SFINAE
+
+namespace detail {
+  namespace function {
+    inline bool has_empty_target(const function_base* f)
+    {
+      return f->empty();
+    }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
+    inline bool has_empty_target(const void*)
+    {
+      return false;
+    }
+#else
+    inline bool has_empty_target(...)
+    {
+      return false;
+    }
+#endif
+  } // end namespace function
+} // end namespace detail
+} // end namespace boost
+
+#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
+#undef BOOST_FUNCTION_COMPARE_TYPE_ID
+
+#endif // BOOST_FUNCTION_BASE_HEADER

include/boost/function/function_fwd.hpp

@@ -0,0 +1,70 @@
+// 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)                         \
+ || !(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

@@ -0,0 +1,45 @@
+// 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

@@ -0,0 +1,26 @@
+#!/usr/bin/perl -w
+#
+# Boost.Function library
+#
+# Copyright Douglas Gregor 2001-2003. Use, modification and
+# distribution is subject to the Boost Software License, Version
+# 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+# For more information, see http://www.boost.org
+use English;
+
+if ($#ARGV < 0) {
+  print "Usage: perl gen_function_N <number of arguments>\n";
+  exit;
+}
+
+
+$totalNumArgs = $ARGV[0];
+for ($numArgs = 0; $numArgs <= $totalNumArgs; ++$numArgs) {
+  open OUT, ">function$numArgs.hpp";
+  print OUT "#define BOOST_FUNCTION_NUM_ARGS $numArgs\n";
+  print OUT "#include <boost/function/detail/maybe_include.hpp>\n";
+  print OUT "#undef BOOST_FUNCTION_NUM_ARGS\n";
+  close OUT;
+}

include/boost/function_equal.hpp

@@ -0,0 +1,28 @@
+//  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,9 +1,20 @@
 <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>
+<a href="../../doc/html/function.html">../../doc/html/function.html</a> &nbsp;<hr>
+<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/CMakeLists.txt

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

test/Jamfile

@@ -1,67 +0,0 @@
-# Function library
-
-# Copyright (C) 2001-2003 Douglas Gregor
-
-# Use, modification and distribution is subject to the Boost Software License, 
-# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
-# http://www.boost.org/LICENSE_1_0.txt) 
-
-# For more information, see http://www.boost.org/
-
-
-# Testing Jamfile autogenerated from XML source
-subproject libs/function/test ;
-
-# bring in rules for testing
-SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
-include testing.jam ;
-
-# Make tests run by default.
-DEPENDS all : test ;
-
-{
-  # look in BOOST_ROOT for sources first, just in this Jamfile
-  local SEARCH_SOURCE = $(BOOST_ROOT) $(SEARCH_SOURCE) ;
-
-  test-suite function
-    : 
-  [ run libs/function/test/function_test.cpp :  :  :  : lib_function_test ]
-
-  [ run libs/function/test/function_n_test.cpp :  :  :  :  ]
-
-  [ run libs/function/test/allocator_test.cpp :  :  :  :  ]
-
-  [ run libs/function/test/stateless_test.cpp :  :  :  :  ]
-
-  [ run libs/function/test/lambda_test.cpp :  :  :  :  ]
-
-  [ compile-fail libs/function/test/function_test_fail1.cpp :  :  :  :  ]
-
-  [ compile-fail libs/function/test/function_test_fail2.cpp :  :  :  :  ]
-
-  [ compile libs/function/test/function_30.cpp :  :  :  :  ] 
-
-  [ run libs/function/test/function_arith_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_arith_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/sum_avg_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/sum_avg_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/mem_fun_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/mem_fun_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/std_bind_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/std_bind_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_ref_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_ref_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/contains_test.cpp : : : : ]
- ;
-}
-      

test/Jamfile.v2

@@ -56,6 +56,11 @@ import testing ;
   
   [ 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

@@ -27,6 +27,14 @@ 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)
   {
@@ -41,9 +49,25 @@ 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; }
 
-struct DoNothing
+template <typename base>
+struct DoNothing: base
 {
   void operator()() const {}
 };
@@ -53,28 +77,56 @@ static void do_nothing() {}
 int
 test_main(int, char*[])
 {
-  function2<int, int, int, counting_allocator<int> > f;
-  f = plus<int>();
+  function2<int, int, int> f;
+  f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<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 = &do_minus;
+  f.assign( &do_minus, counting_allocator<int>() );
+  f.clear();
+  BOOST_CHECK(alloc_count == 0);
+  BOOST_CHECK(dealloc_count == 0);
+  f.assign( &do_minus, std::allocator<int>() );
   f.clear();
 
-  function0<void, counting_allocator<int> > fv;
+  function0<void> fv;
   alloc_count = 0;
   dealloc_count = 0;
-  fv = DoNothing();
+  fv.assign( DoNothing<disable_small_object_optimization>(), counting_allocator<int>() );
+  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 = &do_nothing;
+  fv.assign( &do_nothing, counting_allocator<int>() );
+  fv.clear();
+  BOOST_CHECK(alloc_count == 0);
+  BOOST_CHECK(dealloc_count == 0);
+  fv.assign( &do_nothing, std::allocator<int>() );
   fv.clear();
 
   return 0;

test/contains2_test.cpp

@@ -0,0 +1,88 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2004.
+//  Copyright 2005 Peter Dimov
+
+//  Use, modification and distribution is subject to
+//  the Boost Software License, Version 1.0.
+//  (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/function.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+static int forty_two()
+{
+    return 42;
+}
+
+struct Seventeen
+{
+    int operator()() const
+    {
+        return 17;
+    }
+};
+
+bool operator==(const Seventeen&, const Seventeen&)
+{
+    return true;
+}
+
+struct ReturnInt
+{
+    explicit ReturnInt(int value) : value(value)
+    {
+    }
+
+    int operator()() const
+    {
+        return value;
+    }
+
+    int value;
+};
+
+bool operator==(const ReturnInt& x, const ReturnInt& y)
+{
+    return x.value == y.value;
+}
+
+bool operator!=(const ReturnInt& x, const ReturnInt& y)
+{
+    return x.value != y.value;
+}
+
+int main()
+{
+    boost::function0<int> fn;
+
+    fn = &forty_two;
+
+    BOOST_TEST( fn() == 42 );
+
+    BOOST_TEST( fn.contains(&forty_two) );
+    BOOST_TEST( !fn.contains( Seventeen() ) );
+    BOOST_TEST( !fn.contains( ReturnInt(0) ) );
+    BOOST_TEST( !fn.contains( ReturnInt(12) ) );
+
+    fn = Seventeen();
+
+    BOOST_TEST( fn() == 17 );
+
+    BOOST_TEST( !fn.contains( &forty_two ) );
+    BOOST_TEST( fn.contains( Seventeen() ) );
+    BOOST_TEST( !fn.contains( ReturnInt(0) ) );
+    BOOST_TEST( !fn.contains( ReturnInt(12) ) );
+
+    fn = ReturnInt(12);
+
+    BOOST_TEST( fn() == 12 );
+
+    BOOST_TEST( !fn.contains( &forty_two ) );
+    BOOST_TEST( !fn.contains( Seventeen() ) );
+    BOOST_TEST( !fn.contains( ReturnInt(0) ) );
+    BOOST_TEST( fn.contains( ReturnInt(12) ) );
+
+    return boost::report_errors();
+}

test/contains_test.cpp

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

test/function_n_test.cpp

@@ -56,30 +56,30 @@ test_zero_args()
 
   // Default construction
   func_void_type v1;
-  BOOST_TEST(v1.empty());
+  BOOST_CHECK(v1.empty());
 
   // Assignment to an empty function
   v1 = five;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation of a function
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear() method
   v1.clear();
-  BOOST_TEST(!v1);
+  BOOST_CHECK(!v1);
 
   // Assignment to an empty function
   v1 = three;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation and self-assignment
   global_int = 0;
   v1 = v1;
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(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_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear
   v1 = 0;
-  BOOST_TEST(v1.empty());
+  BOOST_CHECK(v1.empty());
 
   // Assignment to an empty function from a free function
   v1 = &write_five;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v1 = &write_three;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v1 = five;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v1 = write_three;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Construction from another function (that is empty)
   v1.clear();
   func_void_type v2(v1);
-  BOOST_TEST(!v2? true : false);
+  BOOST_CHECK(!v2? true : false);
 
   // Assignment to an empty function
   v2 = three;
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v2 = (five);
@@ -150,86 +150,86 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   v2.clear();
-  BOOST_TEST(v2.empty());
+  BOOST_CHECK(v2.empty());
 
   // Assignment to an empty function from a free function
   v2 = (&write_five);
-  BOOST_TEST(v2? true : false);
+  BOOST_CHECK(v2? true : false);
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v2 = &write_three;
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Swapping
   v1 = five;
   swap(v1, v2);
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
   swap(v1, v2);
   v1.clear();
 
   // Assignment
   v2 = five;
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v2 = &write_three;
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a function from an empty function
   v2 = v1;
-  BOOST_TEST(v2.empty());
+  BOOST_CHECK(v2.empty());
 
   // Assignment to a function from a function with a functor
   v1 = three;
   v2 = v1;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v1.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assign to a function from a function with a function
   v2 = &write_five;
   v1 = v2;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v1.empty());
+  BOOST_CHECK(!v2.empty());
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(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_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear() method
   v3.clear();
-  BOOST_TEST(!v3? true : false);
+  BOOST_CHECK(!v3? true : false);
 
   // Assignment to an empty function
   v3 = three;
-  BOOST_TEST(!v3.empty());
+  BOOST_CHECK(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v3 = five;
@@ -258,38 +258,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear()
   v3.clear();
-  BOOST_TEST(v3.empty());
+  BOOST_CHECK(v3.empty());
 
   // Assignment to an empty function from a free function
   v3 = &write_five;
-  BOOST_TEST(!v3.empty());
+  BOOST_CHECK(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v3 = &write_three;
-  BOOST_TEST(!v3.empty());
+  BOOST_CHECK(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v3 = five;
-  BOOST_TEST(!v3.empty());
+  BOOST_CHECK(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(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_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear() method
   v4.clear();
-  BOOST_TEST(v4.empty());
+  BOOST_CHECK(v4.empty());
 
   // Assignment to an empty function
   v4 = three;
-  BOOST_TEST(!v4.empty());
+  BOOST_CHECK(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v4 = five;
@@ -318,38 +318,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear()
   v4.clear();
-  BOOST_TEST(v4.empty());
+  BOOST_CHECK(v4.empty());
 
   // Assignment to an empty function from a free function
   v4 = &write_five;
-  BOOST_TEST(!v4.empty());
+  BOOST_CHECK(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v4 = &write_three;
-  BOOST_TEST(!v4.empty());
+  BOOST_CHECK(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v4 = five;
-  BOOST_TEST(!v4.empty());
+  BOOST_CHECK(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(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_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear() method
   v5.clear();
-  BOOST_TEST(v5.empty());
+  BOOST_CHECK(v5.empty());
 
   // Assignment to an empty function
   v5 = three;
-  BOOST_TEST(!v5.empty());
+  BOOST_CHECK(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v5 = five;
@@ -378,38 +378,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear()
   v5.clear();
-  BOOST_TEST(v5.empty());
+  BOOST_CHECK(v5.empty());
 
   // Assignment to an empty function from a free function
   v5 = &write_five;
-  BOOST_TEST(!v5.empty());
+  BOOST_CHECK(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v5 = &write_three;
-  BOOST_TEST(!v5.empty());
+  BOOST_CHECK(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v5 = five;
-  BOOST_TEST(!v5.empty());
+  BOOST_CHECK(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(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_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear() method
   v6.clear();
-  BOOST_TEST(v6.empty());
+  BOOST_CHECK(v6.empty());
 
   // Assignment to an empty function
   v6 = three;
-  BOOST_TEST(!v6.empty());
+  BOOST_CHECK(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v6 = five;
@@ -438,38 +438,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear()
   v6.clear();
-  BOOST_TEST(v6.empty());
+  BOOST_CHECK(v6.empty());
 
   // Assignment to an empty function from a free function
   v6 = &write_five;
-  BOOST_TEST(!v6.empty());
+  BOOST_CHECK(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v6 = &write_three;
-  BOOST_TEST(!v6.empty());
+  BOOST_CHECK(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v6 = five;
-  BOOST_TEST(!v6.empty());
+  BOOST_CHECK(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(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_TEST(global_int == 2);
+  BOOST_CHECK(global_int == 2);
 
   global_int = 0;
   v8();
-  BOOST_TEST(global_int == 2);
+  BOOST_CHECK(global_int == 2);
 
   // Test construction from 0 and comparison to 0
   func_void_type v9(0);
-  BOOST_TEST(v9 == 0);
+  BOOST_CHECK(v9 == 0);
 # if !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540 || defined(BOOST_STRICT_CONFIG)
-  BOOST_TEST(0 == v9);
+  BOOST_CHECK(0 == v9);
 #else
-  BOOST_TEST(v9.empty());
+  BOOST_CHECK(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_TEST(i0() == 5);
+  BOOST_CHECK(i0() == 5);
   i0 = gen_three;
-  BOOST_TEST(i0() == 3);
+  BOOST_CHECK(i0() == 3);
   i0 = &generate_five;
-  BOOST_TEST(i0() == 5);
+  BOOST_CHECK(i0() == 5);
   i0 = &generate_three;
-  BOOST_TEST(i0() == 3);
-  BOOST_TEST(i0? true : false);
+  BOOST_CHECK(i0() == 3);
+  BOOST_CHECK(i0? true : false);
   i0.clear();
-  BOOST_TEST(!i0? true : false);
+  BOOST_CHECK(!i0? true : false);
 
   // Test return values with compatible types
   typedef function0<long> func_long_type;
   func_long_type i1(gen_five);
 
-  BOOST_TEST(i1() == 5);
+  BOOST_CHECK(i1() == 5);
   i1 = gen_three;
-  BOOST_TEST(i1() == 3);
+  BOOST_CHECK(i1() == 3);
   i1 = &generate_five;
-  BOOST_TEST(i1() == 5);
+  BOOST_CHECK(i1() == 5);
   i1 = &generate_three;
-  BOOST_TEST(i1() == 3);
-  BOOST_TEST(i1? true : false);
+  BOOST_CHECK(i1() == 3);
+  BOOST_CHECK(i1? true : false);
   i1.clear();
-  BOOST_TEST(!i1? true : false);
+  BOOST_CHECK(!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_TEST(f1(5) == -5);
+  BOOST_CHECK(f1(5) == -5);
 
   function1<string, string> id(&identity_str);
-  BOOST_TEST(id("str") == "str");
+  BOOST_CHECK(id("str") == "str");
 
   function1<std::string, const char*> id2(&identity_str);
-  BOOST_TEST(id2("foo") == "foo");
+  BOOST_CHECK(id2("foo") == "foo");
 
   add_to_obj add_to(5);
   function1<int, int> f2(add_to);
-  BOOST_TEST(f2(3) == 8);
+  BOOST_CHECK(f2(3) == 8);
 
   const function1<int, int> cf2(add_to);
-  BOOST_TEST(cf2(3) == 8);
+  BOOST_CHECK(cf2(3) == 8);
 }
 
 static void
 test_two_args()
 {
   function2<string, const string&, const string&> cat(&string_cat);
-  BOOST_TEST(cat("str", "ing") == "string");
+  BOOST_CHECK(cat("str", "ing") == "string");
 
   function2<int, short, short> sum(&sum_ints);
-  BOOST_TEST(sum(2, 3) == 5);
+  BOOST_CHECK(sum(2, 3) == 5);
 }
 
 static void
 test_emptiness()
 {
   function0<float> f1;
-  BOOST_TEST(f1.empty());
+  BOOST_CHECK(f1.empty());
 
   function0<float> f2;
   f2 = f1;
-  BOOST_TEST(f2.empty());
+  BOOST_CHECK(f2.empty());
 
   function0<double> f3;
   f3 = f2;
-  BOOST_TEST(f3.empty());
+  BOOST_CHECK(f3.empty());
 }
 
 struct X {
@@ -593,18 +593,18 @@ test_member_functions()
   X one(1);
   X five(5);
 
-  BOOST_TEST(f1(&one) == 2);
-  BOOST_TEST(f1(&five) == 10);
+  BOOST_CHECK(f1(&one) == 2);
+  BOOST_CHECK(f1(&five) == 10);
 
   boost::function1<int, X*> f1_2;
   f1_2 = &X::twice;
 
-  BOOST_TEST(f1_2(&one) == 2);
-  BOOST_TEST(f1_2(&five) == 10);
+  BOOST_CHECK(f1_2(&one) == 2);
+  BOOST_CHECK(f1_2(&five) == 10);
 
   boost::function2<int, X&, int> f2(&X::plus);
-  BOOST_TEST(f2(one, 3) == 4);
-  BOOST_TEST(f2(five, 4) == 9);
+  BOOST_CHECK(f2(one, 3) == 4);
+  BOOST_CHECK(f2(five, 4) == 9);
 }
 
 struct add_with_throw_on_copy {
@@ -629,13 +629,61 @@ test_ref()
   add_with_throw_on_copy atc;
   try {
     boost::function2<int, int, int> f(ref(atc));
-    BOOST_TEST(f(1, 3) == 4);
+    BOOST_CHECK(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();
@@ -644,5 +692,6 @@ int test_main(int, char* [])
   test_emptiness();
   test_member_functions();
   test_ref();
+  test_construct_destroy_count();
   return 0;
 }

test/function_test.cpp

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

test/function_test_fail1.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright (C) Douglas Gregor 2001-2005. Use, modification and
 //  distribution is subject to the Boost Software License, Version
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
@@ -22,7 +22,7 @@ test_main(int, char*[])
   if (f1 == f2) {
   }
 
-  BOOST_CRITICAL_ERROR("This should not have compiled.");
+  BOOST_ERROR("This should not have compiled.");
 
   return 0;
 }

test/function_test_fail2.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  Copyright (C) Douglas Gregor 2001-2005. Use, modification and
 //  distribution is subject to the Boost Software License, Version
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
@@ -21,7 +21,7 @@ test_main(int, char*[])
   function0<int> f1;
   f1 = bad_fn;
 
-  BOOST_CRITICAL_ERROR("This should not have compiled.");
+  BOOST_ERROR("This should not have compiled.");
 
   return 0;
 }

test/function_typeof_test.cpp

@@ -0,0 +1,18 @@
+// 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/nothrow_swap.cpp

@@ -0,0 +1,60 @@
+// 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

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