Removed part of the Boost files from the SPIRIT_MINIBOOST branch.

[SVN r26368]

doc/Jamfile.v2

@@ -1,8 +1,3 @@
-#   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,11 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under the Boost Software License, Version 1.0.
-   (See accompanying file LICENSE_1_0.txt or copy at
-   http://www.boost.org/LICENSE_1_0.txt)
-  -->
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 <section id="function.faq" last-revision="$Date$">

doc/history.xml

@@ -1,25 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under the Boost Software License, Version 1.0.
-   (See accompanying file LICENSE_1_0.txt or copy at
-   http://www.boost.org/LICENSE_1_0.txt)
-  -->
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 <section id="function.history" last-revision="$Date$">
   <title>History &amp; Compatibility Notes</title>
 
 <itemizedlist spacing="compact">
-
-  <listitem><para><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> 
+  <listitem><para><emphasis role="bold">Version 1.30.0</emphasis>: </para> 
     <itemizedlist spacing="compact">
       <listitem><para>All features deprecated in version 1.29.0 have
       been removed from Boost.Function.</para></listitem>
@@ -46,7 +32,7 @@
       </itemizedlist>
   </listitem>
 
-  <listitem><para><bold>Version 1.29.0</bold>:
+  <listitem><para><emphasis role="bold">Version 1.29.0</emphasis>:
   Boost.Function has been partially redesigned to minimize the
   interface and make it cleaner. Several seldom- or never-used
   features of the older Boost.Function have been deprecated and will

doc/misc.xml

@@ -1,11 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under the Boost Software License, Version 1.0.
-   (See accompanying file LICENSE_1_0.txt or copy at
-   http://www.boost.org/LICENSE_1_0.txt)
-  -->
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 <section id="function.misc" last-revision="$Date$">

doc/reference.xml

@@ -1,11 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under the Boost Software License, Version 1.0.
-   (See accompanying file LICENSE_1_0.txt or copy at
-   http://www.boost.org/LICENSE_1_0.txt)
-  -->
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 
@@ -125,12 +118,6 @@
         <returns><simpara><code>true</code> if <code>this-&gt;<methodname>target</methodname>&lt;Functor&gt;()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this-&gt;target&lt;Functor&gt;()), f)</code></simpara></returns>
  
       </method>
-
-      <method name="target_type" cv="const">
-        <type>const std::type_info&amp;</type>
-        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
-        <throws><simpara>Will not throw.</simpara></throws>
-      </method>
     </method-group>
   </class>
 
@@ -195,7 +182,7 @@
     </struct>
 
     <constructor>
-      <postconditions><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></postconditions>
+      <postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
       <throws><simpara>Will not throw.</simpara></throws>
     </constructor>
 
@@ -214,10 +201,11 @@
       <parameter name="f"><paramtype>F</paramtype></parameter>
       <requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
       <postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-&gt;<methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
+      <throws><simpara>Will not throw when <code>f</code> is a stateless function object.</simpara></throws>
     </constructor>
 
     <destructor>
-      <effects><simpara>If <code>!this-&gt;<methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
+      <effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
 
     </destructor>
 
@@ -225,7 +213,8 @@
       <parameter name="f">
         <paramtype>const <classname>functionN</classname>&amp;</paramtype>
       </parameter>
-      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
+      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
+      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object.</simpara></throws>
     </copy-assignment>
 
     <method-group name="modifiers">
@@ -233,11 +222,13 @@
         <type>void</type>
         <parameter name="f"><paramtype>const <classname>functionN</classname>&amp;</paramtype></parameter>
         <effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
+        <throws><simpara>Will not throw.</simpara></throws>
       </method>
 
       <method name="clear">
         <type>void</type>
         <postconditions><simpara>this-&gt;<methodname>empty</methodname>()</simpara></postconditions>
+        <throws><simpara>Will not throw.</simpara></throws>
       </method>
     </method-group>
 
@@ -295,13 +286,6 @@
         <returns><simpara><code>true</code> if <code>this-&gt;<methodname>target</methodname>&lt;Functor&gt;()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this-&gt;target&lt;Functor&gt;()), f)</code></simpara></returns>
  
       </method>
-
-      <method name="target_type" cv="const">
-        <type>const std::type_info&amp;</type>
-        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
-        <throws><simpara>Will not throw.</simpara></throws>
-      </method>
-
     </method-group>
 
     <method-group name="invocation">
@@ -313,7 +297,7 @@
         <parameter name="aN"><paramtype>argN_type</paramtype></parameter>
         <effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
         <returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
-        <throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-&gt;<methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
+        <throws><simpara><code><classname>bad_function_call</classname></code> if <code>!this-&gt;<methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
       </method>
     </method-group>
 
@@ -330,6 +314,7 @@
         <parameter name="f1"><paramtype><classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
         <parameter name="f2"><paramtype><classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
         <effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
+        <throws><simpara>Will not throw.</simpara></throws>
       </function>
     </free-function-group>
 
@@ -604,7 +589,7 @@
     </struct>
 
     <constructor>
-      <postconditions><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></postconditions>
+      <postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
       <throws><simpara>Will not throw.</simpara></throws>
     </constructor>
 
@@ -631,26 +616,28 @@
       <parameter name="f"><paramtype>F</paramtype></parameter>
       <requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
       <postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-&gt;<methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
