Create branches/filesystem-v3 for v2 removal

[SVN r77385]

.travis.yml

@@ -1,322 +0,0 @@
-# Copyright 2016-2019 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
-
-dist: trusty
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc CXXSTD=11
-
-    - os: linux
-      compiler: g++-4.4
-      env: TOOLSET=gcc CXXSTD=0x
-      addons:
-        apt:
-          packages:
-            - g++-4.4
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.6
-      env: TOOLSET=gcc CXXSTD=0x
-      addons:
-        apt:
-          packages:
-            - g++-4.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.7
-      env: TOOLSET=gcc CXXSTD=11
-      addons:
-        apt:
-          packages:
-            - g++-4.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.8
-      env: TOOLSET=gcc CXXSTD=11
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources:
-            - ubuntu-toolchain-r-test
-    - os: linux
-      compiler: g++-4.9
-      env: TOOLSET=gcc CXXSTD=11
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-7
-      env: TOOLSET=gcc CXXSTD=11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-8
-      env: TOOLSET=gcc CXXSTD=11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-9
-      env: TOOLSET=gcc CXXSTD=11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - g++-9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-7
-      env: UBSAN=1 TOOLSET=gcc CXXSTD=11,14,17 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang CXXSTD=11
-
-    - os: linux
-      compiler: /usr/bin/clang++
-      env: TOOLSET=clang CXXSTD=11
-      addons:
-        apt:
-          packages:
-            - clang-3.3
-
-    - os: linux
-      compiler: /usr/bin/clang++
-      env: TOOLSET=clang CXXSTD=11
-      addons:
-        apt:
-          packages:
-            - clang-3.4
-
-    - os: linux
-      compiler: clang++-3.5
-      env: TOOLSET=clang CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.5
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.5
-
-    - os: linux
-      compiler: clang++-3.6
-      env: TOOLSET=clang CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.6
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.6
-
-    - os: linux
-      compiler: clang++-3.7
-      env: TOOLSET=clang CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.9
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.9
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-5.0
-      env: TOOLSET=clang CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
-
-    - os: linux
-      compiler: clang++-6.0
-      env: TOOLSET=clang CXXSTD=11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
-
-    - os: linux
-      compiler: clang++-7
-      env: TOOLSET=clang CXXSTD=11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-7
-
-    - os: linux
-      compiler: clang++-8
-      env: TOOLSET=clang CXXSTD=11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-8
-
-    - os: linux
-      compiler: clang++-8
-      env: UBSAN=1 TOOLSET=clang CXXSTD=11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - clang-8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-8
-
-    - os: linux
-      compiler: clang++-libc++
-      env: TOOLSET=clang CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-
-    - os: linux
-      compiler: clang++-libc++
-      env: UBSAN=1 TOOLSET=clang CXXSTD=11,14,1z UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang CXXSTD=11,14,1z
-
-install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
-  - cd ..
-  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - 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 : : $TRAVIS_COMPILER ;" > ~/user-config.jam
-  - ./b2 -j3 libs/function/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
-
-notifications:
-  email:
-    on_success: always

CMakeLists.txt

@@ -1,28 +0,0 @@
-# Copyright 2019 Peter Dimov
-# 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
-
-# Partial (add_subdirectory only) and experimental CMake support
-# Subject to change; please do not rely on the contents of this file yet
-
-cmake_minimum_required(VERSION 3.5)
-project(BoostFunction LANGUAGES CXX)
-
-add_library(boost_function INTERFACE)
-add_library(Boost::function ALIAS boost_function)
-
-target_include_directories(boost_function INTERFACE include)
-
-target_link_libraries(boost_function
-    INTERFACE
-        Boost::assert
-        Boost::bind
-        Boost::config
-        Boost::core
-        Boost::integer
-        Boost::preprocessor
-        Boost::throw_exception
-        Boost::type_index
-        Boost::type_traits
-        Boost::typeof
-)

README.md

