Branch at revision 46530

[SVN r46531]
2025-06-26 04:21:38 +02:00 · 2008-06-19 18:57:10 +00:00
28 changed files with 455 additions and 1674 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -1,140 +0,0 @@
-# Copyright 2016, 2017 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-language: cpp
-
-sudo: false
-
-python: "2.7"
-
-os:
-  - linux
-  - osx
-
-branches:
-  only:
-    - master
-    - develop
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++03
-
-    - os: linux
-      compiler: g++-4.7
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-4.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
-
-    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
-
-    - os: linux
-      compiler: clang++-3.5
-      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - clang-3.5
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.5
-
-    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++1z
-      addons:
-        apt:
-          packages:
-            - clang-3.9
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.9
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++1z
-
-install:
-  - cd ..
-  - git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - cp -r $TRAVIS_BUILD_DIR/* libs/function
-  - python tools/boostdep/depinst/depinst.py function
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - |-
-    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
-  - ./b2 libs/function/test toolset=$TOOLSET
-
-notifications:
-  email:
-    on_success: always
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -3,23 +3,8 @@
 #   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 function/doc ;
+project boost/doc ;
 import boostbook : boostbook ;

-boostbook function-doc 
-    : 
-    function.xml 
-    :
-        <xsl:param>boost.root=../../../..
-        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
-    ;
+boostbook function-doc : function.xml ;

-###############################################################################
-alias boostdoc
-    : function.xml
-    :
-    :
-    : ;
-explicit boostdoc ;
-alias boostrelease ;
-explicit boostrelease ;
--- a/doc/history.xml
+++ b/doc/history.xml
@ -13,35 +13,6 @@

 <itemizedlist spacing="compact">

-  <listitem><para><bold>Version 1.52.0</bold>: </para>
-    <itemizedlist spacing="compact">
-      <listitem><para>Move constructors and move assignment 
-      operators added (only for compilers with C++11 rvalue 
-      references support). Original patch
-      contributed by Antony Polukhin.</para></listitem>
-    </itemizedlist>
-  </listitem>
-
-  <listitem><para><bold>Version 1.37.0</bold>: </para>
-    <itemizedlist spacing="compact">
-      <listitem><para>Improved the performance of Boost.Function's
-      swap() operation for large function objects. Original patch
-      contributed by Niels Dekker.</para></listitem>
-
-      <listitem><para>Added a new header &lt;boost/function/function_typeof.hpp&gt; that provides support for using the Boost.Typeof library on Boost.Function objects.</para></listitem>
-
-      <listitem><para>Added a new header &lt;boost/function/function_fwd.hpp&gt; that provides support for using the Boost.Typeof library on Boost.Function objects.</para></listitem>
-
-      <listitem><para>The <methodname alt="boost::function::target">target</methodname>()
-      function now respects the cv-qualifiers of function objects
-      stored by reference
-      (using <classname>boost::reference_wrapper</classname>), such
-      that a reference to a <code>const</code> function object cannot
-      be accessed as a reference to a non-<code>const</code> function
-      object.</para></listitem>
-    </itemizedlist>
-  </listitem>
-
  <listitem><para><bold>Version 1.36.0</bold>: </para>
    <itemizedlist spacing="compact">
      <listitem><para>Boost.Function now implements allocator support
--- a/doc/reference.xml
+++ b/doc/reference.xml
@ -58,7 +58,7 @@
      <para>A function object <code>f</code> of
      type <code>F</code> is
      <emphasis>stateless</emphasis> if it is a function pointer or if
-      <code><classname>boost::is_stateless</classname>&lt;F&gt;</code>
+      <code><classname>boost::is_stateless</classname>&lt;T&gt;</code>
      is true. The construction of or copy to a Boost.Function object
      from a stateless function object will not cause exceptions to be
      thrown and will not allocate any storage.
@ -128,7 +128,7 @@

      <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>. Works even with RTTI off.</simpara></returns>
+        <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>
@ -203,15 +203,6 @@
      <throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>

-    <constructor>
-      <parameter name="f">
-        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
-      </parameter>
-      <requires><simpara>C++11 compatible compiler.</simpara></requires>
-      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
-      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
-    </constructor>
-    
    <constructor>
      <template>
        <template-type-parameter name="F"/>
@ -245,15 +236,6 @@
      </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>
    </copy-assignment>
-    
-    <copy-assignment>
-      <parameter name="f">
-        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
-      </parameter>
-      <requires><simpara>C++11 compatible compiler.</simpara></requires>
-      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
-      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
-    </copy-assignment>

    <method-group name="modifiers">
      <method name="swap">
@ -625,16 +607,7 @@
      <postconditions><simpara>Contains a copy of the <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 unless copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>
-        
-    <constructor>
-      <parameter name="f">
-        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
-      </parameter>
-      <requires><simpara>C++11 compatible compiler.</simpara></requires>
-      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
-      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
-    </constructor>
-    
+
    <constructor>
      <parameter name="f">
        <paramtype>const <classname>function</classname>&amp;</paramtype>
@ -643,15 +616,6 @@
      <throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>

-    <constructor>
-      <parameter name="f">
-        <paramtype><classname>function</classname>&amp;&amp;</paramtype>
-      </parameter>
-      <requires><simpara>C++11 compatible compiler.</simpara></requires>
-      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
-      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
-    </constructor>
-    
    <constructor>
      <template>
        <template-type-parameter name="F"/>
@ -681,19 +645,10 @@

    <copy-assignment>
      <parameter name="f">
-        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
+        <paramtype>const <classname>function</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>
    </copy-assignment>
-    
-    <copy-assignment>
-      <parameter name="f">
-        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
-      </parameter>
-      <requires><simpara>C++11 compatible compiler.</simpara></requires>
-      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
-      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
-    </copy-assignment>

    <copy-assignment>
      <parameter name="f">
@ -702,15 +657,6 @@
      <postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></throws>
    </copy-assignment>
-    
-    <copy-assignment>
-      <parameter name="f">
-        <paramtype><classname>function</classname>&amp;&amp;</paramtype>
-      </parameter>
-      <requires><simpara>C++11 compatible compiler.</simpara></requires>
-      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
-      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
-    </copy-assignment>

    <method-group name="modifiers">
      <method name="swap">
--- a/doc/tutorial.xml
+++ b/doc/tutorial.xml
@ -35,12 +35,12 @@ form to use for your compiler.
        <row>
          <entry>
            <itemizedlist spacing="compact">
-              <listitem><simpara>GNU C++ 2.95.x, 3.0.x and later versions</simpara></listitem>
+              <listitem><simpara>GNU C++ 2.95.x, 3.0.x, 3.1.x</simpara></listitem>
              <listitem><simpara>Comeau C++ 4.2.45.2</simpara></listitem>
              <listitem><simpara>SGI MIPSpro 7.3.0</simpara></listitem>
              <listitem><simpara>Intel C++ 5.0, 6.0</simpara></listitem>
              <listitem><simpara>Compaq's cxx 6.2</simpara></listitem>
-	      <listitem><simpara>Microsoft Visual C++ 7.1 and later versions</simpara></listitem>
+	      <listitem><simpara>Microsoft Visual C++ 7.1</simpara></listitem>
            </itemizedlist>
          </entry>
          <entry>
--- a/include/boost/function.hpp
+++ b/include/boost/function.hpp
@ -10,27 +10,21 @@
 // William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
 // design of this library.

-#ifndef BOOST_FUNCTION_MAX_ARGS
-#  define BOOST_FUNCTION_MAX_ARGS 10
-#endif // BOOST_FUNCTION_MAX_ARGS
-
-#if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) || (BOOST_FUNCTION_MAX_ARGS_DEFINED != BOOST_FUNCTION_MAX_ARGS)
-
-#if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED)
-#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
-#endif
-
 #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>

-// Older Visual Age C++ version do not handle the file iteration well
-#if BOOST_WORKAROUND(__IBMCPP__, >= 500) && BOOST_WORKAROUND(__IBMCPP__, < 800)
+// 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
@ -70,5 +64,3 @@
 #  include BOOST_PP_ITERATE()
 #  undef BOOST_PP_ITERATION_PARAMS_1
 #endif
-
-#endif // !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) || (BOOST_FUNCTION_MAX_ARGS_DEFINED != BOOST_FUNCTION_MAX_ARGS)
--- a/include/boost/function/detail/gen_maybe_include.pl
+++ b/include/boost/function/detail/gen_maybe_include.pl
@ -27,8 +27,6 @@ for($on_arg = 0; $on_arg <= $max_args; ++$on_arg) {
 	print OUT "#elif";
    }
    print OUT " BOOST_FUNCTION_NUM_ARGS == $on_arg\n";
-    print OUT "#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED\n";
-    print OUT "#  define BOOST_FUNCTION_MAX_ARGS_DEFINED $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";
--- a/include/boost/function/detail/maybe_include.hpp
+++ b/include/boost/function/detail/maybe_include.hpp
@ -8,358 +8,256 @@
 // For more information, see http://www.boost.org

 #if BOOST_FUNCTION_NUM_ARGS == 0
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
 #  ifndef BOOST_FUNCTION_0
 #    define BOOST_FUNCTION_0
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 1
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 1
 #  ifndef BOOST_FUNCTION_1
 #    define BOOST_FUNCTION_1
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 2
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 2
 #  ifndef BOOST_FUNCTION_2
 #    define BOOST_FUNCTION_2
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 3
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 3
 #  ifndef BOOST_FUNCTION_3
 #    define BOOST_FUNCTION_3
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 4
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 4
 #  ifndef BOOST_FUNCTION_4
 #    define BOOST_FUNCTION_4
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 5
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 5
 #  ifndef BOOST_FUNCTION_5
 #    define BOOST_FUNCTION_5
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 6
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 6
 #  ifndef BOOST_FUNCTION_6
 #    define BOOST_FUNCTION_6
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 7
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 7
 #  ifndef BOOST_FUNCTION_7
 #    define BOOST_FUNCTION_7
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 8
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 8
 #  ifndef BOOST_FUNCTION_8
 #    define BOOST_FUNCTION_8
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 9
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 9
 #  ifndef BOOST_FUNCTION_9
 #    define BOOST_FUNCTION_9
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 10
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 10
 #  ifndef BOOST_FUNCTION_10
 #    define BOOST_FUNCTION_10
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 11
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 11
 #  ifndef BOOST_FUNCTION_11
 #    define BOOST_FUNCTION_11
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 12
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 12
 #  ifndef BOOST_FUNCTION_12
 #    define BOOST_FUNCTION_12
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 13
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 13
 #  ifndef BOOST_FUNCTION_13
 #    define BOOST_FUNCTION_13
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 14
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 14
 #  ifndef BOOST_FUNCTION_14
 #    define BOOST_FUNCTION_14
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 15
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 15
 #  ifndef BOOST_FUNCTION_15
 #    define BOOST_FUNCTION_15
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 16
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 16
 #  ifndef BOOST_FUNCTION_16
 #    define BOOST_FUNCTION_16
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 17
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 17
 #  ifndef BOOST_FUNCTION_17
 #    define BOOST_FUNCTION_17
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 18
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 18
 #  ifndef BOOST_FUNCTION_18
 #    define BOOST_FUNCTION_18
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 19
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 19
 #  ifndef BOOST_FUNCTION_19
 #    define BOOST_FUNCTION_19
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 20
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 20
 #  ifndef BOOST_FUNCTION_20
 #    define BOOST_FUNCTION_20
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 21
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 21
 #  ifndef BOOST_FUNCTION_21
 #    define BOOST_FUNCTION_21
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 22
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 22
 #  ifndef BOOST_FUNCTION_22
 #    define BOOST_FUNCTION_22
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 23
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 23
 #  ifndef BOOST_FUNCTION_23
 #    define BOOST_FUNCTION_23
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 24
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 24
 #  ifndef BOOST_FUNCTION_24
 #    define BOOST_FUNCTION_24
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 25
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 25
 #  ifndef BOOST_FUNCTION_25
 #    define BOOST_FUNCTION_25
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 26
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 26
 #  ifndef BOOST_FUNCTION_26
 #    define BOOST_FUNCTION_26
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 27
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 27
 #  ifndef BOOST_FUNCTION_27
 #    define BOOST_FUNCTION_27
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 28
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 28
 #  ifndef BOOST_FUNCTION_28
 #    define BOOST_FUNCTION_28
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 29
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 29
 #  ifndef BOOST_FUNCTION_29
 #    define BOOST_FUNCTION_29
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 30
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 30
 #  ifndef BOOST_FUNCTION_30
 #    define BOOST_FUNCTION_30
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 31
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 31
 #  ifndef BOOST_FUNCTION_31
 #    define BOOST_FUNCTION_31
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 32
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 32
 #  ifndef BOOST_FUNCTION_32
 #    define BOOST_FUNCTION_32
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 33
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 33
 #  ifndef BOOST_FUNCTION_33
 #    define BOOST_FUNCTION_33
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 34
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 34
 #  ifndef BOOST_FUNCTION_34
 #    define BOOST_FUNCTION_34
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 35
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 35
 #  ifndef BOOST_FUNCTION_35
 #    define BOOST_FUNCTION_35
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 36
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 36
 #  ifndef BOOST_FUNCTION_36
 #    define BOOST_FUNCTION_36
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 37
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 37
 #  ifndef BOOST_FUNCTION_37
 #    define BOOST_FUNCTION_37
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 38
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 38
 #  ifndef BOOST_FUNCTION_38
 #    define BOOST_FUNCTION_38
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 39
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 39
 #  ifndef BOOST_FUNCTION_39
 #    define BOOST_FUNCTION_39
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 40
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 40
 #  ifndef BOOST_FUNCTION_40
 #    define BOOST_FUNCTION_40
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 41
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 41
 #  ifndef BOOST_FUNCTION_41
 #    define BOOST_FUNCTION_41
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 42
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 42
 #  ifndef BOOST_FUNCTION_42
 #    define BOOST_FUNCTION_42
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 43
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 43
 #  ifndef BOOST_FUNCTION_43
 #    define BOOST_FUNCTION_43
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 44
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 44
 #  ifndef BOOST_FUNCTION_44
 #    define BOOST_FUNCTION_44
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 45
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 45
 #  ifndef BOOST_FUNCTION_45
 #    define BOOST_FUNCTION_45
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 46
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 46
 #  ifndef BOOST_FUNCTION_46
 #    define BOOST_FUNCTION_46
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 47
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 47
 #  ifndef BOOST_FUNCTION_47
 #    define BOOST_FUNCTION_47
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 48
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 48
 #  ifndef BOOST_FUNCTION_48
 #    define BOOST_FUNCTION_48
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 49
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 49
 #  ifndef BOOST_FUNCTION_49
 #    define BOOST_FUNCTION_49
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 50
-#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
-#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 50
 #  ifndef BOOST_FUNCTION_50
 #    define BOOST_FUNCTION_50
 #    include <boost/function/function_template.hpp>
--- a/include/boost/function/function_base.hpp
+++ b/include/boost/function/function_base.hpp
@ -15,15 +15,10 @@
 #include <string>
 #include <memory>
 #include <new>
+#include <typeinfo>
 #include <boost/config.hpp>
 #include <boost/assert.hpp>
-#include <boost/integer.hpp>
-#include <boost/type_index.hpp>
-#include <boost/type_traits/has_trivial_copy.hpp>
-#include <boost/type_traits/has_trivial_destructor.hpp>
-#include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_volatile.hpp>
 #include <boost/type_traits/composite_traits.hpp>
 #include <boost/ref.hpp>
 #include <boost/mpl/if.hpp>
@ -35,24 +30,83 @@
 #  include "boost/mpl/bool.hpp"
 #endif
 #include <boost/function_equal.hpp>
-#include <boost/function/function_fwd.hpp>

 #if defined(BOOST_MSVC)
 #   pragma warning( push )
 #   pragma warning( disable : 4793 ) // complaint about native code generation
 #   pragma warning( disable : 4127 ) // "conditional expression is constant"
+#endif       
+
+// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
+#ifdef BOOST_NO_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

-#if defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
+// 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 // __ICL etc
+#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)                         \
+ || !(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::is_integral<Functor>::value), \
+      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 {
+
+template<typename Signature>
+class function;
+
+template<typename Signature>
+inline void swap(function<Signature>& f1,
+                 function<Signature>& f2)
+{
+  f1.swap(f2);
+}
+
+} // end namespace boost
+#endif // have partial specialization

 namespace boost {
  namespace detail {
@ -65,26 +119,17 @@ namespace boost {
       * object pointers, and a structure that resembles a bound
       * member function pointer.
       */