+      <throws><simpara>Will not throw when <code>f</code> is a stateless function object.</simpara></throws>
     </constructor>
 
     <destructor>
-      <effects><simpara>If <code>!this-&gt;<methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
+      <effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
 
     </destructor>
 
     <copy-assignment>
       <parameter name="f">
-        <paramtype>const <classname>function</classname>&amp;</paramtype>
+        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
       </parameter>
-      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
+      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code></simpara></postconditions>
+      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object.</simpara></throws>
     </copy-assignment>
 
     <copy-assignment>
       <parameter name="f">
         <paramtype>const <classname>function</classname>&amp;</paramtype>
       </parameter>
-      <postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
-      <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>
+      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code></simpara></postconditions>
+      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object.</simpara></throws>
     </copy-assignment>
 
     <method-group name="modifiers">
@@ -658,6 +645,7 @@
         <type>void</type>
         <parameter name="f"><paramtype>const <classname>function</classname>&amp;</paramtype></parameter>
         <effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
+        <throws><simpara>Will not throw.</simpara></throws>
       </method>
 
       <method name="clear">
@@ -720,12 +708,6 @@
         <returns><simpara><code>true</code> if <code>this-&gt;<methodname>target</methodname>&lt;Functor&gt;()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this-&gt;target&lt;Functor&gt;()), f)</code></simpara></returns>
  
       </method>
-
-      <method name="target_type" cv="const">
-        <type>const std::type_info&amp;</type>
-        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
-        <throws><simpara>Will not throw.</simpara></throws>
-      </method>
     </method-group>
 
     <method-group name="invocation">
@@ -737,7 +719,7 @@
         <parameter name="aN"><paramtype>argN_type</paramtype></parameter>
         <effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
         <returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
-        <throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-&gt;<methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
+        <throws><simpara><code><classname>bad_function_call</classname></code> if <code>!this-&gt;<methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
       </method>
     </method-group>
 
@@ -751,6 +733,7 @@
         <parameter name="f1"><paramtype><classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
         <parameter name="f2"><paramtype><classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
         <effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
+        <throws><simpara>Will not throw.</simpara></throws>
       </function>
     </free-function-group>
 

doc/tests.xml