@@ -1,18 +0,0 @@
-# Boost.Function, a polymorphic function wrapper
-
-[Boost.Function](http://boost.org/libs/function), part of the
-[Boost C++ Libraries](http://boost.org), is the original implementation of the
-polymorphic function wrapper `boost::function`, which was eventually accepted
-into the C++11 standard as [`std::function`](https://en.cppreference.com/w/cpp/utility/functional/function).
-
-## Currently supported compilers
-
-* g++ 4.4 or later
-* clang++ 3.3 or later
-* Visual Studio 2005-2017
-
-Tested on [Travis](https://travis-ci.org/boostorg/function/) and [Appveyor](https://ci.appveyor.com/project/pdimov/function/).
-
-## License
-
-Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).

appveyor.yml

@@ -1,61 +0,0 @@
-# Copyright 2016-2019 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)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-12.0,msvc-14.0
-      ADDRMD: 32,64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: 14,17
-      ADDRMD: 32,64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\cygwin\bin;
-      TOOLSET: gcc
-      CXXSTD: 11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\cygwin64\bin;
-      TOOLSET: gcc
-      CXXSTD: 11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\mingw\bin;
-      TOOLSET: gcc
-      CXXSTD: 11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
-      TOOLSET: gcc
-      CXXSTD: 11,14,1z
-
-install:
-  - set BOOST_BRANCH=develop
-  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
-  - cd ..
-  - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/boostdep
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\function\
-  - python tools/boostdep/depinst/depinst.py function
-  - cmd /c bootstrap
-  - b2 -d0 headers
-
-build: off
-
-test_script:
-  - PATH=%ADDPATH%%PATH%
-  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - b2 -j3 libs/function/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release

doc/Jamfile.v2

@@ -3,7 +3,7 @@
 #   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 
@@ -14,12 +14,3 @@ boostbook function-doc
         <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
     ;
 
-###############################################################################
-alias boostdoc
-    : function.xml
-    :
-    :
-    : ;
-explicit boostdoc ;
-alias boostrelease ;
-explicit boostrelease ;

doc/history.xml

@@ -13,15 +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

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">

example/Jamfile

@@ -1,14 +0,0 @@
-# Boost.Function Library example Jamfile
-#
-# Copyright (c) 2008 James E. King III
-#
-# 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
-
-import ../../config/checks/config : requires ;
-import testing ;
-
-run bind1st.cpp : : : [ requires cxx98_binders ] ;
-run int_div.cpp ;
-run sum_avg.cpp ;

include/boost/function.hpp

@@ -10,379 +10,15 @@
 // William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
 // design of this library.
 
-#include <boost/function/detail/config.hpp>
+#include <functional> // unary_function, binary_function
 
-#if !BOOST_FUNCTION_ENABLE_CXX03
+#include <boost/preprocessor/iterate.hpp>
-
+#include <boost/detail/workaround.hpp>
-#ifndef BOOST_FUNCTION_HPP_INCLUDED
-#define BOOST_FUNCTION_HPP_INCLUDED
-
-#include <boost/ref.hpp>
-#include <boost/function_equal.hpp>
-#include <functional>
-#include <type_traits>
-
-namespace boost
-{
-
-#define BOOST_FUNCTION_TARGET_FIX(x)
-
-using std::bad_function_call;
-
-template<class S> class function: public std::function<S>
-{
-public:
-
-    function() = default;
-
-    function(function const&) = default;
-    function(function&&) = default;
-
-    using std::function<S>::function;
-
-    template<class T> function( boost::reference_wrapper<T> rt ): std::function<S>( std::ref( rt.get() ) )
-    {
-    }
-
-    function& operator=( function const& r ) = default;
-    function& operator=( function&& r ) = default;
-
-    template<class S2> function& operator=( function<S2> const& r )
-    {
-        std::function<S>::operator=( static_cast< std::function<S2> const& >( r ) );
-        return *this;
-    }
-
-    template<class S2> function& operator=( function<S2>&& r )
-    {
-        std::function<S>::operator=( static_cast< std::function<S2>&& >( r ) );
-        return *this;
-    }
-
-    template<class F, class E = typename std::enable_if< !std::is_integral<F>::value && !std::is_same<F, function>::value >::type > function& operator=( F f )
-    {
-        std::function<S>::operator=( std::move( f ) );
-        return *this;
-    }
-
-    function& operator=( std::nullptr_t f )
-    {
-        std::function<S>::operator=( f );
-        return *this;
-    }
-
-    template<class T> function& operator=( boost::reference_wrapper<T> rt )
-    {
-        std::function<S>::operator=( std::ref( rt.get() ) );
-        return *this;
-    }
-
-    bool empty() const noexcept
-    {
-        return ! *this;
-    }
-
-    void clear()
-    {
-        *this = nullptr;
-    }
-
-    template<class F, class A> void assign( F f, A )
-    {
-        this->operator=( std::move( f ) );
-    }
-
-    template<class F> F * target() noexcept
-    {
-        if( F * p = std::function<S>::template target<F>() )
-        {
-            return p;
-        }
-
-        if( std::reference_wrapper<F> * p = std::function<S>::template target< std::reference_wrapper<F> >() )
-        {
-            return std::addressof( p->get() );
-        }
-
-        return nullptr;
-    }
-
-    template<class F> F const * target() const noexcept
-    {
-        if( F const * p = std::function<S>::template target<F>() )
-        {
-            return p;
-        }
-
-        if( std::reference_wrapper<F> const * p = std::function<S>::template target< std::reference_wrapper<F> >() )
-        {
-            return std::addressof( p->get() );
-        }
-
-        return nullptr;
-    }
-
-    template<class F> bool contains( F const& f ) const noexcept
-    {
-        if( F const * fp = this->template target<F>() )
-        {
-            return function_equal( *fp, f );
-        }
-        else
-        {
-            return false;
-        }
-    }
-};
-
-template<class S, class F, class E = typename std::enable_if< !std::is_integral<F>::value && !std::is_same<F, std::nullptr_t>::value>::type> inline bool operator==( function<S> const & g, F f )
-{
-    return g.contains( f );
-}
-
-template<class S, class F, class E = typename std::enable_if< !std::is_integral<F>::value && !std::is_same<F, std::nullptr_t>::value>::type> inline bool operator!=( function<S> const & g, F f )
-{
-    return !g.contains( f );
-}
-
-template<class S, class F> inline bool operator==( function<S> const & g, boost::reference_wrapper<F> rf )
-{
-    return g.template target<F>() == std::addressof( rf.get() );
-}
-
-template<class S, class F> inline bool operator!=( function<S> const & g, boost::reference_wrapper<F> rf )
-{
-    return g.template target<F>() != std::addressof( rf.get() );
-}
-
-template<class S, class F, class E = typename std::enable_if< !std::is_integral<F>::value && !std::is_same<F, std::nullptr_t>::value>::type> inline bool operator==( F f, function<S> const & g )
-{
-    return g.contains( f );
-}
-
-template<class S, class F, class E = typename std::enable_if< !std::is_integral<F>::value && !std::is_same<F, std::nullptr_t>::value>::type> inline bool operator!=( F f, function<S> const & g )
-{
-    return !g.contains( f );
-}
-
-template<class S, class F> inline bool operator==( boost::reference_wrapper<F> rf, function<S> const & g )
-{
-    return g.template target<F>() == std::addressof( rf.get() );
-}
-
-template<class S, class F> inline bool operator!=( boost::reference_wrapper<F> rf, function<S> const & g )
-{
-    return g.template target<F>() != std::addressof( rf.get() );
-}
-
-namespace detail
-{
-
-template<class T1, class T2> struct is_similar
-{
-    BOOST_STATIC_CONSTANT( bool, value = false );
-};
-
-template<template<class...> class L, class... T1, class... T2> struct is_similar< L<T1...>, L<T2...> >
-{
-    BOOST_STATIC_CONSTANT( bool, value = true );
-};
-
-} // namespace detail
-
-#define BOOST_FUNCTION_N_COMMON \
-\
-    using base_type::base_type;\
-\
-    template<class F, class E = typename std::enable_if< !std::is_integral<F>::value && !detail::is_similar<F, this_type>::value >::type > this_type& operator=( F f )\
-    {\
-        base_type::operator=( std::move( f ) );\
-        return *this;\
-    }\
-\
-    this_type& operator=( std::nullptr_t f )\
-    {\
-        base_type::operator=( f );\
-        return *this;\
-    }\
-\
-    template<class S2> this_type& operator=( boost::function<S2> const& r )\
-    {\
-        base_type::operator=( r );\
-        return *this;\
-    }\
-\
-    template<class S2> this_type& operator=( boost::function<S2>&& r )\
-    {\
-        base_type::operator=( std::move( r ) );\
-        return *this;\
-    }
-
-template<typename R> class function0: public function<R()>
-{
-private:
-
-    typedef function0 this_type;
-    typedef function<R()> base_type;
-
-public:
-
-	BOOST_FUNCTION_N_COMMON
-};
-
-template<typename R, typename T1> class function1: public function<R(T1)>
-{
-private:
-
-    typedef function1 this_type;
-    typedef function<R(T1)> base_type;
-
-public:
-
-	BOOST_FUNCTION_N_COMMON
-};
-
-template<typename R, typename T1, typename T2> class function2: public function<R(T1, T2)>
-{
-private:
-
-    typedef function2 this_type;
-    typedef function<R(T1, T2)> base_type;
-
-public:
-
-	BOOST_FUNCTION_N_COMMON
-};
-
-template<typename R, typename T1, typename T2, typename T3> class function3: public function<R(T1, T2, T3)>
-{
-private:
-
-    typedef function3 this_type;
-    typedef function<R(T1, T2, T3)> base_type;
-
-public:
-
-	BOOST_FUNCTION_N_COMMON
-};
-
-template<typename R, typename T1, typename T2, typename T3, typename T4> class function4: public function<R(T1, T2, T3, T4)>
-{
-private:
-
-    typedef function4 this_type;
-    typedef function<R(T1, T2, T3, T4)> base_type;
-
-public:
-
-	BOOST_FUNCTION_N_COMMON
-};
-
-template<typename R, typename T1, typename T2, typename T3, typename T4, typename T5> class function5: public function<R(T1, T2, T3, T4, T5)>
-{
-private:
-
-    typedef function5 this_type;
-    typedef function<R(T1, T2, T3, T4, T5)> base_type;
-
-public:
-
-	BOOST_FUNCTION_N_COMMON
-};
-
-template<typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> class function6: public function<R(T1, T2, T3, T4, T5, T6)>
-{
-private:
-
-    typedef function6 this_type;
-    typedef function<R(T1, T2, T3, T4, T5, T6)> base_type;
-
-public:
-
-	BOOST_FUNCTION_N_COMMON
-};
-
-template<typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> class function7: public function<R(T1, T2, T3, T4, T5, T6, T7)>
-{
-private:
-
-    typedef function7 this_type;
-    typedef function<R(T1, T2, T3, T4, T5, T6, T7)> base_type;
-
-public:
-
-	BOOST_FUNCTION_N_COMMON
-};
-
-template<typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> class function8: public function<R(T1, T2, T3, T4, T5, T6, T7, T8)>
-{
-private:
-
-    typedef function8 this_type;
-    typedef function<R(T1, T2, T3, T4, T5, T6, T7, T8)> base_type;
-
-public:
-
-	BOOST_FUNCTION_N_COMMON
-};
-
-template<typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> class function9: public function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
-{
-private:
-
-    typedef function9 this_type;
-    typedef function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9)> base_type;
-
-public:
-
-	BOOST_FUNCTION_N_COMMON
-};
-
-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: public function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
-{
-private:
-
-    typedef function10 this_type;
-    typedef function<R(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> base_type;
-
-public:
-
-	BOOST_FUNCTION_N_COMMON
-};
-
-template<typename R, typename... A> class function30: public function<R(A...)>
-{
-private:
-
-    typedef function30 this_type;
-    typedef function<R(A...)> base_type;
-
-public:
-
-	BOOST_FUNCTION_N_COMMON
-};
-
-} // namespace boost
-
-#endif // #ifndef BOOST_FUNCTION_HPP_INCLUDED
-
-#else
 
 #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/config/workaround.hpp>
-
 // 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>
@@ -428,7 +64,3 @@ public:
 #  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)
-
-#endif

include/boost/function/detail/config.hpp

@@ -1,12 +0,0 @@
-// Copyright 2019 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
-
-#ifndef BOOST_FUNCTION_DETAIL_CONFIG_HPP_INCLUDED
-#define BOOST_FUNCTION_DETAIL_CONFIG_HPP_INCLUDED
-
-#if !defined(BOOST_FUNCTION_ENABLE_CXX03)
-# define BOOST_FUNCTION_ENABLE_CXX03 0
-#endif
-
-#endif // #ifndef BOOST_FUNCTION_DETAIL_CONFIG_HPP_INCLUDED

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";

include/boost/function/detail/maybe_include.hpp

@@ -7,363 +7,257 @@
 
 // For more information, see http://www.boost.org
 
-#include <boost/function/detail/config.hpp>
-
-#if BOOST_FUNCTION_ENABLE_CXX03
-
 #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>
@@ -371,5 +265,3 @@
 #else
 #  error Cannot handle Boost.Function objects that accept more than 50 arguments!
 #endif
-
-#endif

include/boost/function/function_base.hpp

@@ -16,23 +16,24 @@
 #include <memory>
 #include <new>
 #include <boost/config.hpp>
+#include <boost/detail/sp_typeinfo.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/type_traits/ice.hpp>
 #include <boost/ref.hpp>
-#include <boost/type_traits/conditional.hpp>
+#include <boost/mpl/if.hpp>
-#include <boost/config/workaround.hpp>
+#include <boost/detail/workaround.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #ifndef BOOST_NO_SFINAE
-#include <boost/type_traits/enable_if.hpp>
+#  include "boost/utility/enable_if.hpp"
 #else
-#include <boost/type_traits/integral_constant.hpp>
+#  include "boost/mpl/bool.hpp"
 #endif
 #include <boost/function_equal.hpp>
 #include <boost/function/function_fwd.hpp>
@@ -41,18 +42,49 @@
 #   pragma warning( push )
 #   pragma warning( disable : 4793 ) // complaint about native code generation
 #   pragma warning( disable : 4127 ) // "conditional expression is constant"
+#endif       
+
+// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
+#ifdef BOOST_NO_STD_TYPEINFO
+// Embedded VC++ does not have type_info in namespace std
+#  define BOOST_FUNCTION_STD_NS
+#else
+#  define BOOST_FUNCTION_STD_NS std
 #endif
 
-#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( BOOST_NO_TYPEID )
+#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
+#elif (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 !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
 #  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
-      typename ::boost::enable_if_<          \
+      typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
-                           !(::boost::is_integral<Functor>::value), \
+                            (::boost::is_integral<Functor>::value)>::value), \
                            Type>::type
+#else
+// BCC doesn't recognize this depends on a template argument and complains
+// about the use of 'typename'
+#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
+      ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
+                   (::boost::is_integral<Functor>::value)>::value), \
+                       Type>::type
+#endif
 
 namespace boost {
   namespace detail {
@@ -65,16 +97,15 @@ 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 void* obj_ptr;
-        mutable obj_ptr_t 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;
+          const detail::sp_typeinfo* type;
 
           // Whether the type is const-qualified.
           bool const_qualified;
@@ -83,8 +114,7 @@ namespace boost {
         } type;
 
         // For function pointers of all kinds
-        typedef void (*func_ptr_t)();
+        mutable void (*func_ptr)();
-        mutable func_ptr_t func_ptr;
 
         // For bound member pointers
         struct bound_memfunc_ptr_t {
@@ -99,15 +129,9 @@ namespace boost {
           bool is_const_qualified;
           bool is_volatile_qualified;
         } obj_ref;
-      };
-
-      union BOOST_SYMBOL_VISIBLE 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;
       };
 
       /**
@@ -152,15 +176,15 @@ namespace boost {
       template<typename F>
       class get_function_tag
       {
-        typedef typename conditional<(is_pointer<F>::value),
+        typedef typename mpl::if_c<(is_pointer<F>::value),
                                    function_ptr_tag,
                                    function_obj_tag>::type ptr_or_obj_tag;
 
-        typedef typename conditional<(is_member_pointer<F>::value),
+        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 conditional<(is_reference_wrapper<F>::value),
+        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
                                    function_obj_ref_tag,
                                    ptr_or_obj_or_mem_tag>::type or_ref_tag;
 
@@ -174,42 +198,45 @@ namespace boost {
       struct reference_manager
       {
         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)
         {
           switch (op) {
-          case clone_functor_tag:
+          case clone_functor_tag: 
-            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
+            out_buffer.obj_ref = in_buffer.obj_ref;
             return;
 
           case move_functor_tag:
-            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
+            out_buffer.obj_ref = in_buffer.obj_ref;
-            in_buffer.members.obj_ref.obj_ptr = 0;
+            in_buffer.obj_ref.obj_ptr = 0;
             return;
 
           case destroy_functor_tag:
-            out_buffer.members.obj_ref.obj_ptr = 0;
+            out_buffer.obj_ref.obj_ptr = 0;
             return;
 
           case check_functor_type_tag:
             {
+              const detail::sp_typeinfo& check_type 
+                = *out_buffer.type.type;
+
               // Check whether we have the same type. We can add
               // cv-qualifiers, but we can't take them away.
-              if (*out_buffer.members.type.type == boost::typeindex::type_id<F>()
+              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(F))
-                  && (!in_buffer.members.obj_ref.is_const_qualified
+                  && (!in_buffer.obj_ref.is_const_qualified 
-                      || out_buffer.members.type.const_qualified)
+                      || out_buffer.type.const_qualified)
-                  && (!in_buffer.members.obj_ref.is_volatile_qualified
+                  && (!in_buffer.obj_ref.is_volatile_qualified
-                      || out_buffer.members.type.volatile_qualified))
+                      || out_buffer.type.volatile_qualified))
-                out_buffer.members.obj_ptr = in_buffer.members.obj_ref.obj_ptr;
+                out_buffer.obj_ptr = in_buffer.obj_ref.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.type.type = &BOOST_SP_TYPEID(F);
-            out_buffer.members.type.const_qualified = in_buffer.members.obj_ref.is_const_qualified;
+            out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
-            out_buffer.members.type.volatile_qualified = in_buffer.members.obj_ref.is_volatile_qualified;
+            out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
             return;
           }
         }
@@ -223,9 +250,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,7 +264,7 @@ namespace boost {
           A(a)
         {
         }
-
+        
         functor_wrapper(const functor_wrapper& f) :
           F(static_cast<const F&>(f)),
           A(static_cast<const A&>(f))
@@ -256,57 +283,61 @@ 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;
+            out_buffer.func_ptr = in_buffer.func_ptr;
           else if (op == move_functor_tag) {
-            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
+            out_buffer.func_ptr = in_buffer.func_ptr;
-            in_buffer.members.func_ptr = 0;
+            in_buffer.func_ptr = 0;
           } else if (op == destroy_functor_tag)
-            out_buffer.members.func_ptr = 0;
+            out_buffer.func_ptr = 0;
           else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+            const detail::sp_typeinfo& check_type 
-              out_buffer.members.obj_ptr = &in_buffer.members.func_ptr;
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
+              out_buffer.obj_ptr = &in_buffer.func_ptr;
             else
-              out_buffer.members.obj_ptr = 0;
+              out_buffer.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
-            out_buffer.members.type.const_qualified = false;
+            out_buffer.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.volatile_qualified = false;
           }
         }
 
         // Function objects that fit in the small-object buffer.
         static inline void
-        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
+        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 =
+            const functor_type* in_functor = 
-              reinterpret_cast<const functor_type*>(in_buffer.data);
+              reinterpret_cast<const functor_type*>(&in_buffer.data);
-            new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor);
+            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);
+              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();
             }
           } 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);
+             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>())
+            const detail::sp_typeinfo& check_type 
-              out_buffer.members.obj_ptr = in_buffer.data;
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
+              out_buffer.obj_ptr = &in_buffer.data;
             else
-              out_buffer.members.obj_ptr = 0;
+              out_buffer.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
-            out_buffer.members.type.const_qualified = false;
+            out_buffer.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.volatile_qualified = false;            
           }
         }
       };
@@ -319,7 +350,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,16 +358,16 @@ 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, true_type)
+                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, false_type)
+                functor_manager_operation_type op, mpl::false_)
         {
           if (op == clone_functor_tag) {
             // Clone the functor
@@ -345,27 +376,29 @@ namespace boost {
             // 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);
+              static_cast<const functor_type*>(in_buffer.obj_ptr);
             functor_type* new_f = new functor_type(*f);
-            out_buffer.members.obj_ptr = new_f;
+            out_buffer.obj_ptr = new_f;
           } else if (op == move_functor_tag) {
-            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
-            in_buffer.members.obj_ptr = 0;
+            in_buffer.obj_ptr = 0;
           } else if (op == destroy_functor_tag) {
             /* Cast from the void pointer to the functor pointer type */
             functor_type* f =
-              static_cast<functor_type*>(out_buffer.members.obj_ptr);
+              static_cast<functor_type*>(out_buffer.obj_ptr);
             delete f;
-            out_buffer.members.obj_ptr = 0;
+            out_buffer.obj_ptr = 0;
           } else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+            const detail::sp_typeinfo& check_type
-              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
+              out_buffer.obj_ptr = in_buffer.obj_ptr;
             else
-              out_buffer.members.obj_ptr = 0;
+              out_buffer.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
-            out_buffer.members.type.const_qualified = false;
+            out_buffer.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.volatile_qualified = false;
           }
         }
 