-      union function_buffer_members
+      union function_buffer
      {
        // For pointers to function objects
-        typedef void* obj_ptr_t;
-        mutable obj_ptr_t obj_ptr;
+        void* obj_ptr;

        // For pointers to std::type_info objects
-        struct type_t {
-          // (get_functor_type_tag, check_functor_type_tag).
-          const boost::typeindex::type_info* type;
-
-          // Whether the type is const-qualified.
-          bool const_qualified;
-          // Whether the type is volatile-qualified.
-          bool volatile_qualified;
-        } type;
+        // (get_functor_type_tag, check_functor_type_tag).
+        const void* const_obj_ptr;

        // For function pointers of all kinds
-        typedef void (*func_ptr_t)();
-        mutable func_ptr_t func_ptr;
+        mutable void (*func_ptr)();

        // For bound member pointers
        struct bound_memfunc_ptr_t {
@ -92,22 +137,8 @@ namespace boost {
          void* obj_ptr;
        } bound_memfunc_ptr;

-        // For references to function objects. We explicitly keep
-        // track of the cv-qualifiers on the object referenced.
-        struct obj_ref_t {
-          mutable void* obj_ptr;
-          bool is_const_qualified;
-          bool is_volatile_qualified;
-        } obj_ref;
-      };
-
-      union function_buffer
-      {
-        // Type-specific union members
-        mutable function_buffer_members members;
-
        // To relax aliasing constraints
-        mutable char data[sizeof(function_buffer_members)];
+        mutable char data;
      };

      /**
@ -137,7 +168,6 @@ namespace boost {
      // The operation type to perform on the given functor/function pointer
      enum functor_manager_operation_type {
        clone_functor_tag,
-        move_functor_tag,
        destroy_functor_tag,
        check_functor_type_tag,
        get_functor_type_tag
@ -174,42 +204,34 @@ namespace boost {
      struct reference_manager
      {
        static inline void
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
-               functor_manager_operation_type op)
+        get(const function_buffer& in_buffer, function_buffer& out_buffer, 
+            functor_manager_operation_type op)
        {
          switch (op) {
-          case clone_functor_tag:
-            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
-            return;
-
-          case move_functor_tag:
-            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
-            in_buffer.members.obj_ref.obj_ptr = 0;
+          case clone_functor_tag: 
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
            return;

          case destroy_functor_tag:
-            out_buffer.members.obj_ref.obj_ptr = 0;
+            out_buffer.obj_ptr = 0;
            return;

          case check_functor_type_tag:
            {
-              // Check whether we have the same type. We can add
-              // cv-qualifiers, but we can't take them away.
-              if (*out_buffer.members.type.type == boost::typeindex::type_id<F>()
-                  && (!in_buffer.members.obj_ref.is_const_qualified
-                      || out_buffer.members.type.const_qualified)
-                  && (!in_buffer.members.obj_ref.is_volatile_qualified
-                      || out_buffer.members.type.volatile_qualified))
-                out_buffer.members.obj_ptr = in_buffer.members.obj_ref.obj_ptr;
+              // 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.members.obj_ptr = 0;
+                out_buffer.obj_ptr = 0;
            }
            return;

          case get_functor_type_tag:
-            out_buffer.members.type.type = &boost::typeindex::type_id<F>().type_info();
-            out_buffer.members.type.const_qualified = in_buffer.members.obj_ref.is_const_qualified;
-            out_buffer.members.type.volatile_qualified = in_buffer.members.obj_ref.is_volatile_qualified;
+            out_buffer.const_obj_ptr = &typeid(F);
            return;
          }
        }
@ -223,9 +245,9 @@ namespace boost {
      struct function_allows_small_object_optimization
      {
        BOOST_STATIC_CONSTANT
-          (bool,
+          (bool, 
           value = ((sizeof(F) <= sizeof(function_buffer) &&
-                     (alignment_of<function_buffer>::value
+                     (alignment_of<function_buffer>::value 
                      % alignment_of<F>::value == 0))));
      };

@ -237,12 +259,6 @@ namespace boost {
          A(a)
        {
        }
-
-        functor_wrapper(const functor_wrapper& f) :
-          F(static_cast<const F&>(f)),
-          A(static_cast<const A&>(f))
-        {
-        }
      };

      /**
@ -256,57 +272,42 @@ namespace boost {

        // Function pointers
        static inline void
-        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op)
        {
          if (op == clone_functor_tag)
-            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
-          else if (op == move_functor_tag) {
-            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
-            in_buffer.members.func_ptr = 0;
-          } else if (op == destroy_functor_tag)
-            out_buffer.members.func_ptr = 0;
-          else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
-              out_buffer.members.obj_ptr = &in_buffer.members.func_ptr;
+            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.members.obj_ptr = 0;
-          } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
-            out_buffer.members.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+              out_buffer.obj_ptr = 0;
          }
        }

        // Function objects that fit in the small-object buffer.
        static inline void
-        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op)
        {
-          if (op == clone_functor_tag || op == move_functor_tag) {
-            const functor_type* in_functor =
-              reinterpret_cast<const functor_type*>(in_buffer.data);
-            new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor);
-
-            if (op == move_functor_tag) {
-              functor_type* f = reinterpret_cast<functor_type*>(in_buffer.data);
-              (void)f; // suppress warning about the value of f not being used (MSVC)
-              f->~Functor();
-            }
+          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.
-             functor_type* f = reinterpret_cast<functor_type*>(out_buffer.data);
-             (void)f; // suppress warning about the value of f not being used (MSVC)
-             f->~Functor();
-          } else if (op == check_functor_type_tag) {
-             if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
-              out_buffer.members.obj_ptr = in_buffer.data;
+            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.members.obj_ptr = 0;
-          } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
-            out_buffer.members.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+              out_buffer.obj_ptr = 0;
          }
        }
      };
@ -319,7 +320,7 @@ namespace boost {

        // Function pointers
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, function_ptr_tag)
        {
          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
@ -327,45 +328,38 @@ namespace boost {

        // Function objects that fit in the small-object buffer.
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, mpl::true_)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }
-
+        
        // Function objects that require heap allocation
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, mpl::false_)
        {
          if (op == clone_functor_tag) {
            // Clone the functor
            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
            // can't do the static_cast that we should do.
-            // jewillco: Changing this to static_cast because GCC 2.95.3 is
-            // obsolete.
            const functor_type* f =
-              static_cast<const functor_type*>(in_buffer.members.obj_ptr);
+              (const functor_type*)(in_buffer.obj_ptr);
            functor_type* new_f = new functor_type(*f);
-            out_buffer.members.obj_ptr = new_f;
-          } else if (op == move_functor_tag) {
-            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
-            in_buffer.members.obj_ptr = 0;
+            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.members.obj_ptr);
+              static_cast<functor_type*>(out_buffer.obj_ptr);
            delete f;
-            out_buffer.members.obj_ptr = 0;
-          } else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
-              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            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.members.obj_ptr = 0;
-          } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
-            out_buffer.members.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+              out_buffer.obj_ptr = 0;
          }
        }

@ -373,34 +367,24 @@ namespace boost {
        // 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,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
        }

-        // For member pointers, we use the small-object optimization buffer.
-        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, member_ptr_tag)
-        {
-          manager(in_buffer, out_buffer, op, mpl::true_());
-        }
-
      public:
        /* Dispatch to an appropriate manager based on whether we have a
           function pointer or a function object pointer. */
        static inline void
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+        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.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
-            out_buffer.members.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.const_obj_ptr = &typeid(functor_type);
            return;

          default:
@ -418,7 +402,7 @@ namespace boost {

        // Function pointers
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, function_ptr_tag)
        {
          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
@ -426,15 +410,15 @@ namespace boost {

        // Function objects that fit in the small-object buffer.
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, mpl::true_)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }
-
+        
        // Function objects that require heap allocation
        static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, mpl::false_)
        {
          typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
@ -447,34 +431,29 @@ namespace boost {
            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
            // can't do the static_cast that we should do.
            const functor_wrapper_type* f =
-              static_cast<const functor_wrapper_type*>(in_buffer.members.obj_ptr);
+              (const functor_wrapper_type*)(in_buffer.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
            wrapper_allocator.construct(copy, *f);

            // Get back to the original pointer type
            functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
-            out_buffer.members.obj_ptr = new_f;
-          } else if (op == move_functor_tag) {
-            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
-            in_buffer.members.obj_ptr = 0;
+            out_buffer.obj_ptr = new_f;
          } else if (op == destroy_functor_tag) {
            /* Cast from the void pointer to the functor_wrapper_type */
            functor_wrapper_type* victim =
-              static_cast<functor_wrapper_type*>(in_buffer.members.obj_ptr);
+              static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
            wrapper_allocator.destroy(victim);
            wrapper_allocator.deallocate(victim,1);
-            out_buffer.members.obj_ptr = 0;
-          } else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
-              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            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.members.obj_ptr = 0;
-          } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
-            out_buffer.members.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+              out_buffer.obj_ptr = 0;
          }
        }