@@ -1,11 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under the Boost Software License, Version 1.0.
-   (See accompanying file LICENSE_1_0.txt or copy at
-   http://www.boost.org/LICENSE_1_0.txt)
-  -->
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 <testsuite id="function.testsuite" last-revision="$Date$">

doc/tutorial.xml

@@ -1,11 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
-  
-   Distributed under the Boost Software License, Version 1.0.
-   (See accompanying file LICENSE_1_0.txt or copy at
-   http://www.boost.org/LICENSE_1_0.txt)
-  -->
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 <section xmlns:xi="http://www.w3.org/2001/XInclude" id="function.tutorial"
@@ -336,8 +329,8 @@ exceptions during assignment or construction.
   or <code>!=</code> against any function object that can be stored
   within the wrapper. If the function object wrapper contains a
   function object of that type, it will be compared against the given
-  function object (which must be either be
-  <conceptname>EqualityComparable</conceptname> or have an overloaded <functionname>boost::function_equal</functionname>). For instance:</para>
+  function object (which must be
+  <conceptname>EqualityComparable</conceptname>). For instance:</para>
   
   <programlisting name="function.tutorial.compare">int compute_with_X(X*, int);
 

include/boost/function.hpp

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

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

@@ -1,37 +0,0 @@
-#!/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

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

@@ -1,25 +0,0 @@
-// 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 <functional> // 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>
-#endif // BOOST_FUNCTION_PROLOGUE_HPP

include/boost/function/function0.hpp

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

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

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

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

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

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

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

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

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

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

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

@@ -1,762 +0,0 @@
-// Boost.Function library
-
-//  Copyright Douglas Gregor 2001-2006. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-// 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_integral.hpp>
-#include <boost/type_traits/composite_traits.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>
-
-#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_EXCEPTION_STD_NAMESPACE
-// Embedded VC++ does not have type_info in namespace std
-#  define BOOST_FUNCTION_STD_NS
-#else
-#  define BOOST_FUNCTION_STD_NS std
-#endif
-
-// Borrowed from Boost.Python library: determines the cases where we
-// need to use std::type_info::name to compare instead of operator==.
-# if (defined(__GNUC__) && __GNUC__ >= 3) \
- || 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 defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
-// Work around a compiler bug.
-// boost::python::objects::function has to be seen by the compiler before the
-// boost::function class template.
-namespace boost { namespace python { namespace objects {
-  class function;
-}}}
-#endif
-
-#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
- || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
- || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
-#  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
-#endif
-
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
-#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
-      typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
-                            (::boost::is_integral<Functor>::value)>::value), \
-                           Type>::type
-#else
-// BCC doesn't recognize this depends on a template argument and complains
-// about the use of 'typename'
-#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
-      ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
-                   (::boost::is_integral<Functor>::value)>::value), \
-                       Type>::type
-#endif
-
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-namespace boost {
-
-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
-// The library shipping with MIPSpro 7.3.1.3m has a broken allocator<void>
-class function_base;
-
-template<typename Signature,
-         typename Allocator = std::allocator<function_base> >
-class function;
-#else
-template<typename Signature, typename Allocator = std::allocator<void> >
-class function;
-#endif
-
-template<typename Signature, typename Allocator>
-inline void swap(function<Signature, Allocator>& f1,
-                 function<Signature, Allocator>& f2)
-{
-  f1.swap(f2);
-}
-
-} // end namespace boost
-#endif // have partial specialization
-
-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
-        void* obj_ptr;
-
-        // For pointers to std::type_info objects
-        // (get_functor_type_tag, check_functor_type_tag).
-        const void* const_obj_ptr;
-
-        // For function pointers of all kinds
-        mutable void (*func_ptr)();
-
-        // For bound member pointers
-        struct bound_memfunc_ptr_t {
-          void (X::*memfunc_ptr)(int);
-          void* obj_ptr;
-        } bound_memfunc_ptr;
-
-        // To relax aliasing constraints
-        mutable char data;
-      };
-
-      /**
-       * 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,
-        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_ptr = in_buffer.obj_ptr;
-            return;
-
-          case destroy_functor_tag:
-            out_buffer.obj_ptr = 0;
-            return;
-
-          case check_functor_type_tag:
-            {
-              // DPG TBD: Since we're only storing a pointer, it's
-              // possible that the user could ask for a base class or
-              // derived class. Is that okay?
-              const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-                *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
-                out_buffer.obj_ptr = in_buffer.obj_ptr;
-              else
-                out_buffer.obj_ptr = 0;
-            }
-            return;
-
-          case get_functor_type_tag:
-            out_buffer.const_obj_ptr = &typeid(F);
-            return;
-          }
-        }
-      };
-
-      /**
-       * Determine if boost::function can use the small-object
-       * optimization with the function object type F.
-       */
-      template<typename F>
-      struct function_allows_small_object_optimization
-      {
-        BOOST_STATIC_CONSTANT
-          (bool, 
-           value = ((sizeof(F) <= sizeof(function_buffer) &&
-                     (alignment_of<function_buffer>::value 
-                      % alignment_of<F>::value == 0))));
-      };
-
-      /**
-       * The functor_manager class contains a static function "manage" which
-       * can clone or destroy the given function/function object pointer.
-       */
-      template<typename Functor, typename Allocator>
-      struct functor_manager
-      {
-      private:
-        typedef Functor functor_type;
-
-        // For function pointers, the manager is trivial
-        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
-                functor_manager_operation_type op, function_ptr_tag)
-        {
-          if (op == clone_functor_tag)
-            out_buffer.func_ptr = in_buffer.func_ptr;
-          else if (op == destroy_functor_tag)
-            out_buffer.func_ptr = 0;
-          else /* op == check_functor_type_tag */ {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
-              out_buffer.obj_ptr = &in_buffer.func_ptr;
-            else
-              out_buffer.obj_ptr = 0;
-          }
-        }
-
-        // Function objects that fit in the small-object buffer.
-        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
-                functor_manager_operation_type op, mpl::true_)
-        {
-          if (op == clone_functor_tag) {
-            const functor_type* in_functor = 
-              reinterpret_cast<const functor_type*>(&in_buffer.data);
-            new ((void*)&out_buffer.data) functor_type(*in_functor);
-          } else if (op == destroy_functor_tag) {
-            // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
-            reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
-          } else /* op == check_functor_type_tag */ {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
-              out_buffer.obj_ptr = &in_buffer.data;
-            else
-              out_buffer.obj_ptr = 0;
-          }
-        }
-        
-        // Function objects that require heap allocation
-        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
-                functor_manager_operation_type op, mpl::false_)
-        {
-#ifndef BOOST_NO_STD_ALLOCATOR
-          typedef typename Allocator::template rebind<functor_type>::other
-            allocator_type;
-          typedef typename allocator_type::pointer pointer_type;
-#else
-          typedef functor_type* pointer_type;
-#endif // BOOST_NO_STD_ALLOCATOR
-
-#  ifndef BOOST_NO_STD_ALLOCATOR
-          allocator_type allocator;
-#  endif // BOOST_NO_STD_ALLOCATOR
-
-          if (op == clone_functor_tag) {
-            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
-            // can't do the static_cast that we should do.
-            const functor_type* f =
-              (const functor_type*)(in_buffer.obj_ptr);
-
-            // Clone the functor
-#  ifndef BOOST_NO_STD_ALLOCATOR
-            pointer_type copy = allocator.allocate(1);
-            allocator.construct(copy, *f);
-
-            // Get back to the original pointer type
-            functor_type* new_f = static_cast<functor_type*>(copy);
-#  else
-            functor_type* new_f = new functor_type(*f);
-#  endif // BOOST_NO_STD_ALLOCATOR
-            out_buffer.obj_ptr = new_f;
-          } else if (op == destroy_functor_tag) {
-            /* Cast from the void pointer to the functor pointer type */
-            functor_type* f =
-              static_cast<functor_type*>(out_buffer.obj_ptr);
-
-#  ifndef BOOST_NO_STD_ALLOCATOR
-            /* Cast from the functor pointer type to the allocator's pointer
-               type */
-            pointer_type victim = static_cast<pointer_type>(f);
-
-            // Destroy and deallocate the functor
-            allocator.destroy(victim);
-            allocator.deallocate(victim, 1);
-#  else
-            delete f;
-#  endif // BOOST_NO_STD_ALLOCATOR
-            out_buffer.obj_ptr = 0;
-          } else /* op == check_functor_type_tag */ {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
-              out_buffer.obj_ptr = in_buffer.obj_ptr;
-            else
-              out_buffer.obj_ptr = 0;
-          }
-        }
-
-        // For function objects, we determine whether the function
-        // 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 treat them as function objects with
-        // the small-object optimization always enabled.
-        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.const_obj_ptr = &typeid(functor_type);
-            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 *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(type.const_obj_ptr);
-  }
-
-  template<typename Functor>
-    Functor* target()
-    {
-      if (!vtable) return 0;
-
-      detail::function::function_buffer type_result;
-      type_result.const_obj_ptr = &typeid(Functor);
-      vtable->manager(functor, type_result, 
-                      detail::function::check_functor_type_tag);
-      return static_cast<Functor*>(type_result.obj_ptr);
-    }
-
-  template<typename Functor>
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    const Functor* target( Functor * = 0 ) const
-#else
-    const Functor* target() const
-#endif
-    {
-      if (!vtable) return 0;
-
-      detail::function::function_buffer type_result;
-      type_result.const_obj_ptr = &typeid(Functor);
-      vtable->manager(functor, type_result, 
-                      detail::function::check_functor_type_tag);
-      // 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
-  const 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
-
-#if defined(BOOST_MSVC)
-#   pragma warning( pop )
-#endif       
-
-#endif // BOOST_FUNCTION_BASE_HEADER

include/boost/function/function_template.hpp

@@ -1,969 +0,0 @@
-// Boost.Function library
-
-//  Copyright Douglas Gregor 2001-2006. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org
-
-// Note: this header is a header template and must NOT have multiple-inclusion
-// protection.
-#include <boost/function/detail/prologue.hpp>
-
-#if defined(BOOST_MSVC)
-#   pragma warning( push )
-#   pragma warning( disable : 4127 ) // "conditional expression is constant"
-#endif       
-
-#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
-
-#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
-
-#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
-
-#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
-
-#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
-
-#define BOOST_FUNCTION_ARG_TYPE(J,I,D) \
-  typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
-
-#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
-
-// Type of the default allocator
-#ifndef BOOST_NO_STD_ALLOCATOR
-#  define BOOST_FUNCTION_DEFAULT_ALLOCATOR std::allocator<function_base>
-#else
-#  define BOOST_FUNCTION_DEFAULT_ALLOCATOR int
-#endif // BOOST_NO_STD_ALLOCATOR
-
-// Comma if nonzero number of arguments
-#if BOOST_FUNCTION_NUM_ARGS == 0
-#  define BOOST_FUNCTION_COMMA
-#else
-#  define BOOST_FUNCTION_COMMA ,
-#endif // BOOST_FUNCTION_NUM_ARGS > 0
-
-// Class names used in this version of the code
-#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_FUNCTION_INVOKER \
-  BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER \
-  BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER \
-  BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \
-  BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_FUNCTION_REF_INVOKER \
-  BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
-  BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_MEMBER_INVOKER \
-  BOOST_JOIN(member_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \
-  BOOST_JOIN(void_member_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
-  BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
-  BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
-  BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_MEMBER_INVOKER \
-  BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_INVOKER \
-  BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
-
-#ifndef BOOST_NO_VOID_RETURNS
-#  define BOOST_FUNCTION_VOID_RETURN_TYPE void
-#  define BOOST_FUNCTION_RETURN(X) X
-#else
-#  define BOOST_FUNCTION_VOID_RETURN_TYPE boost::detail::function::unusable
-#  define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()
-#endif
-
-namespace boost {
-  namespace detail {
-    namespace function {
-      template<
-        typename FunctionPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
-        >
-      struct BOOST_FUNCTION_FUNCTION_INVOKER
-      {
-        static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_PARMS)
-        {
-          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
-          return f(BOOST_FUNCTION_ARGS);
-        }
-      };
-
-      template<
-        typename FunctionPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
-        >
-      struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-      {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
-
-        {
-          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
-          BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
-        }
-      };
-
-      template<
-        typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
-      >
-      struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-      {
-        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_PARMS)
-
-        {
-          FunctionObj* f;
-          if (function_allows_small_object_optimization<FunctionObj>::value)
-            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
-          else
-            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
-          return (*f)(BOOST_FUNCTION_ARGS);
-        }
-      };
-
-      template<
-        typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
-      >
-      struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-      {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
-
-        {
-          FunctionObj* f;
-          if (function_allows_small_object_optimization<FunctionObj>::value)
-            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
-          else
-            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
-          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
-        }
-      };
-
-      template<
-        typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
-      >
-      struct BOOST_FUNCTION_FUNCTION_REF_INVOKER
-      {
-        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_PARMS)
-
-        {
-          FunctionObj* f = 
-            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
-          return (*f)(BOOST_FUNCTION_ARGS);
-        }
-      };
-
-      template<
-        typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
-      >
-      struct BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
-      {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
-
-        {
-          FunctionObj* f = 
-            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
-          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
-        }
-      };
-
-#if BOOST_FUNCTION_NUM_ARGS > 0
-      /* Handle invocation of member pointers. */
-      template<
-        typename MemberPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
-      >
-      struct BOOST_FUNCTION_MEMBER_INVOKER
-      {
-        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-                        BOOST_FUNCTION_PARMS)
-
-        {
-          MemberPtr* f = 
-            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
-          return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
-        }
-      };
-
-      template<
-        typename MemberPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
-      >
-      struct BOOST_FUNCTION_VOID_MEMBER_INVOKER
-      {
-        static BOOST_FUNCTION_VOID_RETURN_TYPE
-        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
-               BOOST_FUNCTION_PARMS)
-
-        {
-          MemberPtr* f = 
-            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
-          BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
-        }
-      };
-#endif
-
-      template<
-        typename FunctionPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
-      >
-      struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
-      {
-        typedef typename mpl::if_c<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
-                            FunctionPtr,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
-                          >,
-                          BOOST_FUNCTION_FUNCTION_INVOKER<
-                            FunctionPtr,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
-                          >
-                       >::type type;
-      };
-
-      template<
-        typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
-       >
-      struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-      {
-        typedef typename mpl::if_c<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
-                            FunctionObj,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
-                          >,
-                          BOOST_FUNCTION_FUNCTION_OBJ_INVOKER<
-                            FunctionObj,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
-                          >
-                       >::type type;
-      };
-
-      template<
-        typename FunctionObj,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
-       >
-      struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
-      {
-        typedef typename mpl::if_c<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
-                            FunctionObj,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
-                          >,
-                          BOOST_FUNCTION_FUNCTION_REF_INVOKER<
-                            FunctionObj,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
-                          >
-                       >::type type;
-      };
-
-#if BOOST_FUNCTION_NUM_ARGS > 0
-      /* Retrieve the appropriate invoker for a member pointer.  */
-      template<
-        typename MemberPtr,
-        typename R BOOST_FUNCTION_COMMA
-        BOOST_FUNCTION_TEMPLATE_PARMS
-       >
-      struct BOOST_FUNCTION_GET_MEMBER_INVOKER
-      {
-        typedef typename mpl::if_c<(is_void<R>::value),
-                            BOOST_FUNCTION_VOID_MEMBER_INVOKER<
-                            MemberPtr,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
-                          >,
-                          BOOST_FUNCTION_MEMBER_INVOKER<
-                            MemberPtr,
-                            R BOOST_FUNCTION_COMMA
-                            BOOST_FUNCTION_TEMPLATE_ARGS
-                          >
-                       >::type type;
-      };
-#endif
-
-      /* Given the tag returned by get_function_tag, retrieve the
-         actual invoker that will be used for the given function
-         object. 
-
-         Each specialization contains an "apply" nested class template
-         that accepts the function object, return type, function
-         argument types, and allocator. The resulting "apply" class
-         contains two typedefs, "invoker_type" and "manager_type",
-         which correspond to the invoker and manager types. */
-      template<typename Tag>
-      struct BOOST_FUNCTION_GET_INVOKER { };
-
-      /* Retrieve the invoker for a function pointer. */
-      template<>
-      struct BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
-      {
-        template<typename FunctionPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-                 typename Allocator>
-        struct apply
-        {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
-                             FunctionPtr,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
-                           >::type
-            invoker_type;
-
-          typedef functor_manager<FunctionPtr, Allocator> manager_type;
-        };
-      };
-
-#if BOOST_FUNCTION_NUM_ARGS > 0
-      /* Retrieve the invoker for a member pointer. */
-      template<>
-      struct BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
-      {
-        template<typename MemberPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-                 typename Allocator>
-        struct apply
-        {
-          typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
-                             MemberPtr,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
-                           >::type
-            invoker_type;
-
-          typedef functor_manager<MemberPtr, Allocator> manager_type;
-        };
-      };
-#endif
-
-      /* Retrieve the invoker for a function object. */
-      template<>
-      struct BOOST_FUNCTION_GET_INVOKER<function_obj_tag>
-      {
-        template<typename FunctionObj,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-                 typename Allocator>
-        struct apply
-        {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
-                             FunctionObj,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
-                           >::type
-            invoker_type;
-
-          typedef functor_manager<FunctionObj, Allocator> manager_type;
-        };
-      };
-
-      /* Retrieve the invoker for a reference to a function object. */
-      template<>
-      struct BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
-      {
-        template<typename RefWrapper,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-                 typename Allocator>
-        struct apply
-        {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
-                             typename RefWrapper::type,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
-                           >::type
-            invoker_type;
-
-          typedef reference_manager<typename RefWrapper::type> manager_type;
-        };
-      };
-
-      /**
-       * vtable for a specific boost::function instance.
-       */
-      template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-               typename Allocator>
-      struct BOOST_FUNCTION_VTABLE
-      {
-#ifndef BOOST_NO_VOID_RETURNS
-        typedef R         result_type;
-#else
-        typedef typename function_return_type<R>::type result_type;
-#endif // BOOST_NO_VOID_RETURNS
-
-        typedef result_type (*invoker_type)(function_buffer&
-                                            BOOST_FUNCTION_COMMA
-                                            BOOST_FUNCTION_TEMPLATE_ARGS);
-
-        template<typename F>
-        bool assign_to(const F& f, function_buffer& functor) const
-        {
-          typedef typename get_function_tag<F>::type tag;
-          return assign_to(f, functor, tag());
-        }
-
-        void clear(function_buffer& functor) const
-        {
-          if (base.manager)
-            base.manager(functor, functor, destroy_functor_tag);
-        }
-#ifndef BOOST_NO_PRIVATE_IN_AGGREGATE
-      private:
-#endif
-        // Function pointers
-        template<typename FunctionPtr>
-        bool 
-        assign_to(FunctionPtr f, function_buffer& functor, 
-                  function_ptr_tag) const
-        {
-          this->clear(functor);
-          if (f) {
-            // should be a reinterpret cast, but some compilers insist
-            // on giving cv-qualifiers to free functions
-            functor.func_ptr = (void (*)())(f);
-            return true;
-          } else {
-            return false;
-          }
-        }
-
-        // Member pointers
-#if BOOST_FUNCTION_NUM_ARGS > 0
-        template<typename MemberPtr>
-        bool 
-        assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
-        {
-          if (f) {
-            // Always use the small-object optimization for member
-            // pointers.
-            assign_functor(f, functor, mpl::true_());
-            return true;
-          } else {
-            return false;
-          }
-        }
-#endif // BOOST_FUNCTION_NUM_ARGS > 0
-
-        // Function objects
-        // Assign to a function object using the small object optimization
-        template<typename FunctionObj>
-        void 
-        assign_functor(const FunctionObj& f, function_buffer& functor, 
-                       mpl::true_) const
-        {
-          new ((void*)&functor.data) FunctionObj(f);
-        }
-
-        // Assign to a function object allocated on the heap.
-        template<typename FunctionObj>
-        void 
-        assign_functor(const FunctionObj& f, function_buffer& functor, 
-                       mpl::false_) const
-        {
-#ifndef BOOST_NO_STD_ALLOCATOR
-          typedef typename Allocator::template rebind<FunctionObj>::other
-            allocator_type;
-          typedef typename allocator_type::pointer pointer_type;
-
-          allocator_type allocator;
-          pointer_type copy = allocator.allocate(1);
-          allocator.construct(copy, f);
-
-          // Get back to the original pointer type
-          functor.obj_ptr = static_cast<FunctionObj*>(copy);
-#  else
-          functor.obj_ptr = new FunctionObj(f);
-#  endif // BOOST_NO_STD_ALLOCATOR
-        }
-
-        template<typename FunctionObj>
-        bool 
-        assign_to(const FunctionObj& f, function_buffer& functor, 
-                  function_obj_tag) const
-        {
-          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
-            assign_functor(f, functor, 
-                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
-            return true;
-          } else {
-            return false;
-          }
-        }
-
-        // Reference to a function object
-        template<typename FunctionObj>
-        bool 
-        assign_to(const reference_wrapper<FunctionObj>& f, 
-                  function_buffer& functor, function_obj_ref_tag) const
-        {
-          if (!boost::detail::function::has_empty_target(f.get_pointer())) {
-            // DPG TBD: We might need to detect constness of
-            // FunctionObj to assign into obj_ptr or const_obj_ptr to
-            // be truly legit, but no platform in existence makes
-            // const void* different from void*.
-            functor.const_obj_ptr = f.get_pointer();
-            return true;
-          } else {
-            return false;
-          }
-        }
-
-      public:
-        vtable_base base;
-        invoker_type invoker;
-      };
-    } // end namespace function
-  } // end namespace detail
-
-  template<
-    typename R BOOST_FUNCTION_COMMA
-    BOOST_FUNCTION_TEMPLATE_PARMS,
-    typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR
-  >
-  class BOOST_FUNCTION_FUNCTION : public function_base
-
-#if BOOST_FUNCTION_NUM_ARGS == 1
-
-    , public std::unary_function<T0,R>
-
-#elif BOOST_FUNCTION_NUM_ARGS == 2
-
-    , public std::binary_function<T0,T1,R>
-
-#endif
-
-  {
-  public:
-#ifndef BOOST_NO_VOID_RETURNS
-    typedef R         result_type;
-#else
-    typedef  typename boost::detail::function::function_return_type<R>::type
-      result_type;
-#endif // BOOST_NO_VOID_RETURNS
-
-  private:
-    typedef boost::detail::function::BOOST_FUNCTION_VTABLE<
-              R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, Allocator>
-      vtable_type;
-
-    struct clear_type {};
-
-  public:
-    BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS);
-
-    // add signature for boost::lambda
-    template<typename Args>
-    struct sig
-    {
-      typedef result_type type;
-    };
-
-#if BOOST_FUNCTION_NUM_ARGS == 1
-    typedef T0 argument_type;
-#elif BOOST_FUNCTION_NUM_ARGS == 2
-    typedef T0 first_argument_type;
-    typedef T1 second_argument_type;
-#endif
-
-    BOOST_STATIC_CONSTANT(int, arity = BOOST_FUNCTION_NUM_ARGS);
-    BOOST_FUNCTION_ARG_TYPES
-
-    typedef Allocator allocator_type;
-    typedef BOOST_FUNCTION_FUNCTION self_type;
-
-    BOOST_FUNCTION_FUNCTION() : function_base() { }
-
-    // MSVC chokes if the following two constructors are collapsed into
-    // one with a default parameter.
-    template<typename Functor>
-    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
-#ifndef BOOST_NO_SFINAE
-                            ,typename enable_if_c<
-                            (boost::type_traits::ice_not<
-                             (is_integral<Functor>::value)>::value),
-                                        int>::type = 0
-#endif // BOOST_NO_SFINAE
-                            ) :
-      function_base()
-    {
-      this->assign_to(f);
-    }
-
-#ifndef BOOST_NO_SFINAE
-    BOOST_FUNCTION_FUNCTION(clear_type*) : function_base() { }
-#else
-    BOOST_FUNCTION_FUNCTION(int zero) : function_base()
-    {
-      BOOST_ASSERT(zero == 0);
-    }
-#endif
-
-    BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) : function_base()
-    {
-      this->assign_to_own(f);
-    }
-
-    ~BOOST_FUNCTION_FUNCTION() { clear(); }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    // MSVC 6.0 and prior require all definitions to be inline, but
-    // these definitions can become very costly.
-    result_type operator()(BOOST_FUNCTION_PARMS) const
-    {
-      if (this->empty())
-        boost::throw_exception(bad_function_call());
-
-      return reinterpret_cast<const vtable_type*>(vtable)->invoker
-               (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
-    }
-#else
-    result_type operator()(BOOST_FUNCTION_PARMS) const;
-#endif
-
-    // The distinction between when to use BOOST_FUNCTION_FUNCTION and
-    // when to use self_type is obnoxious. MSVC cannot handle self_type as
-    // the return type of these assignment operators, but Borland C++ cannot
-    // handle BOOST_FUNCTION_FUNCTION as the type of the temporary to
-    // construct.
-    template<typename Functor>
-#ifndef BOOST_NO_SFINAE
-    typename enable_if_c<
-               (boost::type_traits::ice_not<
-                 (is_integral<Functor>::value)>::value),
-               BOOST_FUNCTION_FUNCTION&>::type
-#else
-    BOOST_FUNCTION_FUNCTION&
-#endif
-    operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
-    {
-      this->clear();
-#ifndef BOOST_NO_EXCEPTIONS
-      try {
-        this->assign_to(f);
-      } catch (...) {
-        vtable = 0;
-        throw;
-      }
-#else
-      this->assign_to(f);
-#endif
-      return *this;
-    }
-
-#ifndef BOOST_NO_SFINAE
-    BOOST_FUNCTION_FUNCTION& operator=(clear_type*)
-    {
-      this->clear();
-      return *this;
-    }
-#else
-    BOOST_FUNCTION_FUNCTION& operator=(int zero)
-    {
-      BOOST_ASSERT(zero == 0);
-      this->clear();
-      return *this;
-    }
-#endif
-
-    // Assignment from another BOOST_FUNCTION_FUNCTION
-    BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
-    {
-      if (&f == this)
-        return *this;
-
-      this->clear();
-#ifndef BOOST_NO_EXCEPTIONS
-      try {
-        this->assign_to_own(f);
-      } catch (...) {
-        vtable = 0;
-        throw;
-      }
-#else
-      this->assign_to_own(f);
-#endif
-      return *this;
-    }
-
-    void swap(BOOST_FUNCTION_FUNCTION& other)
-    {
-      if (&other == this)
-        return;
-
-      BOOST_FUNCTION_FUNCTION tmp = *this;
-      *this = other;
-      other = tmp;
-    }
-
-    // Clear out a target, if there is one
-    void clear()
-    {
-      if (vtable) {
-        reinterpret_cast<const vtable_type*>(vtable)->clear(this->functor);
-        vtable = 0;
-      }
-    }
-
-#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG)
-    // Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it
-    operator bool () const { return !this->empty(); }
-#else
-  private:
-    struct dummy {
-      void nonnull() {};
-    };
-
-    typedef void (dummy::*safe_bool)();
-
-  public:
-    operator safe_bool () const
-      { return (this->empty())? 0 : &dummy::nonnull; }
-
-    bool operator!() const
-      { return this->empty(); }
-#endif
-
-  private:
-    void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)
-    {
-      if (!f.empty()) {
-        this->vtable = f.vtable;
-        f.vtable->manager(f.functor, this->functor,
-                          boost::detail::function::clone_functor_tag);
-      }
-    }
-
-    template<typename Functor>
-    void assign_to(const Functor& f)
-    {
-      using detail::function::vtable_base;
-
-      typedef typename detail::function::get_function_tag<Functor>::type tag;
-      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
-      typedef typename get_invoker::
-                         template apply<Functor, R BOOST_FUNCTION_COMMA 
-                        BOOST_FUNCTION_TEMPLATE_ARGS, Allocator>
-        handler_type;
-      
-      typedef typename handler_type::invoker_type invoker_type;
-      typedef typename handler_type::manager_type manager_type;
-      
-      static const vtable_type stored_vtable = 
-        { { &manager_type::manage }, &invoker_type::invoke };
-
-      if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable.base;
-      else vtable = 0;
-    }
-  };
-
-  template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
-           typename Allocator>
-  inline void swap(BOOST_FUNCTION_FUNCTION<
-                     R BOOST_FUNCTION_COMMA
-                     BOOST_FUNCTION_TEMPLATE_ARGS ,
-                     Allocator
-                   >& f1,
-                   BOOST_FUNCTION_FUNCTION<
-                     R BOOST_FUNCTION_COMMA
-                     BOOST_FUNCTION_TEMPLATE_ARGS,
-                     Allocator
-                   >& f2)
-  {
-    f1.swap(f2);
-  }
-
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-  template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-           typename Allocator>
-  typename BOOST_FUNCTION_FUNCTION<
-      R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
-      Allocator>::result_type
-   BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
-
-                           Allocator>
-  ::operator()(BOOST_FUNCTION_PARMS) const
-  {
-    if (this->empty())
-      boost::throw_exception(bad_function_call());
-
-    return reinterpret_cast<const vtable_type*>(vtable)->invoker
-             (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
-  }
-#endif
-
-// Poison comparisons between boost::function objects of the same type.
-template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
-         typename Allocator>
-  void operator==(const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS ,
-                          Allocator>&,
-                  const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS ,
-                  Allocator>&);
-template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
-         typename Allocator>
-  void operator!=(const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS ,
-                          Allocator>&,
-                  const BOOST_FUNCTION_FUNCTION<
-                          R BOOST_FUNCTION_COMMA
-                          BOOST_FUNCTION_TEMPLATE_ARGS ,
-                  Allocator>&);
-
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-
-#if BOOST_FUNCTION_NUM_ARGS == 0
-#define BOOST_FUNCTION_PARTIAL_SPEC R (void)
-#else
-#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))
-#endif
-
-template<typename R BOOST_FUNCTION_COMMA
-         BOOST_FUNCTION_TEMPLATE_PARMS,
-         typename Allocator>
-class function<BOOST_FUNCTION_PARTIAL_SPEC, Allocator>
-  : public BOOST_FUNCTION_FUNCTION<R, BOOST_FUNCTION_TEMPLATE_ARGS
-                                   BOOST_FUNCTION_COMMA Allocator>
-{
-  typedef BOOST_FUNCTION_FUNCTION<R, BOOST_FUNCTION_TEMPLATE_ARGS
-                                  BOOST_FUNCTION_COMMA Allocator> base_type;
-  typedef function self_type;
-
-  struct clear_type {};
-
-public:
-  typedef typename base_type::allocator_type allocator_type;
-
-  function() : base_type() {}
-
-  template<typename Functor>
-  function(Functor f
-#ifndef BOOST_NO_SFINAE
-           ,typename enable_if_c<
-                            (boost::type_traits::ice_not<
-                          (is_integral<Functor>::value)>::value),
-                       int>::type = 0
-#endif
-           ) :
-    base_type(f)
-  {
-  }
-
-#ifndef BOOST_NO_SFINAE
-  function(clear_type*) : base_type() {}
-#endif
-
-  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
-
-  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
-
-  self_type& operator=(const self_type& f)
-  {
-    self_type(f).swap(*this);
-    return *this;
-  }
-
-  template<typename Functor>
-#ifndef BOOST_NO_SFINAE
-  typename enable_if_c<
-                            (boost::type_traits::ice_not<
-                         (is_integral<Functor>::value)>::value),
-                      self_type&>::type
-#else
-  self_type&
-#endif
-  operator=(Functor f)
-  {
-    self_type(f).swap(*this);
-    return *this;
-  }
-
-#ifndef BOOST_NO_SFINAE
-  self_type& operator=(clear_type*)
-  {
-    this->clear();
-    return *this;
-  }
-#endif
-
-  self_type& operator=(const base_type& f)
-  {
-    self_type(f).swap(*this);
-    return *this;
-  }
-};
-
-#undef BOOST_FUNCTION_PARTIAL_SPEC
-#endif // have partial specialization
-
-} // end namespace boost
-
-// Cleanup after ourselves...
-#undef BOOST_FUNCTION_VTABLE
-#undef BOOST_FUNCTION_GET_INVOKER
-#undef BOOST_FUNCTION_DEFAULT_ALLOCATOR
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
-#undef BOOST_FUNCTION_MEMBER_INVOKER
-#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
-#undef BOOST_FUNCTION_GET_MEMBER_INVOKER
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_PARM
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_ARG_TYPE
-#undef BOOST_FUNCTION_ARG_TYPES
-#undef BOOST_FUNCTION_VOID_RETURN_TYPE
-#undef BOOST_FUNCTION_RETURN
-
-#if defined(BOOST_MSVC)
-#   pragma warning( pop )
-#endif       