@@ -373,35 +406,39 @@ 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,
-                  integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
+                  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,
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
                 functor_manager_operation_type op, member_ptr_tag)
         {
-          manager(in_buffer, out_buffer, op, true_type());
+          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;
-          if (op == get_functor_type_tag) {
+          switch (op) {
-            out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
+          case get_functor_type_tag:
-            out_buffer.members.type.const_qualified = false;
+            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.const_qualified = false;
-          } else {
+            out_buffer.type.volatile_qualified = false;
+            return;
+
+          default:
             manager(in_buffer, out_buffer, op, tag_type());
+            return;
           }
         }
       };
@@ -414,7 +451,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);
@@ -422,68 +459,57 @@ 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, true_type)
+                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, false_type)
+                functor_manager_operation_type op, mpl::false_)
         {
           typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
           typedef typename Allocator::template rebind<functor_wrapper_type>::other
             wrapper_allocator_type;
           typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
-#else
-          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
-          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
-#endif
 
           if (op == clone_functor_tag) {
             // Clone the functor
             // GCC 2.95.3 gets the CV qualifiers wrong here, so we
             // can't do the static_cast that we should do.
             const functor_wrapper_type* f =
-              static_cast<const functor_wrapper_type*>(in_buffer.members.obj_ptr);
+              static_cast<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);
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
             wrapper_allocator.construct(copy, *f);
-#else
-            std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, *f);
-#endif
 
             // 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;
+            out_buffer.obj_ptr = new_f;
           } else if (op == move_functor_tag) {
-            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
-            in_buffer.members.obj_ptr = 0;
+            in_buffer.obj_ptr = 0;
           } else if (op == destroy_functor_tag) {
             /* Cast from the void pointer to the functor_wrapper_type */
             functor_wrapper_type* victim =
-              static_cast<functor_wrapper_type*>(in_buffer.members.obj_ptr);
+              static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
             wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
             wrapper_allocator.destroy(victim);
-#else
-            std::allocator_traits<wrapper_allocator_type>::destroy(wrapper_allocator, victim);
-#endif
             wrapper_allocator.deallocate(victim,1);
-            out_buffer.members.obj_ptr = 0;
+            out_buffer.obj_ptr = 0;
           } else if (op == check_functor_type_tag) {
-            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+            const detail::sp_typeinfo& check_type 
-              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
+              out_buffer.obj_ptr = in_buffer.obj_ptr;
             else
-              out_buffer.members.obj_ptr = 0;
+              out_buffer.obj_ptr = 0;
           } else /* op == get_functor_type_tag */ {
-            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
-            out_buffer.members.type.const_qualified = false;
+            out_buffer.type.const_qualified = false;
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.volatile_qualified = false;
           }
         }
 