@ -482,7 +461,7 @@ namespace boost {
        // 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,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
@ -493,15 +472,13 @@ namespace boost {
        /* 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,
+        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.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
-            out_buffer.members.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.const_obj_ptr = &typeid(functor_type);
            return;

          default:
@ -579,8 +556,9 @@ namespace boost {
       */
      struct vtable_base
      {
-        void (*manager)(const function_buffer& in_buffer,
-                        function_buffer& out_buffer,
+        vtable_base() : manager(0) { }
+        void (*manager)(const function_buffer& in_buffer, 
+                        function_buffer& out_buffer, 
                        functor_manager_operation_type op);
      };
    } // end namespace function
@ -600,15 +578,15 @@ public:
  /** 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 type_id<void>()
+  /** Retrieve the type of the stored function object, or typeid(void)
      if this is empty. */
-  const boost::typeindex::type_info& target_type() const
+  const BOOST_FUNCTION_STD_NS::type_info& target_type() const
  {
-    if (!vtable) return boost::typeindex::type_id<void>().type_info();
+    if (!vtable) return typeid(void);

    detail::function::function_buffer type;
-    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
-    return *type.members.type.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>
@ -617,34 +595,38 @@ public:
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
-      type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
-      type_result.members.type.const_qualified = is_const<Functor>::value;
-      type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
-      get_vtable()->manager(functor, 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.members.obj_ptr);
+      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.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
-      type_result.members.type.const_qualified = true;
-      type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
-      get_vtable()->manager(functor, 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 static_cast<const Functor*>(type_result.members.obj_ptr);
+      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 {
@ -676,23 +658,10 @@ public:
 #endif

 public: // should be protected, but GCC 2.95.3 will fail to allow access
-  detail::function::vtable_base* get_vtable() const {
-    return reinterpret_cast<detail::function::vtable_base*>(
-             reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
-  }
-
-  bool has_trivial_copy_and_destroy() const {
-    return reinterpret_cast<std::size_t>(vtable) & 0x01;
-  }
-
  detail::function::vtable_base* vtable;
  mutable detail::function::function_buffer functor;
 };

-#if defined(BOOST_CLANG)
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
 /**
 * The bad_function_call exception class is thrown when a boost::function
 * object is invoked
@ -702,9 +671,6 @@ class bad_function_call : public std::runtime_error
 public:
  bad_function_call() : std::runtime_error("call to empty boost::function") {}
 };
-#if defined(BOOST_CLANG)
-#   pragma clang diagnostic pop
-#endif

 #ifndef BOOST_NO_SFINAE
 inline bool operator==(const function_base& f,
@ -865,9 +831,6 @@ namespace detail {
 } // end namespace boost

 #undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
-
-#if defined(BOOST_MSVC)
-#   pragma warning( pop )
-#endif
+#undef BOOST_FUNCTION_COMPARE_TYPE_ID

 #endif // BOOST_FUNCTION_BASE_HEADER
--- a/include/boost/function/function_fwd.hpp
+++ b/include/boost/function/function_fwd.hpp
@ -1,69 +0,0 @@
-// Boost.Function library
-//  Copyright (C) Douglas Gregor 2008
-//
-//  Use, modification and distribution is subject to the Boost
-//  Software License, Version 1.0.  (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// For more information, see http://www.boost.org
-#ifndef BOOST_FUNCTION_FWD_HPP
-#define BOOST_FUNCTION_FWD_HPP
-#include <boost/config.hpp>
-
-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
-// Work around a compiler bug.
-// boost::python::objects::function has to be seen by the compiler before the
-// boost::function class template.
-namespace boost { namespace python { namespace objects {
-  class function;
-}}}
-#endif
-
-#if defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
- || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
-#  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
-#endif
-
-namespace boost {
-  class bad_function_call;
-
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-  // Preferred syntax
-  template<typename Signature> class function;
-
-  template<typename Signature>
-  inline void swap(function<Signature>& f1, function<Signature>& f2)
-  {
-    f1.swap(f2);
-  }
-#endif // have partial specialization
-
-  // Portable syntax
-  template<typename R> class function0;
-  template<typename R, typename T1> class function1;
-  template<typename R, typename T1, typename T2> class function2;
-  template<typename R, typename T1, typename T2, typename T3> class function3;
-  template<typename R, typename T1, typename T2, typename T3, typename T4> 
-    class function4;
-  template<typename R, typename T1, typename T2, typename T3, typename T4,
-           typename T5> 
-    class function5;
-  template<typename R, typename T1, typename T2, typename T3, typename T4,
-           typename T5, typename T6> 
-    class function6;
-  template<typename R, typename T1, typename T2, typename T3, typename T4,
-           typename T5, typename T6, typename T7> 
-    class function7;
-  template<typename R, typename T1, typename T2, typename T3, typename T4,
-           typename T5, typename T6, typename T7, typename T8> 
-    class function8;
-  template<typename R, typename T1, typename T2, typename T3, typename T4,
-           typename T5, typename T6, typename T7, typename T8, typename T9> 
-    class function9;
-  template<typename R, typename T1, typename T2, typename T3, typename T4,
-           typename T5, typename T6, typename T7, typename T8, typename T9,
-           typename T10> 
-    class function10;
-}
-
-#endif
--- a/include/boost/function/function_template.hpp
+++ b/include/boost/function/function_template.hpp
--- a/include/boost/function/function_typeof.hpp
+++ b/include/boost/function/function_typeof.hpp
@ -1,45 +0,0 @@
-// Boost.Function library - Typeof support
-//  Copyright (C) Douglas Gregor 2008
-//
-//  Use, modification and distribution is subject to the Boost
-//  Software License, Version 1.0.  (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// For more information, see http://www.boost.org
-#ifndef BOOST_FUNCTION_TYPEOF_HPP
-#define BOOST_FUNCTION_TYPEOF_HPP
-#include <boost/function/function_fwd.hpp>
-#include <boost/typeof/typeof.hpp>
-
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-BOOST_TYPEOF_REGISTER_TYPE(boost::bad_function_call)
-
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function, (typename))
-#endif
-
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function0, (typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function1, (typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function2, (typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function3, 
-  (typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function4, 
-  (typename)(typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function5, 
-  (typename)(typename)(typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function6, 
-  (typename)(typename)(typename)(typename)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function7, 
-  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
-  (typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function8, 
-  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
-  (typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function9, 
-  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
-  (typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function10, 
-  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
-  (typename)(typename)(typename)(typename))
-#endif
--- a/meta/libraries.json
+++ b/meta/libraries.json
@ -1,18 +0,0 @@
-{
-    "key": "function",
-    "name": "Function",
-    "authors": [
-        "Doug Gregor"
-    ],
-    "description": "Function object wrappers for deferred calls or callbacks.",
-    "std": [
-        "tr1"
-    ],
-    "category": [
-        "Function-objects",
-        "Programming"
-    ],
-    "maintainers": [
-        "Douglas Gregor <dgregor -at- cs.indiana.edu>"
-    ]
-}
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -8,7 +8,6 @@
 # For more information, see http://www.boost.org/

 project
-    : requirements <toolset>msvc:<asynch-exceptions>on
    : source-location $(BOOST_ROOT)
    ;

@ -21,8 +20,6 @@ import testing ;
    : 
  [ run libs/function/test/function_test.cpp :  :  :  : lib_function_test ]

-  [ run libs/function/test/function_test.cpp :  :  : <rtti>off : lib_function_test_no_rtti ]
-
  [ run libs/function/test/function_n_test.cpp :  :  :  :  ]

  [ run libs/function/test/allocator_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
@ -37,8 +34,6 @@ import testing ;

  [ compile libs/function/test/function_30.cpp :  :  :  :  ] 

-  [ compile libs/function/test/function_30_repeat.cpp :  :  :  :  ] 
-
  [ run libs/function/test/function_arith_cxx98.cpp :  :  :  :  ]

  [ run libs/function/test/function_arith_portable.cpp :  :  :  :  ]
@ -63,13 +58,6 @@ import testing ;
   
  [ run libs/function/test/contains2_test.cpp : : : : ]
   
-  [ run libs/function/test/nothrow_swap.cpp :  :  :  :  ]
-
-  [ run libs/function/test/rvalues_test.cpp :  :  :  :  ]
-
-  [ compile libs/function/test/function_typeof_test.cpp ]
-
-  [ run libs/function/test/result_arg_types_test.cpp ]
 ;
 }
      
--- a/test/allocator_test.cpp
+++ b/test/allocator_test.cpp
@ -128,10 +128,6 @@ test_main(int, char*[])
  BOOST_CHECK(dealloc_count == 0);
  fv.assign( &do_nothing, std::allocator<int>() );
  fv.clear();
-  
-  function0<void> fv2;
-  fv.assign(&do_nothing, std::allocator<int>() );
-  fv2.assign(fv, std::allocator<int>() );

  return 0;
 }
--- a/test/contains_test.cpp
+++ b/test/contains_test.cpp
@ -88,15 +88,6 @@ static void target_test()
  BOOST_CHECK(!f.target<int (*)()>());
  BOOST_CHECK(f.target<Seventeen>());
  BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);
-
-  const Seventeen const_seventeen = this_seventeen;
-  f = boost::ref(const_seventeen);
-  BOOST_CHECK(!f.target<int (*)()>());
-  BOOST_CHECK(f.target<const Seventeen>());
-  BOOST_CHECK(f.target<const Seventeen>() == &const_seventeen);
-  BOOST_CHECK(f.target<const volatile Seventeen>());
-  BOOST_CHECK(!f.target<Seventeen>());
-  BOOST_CHECK(!f.target<volatile Seventeen>());
 }

 static void equal_test()
--- a/test/function_30_repeat.cpp
+++ b/test/function_30_repeat.cpp
@ -1,35 +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
-
-// Make sure we don't try to redefine function2
-#include <boost/function/function2.hpp>
-
-// Define all Boost.Function class templates up to 30 arguments
-#define BOOST_FUNCTION_MAX_ARGS 20
-#include <boost/function.hpp>
-#undef BOOST_FUNCTION_MAX_ARGS
-#define BOOST_FUNCTION_MAX_ARGS 40
-#include <boost/function.hpp>
-#undef BOOST_FUNCTION_MAX_ARGS
-#define BOOST_FUNCTION_MAX_ARGS 25
-#include <boost/function.hpp>
-#undef BOOST_FUNCTION_MAX_ARGS
-#define BOOST_FUNCTION_MAX_ARGS 30
-#include <boost/function.hpp>
-#include <boost/function.hpp>
-
-int main()
-{
-  boost::function0<float> f0;
-
-  boost::function30<float, int, int, int, int, int, int, int, int, int, int,
-                    int, int, int, int, int, int, int, int, int, int,
-                    int, int, int, int, int, int, int, int, int, int> f30;
-  return 0;
-}
--- a/test/function_n_test.cpp
+++ b/test/function_n_test.cpp
@ -636,54 +636,6 @@ test_ref()
  }
 }

-static unsigned construction_count = 0;
-static unsigned destruction_count = 0;
-
-struct MySmallFunctor {
-  MySmallFunctor() { ++construction_count; }
-  MySmallFunctor(const MySmallFunctor &) { ++construction_count; }
-  ~MySmallFunctor() { ++destruction_count; }
-  int operator()() { return 0; }
- };
-
-struct MyLargeFunctor {
-  MyLargeFunctor() { ++construction_count; }
-  MyLargeFunctor(const MyLargeFunctor &) { ++construction_count; }
-  ~MyLargeFunctor() { ++destruction_count; }
-  int operator()() { return 0; }
-
-  float data[128];
- };
-
-void test_construct_destroy_count()
-{
-  {
-    boost::function0<int> f;
-    boost::function0<int> g;
-    f = MySmallFunctor();
-    g = MySmallFunctor();
-    f.swap(g);
-  }
-
-  // MySmallFunctor objects should be constructed as many times as
-  // they are destroyed.
-  BOOST_CHECK(construction_count == destruction_count);
- 
-  construction_count = 0;
-  destruction_count = 0;
-  {
-    boost::function0<int> f;
-    boost::function0<int> g;
-    f = MyLargeFunctor();
-    g = MyLargeFunctor();
-    f.swap(g);
-   }
-
-   // MyLargeFunctor objects should be constructed as many times as
-   // they are destroyed.
-   BOOST_CHECK(construction_count == destruction_count);
-}
-
 int test_main(int, char* [])
 {
  test_zero_args();
@ -692,6 +644,5 @@ int test_main(int, char* [])
  test_emptiness();
  test_member_functions();
  test_ref();
-  test_construct_destroy_count();
  return 0;
 }
--- a/test/function_test.cpp
+++ b/test/function_test.cpp
@ -13,8 +13,8 @@
 #include <string>
 #include <utility>

-using boost::function;
-using std::string;
+using namespace boost;
+using namespace std;

 int global_int;

@ -525,7 +525,7 @@ test_zero_args()
 static void
 test_one_arg()
 {
-  std::negate<int> neg;
+  negate<int> neg;

  function<int (int)> f1(neg);
  BOOST_CHECK(f1(5) == -5);
@ -607,12 +607,12 @@ struct add_with_throw_on_copy {

  add_with_throw_on_copy(const add_with_throw_on_copy&)
  {
-    throw std::runtime_error("But this CAN'T throw");
+    throw runtime_error("But this CAN'T throw");
  }

  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
  {
-    throw std::runtime_error("But this CAN'T throw");
+    throw runtime_error("But this CAN'T throw");
  }
 };

@ -621,38 +621,14 @@ test_ref()
 {
  add_with_throw_on_copy atc;
  try {
-    boost::function<int (int, int)> f(boost::ref(atc));
+    boost::function<int (int, int)> f(ref(atc));
    BOOST_CHECK(f(1, 3) == 4);
  }
-  catch(std::runtime_error e) {
+  catch(runtime_error e) {
    BOOST_ERROR("Nonthrowing constructor threw an exception");
  }
 }

-static void dummy() {}
-
-static void test_empty_ref()
-{
-  boost::function<void()> f1;
-  boost::function<void()> f2(boost::ref(f1));
-
-  try {
-    f2();
-    BOOST_ERROR("Exception didn't throw for reference to empty function.");
-  }
-  catch(std::runtime_error e) {}
-
-  f1 = dummy;
-
-  try {
-    f2();
-  }
-  catch(std::runtime_error e) {
-    BOOST_ERROR("Error calling referenced function.");
-  }
-}
-
-
 static void test_exception()
 {
  boost::function<int (int, int)> f;
@ -690,95 +666,6 @@ static void test_call()
  test_call_cref(std::plus<int>());
 }

-struct big_aggregating_structure {
-  int disable_small_objects_optimizations[32];
-    
-  big_aggregating_structure()
-  {
-    ++ global_int;
-  }
-    
-  big_aggregating_structure(const big_aggregating_structure&)
-  {
-    ++ global_int;
-  }
-
-  ~big_aggregating_structure()
-  {
-    -- global_int;
-  }
-    
-  void operator()() 
-  {
-    ++ global_int;
-  }
-
-  void operator()(int) 
-  {
-    ++ global_int;
-  }
-};
-
-template <class FunctionT>
-static void test_move_semantics() 
-{
-  typedef FunctionT f1_type;
-
-  big_aggregating_structure obj;
-  
-  f1_type f1 = obj;
-  global_int = 0;
-  f1();
-  
-  BOOST_CHECK(!f1.empty());
-  BOOST_CHECK(global_int == 1);
-  
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-  // Testing rvalue constructors
-  f1_type f2(static_cast<f1_type&&>(f1));
-  BOOST_CHECK(f1.empty());
-  BOOST_CHECK(!f2.empty());
-  BOOST_CHECK(global_int == 1);
-  f2();
-  BOOST_CHECK(global_int == 2);
-  
-  f1_type f3(static_cast<f1_type&&>(f2));
-  BOOST_CHECK(f1.empty());
-  BOOST_CHECK(f2.empty());
-  BOOST_CHECK(!f3.empty());
-  BOOST_CHECK(global_int == 2);
-  f3();
-  BOOST_CHECK(global_int == 3);
-    
-  // Testing move assignment
-  f1_type f4;
-  BOOST_CHECK(f4.empty());
-  f4 = static_cast<f1_type&&>(f3);
-  BOOST_CHECK(f1.empty());
-  BOOST_CHECK(f2.empty());
-  BOOST_CHECK(f3.empty());
-  BOOST_CHECK(!f4.empty());
-  BOOST_CHECK(global_int == 3);
-  f4();
-  BOOST_CHECK(global_int == 4);
-  
-  // Testing self move assignment
-  f4 = static_cast<f1_type&&>(f4);
-  BOOST_CHECK(!f4.empty());
-  BOOST_CHECK(global_int == 4);
-
-  // Testing, that no memory leaked when assigning to nonempty function
-  f4 = obj;
-  BOOST_CHECK(!f4.empty());
-  BOOST_CHECK(global_int == 4);
-  f1_type f5 = obj;
-  BOOST_CHECK(global_int == 5);
-  f4 = static_cast<f1_type&&>(f5);
-  BOOST_CHECK(global_int == 4);
-  
-#endif  
-}
-
 int test_main(int, char* [])
 {
  test_zero_args();
@ -787,12 +674,9 @@ int test_main(int, char* [])
  test_emptiness();
  test_member_functions();
  test_ref();
-  test_empty_ref();
  test_exception();
  test_implicit();
  test_call();
-  test_move_semantics<function<void()> >();
-  test_move_semantics<boost::function0<void> >();

  return 0;
 }
--- a/test/function_typeof_test.cpp
+++ b/test/function_typeof_test.cpp
@ -1,18 +0,0 @@
-// Boost.Function library
-
-//  Copyright Douglas Gregor 2008. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org
-#include <boost/function/function_typeof.hpp>
-#include <boost/function.hpp>
-#include <boost/typeof/typeof.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/static_assert.hpp>
-
-void f(boost::function0<void> f, boost::function0<void> g)
-{
-  BOOST_STATIC_ASSERT((boost::is_same<boost::function0<void>, BOOST_TYPEOF(f = g)>::value));
-}
--- a/test/lambda_test.cpp
+++ b/test/lambda_test.cpp
@ -15,21 +15,21 @@
 #include <boost/lambda/bind.hpp>
 #include <boost/function.hpp>

+using namespace std;
+using namespace boost;
+using namespace boost::lambda;
+
 static unsigned
 func_impl(int arg1, bool arg2, double arg3)
 {
-  using namespace std;
  return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
 }

 int test_main(int, char*[])
 {
-  using boost::function;
-  using namespace boost::lambda;
-
  function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
-  function <unsigned(double)>       f2 = boost::lambda::bind(f1, false, _1);
-  function <unsigned()>             f3 = boost::lambda::bind(f2, 4.0);
+  function <unsigned(double)>       f2 = bind(f1, false, _1);
+  function <unsigned()>             f3 = bind(f2, 4.0);

  f3();

--- a/test/mem_fun_cxx98.cpp
+++ b/test/mem_fun_cxx98.cpp
@ -10,36 +10,22 @@

    
 #include <boost/function.hpp>
-#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <functional>

-struct Y {
-    Y(int y = 0) : y_(y) {}
-    bool operator==(const Y& rhs) { return y_ == rhs.y_; }
-private:
-    int y_;
-    };
-
 struct X {
  int foo(int);
-  Y& foo2(Y&) const;
 };
 int X::foo(int x) { return -x; }
-Y& X::foo2(Y& x) const { return x; }

 int main()
 {
    boost::function<int (X*, int)> f;
-    boost::function<Y& (X*, Y&)> f2;
-	Y y1;
-	
-    f = &X::foo;
-    f2 = &X::foo2;

-    X x;
-    BOOST_TEST(f(&x, 5) == -5);
-    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
+f = &X::foo;
+  
+X x;
+f(&x, 5);

-    return ::boost::report_errors();
+    return 0;
 }
--- a/test/mem_fun_portable.cpp
+++ b/test/mem_fun_portable.cpp
@ -10,36 +10,22 @@

    
 #include <boost/function.hpp>
-#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <functional>

-struct Y {
-    Y(int y = 0) : y_(y) {}
-    bool operator==(const Y& rhs) { return y_ == rhs.y_; }
-private:
-    int y_;
-    };
-
 struct X {
  int foo(int);
-  Y& foo2(Y&) const;
 };
 int X::foo(int x) { return -x; }
-Y& X::foo2(Y& x) const { return x; }

 int main()
 {
    boost::function2<int, X*, int> f;
-    boost::function2<Y&, X*, Y&> f2;
-    Y y1;
-    
-    f = &X::foo;
-    f2 = &X::foo2;

-    X x;
-    BOOST_TEST(f(&x, 5) == -5);
-    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
+f = &X::foo;
+  
+X x;
+f(&x, 5);

-    return ::boost::report_errors();
+    return 0;
 }
--- a/test/nothrow_swap.cpp
+++ b/test/nothrow_swap.cpp
@ -1,60 +0,0 @@
-// Boost.Function library
-
-//  Copyright Douglas Gregor 2008. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org
-
-#include <boost/test/minimal.hpp>
-#include <boost/function.hpp>
-
-struct tried_to_copy { };
-
-struct MaybeThrowOnCopy {
-  MaybeThrowOnCopy(int value = 0) : value(value) { }
-
-  MaybeThrowOnCopy(const MaybeThrowOnCopy& other) : value(other.value) {
-    if (throwOnCopy)
-      throw tried_to_copy();
-  }
-
-  MaybeThrowOnCopy& operator=(const MaybeThrowOnCopy& other) {
-    if (throwOnCopy)
-      throw tried_to_copy();
-    value = other.value;
-    return *this;
-  }
-
-  int operator()() { return value; }
-
-  int value;
-
-  // Make sure that this function object doesn't trigger the
-  // small-object optimization in Function.
-  float padding[100];
-
-  static bool throwOnCopy;
-};
-
-bool MaybeThrowOnCopy::throwOnCopy = false;
-
-int test_main(int, char* [])
-{
-  boost::function0<int> f;
-  boost::function0<int> g;
-
-  MaybeThrowOnCopy::throwOnCopy = false;
-  f = MaybeThrowOnCopy(1);
-  g = MaybeThrowOnCopy(2);
-  BOOST_CHECK(f() == 1);
-  BOOST_CHECK(g() == 2);
-
-  MaybeThrowOnCopy::throwOnCopy = true;
-  f.swap(g);
-  BOOST_CHECK(f() == 2);
-  BOOST_CHECK(g() == 1);
-  
-  return 0;
-}
--- a/test/result_arg_types_test.cpp
+++ b/test/result_arg_types_test.cpp
@ -1,40 +0,0 @@
-// Boost.Function library
-
-//  Copyright 2016 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/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-struct X
-{
-};
-
-struct Y
-{
-};
-
-struct Z
-{
-};
-
-int main()
-{
-    typedef boost::function<X(Y)> F1;
-
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F1::result_type, X> ));
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F1::argument_type, Y> ));
-
-    typedef boost::function<X(Y, Z)> F2;
-
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F2::result_type, X> ));
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F2::first_argument_type, Y> ));
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F2::second_argument_type, Z> ));
-
-    return boost::report_errors();
-}
--- a/test/rvalues_test.cpp
+++ b/test/rvalues_test.cpp
@ -1,106 +0,0 @@
-// Copyright 2014 Antony Polukhin.
-//
-// 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)
-
-// For more information, see http://www.boost.org
-
-#include <iostream>
-#include <cstdlib>
-
-#include <boost/test/minimal.hpp>
-#include <boost/function.hpp>
-#include <boost/move/move.hpp>
-
-class only_movable {
-private:
-    BOOST_MOVABLE_BUT_NOT_COPYABLE(only_movable)
-    int value_;
-    bool moved_;
-
-public:
-    only_movable(BOOST_RV_REF(only_movable) x)
-        : value_(x.value_)
-        , moved_(false)
-    {
-        x.moved_ = true;
-    }
-
-   only_movable& operator=(BOOST_RV_REF(only_movable) x) {
-        value_ = x.value_;
-        x.moved_ = true;
-        moved_ = false;
-        return *this;
-   }
-
-    explicit only_movable(int value = 0) : value_(value), moved_(false) {}
-    int get_value() const {  return value_;  }
-    bool is_moved() const { return moved_; }
-};
-
-
-int one(BOOST_RV_REF(only_movable) v) { return v.get_value(); }
-only_movable two(BOOST_RV_REF(only_movable) t) {
-    only_movable t1 = boost::move(t);
-    return BOOST_MOVE_RET(only_movable, t1);
-}
-
-only_movable two_sum(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) {
-    only_movable ret(t1.get_value() + t2.get_value());
-    return BOOST_MOVE_RET(only_movable, ret);
-}
-
-struct sum_struct {
-    only_movable operator()(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) const {
-        only_movable ret(t1.get_value() + t2.get_value());
-        return BOOST_MOVE_RET(only_movable, ret);
-    }
-};
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-int three(std::string&&) { return 1; }
-std::string&& four(std::string&& s) { return boost::move(s); }
-#endif
-
-int test_main(int, char*[])
-{
-    using boost::function;
-
-    function <int(BOOST_RV_REF(only_movable))>  f1 = one;
-
-    only_movable om1(1);
-    BOOST_CHECK(f1(boost::move(om1)) == 1);
-
-    function <only_movable(BOOST_RV_REF(only_movable))>  f2 = two;
-
-    only_movable om2(2);
-    only_movable om2_2 = f2(boost::move(om2));
-    BOOST_CHECK(om2_2.get_value() == 2);
-    BOOST_CHECK(om2.is_moved());
-
-    {
-        function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))>  f2_sum = two_sum;
-        only_movable om1_sum(1), om2_sum(2);
-        only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
-        BOOST_CHECK(om2_sum_2.get_value() == 3);
-    }
-
-    {
-        sum_struct s;
-        function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))>  f2_sum = s;
-        only_movable om1_sum(1), om2_sum(2);
-        only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
-        BOOST_CHECK(om2_sum_2.get_value() == 3);
-    }
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    function <int(std::string&&)>               f3 = three;
-    function <std::string&& (std::string&& s)>  f4 = four;
-
-    f3(std::string("Hello"));
-    BOOST_CHECK(f4(std::string("world")) == "world");
-#endif
-
-    return 0;
-}
--- a/test/std_bind_cxx98.cpp
+++ b/test/std_bind_cxx98.cpp
@ -20,12 +20,11 @@ int X::foo(int x) { return -x; }

 int main()
 {
-#ifndef BOOST_NO_CXX98_BINDERS
      boost::function<int (int)> f;
  X x;
  f = std::bind1st(
        std::mem_fun(&X::foo), &x);
  f(5); // Call x.foo(5)
-#endif
+
    return 0;
 }
--- a/test/std_bind_portable.cpp
+++ b/test/std_bind_portable.cpp
@ -20,12 +20,11 @@ int X::foo(int x) { return -x; }

 int main()
 {
-#ifndef BOOST_NO_CXX98_BINDERS
      boost::function1<int, int> f;
  X x;
  f = std::bind1st(
        std::mem_fun(&X::foo), &x);
  f(5); // Call x.foo(5)
-#endif
+
    return 0;
 }