include/boost/function/gen_function_N.pl

@@ -1,26 +0,0 @@
-#!/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

@@ -1,28 +0,0 @@
-//  Copyright Douglas Gregor 2004.
-//  Copyright 2005 Peter Dimov
-
-//  Use, modification and distribution is subject to
-//  the Boost Software License, Version 1.0.
-//  (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org
-#ifndef BOOST_FUNCTION_EQUAL_HPP
-#define BOOST_FUNCTION_EQUAL_HPP
-
-namespace boost {
-
-template<typename F, typename G>
-  bool function_equal_impl(const F& f, const G& g, long)
-  { return f == g; }
-
-// function_equal_impl needs to be unqualified to pick
-// user overloads on two-phase compilers
-
-template<typename F, typename G>
-  bool function_equal(const F& f, const G& g)
-  { return function_equal_impl(f, g, 0); }
-
-} // end namespace boost
-
-#endif // BOOST_FUNCTION_EQUAL_HPP

index.html

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

test/Jamfile

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

test/Jamfile.v2

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

test/allocator_test.cpp

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

test/contains2_test.cpp

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

test/contains_test.cpp

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

test/function_n_test.cpp

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

test/function_test.cpp

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

test/function_test_fail1.cpp

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

test/function_test_fail2.cpp

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

test/stateless_test.cpp

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