@@ -491,27 +517,31 @@ 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,
-                  integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
+                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
         }
 
       public:
         /* Dispatch to an appropriate manager based on whether we have a
            function pointer or a function object pointer. */
         static inline void
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+        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;
-          if (op == get_functor_type_tag) {
+          switch (op) {
-            out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
+          case get_functor_type_tag:
-            out_buffer.members.type.const_qualified = false;
+            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
-            out_buffer.members.type.volatile_qualified = false;
+            out_buffer.type.const_qualified = false;
-          } else {
+            out_buffer.type.volatile_qualified = false;
+            return;
+
+          default:
             manager(in_buffer, out_buffer, op, tag_type());
+            return;
           }
         }
       };
@@ -522,24 +552,24 @@ namespace boost {
 #ifdef BOOST_NO_SFINAE
       // These routines perform comparisons between a Boost.Function
       // object and an arbitrary function object (when the last
-      // parameter is false_type) or against zero (when the
+      // parameter is mpl::bool_<false>) or against zero (when the
-      // last parameter is true_type). They are only necessary
+      // 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, true_type)
+        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,
-                          true_type)
+                          mpl::bool_<true>)
         { return !f.empty(); }
 
       template<typename Function, typename Functor>
         bool
         compare_equal(const Function& f, const Functor& g, long,
-                      false_type)
+                      mpl::bool_<false>)
         {
           if (const Functor* fp = f.template target<Functor>())
             return function_equal(*fp, g);
@@ -549,7 +579,7 @@ namespace boost {
       template<typename Function, typename Functor>
         bool
         compare_equal(const Function& f, const reference_wrapper<Functor>& g,
-                      int, false_type)
+                      int, mpl::bool_<false>)
         {
           if (const Functor* fp = f.template target<Functor>())
             return fp == g.get_pointer();
@@ -559,7 +589,7 @@ namespace boost {
       template<typename Function, typename Functor>
         bool
         compare_not_equal(const Function& f, const Functor& g, long,
-                          false_type)
+                          mpl::bool_<false>)
         {
           if (const Functor* fp = f.template target<Functor>())
             return !function_equal(*fp, g);
@@ -570,7 +600,7 @@ namespace boost {
         bool
         compare_not_equal(const Function& f,
                           const reference_wrapper<Functor>& g, int,
-                          false_type)
+                          mpl::bool_<false>)
         {
           if (const Functor* fp = f.template target<Functor>())
             return fp != g.get_pointer();
@@ -584,8 +614,8 @@ namespace boost {
        */
       struct vtable_base
       {
-        void (*manager)(const function_buffer& in_buffer,
+        void (*manager)(const function_buffer& in_buffer, 
-                        function_buffer& out_buffer,
+                        function_buffer& out_buffer, 
                         functor_manager_operation_type op);
       };
     } // end namespace function
@@ -605,15 +635,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 BOOST_SP_TYPEID(void)
       if this is empty. */
-  const boost::typeindex::type_info& target_type() const
+  const detail::sp_typeinfo& target_type() const
   {
-    if (!vtable) return boost::typeindex::type_id<void>().type_info();
+    if (!vtable) return BOOST_SP_TYPEID(void);
 
     detail::function::function_buffer type;
     get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
-    return *type.members.type.type;
+    return *type.type.type;
   }
 
   template<typename Functor>
@@ -622,34 +652,42 @@ 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.type.type = &BOOST_SP_TYPEID(Functor);
-      type_result.members.type.const_qualified = is_const<Functor>::value;
+      type_result.type.const_qualified = is_const<Functor>::value;
-      type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
-      get_vtable()->manager(functor, type_result,
+      get_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.type.type = &BOOST_SP_TYPEID(Functor);
-      type_result.members.type.const_qualified = true;
+      type_result.type.const_qualified = true;
-      type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
-      get_vtable()->manager(functor, type_result,
+      get_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 static_cast<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 {
@@ -694,22 +732,15 @@ public: // should be protected, but GCC 2.95.3 will fail to allow access
   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
  */
-class BOOST_SYMBOL_VISIBLE bad_function_call : public std::runtime_error
+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,
@@ -742,28 +773,28 @@ inline bool operator!=(detail::function::useless_clear_type*,
 template<typename Functor>
   inline bool operator==(const function_base& f, Functor g)
   {
-    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
+    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 integral_constant<bool, (is_integral<Functor>::value)> integral;
+    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 integral_constant<bool, (is_integral<Functor>::value)> integral;
+    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 integral_constant<bool, (is_integral<Functor>::value)> integral;
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
     return detail::function::compare_not_equal(f, g, 0, integral());
   }
 #else
@@ -870,9 +901,10 @@ 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       
 
 #endif // BOOST_FUNCTION_BASE_HEADER

include/boost/function/function_fwd.hpp

@@ -9,7 +9,6 @@
 #ifndef BOOST_FUNCTION_FWD_HPP
 #define BOOST_FUNCTION_FWD_HPP
 #include <boost/config.hpp>
-#include <boost/function/detail/config.hpp>
 
 #if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
 // Work around a compiler bug.
@@ -20,27 +19,15 @@ namespace boost { namespace python { namespace objects {
 }}}
 #endif
 
-#if defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
+#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_FUNCTION_ENABLE_CXX03
-# include <functional>
-#endif
-
 namespace boost {
-
-#if BOOST_FUNCTION_ENABLE_CXX03
-
   class bad_function_call;
 
-#else
-
-  using std::bad_function_call;
-
-#endif
-
 #if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
   // Preferred syntax
   template<typename Signature> class function;

include/boost/function/function_template.hpp

@@ -11,12 +11,12 @@
 // Note: this header is a header template and must NOT have multiple-inclusion
 // protection.
 #include <boost/function/detail/prologue.hpp>
-#include <boost/core/no_exceptions_support.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
 
 #if defined(BOOST_MSVC)
 #   pragma warning( push )
 #   pragma warning( disable : 4127 ) // "conditional expression is constant"
-#endif
+#endif       
 
 #define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
 
@@ -26,12 +26,7 @@
 
 #define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
 
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
-#   define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
-#else
-#   define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
-#   define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
-#endif
 
 #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);
@@ -96,7 +91,7 @@ namespace boost {
         static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
                         BOOST_FUNCTION_PARMS)
         {
-          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
           return f(BOOST_FUNCTION_ARGS);
         }
       };
@@ -113,7 +108,7 @@ namespace boost {
                BOOST_FUNCTION_PARMS)
 
         {
-          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
           BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
         }
       };
@@ -131,9 +126,9 @@ namespace boost {
         {
           FunctionObj* f;
           if (function_allows_small_object_optimization<FunctionObj>::value)
-            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
           else
-            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
           return (*f)(BOOST_FUNCTION_ARGS);
         }
       };
@@ -152,9 +147,9 @@ namespace boost {
         {
           FunctionObj* f;
           if (function_allows_small_object_optimization<FunctionObj>::value)
-            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
           else
-            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
           BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
         }
       };
@@ -170,8 +165,8 @@ namespace boost {
                         BOOST_FUNCTION_PARMS)
 
         {
-          FunctionObj* f =
+          FunctionObj* f = 
-            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
           return (*f)(BOOST_FUNCTION_ARGS);
         }
       };
@@ -188,8 +183,8 @@ namespace boost {
                BOOST_FUNCTION_PARMS)
 
         {
-          FunctionObj* f =
+          FunctionObj* f = 
-            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
           BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
         }
       };
@@ -207,8 +202,8 @@ namespace boost {
                         BOOST_FUNCTION_PARMS)
 
         {
-          MemberPtr* f =
+          MemberPtr* f = 
-            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
           return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
         }
       };
@@ -225,8 +220,8 @@ namespace boost {
                BOOST_FUNCTION_PARMS)
 
         {
-          MemberPtr* f =
+          MemberPtr* f = 
-            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
           BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
         }
       };
@@ -239,7 +234,7 @@ namespace boost {
       >
       struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
       {
-        typedef typename conditional<(is_void<R>::value),
+        typedef typename mpl::if_c<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
                             FunctionPtr,
                             R BOOST_FUNCTION_COMMA
@@ -260,7 +255,7 @@ namespace boost {
        >
       struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
       {
-        typedef typename conditional<(is_void<R>::value),
+        typedef typename mpl::if_c<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
                             FunctionObj,
                             R BOOST_FUNCTION_COMMA
@@ -281,7 +276,7 @@ namespace boost {
        >
       struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
       {
-        typedef typename conditional<(is_void<R>::value),
+        typedef typename mpl::if_c<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
                             FunctionObj,
                             R BOOST_FUNCTION_COMMA
@@ -304,7 +299,7 @@ namespace boost {
        >
       struct BOOST_FUNCTION_GET_MEMBER_INVOKER
       {
-        typedef typename conditional<(is_void<R>::value),
+        typedef typename mpl::if_c<(is_void<R>::value),
                             BOOST_FUNCTION_VOID_MEMBER_INVOKER<
                             MemberPtr,
                             R BOOST_FUNCTION_COMMA
@@ -321,7 +316,7 @@ namespace boost {
 
       /* Given the tag returned by get_function_tag, retrieve the
          actual invoker that will be used for the given function
-         object.
+         object. 
 
          Each specialization contains an "apply" nested class template
          that accepts the function object, return type, function
@@ -349,8 +344,9 @@ namespace boost {
           typedef functor_manager<FunctionPtr> manager_type;
         };
 
-        template<typename FunctionPtr, typename Allocator,
+        template<typename FunctionPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+                 typename Allocator>
         struct apply_a
         {
           typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
@@ -383,8 +379,9 @@ namespace boost {
           typedef functor_manager<MemberPtr> manager_type;
         };
 
-        template<typename MemberPtr, typename Allocator,
+        template<typename MemberPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+                 typename Allocator>
         struct apply_a
         {
           typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
@@ -417,8 +414,9 @@ namespace boost {
           typedef functor_manager<FunctionObj> manager_type;
         };
 
-        template<typename FunctionObj, typename Allocator,
+        template<typename FunctionObj,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+                 typename Allocator>
         struct apply_a
         {
           typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
@@ -450,8 +448,9 @@ namespace boost {
           typedef reference_manager<typename RefWrapper::type> manager_type;
         };
 
-        template<typename RefWrapper, typename Allocator,
+        template<typename RefWrapper,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+                 typename Allocator>
         struct apply_a
         {
           typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
@@ -508,21 +507,21 @@ namespace boost {
       private:
         // Function pointers
         template<typename FunctionPtr>
-        bool
+        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.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
             return true;
           } else {
             return false;
           }
         }
         template<typename FunctionPtr,typename Allocator>
-        bool
+        bool 
         assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
         {
           return assign_to(f,functor,function_ptr_tag());
@@ -561,68 +560,59 @@ namespace boost {
         // Function objects
         // Assign to a function object using the small object optimization
         template<typename FunctionObj>
-        void
+        void 
-        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
         {
-          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
         }
         template<typename FunctionObj,typename Allocator>
-        void
+        void 
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
         {
-          assign_functor(f,functor,true_type());
+          assign_functor(f,functor,mpl::true_());
         }
 
         // Assign to a function object allocated on the heap.
         template<typename FunctionObj>
-        void
+        void 
-        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
         {
-          functor.members.obj_ptr = new FunctionObj(f);
+          functor.obj_ptr = new FunctionObj(f);
         }
         template<typename FunctionObj,typename Allocator>
-        void
+        void 
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
         {
           typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
           typedef typename Allocator::template rebind<functor_wrapper_type>::other
             wrapper_allocator_type;
           typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
-#else
-          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
-          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
-#endif
           wrapper_allocator_type wrapper_allocator(a);
           wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
           wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
-#else
-          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
-#endif
           functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
-          functor.members.obj_ptr = new_f;
+          functor.obj_ptr = new_f;
         }
 
         template<typename FunctionObj>
-        bool
+        bool 
         assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
         {
           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
-            assign_functor(f, functor,
+            assign_functor(f, functor, 
-                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
             return true;
           } else {
             return false;
           }
         }
         template<typename FunctionObj,typename Allocator>
-        bool
+        bool 
         assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
         {
           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
             assign_functor_a(f, functor, a,
-                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
             return true;
           } else {
             return false;
@@ -631,18 +621,18 @@ namespace boost {
 
         // Reference to a function object
         template<typename FunctionObj>
-        bool
+        bool 
-        assign_to(const reference_wrapper<FunctionObj>& f,
+        assign_to(const reference_wrapper<FunctionObj>& f, 
                   function_buffer& functor, function_obj_ref_tag) const
         {
-          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
-          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
-          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
           return true;
         }
         template<typename FunctionObj,typename Allocator>
-        bool
+        bool 
-        assign_to_a(const reference_wrapper<FunctionObj>& f,
+        assign_to_a(const reference_wrapper<FunctionObj>& f, 
                   function_buffer& functor, Allocator, function_obj_ref_tag) const
         {
           return assign_to(f,functor,function_obj_ref_tag());
@@ -660,6 +650,17 @@ namespace boost {
     BOOST_FUNCTION_TEMPLATE_PARMS
   >
   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
@@ -676,7 +677,7 @@ namespace boost {
 
     vtable_type* get_vtable() const {
       return reinterpret_cast<vtable_type*>(
-               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
     }
 
     struct clear_type {};
@@ -703,15 +704,16 @@ namespace boost {
 
     typedef BOOST_FUNCTION_FUNCTION self_type;
 
-    BOOST_DEFAULTED_FUNCTION(BOOST_FUNCTION_FUNCTION(), : function_base() {})
+    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 boost::enable_if_<
+                            ,typename enable_if_c<
-                             !(is_integral<Functor>::value),
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
                                         int>::type = 0
 #endif // BOOST_NO_SFINAE
                             ) :
@@ -722,8 +724,9 @@ namespace boost {
     template<typename Functor,typename Allocator>
     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
 #ifndef BOOST_NO_SFINAE
-                            ,typename boost::enable_if_<
+                            ,typename enable_if_c<
-                              !(is_integral<Functor>::value),
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
                                         int>::type = 0
 #endif // BOOST_NO_SFINAE
                             ) :
@@ -746,13 +749,6 @@ namespace boost {
       this->assign_to_own(f);
     }
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    BOOST_FUNCTION_FUNCTION(BOOST_FUNCTION_FUNCTION&& f) : function_base()
-    {
-      this->move_assign(f);
-    }
-#endif
-
     ~BOOST_FUNCTION_FUNCTION() { clear(); }
 
     result_type operator()(BOOST_FUNCTION_PARMS) const
@@ -771,8 +767,9 @@ namespace boost {
     // construct.
     template<typename Functor>
 #ifndef BOOST_NO_SFINAE
-    typename boost::enable_if_<
+    typename enable_if_c<
-                  !(is_integral<Functor>::value),
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
                BOOST_FUNCTION_FUNCTION&>::type
 #else
     BOOST_FUNCTION_FUNCTION&
@@ -834,25 +831,6 @@ namespace boost {
       return *this;
     }
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    // Move assignment from another BOOST_FUNCTION_FUNCTION
-    BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f)
-    {
-      if (&f == this)
-        return *this;
-
-      this->clear();
-      BOOST_TRY {
-        this->move_assign(f);
-      } BOOST_CATCH (...) {
-        vtable = 0;
-        BOOST_RETHROW;
-      }
-      BOOST_CATCH_END
-      return *this;
-    }
-#endif
-
     void swap(BOOST_FUNCTION_FUNCTION& other)
     {
       if (&other == this)
@@ -899,9 +877,7 @@ namespace boost {
       if (!f.empty()) {
         this->vtable = f.vtable;
         if (this->has_trivial_copy_and_destroy())
-          // Don't operate on storage directly since union type doesn't relax
+          this->functor = f.functor;
-          // strict aliasing rules, despite of having member char type.
-          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
         else
           get_vtable()->base.manager(f.functor, this->functor,
                                      boost::detail::function::clone_functor_tag);
@@ -911,15 +887,15 @@ namespace boost {
     template<typename Functor>
     void assign_to(Functor f)
     {
-      using boost::detail::function::vtable_base;
+      using detail::function::vtable_base;
 
-      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
-      typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
       typedef typename get_invoker::
-                         template apply<Functor, R BOOST_FUNCTION_COMMA
+                         template apply<Functor, R BOOST_FUNCTION_COMMA 
                         BOOST_FUNCTION_TEMPLATE_ARGS>
         handler_type;
-
+      
       typedef typename handler_type::invoker_type invoker_type;
       typedef typename handler_type::manager_type manager_type;
 
@@ -927,33 +903,33 @@ namespace boost {
       // static initialization. Otherwise, we will have a race
       // condition here in multi-threaded code. See
       // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
-      static const vtable_type stored_vtable =
+      static const vtable_type stored_vtable = 
         { { &manager_type::manage }, &invoker_type::invoke };
 
       if (stored_vtable.assign_to(f, functor)) {
         std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
-        // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
         if (boost::has_trivial_copy_constructor<Functor>::value &&
             boost::has_trivial_destructor<Functor>::value &&
-            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+            detail::function::function_allows_small_object_optimization<Functor>::value)
-          value |= static_cast<std::size_t>(0x01);
+          value |= static_cast<size_t>(0x01);
-        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
-      } else
+      } else 
         vtable = 0;
     }
 
     template<typename Functor,typename Allocator>
     void assign_to_a(Functor f,Allocator a)
     {
-      using boost::detail::function::vtable_base;
+      using detail::function::vtable_base;
 
-      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
-      typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
       typedef typename get_invoker::
-                         template apply_a<Functor, Allocator, R BOOST_FUNCTION_COMMA
+                         template apply_a<Functor, R BOOST_FUNCTION_COMMA 
-                         BOOST_FUNCTION_TEMPLATE_ARGS>
+                         BOOST_FUNCTION_TEMPLATE_ARGS,
+                         Allocator>
         handler_type;
-
+      
       typedef typename handler_type::invoker_type invoker_type;
       typedef typename handler_type::manager_type manager_type;
 
@@ -964,23 +940,22 @@ namespace boost {
       static const vtable_type stored_vtable =
         { { &manager_type::manage }, &invoker_type::invoke };
 
-      if (stored_vtable.assign_to_a(f, functor, a)) {
+      if (stored_vtable.assign_to_a(f, functor, a)) { 
         std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
-        // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
         if (boost::has_trivial_copy_constructor<Functor>::value &&
             boost::has_trivial_destructor<Functor>::value &&
-            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+            detail::function::function_allows_small_object_optimization<Functor>::value)
           value |= static_cast<std::size_t>(0x01);
-        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
-      } else
+      } else 
         vtable = 0;
     }
 
-    // Moves the value from the specified argument to *this. If the argument
+    // Moves the value from the specified argument to *this. If the argument 
-    // has its function object allocated on the heap, move_assign will pass
+    // has its function object allocated on the heap, move_assign will pass 
-    // its buffer to *this, and set the argument's buffer pointer to NULL.
+    // its buffer to *this, and set the argument's buffer pointer to NULL. 
-    void move_assign(BOOST_FUNCTION_FUNCTION& f)
+    void move_assign(BOOST_FUNCTION_FUNCTION& f) 
-    {
+    { 
       if (&f == this)
         return;
 
@@ -988,9 +963,7 @@ namespace boost {
         if (!f.empty()) {
           this->vtable = f.vtable;
           if (this->has_trivial_copy_and_destroy())
-            // Don't operate on storage directly since union type doesn't relax
+            this->functor = f.functor;
-            // strict aliasing rules, despite of having member char type.
-            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
           else
             get_vtable()->base.manager(f.functor, this->functor,
                                      boost::detail::function::move_functor_tag);
@@ -1040,7 +1013,7 @@ template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
 #if BOOST_FUNCTION_NUM_ARGS == 0
 #define BOOST_FUNCTION_PARTIAL_SPEC R (void)
 #else
-#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))
 #endif
 
 template<typename R BOOST_FUNCTION_COMMA
@@ -1055,13 +1028,14 @@ class function<BOOST_FUNCTION_PARTIAL_SPEC>
 
 public:
 
-  BOOST_DEFAULTED_FUNCTION(function(), : base_type() {})
+  function() : base_type() {}
 
   template<typename Functor>
   function(Functor f
 #ifndef BOOST_NO_SFINAE
-           ,typename boost::enable_if_<
+           ,typename enable_if_c<
-                          !(is_integral<Functor>::value),
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
                        int>::type = 0
 #endif
            ) :
@@ -1071,8 +1045,9 @@ public:
   template<typename Functor,typename Allocator>
   function(Functor f, Allocator a
 #ifndef BOOST_NO_SFINAE
-           ,typename boost::enable_if_<
+           ,typename enable_if_c<
-                           !(is_integral<Functor>::value),
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
                        int>::type = 0
 #endif
            ) :
@@ -1088,30 +1063,17 @@ public:
 
   function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-  // Move constructors
-  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
-  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
-#endif
-
   self_type& operator=(const self_type& f)
   {
     self_type(f).swap(*this);
     return *this;
   }
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-  self_type& operator=(self_type&& f)
-  {
-    self_type(static_cast<self_type&&>(f)).swap(*this);
-    return *this;
-  }
-#endif
-
   template<typename Functor>
 #ifndef BOOST_NO_SFINAE
-  typename boost::enable_if_<
+  typename enable_if_c<
-                         !(is_integral<Functor>::value),
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
                       self_type&>::type
 #else
   self_type&
@@ -1135,14 +1097,6 @@ public:
     self_type(f).swap(*this);
     return *this;
   }
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-  self_type& operator=(base_type&& f)
-  {
-    self_type(static_cast<base_type&&>(f)).swap(*this);
-    return *this;
-  }
-#endif
 };
 
 #undef BOOST_FUNCTION_PARTIAL_SPEC
@@ -1171,9 +1125,6 @@ public:
 #undef BOOST_FUNCTION_TEMPLATE_ARGS
 #undef BOOST_FUNCTION_PARMS
 #undef BOOST_FUNCTION_PARM
-#ifdef BOOST_FUNCTION_ARG
-#   undef BOOST_FUNCTION_ARG
-#endif
 #undef BOOST_FUNCTION_ARGS
 #undef BOOST_FUNCTION_ARG_TYPE
 #undef BOOST_FUNCTION_ARG_TYPES
@@ -1182,4 +1133,4 @@ public:
 
 #if defined(BOOST_MSVC)
 #   pragma warning( pop )
-#endif
+#endif       

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": [
-        "Peter Dimov <pdimov -at- pdimov.com>"
-    ]
-}

test/Jamfile.v2

@@ -7,69 +7,61 @@
 
 # For more information, see http://www.boost.org/
 
+project
+    : requirements <toolset>msvc:<asynch-exceptions>on
+    : source-location $(BOOST_ROOT)
+    ;
+
+# bring in rules for testing
 import testing ;
 
-run function_test.cpp ;
+{
-# /usr/include/c++/4.4/bits/shared_ptr.h:146: error: cannot use typeid with -fno-rtti
-run function_test.cpp : : : <rtti>off <toolset>gcc-4.4.7,<cxxstd>0x:<build>no : function_test_no_rtti ;
-run function_n_test.cpp ;
-run allocator_test.cpp ;
-run stateless_test.cpp ;
-run lambda_test.cpp ;
-compile-fail function_test_fail1.cpp ;
-compile-fail function_test_fail2.cpp ;
-compile function_30.cpp ;
-compile function_30_repeat.cpp ;
-run function_arith_cxx98.cpp ;
-run function_arith_portable.cpp ;
-run sum_avg_cxx98.cpp ;
-run sum_avg_portable.cpp ;
-run mem_fun_cxx98.cpp ;
-run mem_fun_portable.cpp ;
-run std_bind_cxx98.cpp ;
-run std_bind_portable.cpp ;
-run function_ref_cxx98.cpp ;
-run function_ref_portable.cpp ;
-run contains_test.cpp ;
-run contains2_test.cpp ;
-run nothrow_swap.cpp ;
-run rvalues_test.cpp ;
-compile function_typeof_test.cpp ;
-run result_arg_types_test.cpp ;
 
-lib throw_bad_function_call : throw_bad_function_call.cpp : <link>shared:<define>THROW_BAD_FUNCTION_CALL_DYN_LINK=1 ;
+  test-suite function
+    : 
+  [ run libs/function/test/function_test.cpp :  :  :  : lib_function_test ]
 
-run test_bad_function_call.cpp throw_bad_function_call : : : <link>shared : test_bad_function_call_shared ;
+  [ run libs/function/test/function_n_test.cpp :  :  :  :  ]
-run test_bad_function_call.cpp throw_bad_function_call : : : <link>static : test_bad_function_call_static ;
 
-lib mixed_cxxstd : mixed_cxxstd.cpp : <link>shared:<define>MIXED_CXXSTD_DYN_LINK=1 ;
+  [ run libs/function/test/allocator_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
 
-run test_mixed_cxxstd.cpp mixed_cxxstd : : : <link>shared : mixed_cxxstd_shared ;
+  [ run libs/function/test/stateless_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
-run test_mixed_cxxstd.cpp mixed_cxxstd : : : <link>static : mixed_cxxstd_static ;
 
-#run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>98 : : : <link>shared : mixed_cxxstd_shared_98 ;
+  [ run libs/function/test/lambda_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
-#run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>98 : : : <link>static : mixed_cxxstd_static_98 ;
 
-run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>0x : : : <link>shared : mixed_cxxstd_shared_0x ;
+  [ compile-fail libs/function/test/function_test_fail1.cpp :  :  :  :  ]
-run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>0x : : : <link>static : mixed_cxxstd_static_0x ;
 
-local check14 = [ check-target-builds mixed_cxxstd/<cxxstd>14 : : <build>no ] ;
+  [ compile-fail libs/function/test/function_test_fail2.cpp :  :  :  :  ]
 
-run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>14 : : : <link>shared $(check14) : mixed_cxxstd_shared_14 ;
+  [ compile libs/function/test/function_30.cpp :  :  :  :  ] 
-run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>14 : : : <link>static $(check14) : mixed_cxxstd_static_14 ;
 
-lib return_function : return_function.cpp : <link>shared:<define>RETURN_FUNCTION_DYN_LINK=1 ;
+  [ run libs/function/test/function_arith_cxx98.cpp :  :  :  :  ]
 
-run test_return_function.cpp return_function : : : <link>shared : return_function_shared ;
+  [ run libs/function/test/function_arith_portable.cpp :  :  :  :  ]
-run test_return_function.cpp return_function : : : <link>static : return_function_static ;
 
-#run test_return_function.cpp return_function/<cxxstd>98 : : : <link>shared : return_function_shared_98 ;
+  [ run libs/function/test/sum_avg_cxx98.cpp :  :  :  :  ]
-#run test_return_function.cpp return_function/<cxxstd>98 : : : <link>static : return_function_static_98 ;
 
-run test_return_function.cpp return_function/<cxxstd>0x : : : <link>shared : return_function_shared_0x ;
+  [ run libs/function/test/sum_avg_portable.cpp :  :  :  :  ]
-run test_return_function.cpp return_function/<cxxstd>0x : : : <link>static : return_function_static_0x ;
 
-run test_return_function.cpp return_function/<cxxstd>14 : : : <link>shared $(check14) : return_function_shared_14 ;
+  [ run libs/function/test/mem_fun_cxx98.cpp :  :  :  :  ]
-run test_return_function.cpp return_function/<cxxstd>14 : : : <link>static $(check14) : return_function_static_14 ;
 
-run quick.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 : : : : ]
+   
+  [ run libs/function/test/contains2_test.cpp : : : : ]
+   
+  [ run libs/function/test/nothrow_swap.cpp :  :  :  :  ]
+
+  [ compile libs/function/test/function_typeof_test.cpp ]
+ ;
+}
+      

test/allocator_test.cpp

@@ -7,10 +7,10 @@
 
 // For more information, see http://www.boost.org
 
-#include <boost/function.hpp>
+#include <boost/test/minimal.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <cassert>
 #include <functional>
+#include <boost/function.hpp>
 
 using namespace std;
 using namespace boost;
@@ -74,21 +74,20 @@ struct DoNothing: base
 
 static void do_nothing() {}
 
-int main()
+int
+test_main(int, char*[])
 {
   function2<int, int, int> f;
   f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<int>() );
   f.clear();
-#if BOOST_FUNCTION_ENABLE_CXX03
+  BOOST_CHECK(alloc_count == 1);
-  BOOST_TEST_EQ( alloc_count, 1 );
+  BOOST_CHECK(dealloc_count == 1);
-  BOOST_TEST_EQ( dealloc_count, 1 );
-#endif
   alloc_count = 0;
   dealloc_count = 0;
   f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
   f.clear();
-  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_CHECK(alloc_count == 0);
-  BOOST_TEST_EQ( dealloc_count, 0 );
+  BOOST_CHECK(dealloc_count == 0);
   f.assign( plus_int<disable_small_object_optimization>(), std::allocator<int>() );
   f.clear();
   f.assign( plus_int<enable_small_object_optimization>(), std::allocator<int>() );
@@ -98,8 +97,8 @@ int main()
   dealloc_count = 0;
   f.assign( &do_minus, counting_allocator<int>() );
   f.clear();
-  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_CHECK(alloc_count == 0);
-  BOOST_TEST_EQ( dealloc_count, 0 );
+  BOOST_CHECK(dealloc_count == 0);
   f.assign( &do_minus, std::allocator<int>() );
   f.clear();
 
@@ -108,16 +107,14 @@ int main()
   dealloc_count = 0;
   fv.assign( DoNothing<disable_small_object_optimization>(), counting_allocator<int>() );
   fv.clear();
-#if BOOST_FUNCTION_ENABLE_CXX03
+  BOOST_CHECK(alloc_count == 1);
-  BOOST_TEST_EQ( alloc_count, 1 );
+  BOOST_CHECK(dealloc_count == 1);
-  BOOST_TEST_EQ( dealloc_count, 1 );
-#endif
   alloc_count = 0;
   dealloc_count = 0;
   fv.assign( DoNothing<enable_small_object_optimization>(), counting_allocator<int>() );
   fv.clear();
-  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_CHECK(alloc_count == 0);
-  BOOST_TEST_EQ( dealloc_count, 0 );
+  BOOST_CHECK(dealloc_count == 0);
   fv.assign( DoNothing<disable_small_object_optimization>(), std::allocator<int>() );
   fv.clear();
   fv.assign( DoNothing<enable_small_object_optimization>(), std::allocator<int>() );
@@ -127,8 +124,8 @@ int main()
   dealloc_count = 0;
   fv.assign( &do_nothing, counting_allocator<int>() );
   fv.clear();
-  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_CHECK(alloc_count == 0);
-  BOOST_TEST_EQ( dealloc_count, 0 );
+  BOOST_CHECK(dealloc_count == 0);
   fv.assign( &do_nothing, std::allocator<int>() );
   fv.clear();
   
@@ -136,5 +133,5 @@ int main()
   fv.assign(&do_nothing, std::allocator<int>() );
   fv2.assign(fv, std::allocator<int>() );
 
-  return boost::report_errors();
+  return 0;
 }

test/cmake_subdir_test/CMakeLists.txt

@@ -1,49 +0,0 @@
-# Copyright 2018, 2019 Peter Dimov
-# 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
-
-cmake_minimum_required(VERSION 3.5)
-
-project(cmake_subdir_test LANGUAGES CXX)
-
-add_subdirectory(../.. boostorg/function)
-
-# boost_add_subdir
-
-function(boost_add_subdir name)
-
-    add_subdirectory(../../../${name} boostorg/${name})
-
-endfunction()
-
-# primary dependencies
-
-boost_add_subdir(assert)
-boost_add_subdir(bind)
-boost_add_subdir(config)
-boost_add_subdir(core)
-boost_add_subdir(integer)
-boost_add_subdir(preprocessor)
-boost_add_subdir(throw_exception)
-boost_add_subdir(type_index)
-boost_add_subdir(type_traits)
-boost_add_subdir(typeof)
-
-# secondary dependencies
-
-boost_add_subdir(static_assert)
-boost_add_subdir(container_hash)
-boost_add_subdir(smart_ptr)
-boost_add_subdir(detail)
-boost_add_subdir(move)
-boost_add_subdir(predef)
-
-# --target check
-
-add_executable(quick ../quick.cpp)
-target_link_libraries(quick Boost::function Boost::core)
-
-enable_testing()
-add_test(quick quick)
-
-add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/contains2_test.cpp

@@ -9,7 +9,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 static int forty_two()
 {

test/contains_test.cpp

@@ -5,12 +5,10 @@
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <boost/ref.hpp>
 
-#define BOOST_CHECK BOOST_TEST
-
 static int forty_two() { return 42; }
 
 struct Seventeen
@@ -96,7 +94,7 @@ static void target_test()
   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<const volatile Seventeen>());
   BOOST_CHECK(!f.target<Seventeen>());
   BOOST_CHECK(!f.target<volatile Seventeen>());
 }
@@ -227,11 +225,11 @@ static void ref_equal_test()
 #endif
 }
 
-int main()
+int test_main(int, char*[])
 {
   target_test();
   equal_test();
   ref_equal_test();
 
-  return boost::report_errors();
+  return 0;
 }

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;
-}

test/function_n_test.cpp

@@ -7,14 +7,12 @@
 
 // For more information, see http://www.boost.org
 
+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <functional>
 #include <cassert>
 #include <string>
 
-#define BOOST_CHECK BOOST_TEST
-
 using namespace boost;
 using std::string;
 using std::negate;
@@ -633,7 +631,7 @@ test_ref()
     boost::function2<int, int, int> f(ref(atc));
     BOOST_CHECK(f(1, 3) == 4);
   }
-  catch(std::runtime_error const&) {
+  catch(std::runtime_error e) {
     BOOST_ERROR("Nonthrowing constructor threw an exception");
   }
 }
@@ -686,7 +684,7 @@ void test_construct_destroy_count()
    BOOST_CHECK(construction_count == destruction_count);
 }
 
-int main()
+int test_main(int, char* [])
 {
   test_zero_args();
   test_one_arg();
@@ -695,5 +693,5 @@ int main()
   test_member_functions();
   test_ref();
   test_construct_destroy_count();
-  return boost::report_errors();
+  return 0;
 }

test/function_test.cpp

@@ -7,15 +7,12 @@
 
 // For more information, see http://www.boost.org
 
+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/config/workaround.hpp>
 #include <functional>
 #include <string>
 #include <utility>
 
-#define BOOST_CHECK BOOST_TEST
-
 using boost::function;
 using std::string;
 
@@ -627,22 +624,11 @@ test_ref()
     boost::function<int (int, int)> f(boost::ref(atc));
     BOOST_CHECK(f(1, 3) == 4);
   }
-  catch(std::runtime_error const&) {
+  catch(std::runtime_error e) {
     BOOST_ERROR("Nonthrowing constructor threw an exception");
   }
 }
 
-#if BOOST_WORKAROUND(BOOST_GCC, >= 70000 && BOOST_GCC < 80000) && __cplusplus >= 201700
-
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81311
-#pragma message("Skipping test_empty_ref on g++ 7 -std=c++17")
-
-static void test_empty_ref()
-{
-}
-
-#else
-
 static void dummy() {}
 
 static void test_empty_ref()
@@ -654,20 +640,18 @@ static void test_empty_ref()
     f2();
     BOOST_ERROR("Exception didn't throw for reference to empty function.");
   }
-  catch(boost::bad_function_call const&) {}
+  catch(std::runtime_error e) {}
 
   f1 = dummy;
 
   try {
     f2();
   }
-  catch(boost::bad_function_call const&) {
+  catch(std::runtime_error e) {
     BOOST_ERROR("Error calling referenced function.");
   }
 }
 
-#endif
-
 
 static void test_exception()
 {
@@ -676,7 +660,7 @@ static void test_exception()
     f(5, 4);
     BOOST_CHECK(false);
   }
-  catch(boost::bad_function_call const&) {
+  catch(boost::bad_function_call) {
     // okay
   }
 }
@@ -706,96 +690,7 @@ static void test_call()
   test_call_cref(std::plus<int>());
 }
 
-struct big_aggregating_structure {
+int test_main(int, char* [])
-  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 main()
 {
   test_zero_args();
   test_one_arg();
@@ -807,8 +702,6 @@ int main()
   test_exception();
   test_implicit();
   test_call();
-  test_move_semantics<function<void()> >();
-  test_move_semantics<boost::function0<void> >();
 
-  return boost::report_errors();
+  return 0;
 }

test/function_test_fail1.cpp

@@ -7,12 +7,22 @@
 
 // For more information, see http://www.boost.org
 
+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
 
-void test()
+using namespace std;
-{
+using namespace boost;
-    boost::function0<int> f1;
-    boost::function0<int> f2;
 
-    if( f1 == f2 ) {}
+int
+test_main(int, char*[])
+{
+  function0<int> f1;
+  function0<int> f2;
+
+  if (f1 == f2) {
+  }
+
+  BOOST_ERROR("This should not have compiled.");
+
+  return 0;
 }

test/function_test_fail2.cpp

@@ -7,12 +7,21 @@
 
 // For more information, see http://www.boost.org
 
+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
 
+using namespace std;
+using namespace boost;
+
 static int bad_fn(float f) { return static_cast<int>(f); }
 
-void test()
+int
+test_main(int, char*[])
 {
-    boost::function0<int> f1;
+  function0<int> f1;
-    f1 = bad_fn;
+  f1 = bad_fn;
+
+  BOOST_ERROR("This should not have compiled.");
+
+  return 0;
 }

test/lambda_test.cpp

@@ -7,13 +7,13 @@
 
 // For more information, see http://www.boost.org
 
-#include <boost/function.hpp>
-#include <boost/lambda/lambda.hpp>
-#include <boost/lambda/bind.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <cstdlib>
 
+#include <boost/test/minimal.hpp>
+#include <boost/lambda/lambda.hpp>
+#include <boost/lambda/bind.hpp>
+#include <boost/function.hpp>
 
 static unsigned
 func_impl(int arg1, bool arg2, double arg3)
@@ -22,19 +22,17 @@ func_impl(int arg1, bool arg2, double arg3)
   return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
 }
 
-int main()
+int test_main(int, char*[])
 {
   using boost::function;
   using namespace boost::lambda;
 
   function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
-  BOOST_TEST_EQ( f1(true, 2.0), 30 );
-
   function <unsigned(double)>       f2 = boost::lambda::bind(f1, false, _1);
-  BOOST_TEST_EQ( f2(2.0), 60 );
-
   function <unsigned()>             f3 = boost::lambda::bind(f2, 4.0);
-  BOOST_TEST_EQ( f3(), 120 );
 
-  return boost::report_errors();
+  f3();
+
+  return 0;
 }
+

test/mem_fun_cxx98.cpp

@@ -10,36 +10,28 @@
 
     
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.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;
+  std::ostream& foo2(std::ostream&) const;
 };
 int X::foo(int x) { return -x; }
-Y& X::foo2(Y& x) const { return x; }
+std::ostream& X::foo2(std::ostream& x) const { return x; }
 
 int main()
 {
     boost::function<int (X*, int)> f;
-    boost::function<Y& (X*, Y&)> f2;
+    boost::function<std::ostream& (X*, std::ostream&)> 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);
+    BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout);
 
     return ::boost::report_errors();
 }

test/mem_fun_portable.cpp

@@ -10,36 +10,28 @@
 
     
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.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;
+  std::ostream& foo2(std::ostream&) const;
 };
 int X::foo(int x) { return -x; }
-Y& X::foo2(Y& x) const { return x; }
+std::ostream& X::foo2(std::ostream& x) const { return x; }
 
 int main()
 {
     boost::function2<int, X*, int> f;
-    boost::function2<Y&, X*, Y&> f2;
+    boost::function2<std::ostream&, X*, std::ostream&> 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);
+    BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout);
 
     return ::boost::report_errors();
 }

test/mixed_cxxstd.cpp

@@ -1,42 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/function.hpp>
-#include <boost/config.hpp>
-
-#if defined(MIXED_CXXSTD_DYN_LINK)
-# define EXPORT BOOST_SYMBOL_EXPORT
-#else
-# define EXPORT
-#endif
-
-EXPORT void call_fn_1( boost::function<void()> const & fn )
-{
-    fn();
-}
-
-EXPORT void call_fn_2( boost::function<void(int)> const & fn )
-{
-    fn( 1 );
-}
-
-EXPORT void call_fn_3( boost::function<void(int, int)> const & fn )
-{
-    fn( 1, 2 );
-}
-
-EXPORT void call_fn_4( boost::function0<void> const & fn )
-{
-    fn();
-}
-
-EXPORT void call_fn_5( boost::function1<void, int> const & fn )
-{
-    fn( 1 );
-}
-
-EXPORT void call_fn_6( boost::function2<void, int, int> const & fn )
-{
-    fn( 1, 2 );
-}

test/nothrow_swap.cpp

@@ -7,10 +7,8 @@
 
 // For more information, see http://www.boost.org
 
+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-#define BOOST_CHECK BOOST_TEST
 
 struct tried_to_copy { };
 
@@ -42,7 +40,7 @@ struct MaybeThrowOnCopy {
 
 bool MaybeThrowOnCopy::throwOnCopy = false;
 
-int main()
+int test_main(int, char* [])
 {
   boost::function0<int> f;
   boost::function0<int> g;
@@ -58,5 +56,5 @@ int main()
   BOOST_CHECK(f() == 2);
   BOOST_CHECK(g() == 1);
   
-  return boost::report_errors();
+  return 0;
 }

test/quick.cpp

@@ -1,21 +0,0 @@
-// Copyright 2019 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/lightweight_test.hpp>
-
-static int f( int x )
-{
-    return x + 1;
-}
-
-int main()
-{
-    boost::function<int(int)> fn( f );
-
-    BOOST_TEST_EQ( fn( 5 ), 6 );
-
-    return boost::report_errors();
-}

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();
-}

test/return_function.cpp

@@ -1,27 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/function.hpp>
-#include <boost/config.hpp>
-
-#if defined(RETURN_FUNCTION_DYN_LINK)
-# define EXPORT BOOST_SYMBOL_EXPORT
-#else
-# define EXPORT
-#endif
-
-int f( int x, int y )
-{
-    return x + y;
-}
-
-EXPORT boost::function<int(int, int)> get_fn_1()
-{
-    return f;
-}
-
-EXPORT boost::function2<int, int, int> get_fn_2()
-{
-    return f;
-}

test/rvalues_test.cpp

@@ -1,107 +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 <boost/function.hpp>
-#include <boost/move/move.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <iostream>
-#include <cstdlib>
-
-#define BOOST_CHECK BOOST_TEST
-
-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 main()
-{
-    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 boost::report_errors();
-}

test/stateless_test.cpp

@@ -7,18 +7,16 @@
 
 // For more information, see http://www.boost.org
 
+#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <stdexcept>
-#include <new>
 
 struct stateless_integer_add {
   int operator()(int x, int y) const { return x+y; }
 
-  void* operator new(std::size_t n)
+  void* operator new(std::size_t)
   {
-    BOOST_ERROR( "stateless_integer_add incorrectly allocated" );
+    throw std::runtime_error("Cannot allocate a stateless_integer_add");
-    return ::operator new( n );
   }
 
   void* operator new(std::size_t, void* p)
@@ -26,17 +24,15 @@ struct stateless_integer_add {
     return p;
   }
 
-  void operator delete(void* p) throw()
+  void operator delete(void*) throw()
   {
-    BOOST_ERROR( "stateless_integer_add incorrectly deallocated" );
-    return ::operator delete( p );
   }
 };
 
-int main()
+int test_main(int, char*[])
 {
   boost::function2<int, int, int> f;
   f = stateless_integer_add();
 
-  return boost::report_errors();
+  return 0;
 }

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;
 }

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;
 }

test/test_bad_function_call.cpp

@@ -1,14 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-void throw_bad_function_call();
-
-int main()
-{
-    BOOST_TEST_THROWS( throw_bad_function_call(), boost::bad_function_call );
-    return boost::report_errors();
-}

test/test_mixed_cxxstd.cpp

@@ -1,48 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-//
-
-void call_fn_1( boost::function<void()> const & fn );
-void call_fn_2( boost::function<void(int)> const & fn );
-void call_fn_3( boost::function<void(int, int)> const & fn );
-
-void call_fn_4( boost::function0<void> const & fn );
-void call_fn_5( boost::function1<void, int> const & fn );
-void call_fn_6( boost::function2<void, int, int> const & fn );
-
-//
-
-static int v;
-
-void f0()
-{
-    v = -1;
-}
-
-void f1( int x )
-{
-    v = x;
-}
-
-void f2( int x, int y )
-{
-    v = x + y;
-}
-
-int main()
-{
-    v = 0; call_fn_1( f0 ); BOOST_TEST_EQ( v, -1 );
-    v = 0; call_fn_2( f1 ); BOOST_TEST_EQ( v, 1 );
-    v = 0; call_fn_3( f2 ); BOOST_TEST_EQ( v, 3 );
-
-    v = 0; call_fn_4( f0 ); BOOST_TEST_EQ( v, -1 );
-    v = 0; call_fn_5( f1 ); BOOST_TEST_EQ( v, 1 );
-    v = 0; call_fn_6( f2 ); BOOST_TEST_EQ( v, 3 );
-
-    return boost::report_errors();
-}

test/test_return_function.cpp

@@ -1,21 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/function.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-//
-
-boost::function<int(int, int)> get_fn_1();
-boost::function2<int, int, int> get_fn_2();
-
-//
-
-int main()
-{
-    BOOST_TEST_EQ( get_fn_1()( 1, 2 ), 3 );
-    BOOST_TEST_EQ( get_fn_2()( 1, 2 ), 3 );
-
-    return boost::report_errors();
-}

test/throw_bad_function_call.cpp

@@ -1,17 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/function.hpp>
-#include <boost/config.hpp>
-
-#if defined(THROW_BAD_FUNCTION_CALL_DYN_LINK)
-# define EXPORT BOOST_SYMBOL_EXPORT
-#else
-# define EXPORT
-#endif
-
-EXPORT void throw_bad_function_call()
-{
-    throw boost::bad_function_call();
-}