Make function_buffer visible, for UBSan

Update toolset name for gcc-4.4
Revert "Added variadic support"
2018-11-13 19:10:11 +02:00 · 2018-11-13 18:13:50 +02:00 · 2018-11-13 18:02:22 +02:00 · 2018-11-13 18:02:05 +02:00 · 2018-11-13 17:58:58 +02:00 · 2018-11-13 17:54:17 +02:00
34 changed files with 1629 additions and 468 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -0,0 +1,301 @@
+# Copyright 2016, 2017, 2018 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
+
+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=03,11 VARIANT=debug,release
+
+    - os: linux
+      compiler: g++-4.4
+      env: TOOLSET=gcc CXXSTD=98,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.6
+      env: TOOLSET=gcc CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.7
+      env: TOOLSET=gcc CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.8
+      env: TOOLSET=gcc CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+    - os: linux
+      compiler: g++-4.9
+      env: TOOLSET=gcc CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: TOOLSET=gcc CXXSTD=03,11,14,17 VARIANT=release
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-8
+      env: TOOLSET=gcc CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: UBSAN=1 TOOLSET=gcc CXXSTD=03,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=03,11 VARIANT=debug,release
+
+    - os: linux
+      compiler: /usr/bin/clang++
+      env: TOOLSET=clang CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.3
+
+    - os: linux
+      compiler: /usr/bin/clang++
+      env: TOOLSET=clang CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.4
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang CXXSTD=03,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=03,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=03,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=03,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=03,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=03,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=03,11,14,1z VARIANT=release
+      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=03,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=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-7
+
+    - os: linux
+      compiler: clang++-5.0
+      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: linux
+      compiler: clang++-libc++
+      env: TOOLSET=clang CXXSTD=03,11,14,1z VARIANT=release
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: linux
+      compiler: clang++-libc++
+      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang CXXSTD=03,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/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - cp -r $TRAVIS_BUILD_DIR/* libs/function
+  - python tools/boostdep/depinst/depinst.py function
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $TRAVIS_COMPILER ;" > ~/user-config.jam
+  - ./b2 -j3 libs/function/test toolset=$TOOLSET cxxstd=$CXXSTD ${VARIANT:+variant=$VARIANT} ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
+
+notifications:
+  email:
+    on_success: always
--- a/11
+++ b/11
@ -0,0 +1,11 @@
+#  Boost.Function Library Jamfile
+#
+#  Copyright (c) 2018 James E. King III
+#
+#  Use, modification, and distribution are 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)
+
+# please order by name to ease maintenance
+build-project example ;
+build-project test ;
--- a/23
+++ b/23
@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
--- a/README.md
+++ b/README.md
@ -0,0 +1,34 @@
+Function, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), contains a family of class templates that are function object wrappers.
+
+### License
+
+Distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
+
+### Properties
+
+* C++03
+* Header-Only
+
+### Build Status
+
+Branch          | Travis | Appveyor | Coverity Scan | codecov.io | Deps | Docs | Tests |
+:-------------: | ------ | -------- | ------------- | ---------- | ---- | ---- | ----- |
+[`master`](https://github.com/boostorg/function/tree/master) | [![Build Status](https://travis-ci.org/boostorg/function.svg?branch=master)](https://travis-ci.org/boostorg/function) | [![Build status](https://ci.appveyor.com/api/projects/status/7tgx4ac44fikr87d/branch/master?svg=true)](https://ci.appveyor.com/project/jeking3/function-d036y/branch/master) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/15843/badge.svg)](https://scan.coverity.com/projects/boostorg-function) | [![codecov](https://codecov.io/gh/boostorg/function/branch/master/graph/badge.svg)](https://codecov.io/gh/boostorg/function/branch/master)| [![Deps](https://img.shields.io/badge/deps-master-brightgreen.svg)](https://pdimov.github.io/boostdep-report/master/function.html) | [![Documentation](https://img.shields.io/badge/docs-master-brightgreen.svg)](http://www.boost.org/doc/libs/master/doc/html/function.html) | [![Enter the Matrix](https://img.shields.io/badge/matrix-master-brightgreen.svg)](http://www.boost.org/development/tests/master/developer/function.html)
+[`develop`](https://github.com/boostorg/function/tree/develop) | [![Build Status](https://travis-ci.org/boostorg/function.svg?branch=develop)](https://travis-ci.org/boostorg/function) | [![Build status](https://ci.appveyor.com/api/projects/status/7tgx4ac44fikr87d/branch/develop?svg=true)](https://ci.appveyor.com/project/jeking3/function-d036y/branch/develop) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/15843/badge.svg)](https://scan.coverity.com/projects/boostorg-function) | [![codecov](https://codecov.io/gh/boostorg/function/branch/develop/graph/badge.svg)](https://codecov.io/gh/boostorg/function/branch/develop) | [![Deps](https://img.shields.io/badge/deps-develop-brightgreen.svg)](https://pdimov.github.io/boostdep-report/develop/function.html) | [![Documentation](https://img.shields.io/badge/docs-develop-brightgreen.svg)](http://www.boost.org/doc/libs/develop/doc/html/function.html) | [![Enter the Matrix](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](http://www.boost.org/development/tests/develop/developer/function.html)
+
+### Directories
+
+| Name        | Purpose                        |
+| ----------- | ------------------------------ |
+| `doc`       | documentation                  |
+| `example`   | examples                       |
+| `include`   | headers                        |
+| `test`      | unit tests                     |
+
+### More information
+
+* [Ask questions](http://stackoverflow.com/questions/ask?tags=c%2B%2B,boost,boost-function)
+* [Report bugs](https://github.com/boostorg/function/issues): Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
+* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
+* Discussions about the library are held on the [Boost developers mailing list](http://www.boost.org/community/groups.html#main). Be sure to read the [discussion policy](http://www.boost.org/community/policy.html) before posting and add the `[function]` tag at the beginning of the subject line.
+
--- a/appveyor.yml
+++ b/appveyor.yml
@ -0,0 +1,126 @@
+# Copyright 2016, 2017 Peter Dimov
+# Copyright (C) 2017, 2018 James E. King III
+# 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)
+
+#
+# Generic Appveyor build script for boostorg repositories
+# See: https://github.com/jeking3/boost-ci/
+#
+# Instructions for customizing this script for your library:
+#
+# 1. Customize the compilers and language levels you want.
+# 2. If you have move than include/, src/, test/, example/, examples/,
+#    benchmark/ or tools/ directories, set the environment variable DEPINST.
+#    For example if your build uses code in "bench/" and "fog/" directories:
+#      - DEPINST: --include bench --include fog
+# 3. Enable pull request builds in your boostorg/<library> account.
+#
+# That's it - the script will do everything else for you.
+#
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - develop
+    - master
+
+matrix:
+  # Adding MAYFAIL to any matrix job allows it to fail but the build stays green:
+  allow_failures:
+    - MAYFAIL: true
+
+environment:
+  global:
+    # see: http://www.boost.org/build/doc/html/bbv2/overview/invocation.html#bbv2.overview.invocation.properties
+    # to use the default for a given environment, comment it out; recommend you build debug and release however:
+    # on Windows it is important to exercise all the possibilities, especially shared vs static, however most
+    # libraries that care about this exercise it in their Jamfiles...
+    # B2_ADDRESS_MODEL: address-model=64,32
+    # B2_LINK: link=shared,static
+    # B2_THREADING: threading=multi,single
+    B2_VARIANT: variant=release,debug
+
+  matrix:
+    - FLAVOR: Visual Studio 2017 C++2a Strict
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      B2_ADDRESS_MODEL: address-model=64
+      CXXFLAGS: cxxflags=-permissive-
+      CXXSTD: latest # 2a
+
+    - FLAVOR: Visual Studio 2017 C++17
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      B2_ADDRESS_MODEL: address-model=64
+      CXXSTD: 17
+
+    - FLAVOR: Visual Studio 2017 C++14 (Default)
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      B2_ADDRESS_MODEL: address-model=64,32
+
+    - FLAVOR: Visual Studio 2015 C++14 (Default)
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.0
+      B2_ADDRESS_MODEL: address-model=64,32
+
+    - FLAVOR: Visual Studio 2010, 2012, 2013
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-10.0,msvc-11.0,msvc-12.0
+
+    - FLAVOR: cygwin (32-bit)
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ADDPATH: C:\cygwin\bin;
+      B2_ADDRESS_MODEL: address-model=32
+      CXXSTD: 03,11
+      # https://github.com/boostorg/test/issues/144
+      DEFINES: define=_POSIX_C_SOURCE=200112L
+      THREADING: threadapi=pthread
+      TOOLSET: gcc
+
+    - FLAVOR: cygwin (64-bit)
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ADDPATH: C:\cygwin64\bin;
+      B2_ADDRESS_MODEL: address-model=64
+      CXXSTD: 11,17
+      # https://github.com/boostorg/test/issues/144
+      DEFINES: define=_POSIX_C_SOURCE=200112L define=__USE_ISOC99
+      THREADING: threadapi=pthread
+      TOOLSET: gcc
+
+    - FLAVOR: mingw32
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ARCH: i686
+      B2_ADDRESS_MODEL: address-model=32
+      CXXSTD: 03,11
+      SCRIPT: ci\appveyor\mingw.bat
+
+    - FLAVOR: mingw64
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ARCH: x86_64
+      B2_ADDRESS_MODEL: address-model=64
+      CXXSTD: 11,17
+      DEFINES: define=__USE_ISOC99
+      SCRIPT: ci\appveyor\mingw.bat
+
+install:
+  - set SELF=%APPVEYOR_PROJECT_NAME:-=_%
+  - git clone https://github.com/jeking3/boost-ci.git C:\boost-ci
+  - xcopy /s /e /q /i C:\boost-ci\ci .\ci
+  - ci\appveyor\install.bat
+
+build: off
+
+test_script:
+  - set SELF=%APPVEYOR_PROJECT_NAME:-=_%
+  - PATH=%ADDPATH%%PATH%
+  # The definition of TOOLCXX omits CXXSTD= if it was not defined above
+  - IF NOT DEFINED CXXSTD (SET TOOLCXX=toolset=%TOOLSET%) ELSE (SET TOOLCXX=toolset=%TOOLSET% cxxstd=%CXXSTD%)
+  # Echo the complete build command to the build log
+  - IF NOT DEFINED SCRIPT                         (ECHO b2 libs/%SELF:\=/% %TOOLCXX% %CXXFLAGS% %DEFINES% %THREADING% %B2_ADDRESS_MODEL% %B2_LINK% %B2_THREADING% %B2_VARIANT% -j3)
+  # Now go build...
+  - IF DEFINED SCRIPT (call libs\%SELF%\%SCRIPT%) ELSE (b2 libs/%SELF:\=/% %TOOLCXX% %CXXFLAGS% %DEFINES% %THREADING% %B2_ADDRESS_MODEL% %B2_LINK% %B2_THREADING% %B2_VARIANT% -j3)
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -3,13 +3,23 @@
 #   Distributed under the Boost Software License, Version 1.0.
 #   (See accompanying file LICENSE_1_0.txt or copy at
 #   http://www.boost.org/LICENSE_1_0.txt)
-project boost/doc ;
+project function/doc ;
 import boostbook : boostbook ;

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

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

 <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
--- a/doc/reference.xml
+++ b/doc/reference.xml
@ -58,7 +58,7 @@
      <para>A function object <code>f</code> of
      type <code>F</code> is
      <emphasis>stateless</emphasis> if it is a function pointer or if
-      <code><classname>boost::is_stateless</classname>&lt;T&gt;</code>
+      <code><classname>boost::is_stateless</classname>&lt;F&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>.</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>. Works even with RTTI off.</simpara></returns>
        <throws><simpara>Will not throw.</simpara></throws>
      </method>
    </method-group>
@ -203,6 +203,15 @@
      <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"/>
@ -237,6 +246,15 @@
      <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">
        <type>void</type>
@ -608,6 +626,15 @@
      <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>
@ -616,6 +643,15 @@
      <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"/>
@ -645,11 +681,20 @@

    <copy-assignment>
      <parameter name="f">
-        <paramtype>const <classname>function</classname>&amp;</paramtype>
+        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
      </parameter>
      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
    </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">
        <paramtype>const <classname>function</classname>&amp;</paramtype>
@ -658,6 +703,15 @@
      <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">
        <type>void</type>
--- a/example/Jamfile.v2
+++ b/example/Jamfile.v2
@ -0,0 +1,21 @@
+#  Boost.Function Library example Jamfile
+#
+#  Copyright (c) 2008 James E. King III
+#
+#  Distributed under the Boost Software License, Version 1.0. (See accompany-
+#  ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+import ../../config/checks/config : requires ;
+import os ;
+import testing ;
+
+project
+    :   requirements
+    ;
+
+test-suite "function-examples"
+   :    [ run bind1st.cpp : : : [ requires cxx98_binders ] ]
+        [ run int_div.cpp ]
+        [ run sum_avg.cpp ]
+   ;
+
--- a/include/boost/function.hpp
+++ b/include/boost/function.hpp
@ -10,21 +10,27 @@
 // William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
 // design of this library.

-#include <functional> // unary_function, binary_function
-
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/detail/workaround.hpp>
-
 #ifndef BOOST_FUNCTION_MAX_ARGS
 #  define BOOST_FUNCTION_MAX_ARGS 10
 #endif // BOOST_FUNCTION_MAX_ARGS

+#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>

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

 #if BOOST_FUNCTION_NUM_ARGS == 0
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
 #  ifndef BOOST_FUNCTION_0
 #    define BOOST_FUNCTION_0
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 1
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 1
 #  ifndef BOOST_FUNCTION_1
 #    define BOOST_FUNCTION_1
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 2
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 2
 #  ifndef BOOST_FUNCTION_2
 #    define BOOST_FUNCTION_2
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 3
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 3
 #  ifndef BOOST_FUNCTION_3
 #    define BOOST_FUNCTION_3
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 4
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 4
 #  ifndef BOOST_FUNCTION_4
 #    define BOOST_FUNCTION_4
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 5
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 5
 #  ifndef BOOST_FUNCTION_5
 #    define BOOST_FUNCTION_5
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 6
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 6
 #  ifndef BOOST_FUNCTION_6
 #    define BOOST_FUNCTION_6
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 7
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 7
 #  ifndef BOOST_FUNCTION_7
 #    define BOOST_FUNCTION_7
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 8
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 8
 #  ifndef BOOST_FUNCTION_8
 #    define BOOST_FUNCTION_8
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 9
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 9
 #  ifndef BOOST_FUNCTION_9
 #    define BOOST_FUNCTION_9
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 10
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 10
 #  ifndef BOOST_FUNCTION_10
 #    define BOOST_FUNCTION_10
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 11
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 11
 #  ifndef BOOST_FUNCTION_11
 #    define BOOST_FUNCTION_11
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 12
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 12
 #  ifndef BOOST_FUNCTION_12
 #    define BOOST_FUNCTION_12
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 13
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 13
 #  ifndef BOOST_FUNCTION_13
 #    define BOOST_FUNCTION_13
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 14
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 14
 #  ifndef BOOST_FUNCTION_14
 #    define BOOST_FUNCTION_14
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 15
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 15
 #  ifndef BOOST_FUNCTION_15
 #    define BOOST_FUNCTION_15
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 16
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 16
 #  ifndef BOOST_FUNCTION_16
 #    define BOOST_FUNCTION_16
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 17
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 17
 #  ifndef BOOST_FUNCTION_17
 #    define BOOST_FUNCTION_17
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 18
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 18
 #  ifndef BOOST_FUNCTION_18
 #    define BOOST_FUNCTION_18
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 19
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 19
 #  ifndef BOOST_FUNCTION_19
 #    define BOOST_FUNCTION_19
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 20
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 20
 #  ifndef BOOST_FUNCTION_20
 #    define BOOST_FUNCTION_20
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 21
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 21
 #  ifndef BOOST_FUNCTION_21
 #    define BOOST_FUNCTION_21
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 22
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 22
 #  ifndef BOOST_FUNCTION_22
 #    define BOOST_FUNCTION_22
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 23
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 23
 #  ifndef BOOST_FUNCTION_23
 #    define BOOST_FUNCTION_23
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 24
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 24
 #  ifndef BOOST_FUNCTION_24
 #    define BOOST_FUNCTION_24
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 25
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 25
 #  ifndef BOOST_FUNCTION_25
 #    define BOOST_FUNCTION_25
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 26
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 26
 #  ifndef BOOST_FUNCTION_26
 #    define BOOST_FUNCTION_26
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 27
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 27
 #  ifndef BOOST_FUNCTION_27
 #    define BOOST_FUNCTION_27
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 28
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 28
 #  ifndef BOOST_FUNCTION_28
 #    define BOOST_FUNCTION_28
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 29
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 29
 #  ifndef BOOST_FUNCTION_29
 #    define BOOST_FUNCTION_29
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 30
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 30
 #  ifndef BOOST_FUNCTION_30
 #    define BOOST_FUNCTION_30
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 31
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 31
 #  ifndef BOOST_FUNCTION_31
 #    define BOOST_FUNCTION_31
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 32
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 32
 #  ifndef BOOST_FUNCTION_32
 #    define BOOST_FUNCTION_32
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 33
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 33
 #  ifndef BOOST_FUNCTION_33
 #    define BOOST_FUNCTION_33
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 34
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 34
 #  ifndef BOOST_FUNCTION_34
 #    define BOOST_FUNCTION_34
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 35
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 35
 #  ifndef BOOST_FUNCTION_35
 #    define BOOST_FUNCTION_35
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 36
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 36
 #  ifndef BOOST_FUNCTION_36
 #    define BOOST_FUNCTION_36
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 37
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 37
 #  ifndef BOOST_FUNCTION_37
 #    define BOOST_FUNCTION_37
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 38
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 38
 #  ifndef BOOST_FUNCTION_38
 #    define BOOST_FUNCTION_38
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 39
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 39
 #  ifndef BOOST_FUNCTION_39
 #    define BOOST_FUNCTION_39
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 40
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 40
 #  ifndef BOOST_FUNCTION_40
 #    define BOOST_FUNCTION_40
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 41
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 41
 #  ifndef BOOST_FUNCTION_41
 #    define BOOST_FUNCTION_41
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 42
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 42
 #  ifndef BOOST_FUNCTION_42
 #    define BOOST_FUNCTION_42
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 43
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 43
 #  ifndef BOOST_FUNCTION_43
 #    define BOOST_FUNCTION_43
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 44
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 44
 #  ifndef BOOST_FUNCTION_44
 #    define BOOST_FUNCTION_44
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 45
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 45
 #  ifndef BOOST_FUNCTION_45
 #    define BOOST_FUNCTION_45
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 46
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 46
 #  ifndef BOOST_FUNCTION_46
 #    define BOOST_FUNCTION_46
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 47
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 47
 #  ifndef BOOST_FUNCTION_47
 #    define BOOST_FUNCTION_47
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 48
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 48
 #  ifndef BOOST_FUNCTION_48
 #    define BOOST_FUNCTION_48
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 49
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 49
 #  ifndef BOOST_FUNCTION_49
 #    define BOOST_FUNCTION_49
 #    include <boost/function/function_template.hpp>
 #  endif
 #elif BOOST_FUNCTION_NUM_ARGS == 50
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 50
 #  ifndef BOOST_FUNCTION_50
 #    define BOOST_FUNCTION_50
 #    include <boost/function/function_template.hpp>
--- a/include/boost/function/function_base.hpp
+++ b/include/boost/function/function_base.hpp
@ -16,24 +16,23 @@
 #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/mpl/if.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/conditional.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #ifndef BOOST_NO_SFINAE
-#  include "boost/utility/enable_if.hpp"
+#include <boost/type_traits/enable_if.hpp>
 #else
-#  include "boost/mpl/bool.hpp"
+#include <boost/type_traits/integral_constant.hpp>
 #endif
 #include <boost/function_equal.hpp>
 #include <boost/function/function_fwd.hpp>
@ -44,47 +43,16 @@
 #   pragma warning( disable : 4127 ) // "conditional expression is constant"
 #endif

-// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
-#ifdef BOOST_NO_STD_TYPEINFO
-// Embedded VC++ does not have type_info in namespace std
-#  define BOOST_FUNCTION_STD_NS
-#else
-#  define BOOST_FUNCTION_STD_NS std
-#endif
-
-// Borrowed from Boost.Python library: determines the cases where we
-// need to use std::type_info::name to compare instead of operator==.
-#if defined( 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)
+#if defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
 #  define BOOST_FUNCTION_TARGET_FIX(x) x
 #else
 #  define BOOST_FUNCTION_TARGET_FIX(x)
-#endif // not MSVC
+#endif // __ICL etc

-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
 #  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
-      typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
-                            (::boost::is_integral<Functor>::value)>::value), \
+      typename ::boost::enable_if_<          \
+                           !(::boost::is_integral<Functor>::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 {
@ -97,15 +65,16 @@ namespace boost {
       * object pointers, and a structure that resembles a bound
       * member function pointer.
       */
-      union function_buffer
+      union function_buffer_members
      {
        // For pointers to function objects
-        mutable void* obj_ptr;
+        typedef void* obj_ptr_t;
+        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 detail::sp_typeinfo* type;
+          const boost::typeindex::type_info* type;

          // Whether the type is const-qualified.
          bool const_qualified;
@ -114,7 +83,8 @@ namespace boost {
        } type;

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

        // For bound member pointers
        struct bound_memfunc_ptr_t {
@ -129,9 +99,15 @@ 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;
+        mutable char data[sizeof(function_buffer_members)];
      };

      /**
@ -176,15 +152,15 @@ namespace boost {
      template<typename F>
      class get_function_tag
      {
-        typedef typename mpl::if_c<(is_pointer<F>::value),
+        typedef typename conditional<(is_pointer<F>::value),
                                   function_ptr_tag,
                                   function_obj_tag>::type ptr_or_obj_tag;

-        typedef typename mpl::if_c<(is_member_pointer<F>::value),
+        typedef typename conditional<(is_member_pointer<F>::value),
                                   member_ptr_tag,
                                   ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;

-        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
+        typedef typename conditional<(is_reference_wrapper<F>::value),
                                   function_obj_ref_tag,
                                   ptr_or_obj_or_mem_tag>::type or_ref_tag;

@ -203,40 +179,37 @@ namespace boost {
        {
          switch (op) {
          case clone_functor_tag:
-            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
+            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
            return;

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

          case destroy_functor_tag:
-            out_buffer.obj_ref.obj_ptr = 0;
+            out_buffer.members.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 (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(F))
-                  && (!in_buffer.obj_ref.is_const_qualified 
-                      || out_buffer.type.const_qualified)
-                  && (!in_buffer.obj_ref.is_volatile_qualified
-                      || out_buffer.type.volatile_qualified))
-                out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
+              if (*out_buffer.members.type.type == boost::typeindex::type_id<F>()
+                  && (!in_buffer.members.obj_ref.is_const_qualified
+                      || out_buffer.members.type.const_qualified)
+                  && (!in_buffer.members.obj_ref.is_volatile_qualified
+                      || out_buffer.members.type.volatile_qualified))
+                out_buffer.members.obj_ptr = in_buffer.members.obj_ref.obj_ptr;
              else
-                out_buffer.obj_ptr = 0;
+                out_buffer.members.obj_ptr = 0;
            }
            return;

          case get_functor_type_tag:
-            out_buffer.type.type = &BOOST_SP_TYPEID(F);
-            out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
-            out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
+            out_buffer.members.type.type = &boost::typeindex::type_id<F>().type_info();
+            out_buffer.members.type.const_qualified = in_buffer.members.obj_ref.is_const_qualified;
+            out_buffer.members.type.volatile_qualified = in_buffer.members.obj_ref.is_volatile_qualified;
            return;
          }
        }
@ -287,23 +260,21 @@ namespace boost {
                functor_manager_operation_type op)
        {
          if (op == clone_functor_tag)
-            out_buffer.func_ptr = in_buffer.func_ptr;
+            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
          else if (op == move_functor_tag) {
-            out_buffer.func_ptr = in_buffer.func_ptr;
-            in_buffer.func_ptr = 0;
+            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
+            in_buffer.members.func_ptr = 0;
          } else if (op == destroy_functor_tag)
-            out_buffer.func_ptr = 0;
+            out_buffer.members.func_ptr = 0;
          else if (op == check_functor_type_tag) {
-            const detail::sp_typeinfo& check_type 
-              = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
-              out_buffer.obj_ptr = &in_buffer.func_ptr;
+            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+              out_buffer.members.obj_ptr = &in_buffer.members.func_ptr;
            else
-              out_buffer.obj_ptr = 0;
+              out_buffer.members.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
-            out_buffer.type.const_qualified = false;
-            out_buffer.type.volatile_qualified = false;
+            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
          }
        }

@ -314,26 +285,28 @@ namespace boost {
        {
          if (op == clone_functor_tag || op == move_functor_tag) {
            const functor_type* in_functor =
-              reinterpret_cast<const functor_type*>(&in_buffer.data);
-            new ((void*)&out_buffer.data) functor_type(*in_functor);
+              reinterpret_cast<const functor_type*>(in_buffer.data);
+            new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor);

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

@ -404,7 +377,7 @@ namespace boost {
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
-                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+                  integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
        }

        // For member pointers, we use the small-object optimization buffer.
@ -412,7 +385,7 @@ namespace boost {
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, member_ptr_tag)
        {
-          manager(in_buffer, out_buffer, op, mpl::true_());
+          manager(in_buffer, out_buffer, op, true_type());
        }

      public:
@ -425,9 +398,9 @@ namespace boost {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
-            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
-            out_buffer.type.const_qualified = false;
-            out_buffer.type.volatile_qualified = false;
+            out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
            return;

          default:
@ -454,7 +427,7 @@ namespace boost {
        // Function objects that fit in the small-object buffer.
        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, mpl::true_)
+                functor_manager_operation_type op, true_type)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }
@ -462,48 +435,59 @@ namespace boost {
        // Function objects that require heap allocation
        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
-                functor_manager_operation_type op, mpl::false_)
+                functor_manager_operation_type op, false_type)
        {
          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 =
-              (const functor_wrapper_type*)(in_buffer.obj_ptr);
+              static_cast<const functor_wrapper_type*>(in_buffer.members.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.obj_ptr = new_f;
+            out_buffer.members.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
-            out_buffer.obj_ptr = in_buffer.obj_ptr;
-            in_buffer.obj_ptr = 0;
+            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            in_buffer.members.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {
            /* Cast from the void pointer to the functor_wrapper_type */
            functor_wrapper_type* victim =
-              static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
+              static_cast<functor_wrapper_type*>(in_buffer.members.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.obj_ptr = 0;
+            out_buffer.members.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
-            const detail::sp_typeinfo& check_type 
-              = *out_buffer.type.type;
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
-              out_buffer.obj_ptr = in_buffer.obj_ptr;
+            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
            else
-              out_buffer.obj_ptr = 0;
+              out_buffer.members.obj_ptr = 0;
          } else /* op == get_functor_type_tag */ {
-            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
-            out_buffer.type.const_qualified = false;
-            out_buffer.type.volatile_qualified = false;
+            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
          }
        }

@ -515,7 +499,7 @@ namespace boost {
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
-                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+                  integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
        }

      public:
@ -528,9 +512,9 @@ namespace boost {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
-            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
-            out_buffer.type.const_qualified = false;
-            out_buffer.type.volatile_qualified = false;
+            out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
            return;

          default:
@ -546,24 +530,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 mpl::bool_<false>) or against zero (when the
-      // last parameter is mpl::bool_<true>). They are only necessary
+      // parameter is false_type) or against zero (when the
+      // last parameter is true_type). They are only necessary
      // for compilers that don't support SFINAE.
      template<typename Function, typename Functor>
        bool
-        compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
+        compare_equal(const Function& f, const Functor&, int, true_type)
        { return f.empty(); }

      template<typename Function, typename Functor>
        bool
        compare_not_equal(const Function& f, const Functor&, int,
-                          mpl::bool_<true>)
+                          true_type)
        { return !f.empty(); }

      template<typename Function, typename Functor>
        bool
        compare_equal(const Function& f, const Functor& g, long,
-                      mpl::bool_<false>)
+                      false_type)
        {
          if (const Functor* fp = f.template target<Functor>())
            return function_equal(*fp, g);
@ -573,7 +557,7 @@ namespace boost {
      template<typename Function, typename Functor>
        bool
        compare_equal(const Function& f, const reference_wrapper<Functor>& g,
-                      int, mpl::bool_<false>)
+                      int, false_type)
        {
          if (const Functor* fp = f.template target<Functor>())
            return fp == g.get_pointer();
@ -583,7 +567,7 @@ namespace boost {
      template<typename Function, typename Functor>
        bool
        compare_not_equal(const Function& f, const Functor& g, long,
-                          mpl::bool_<false>)
+                          false_type)
        {
          if (const Functor* fp = f.template target<Functor>())
            return !function_equal(*fp, g);
@ -594,7 +578,7 @@ namespace boost {
        bool
        compare_not_equal(const Function& f,
                          const reference_wrapper<Functor>& g, int,
-                          mpl::bool_<false>)
+                          false_type)
        {
          if (const Functor* fp = f.template target<Functor>())
            return fp != g.get_pointer();
@ -629,15 +613,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 BOOST_SP_TYPEID(void)
+  /** Retrieve the type of the stored function object, or type_id<void>()
      if this is empty. */
-  const detail::sp_typeinfo& target_type() const
+  const boost::typeindex::type_info& target_type() const
  {
-    if (!vtable) return BOOST_SP_TYPEID(void);
+    if (!vtable) return boost::typeindex::type_id<void>().type_info();

    detail::function::function_buffer type;
    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
-    return *type.type.type;
+    return *type.members.type.type;
  }

  template<typename Functor>
@ -646,42 +630,34 @@ public:
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
-      type_result.type.type = &BOOST_SP_TYPEID(Functor);
-      type_result.type.const_qualified = is_const<Functor>::value;
-      type_result.type.volatile_qualified = is_volatile<Functor>::value;
+      type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+      type_result.members.type.const_qualified = is_const<Functor>::value;
+      type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
      get_vtable()->manager(functor, type_result,
                      detail::function::check_functor_type_tag);
-      return static_cast<Functor*>(type_result.obj_ptr);
+      return static_cast<Functor*>(type_result.members.obj_ptr);
    }

  template<typename Functor>
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    const Functor* target( Functor * = 0 ) const
-#else
    const Functor* target() const
-#endif
    {
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
-      type_result.type.type = &BOOST_SP_TYPEID(Functor);
-      type_result.type.const_qualified = true;
-      type_result.type.volatile_qualified = is_volatile<Functor>::value;
+      type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+      type_result.members.type.const_qualified = true;
+      type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
      get_vtable()->manager(functor, type_result,
                      detail::function::check_functor_type_tag);
      // GCC 2.95.3 gets the CV qualifiers wrong here, so we
      // can't do the static_cast that we should do.
-      return (const Functor*)(type_result.obj_ptr);
+      return static_cast<const Functor*>(type_result.members.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 {
@ -715,7 +691,7 @@ public:
 public: // should be protected, but GCC 2.95.3 will fail to allow access
  detail::function::vtable_base* get_vtable() const {
    return reinterpret_cast<detail::function::vtable_base*>(
-             reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
+             reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
  }

  bool has_trivial_copy_and_destroy() const {
@ -726,15 +702,22 @@ 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 bad_function_call : public std::runtime_error
+class BOOST_SYMBOL_VISIBLE 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,
@ -767,28 +750,28 @@ inline bool operator!=(detail::function::useless_clear_type*,
 template<typename Functor>
  inline bool operator==(const function_base& f, Functor g)
  {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
    return detail::function::compare_equal(f, g, 0, integral());
  }

 template<typename Functor>
  inline bool operator==(Functor g, const function_base& f)
  {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
    return detail::function::compare_equal(f, g, 0, integral());
  }

 template<typename Functor>
  inline bool operator!=(const function_base& f, Functor g)
  {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
    return detail::function::compare_not_equal(f, g, 0, integral());
  }

 template<typename Functor>
  inline bool operator!=(Functor g, const function_base& f)
  {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
    return detail::function::compare_not_equal(f, g, 0, integral());
  }
 #else
@ -895,7 +878,6 @@ 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 )
--- a/include/boost/function/function_fwd.hpp
+++ b/include/boost/function/function_fwd.hpp
@ -19,8 +19,7 @@ namespace boost { namespace python { namespace objects {
 }}}
 #endif

-#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
- || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
+#if defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
 || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
 #  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
 #endif
--- a/include/boost/function/function_template.hpp
+++ b/include/boost/function/function_template.hpp
@ -11,7 +11,7 @@
 // Note: this header is a header template and must NOT have multiple-inclusion
 // protection.
 #include <boost/function/detail/prologue.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/core/no_exceptions_support.hpp>

 #if defined(BOOST_MSVC)
 #   pragma warning( push )
@ -26,7 +26,12 @@

 #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)
+#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);
@ -91,7 +96,7 @@ namespace boost {
        static R invoke(function_buffer& function_ptr BOOST_FUNCTION_COMMA
                        BOOST_FUNCTION_PARMS)
        {
-          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          return f(BOOST_FUNCTION_ARGS);
        }
      };
@ -108,7 +113,7 @@ namespace boost {
               BOOST_FUNCTION_PARMS)

        {
-          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          BOOST_FUNCTION_RETURN(f(BOOST_FUNCTION_ARGS));
        }
      };
@ -126,9 +131,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.obj_ptr);
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)(BOOST_FUNCTION_ARGS);
        }
      };
@ -147,9 +152,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.obj_ptr);
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
        }
      };
@ -166,7 +171,7 @@ namespace boost {

        {
          FunctionObj* f =
-            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)(BOOST_FUNCTION_ARGS);
        }
      };
@ -184,7 +189,7 @@ namespace boost {

        {
          FunctionObj* f =
-            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          BOOST_FUNCTION_RETURN((*f)(BOOST_FUNCTION_ARGS));
        }
      };
@ -203,7 +208,7 @@ namespace boost {

        {
          MemberPtr* f =
-            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
        }
      };
@ -221,7 +226,7 @@ namespace boost {

        {
          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));
        }
      };
@ -234,7 +239,7 @@ namespace boost {
      >
      struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
      {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename conditional<(is_void<R>::value),
                            BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
                            FunctionPtr,
                            R BOOST_FUNCTION_COMMA
@ -255,7 +260,7 @@ namespace boost {
       >
      struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
      {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename conditional<(is_void<R>::value),
                            BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
                            FunctionObj,
                            R BOOST_FUNCTION_COMMA
@ -276,7 +281,7 @@ namespace boost {
       >
      struct BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
      {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename conditional<(is_void<R>::value),
                            BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER<
                            FunctionObj,
                            R BOOST_FUNCTION_COMMA
@ -299,7 +304,7 @@ namespace boost {
       >
      struct BOOST_FUNCTION_GET_MEMBER_INVOKER
      {
-        typedef typename mpl::if_c<(is_void<R>::value),
+        typedef typename conditional<(is_void<R>::value),
                            BOOST_FUNCTION_VOID_MEMBER_INVOKER<
                            MemberPtr,
                            R BOOST_FUNCTION_COMMA
@ -344,9 +349,8 @@ namespace boost {
          typedef functor_manager<FunctionPtr> manager_type;
        };

-        template<typename FunctionPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-                 typename Allocator>
+        template<typename FunctionPtr, typename Allocator,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
        struct apply_a
        {
          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
@ -379,9 +383,8 @@ namespace boost {
          typedef functor_manager<MemberPtr> manager_type;
        };

-        template<typename MemberPtr,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-                 typename Allocator>
+        template<typename MemberPtr, typename Allocator,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
        struct apply_a
        {
          typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
@ -414,9 +417,8 @@ namespace boost {
          typedef functor_manager<FunctionObj> manager_type;
        };

-        template<typename FunctionObj,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-                 typename Allocator>
+        template<typename FunctionObj, typename Allocator,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
        struct apply_a
        {
          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
@ -448,9 +450,8 @@ namespace boost {
          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

-        template<typename RefWrapper,
-                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
-                 typename Allocator>
+        template<typename RefWrapper, typename Allocator,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
        struct apply_a
        {
          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
@ -486,19 +487,19 @@ namespace boost {
                                            BOOST_FUNCTION_TEMPLATE_ARGS);

        template<typename F>
-        bool assign_to(F f, function_buffer& functor)
+        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
-        bool assign_to_a(F f, function_buffer& functor, Allocator a)
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

-        void clear(function_buffer& functor)
+        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
@ -508,13 +509,13 @@ namespace boost {
        // Function pointers
        template<typename FunctionPtr>
        bool
-        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {
            // should be a reinterpret cast, but some compilers insist
            // on giving cv-qualifiers to free functions
-            functor.func_ptr = (void (*)())(f);
+            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
@ -522,7 +523,7 @@ namespace boost {
        }
        template<typename FunctionPtr,typename Allocator>
        bool
-        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }
@ -530,26 +531,26 @@ namespace boost {
        // Member pointers
 #if BOOST_FUNCTION_NUM_ARGS > 0
        template<typename MemberPtr>
-        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {
          // DPG TBD: Add explicit support for member function
          // objects, so we invoke through mem_fn() but we retain the
          // right target_type() values.
          if (f) {
-            this->assign_to(mem_fn(f), functor);
+            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
-        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {
          // DPG TBD: Add explicit support for member function
          // objects, so we invoke through mem_fn() but we retain the
          // right target_type() values.
          if (f) {
-            this->assign_to_a(mem_fn(f), functor, a);
+            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
@ -561,46 +562,55 @@ namespace boost {
        // Assign to a function object using the small object optimization
        template<typename FunctionObj>
        void
-        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
        {
-          new ((void*)&functor.data) FunctionObj(f);
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
        {
-          assign_functor(f,functor,mpl::true_());
+          assign_functor(f,functor,true_type());
        }

        // Assign to a function object allocated on the heap.
        template<typename FunctionObj>
        void
-        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
        {
-          functor.obj_ptr = new FunctionObj(f);
+          functor.members.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) 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.obj_ptr = new_f;
+          functor.members.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
-        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
+        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,
-                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
@ -608,11 +618,11 @@ namespace boost {
        }
        template<typename FunctionObj,typename Allocator>
        bool
-        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
+        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,
-                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
@ -623,17 +633,17 @@ namespace boost {
        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
-                  function_buffer& functor, function_obj_ref_tag)
+                  function_buffer& functor, function_obj_ref_tag) const
        {
-          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
-          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
-          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
-                  function_buffer& functor, Allocator, function_obj_ref_tag)
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }
@ -650,17 +660,6 @@ 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
@ -677,7 +676,7 @@ namespace boost {

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
-               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
    }

    struct clear_type {};
@ -704,16 +703,15 @@ namespace boost {

    typedef BOOST_FUNCTION_FUNCTION self_type;

-    BOOST_FUNCTION_FUNCTION() : function_base() { }
+    BOOST_DEFAULTED_FUNCTION(BOOST_FUNCTION_FUNCTION(), : function_base() {})

    // MSVC chokes if the following two constructors are collapsed into
    // one with a default parameter.
    template<typename Functor>
    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
 #ifndef BOOST_NO_SFINAE
-                            ,typename enable_if_c<
-                            (boost::type_traits::ice_not<
-                             (is_integral<Functor>::value)>::value),
+                            ,typename boost::enable_if_<
+                             !(is_integral<Functor>::value),
                                        int>::type = 0
 #endif // BOOST_NO_SFINAE
                            ) :
@ -724,9 +722,8 @@ namespace boost {
    template<typename Functor,typename Allocator>
    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a
 #ifndef BOOST_NO_SFINAE
-                            ,typename enable_if_c<
-                            (boost::type_traits::ice_not<
-                             (is_integral<Functor>::value)>::value),
+                            ,typename boost::enable_if_<
+                              !(is_integral<Functor>::value),
                                        int>::type = 0
 #endif // BOOST_NO_SFINAE
                            ) :
@ -749,11 +746,15 @@ 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(); }

-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    // MSVC 6.0 and prior require all definitions to be inline, but
-    // these definitions can become very costly.
    result_type operator()(BOOST_FUNCTION_PARMS) const
    {
      if (this->empty())
@ -762,9 +763,6 @@ namespace boost {
      return get_vtable()->invoker
               (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
    }
-#else
-    result_type operator()(BOOST_FUNCTION_PARMS) const;
-#endif

    // The distinction between when to use BOOST_FUNCTION_FUNCTION and
    // when to use self_type is obnoxious. MSVC cannot handle self_type as
@ -773,9 +771,8 @@ namespace boost {
    // construct.
    template<typename Functor>
 #ifndef BOOST_NO_SFINAE
-    typename enable_if_c<
-               (boost::type_traits::ice_not<
-                 (is_integral<Functor>::value)>::value),
+    typename boost::enable_if_<
+                  !(is_integral<Functor>::value),
               BOOST_FUNCTION_FUNCTION&>::type
 #else
    BOOST_FUNCTION_FUNCTION&
@ -837,6 +834,25 @@ 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)
@ -864,7 +880,7 @@ namespace boost {
 #else
  private:
    struct dummy {
-      void nonnull() {};
+      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();
@ -883,7 +899,9 @@ namespace boost {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
-          this->functor = f.functor;
+          // Don't operate on storage directly since union type doesn't relax
+          // 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);
@ -893,10 +911,10 @@ namespace boost {
    template<typename Functor>
    void assign_to(Functor f)
    {
-      using detail::function::vtable_base;
+      using boost::detail::function::vtable_base;

-      typedef typename detail::function::get_function_tag<Functor>::type tag;
-      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R BOOST_FUNCTION_COMMA
                        BOOST_FUNCTION_TEMPLATE_ARGS>
@ -909,16 +927,17 @@ 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 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 &&
-            detail::function::function_allows_small_object_optimization<Functor>::value)
-          value |= (std::size_t)0x01;
-        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+            boost::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);
      } else
        vtable = 0;
    }
@ -926,14 +945,13 @@ namespace boost {
    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
-      using detail::function::vtable_base;
+      using boost::detail::function::vtable_base;

-      typedef typename detail::function::get_function_tag<Functor>::type tag;
-      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
      typedef typename get_invoker::
-                         template apply_a<Functor, R BOOST_FUNCTION_COMMA 
-                         BOOST_FUNCTION_TEMPLATE_ARGS,
-                         Allocator>
+                         template apply_a<Functor, Allocator, R BOOST_FUNCTION_COMMA
+                         BOOST_FUNCTION_TEMPLATE_ARGS>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
@ -943,16 +961,17 @@ 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 vtable_type stored_vtable =
+      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      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 &&
-            detail::function::function_allows_small_object_optimization<Functor>::value)
-          value |= (std::size_t)0x01;
-        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+            boost::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);
      } else
        vtable = 0;
    }
@ -969,7 +988,9 @@ namespace boost {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
-            this->functor = f.functor;
+            // Don't operate on storage directly since union type doesn't relax
+            // 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);
@ -998,22 +1019,6 @@ namespace boost {
    f1.swap(f2);
  }

-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-  template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-  typename BOOST_FUNCTION_FUNCTION<
-      R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>::result_type
-  inline 
-  BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
-  ::operator()(BOOST_FUNCTION_PARMS) const
-  {
-    if (this->empty())
-      boost::throw_exception(bad_function_call());
-
-    return get_vtable()->invoker
-             (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
-  }
-#endif
-
 // Poison comparisons between boost::function objects of the same type.
 template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
  void operator==(const BOOST_FUNCTION_FUNCTION<
@ -1035,7 +1040,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_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS,T))
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
 #endif

 template<typename R BOOST_FUNCTION_COMMA
@ -1050,14 +1055,13 @@ class function<BOOST_FUNCTION_PARTIAL_SPEC>

 public:

-  function() : base_type() {}
+  BOOST_DEFAULTED_FUNCTION(function(), : base_type() {})

  template<typename Functor>
  function(Functor f
 #ifndef BOOST_NO_SFINAE
-           ,typename enable_if_c<
-                            (boost::type_traits::ice_not<
-                          (is_integral<Functor>::value)>::value),
+           ,typename boost::enable_if_<
+                          !(is_integral<Functor>::value),
                       int>::type = 0
 #endif
           ) :
@ -1067,9 +1071,8 @@ public:
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a
 #ifndef BOOST_NO_SFINAE
-           ,typename enable_if_c<
-                            (boost::type_traits::ice_not<
-                          (is_integral<Functor>::value)>::value),
+           ,typename boost::enable_if_<
+                           !(is_integral<Functor>::value),
                       int>::type = 0
 #endif
           ) :
@ -1085,17 +1088,30 @@ 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 enable_if_c<
-                            (boost::type_traits::ice_not<
-                         (is_integral<Functor>::value)>::value),
+  typename boost::enable_if_<
+                         !(is_integral<Functor>::value),
                      self_type&>::type
 #else
  self_type&
@ -1119,6 +1135,14 @@ 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
@ -1147,6 +1171,9 @@ 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
--- a/meta/libraries.json
+++ b/meta/libraries.json
@ -0,0 +1,18 @@
+{
+    "key": "function",
+    "name": "Function",
+    "authors": [
+        "Doug Gregor"
+    ],
+    "description": "Function object wrappers for deferred calls or callbacks.",
+    "std": [
+        "tr1"
+    ],
+    "category": [
+        "Function-objects",
+        "Programming"
+    ],
+    "maintainers": [
+        "Douglas Gregor <dgregor -at- cs.indiana.edu>"
+    ]
+}
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -7,60 +7,53 @@

 # For more information, see http://www.boost.org/

-project
-    : 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 ;

-  test-suite function
-    : 
-  [ run libs/function/test/function_test.cpp :  :  :  : lib_function_test ]
+lib throw_bad_function_call : throw_bad_function_call.cpp : <link>shared:<define>THROW_BAD_FUNCTION_CALL_DYN_LINK=1 ;

-  [ run libs/function/test/function_n_test.cpp :  :  :  :  ]
+run test_bad_function_call.cpp throw_bad_function_call : : : <link>shared : test_bad_function_call_shared ;
+run test_bad_function_call.cpp throw_bad_function_call : : : <link>static : test_bad_function_call_static ;

-  [ run libs/function/test/allocator_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
+lib mixed_cxxstd : mixed_cxxstd.cpp : <link>shared:<define>MIXED_CXXSTD_DYN_LINK=1 ;

-  [ run libs/function/test/stateless_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
+run test_mixed_cxxstd.cpp mixed_cxxstd : : : <link>shared : mixed_cxxstd_shared ;
+run test_mixed_cxxstd.cpp mixed_cxxstd : : : <link>static : mixed_cxxstd_static ;

-  [ run libs/function/test/lambda_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
+run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>98 : : : <link>shared : mixed_cxxstd_shared_98 ;
+run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>98 : : : <link>static : mixed_cxxstd_static_98 ;

-  [ compile-fail libs/function/test/function_test_fail1.cpp :  :  :  :  ]
+run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>0x : : : <link>shared : mixed_cxxstd_shared_0x ;
+run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>0x : : : <link>static : mixed_cxxstd_static_0x ;

-  [ compile-fail libs/function/test/function_test_fail2.cpp :  :  :  :  ]
-
-  [ compile libs/function/test/function_30.cpp :  :  :  :  ] 
-
-  [ run libs/function/test/function_arith_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_arith_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/sum_avg_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/sum_avg_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/mem_fun_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/mem_fun_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/std_bind_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/std_bind_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_ref_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_ref_portable.cpp :  :  :  :  ]
-  
-  [ run libs/function/test/contains_test.cpp : : : : ]
-   
-  [ run libs/function/test/contains2_test.cpp : : : : ]
-   
-  [ run libs/function/test/nothrow_swap.cpp :  :  :  :  ]
-
-  [ compile libs/function/test/function_typeof_test.cpp ]
- ;
-}
+local check14 = [ check-target-builds mixed_cxxstd/<cxxstd>14 : : <build>no ] ;

+run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>14 : : : <link>shared $(check14) : mixed_cxxstd_shared_14 ;
+run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>14 : : : <link>static $(check14) : mixed_cxxstd_static_14 ;
--- a/test/allocator_test.cpp
+++ b/test/allocator_test.cpp
@ -7,10 +7,10 @@

 // For more information, see http://www.boost.org

-#include <boost/test/minimal.hpp>
+#include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <cassert>
 #include <functional>
-#include <boost/function.hpp>

 using namespace std;
 using namespace boost;
@ -74,20 +74,19 @@ struct DoNothing: base

 static void do_nothing() {}

-int
-test_main(int, char*[])
+int main()
 {
  function2<int, int, int> f;
  f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<int>() );
  f.clear();
-  BOOST_CHECK(alloc_count == 1);
-  BOOST_CHECK(dealloc_count == 1);
+  BOOST_TEST_EQ( alloc_count, 1 );
+  BOOST_TEST_EQ( dealloc_count, 1 );
  alloc_count = 0;
  dealloc_count = 0;
  f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
  f.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
+  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_TEST_EQ( 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>() );
@ -97,8 +96,8 @@ test_main(int, char*[])
  dealloc_count = 0;
  f.assign( &do_minus, counting_allocator<int>() );
  f.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
+  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_TEST_EQ( dealloc_count, 0 );
  f.assign( &do_minus, std::allocator<int>() );
  f.clear();

@ -107,14 +106,14 @@ test_main(int, char*[])
  dealloc_count = 0;
  fv.assign( DoNothing<disable_small_object_optimization>(), counting_allocator<int>() );
  fv.clear();
-  BOOST_CHECK(alloc_count == 1);
-  BOOST_CHECK(dealloc_count == 1);
+  BOOST_TEST_EQ( alloc_count, 1 );
+  BOOST_TEST_EQ( dealloc_count, 1 );
  alloc_count = 0;
  dealloc_count = 0;
  fv.assign( DoNothing<enable_small_object_optimization>(), counting_allocator<int>() );
  fv.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
+  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_TEST_EQ( 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>() );
@ -124,8 +123,8 @@ test_main(int, char*[])
  dealloc_count = 0;
  fv.assign( &do_nothing, counting_allocator<int>() );
  fv.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
+  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_TEST_EQ( dealloc_count, 0 );
  fv.assign( &do_nothing, std::allocator<int>() );
  fv.clear();
  
@ -133,5 +132,5 @@ test_main(int, char*[])
  fv.assign(&do_nothing, std::allocator<int>() );
  fv2.assign(fv, std::allocator<int>() );

-  return 0;
+  return boost::report_errors();
 }
--- a/test/contains2_test.cpp
+++ b/test/contains2_test.cpp
@ -9,7 +9,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt)

 #include <boost/function.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>

 static int forty_two()
 {
--- a/test/function_30_repeat.cpp
+++ b/test/function_30_repeat.cpp
@ -0,0 +1,35 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2002-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+// Make sure we don't try to redefine function2
+#include <boost/function/function2.hpp>
+
+// Define all Boost.Function class templates up to 30 arguments
+#define BOOST_FUNCTION_MAX_ARGS 20
+#include <boost/function.hpp>
+#undef BOOST_FUNCTION_MAX_ARGS
+#define BOOST_FUNCTION_MAX_ARGS 40
+#include <boost/function.hpp>
+#undef BOOST_FUNCTION_MAX_ARGS
+#define BOOST_FUNCTION_MAX_ARGS 25
+#include <boost/function.hpp>
+#undef BOOST_FUNCTION_MAX_ARGS
+#define BOOST_FUNCTION_MAX_ARGS 30
+#include <boost/function.hpp>
+#include <boost/function.hpp>
+
+int main()
+{
+  boost::function0<float> f0;
+
+  boost::function30<float, int, int, int, int, int, int, int, int, int, int,
+                    int, int, int, int, int, int, int, int, int, int,
+                    int, int, int, int, int, int, int, int, int, int> f30;
+  return 0;
+}
--- a/test/function_n_test.cpp
+++ b/test/function_n_test.cpp
@ -631,7 +631,7 @@ test_ref()
    boost::function2<int, int, int> f(ref(atc));
    BOOST_CHECK(f(1, 3) == 4);
  }
-  catch(std::runtime_error e) {
+  catch(std::runtime_error const&) {
    BOOST_ERROR("Nonthrowing constructor threw an exception");
  }
 }
--- a/test/function_test.cpp
+++ b/test/function_test.cpp
@ -624,11 +624,22 @@ test_ref()
    boost::function<int (int, int)> f(boost::ref(atc));
    BOOST_CHECK(f(1, 3) == 4);
  }
-  catch(std::runtime_error e) {
+  catch(std::runtime_error const&) {
    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()
@ -640,18 +651,20 @@ static void test_empty_ref()
    f2();
    BOOST_ERROR("Exception didn't throw for reference to empty function.");
  }
-  catch(std::runtime_error e) {}
+  catch(std::runtime_error const&) {}

  f1 = dummy;

  try {
    f2();
  }
-  catch(std::runtime_error e) {
+  catch(std::runtime_error const&) {
    BOOST_ERROR("Error calling referenced function.");
  }
 }

+#endif
+

 static void test_exception()
 {
@ -660,7 +673,7 @@ static void test_exception()
    f(5, 4);
    BOOST_CHECK(false);
  }
-  catch(boost::bad_function_call) {
+  catch(boost::bad_function_call const&) {
    // okay
  }
 }
@ -690,6 +703,95 @@ static void test_call()
  test_call_cref(std::plus<int>());
 }

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

  return 0;
 }
--- a/test/lambda_test.cpp
+++ b/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,17 +22,19 @@ func_impl(int arg1, bool arg2, double arg3)
  return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
 }

-int test_main(int, char*[])
+int main()
 {
  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 );

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

    
 #include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <functional>

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

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

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

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

    
 #include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <functional>

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

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

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

-    return 0;
+    return ::boost::report_errors();
 }
--- a/test/mixed_cxxstd.cpp
+++ b/test/mixed_cxxstd.cpp
@ -0,0 +1,42 @@
+
+// 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 );
+}
--- a/test/result_arg_types_test.cpp
+++ b/test/result_arg_types_test.cpp
@ -0,0 +1,40 @@
+// Boost.Function library
+
+//  Copyright 2016 Peter Dimov
+
+//  Use, modification and distribution is subject to
+//  the Boost Software License, Version 1.0.
+//  (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/function.hpp>
+#include <boost/core/is_same.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+struct X
+{
+};
+
+struct Y
+{
+};
+
+struct Z
+{
+};
+
+int main()
+{
+    typedef boost::function<X(Y)> F1;
+
+    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F1::result_type, X> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F1::argument_type, Y> ));
+
+    typedef boost::function<X(Y, Z)> F2;
+
+    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F2::result_type, X> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F2::first_argument_type, Y> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F2::second_argument_type, Z> ));
+
+    return boost::report_errors();
+}
--- a/test/rvalues_test.cpp
+++ b/test/rvalues_test.cpp
@ -0,0 +1,106 @@
+// Copyright 2014 Antony Polukhin.
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <cstdlib>
+
+#include <boost/test/minimal.hpp>
+#include <boost/function.hpp>
+#include <boost/move/move.hpp>
+
+class only_movable {
+private:
+    BOOST_MOVABLE_BUT_NOT_COPYABLE(only_movable)
+    int value_;
+    bool moved_;
+
+public:
+    only_movable(BOOST_RV_REF(only_movable) x)
+        : value_(x.value_)
+        , moved_(false)
+    {
+        x.moved_ = true;
+    }
+
+   only_movable& operator=(BOOST_RV_REF(only_movable) x) {
+        value_ = x.value_;
+        x.moved_ = true;
+        moved_ = false;
+        return *this;
+   }
+
+    explicit only_movable(int value = 0) : value_(value), moved_(false) {}
+    int get_value() const {  return value_;  }
+    bool is_moved() const { return moved_; }
+};
+
+
+int one(BOOST_RV_REF(only_movable) v) { return v.get_value(); }
+only_movable two(BOOST_RV_REF(only_movable) t) {
+    only_movable t1 = boost::move(t);
+    return BOOST_MOVE_RET(only_movable, t1);
+}
+
+only_movable two_sum(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) {
+    only_movable ret(t1.get_value() + t2.get_value());
+    return BOOST_MOVE_RET(only_movable, ret);
+}
+
+struct sum_struct {
+    only_movable operator()(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) const {
+        only_movable ret(t1.get_value() + t2.get_value());
+        return BOOST_MOVE_RET(only_movable, ret);
+    }
+};
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+int three(std::string&&) { return 1; }
+std::string&& four(std::string&& s) { return boost::move(s); }
+#endif
+
+int test_main(int, char*[])
+{
+    using boost::function;
+
+    function <int(BOOST_RV_REF(only_movable))>  f1 = one;
+
+    only_movable om1(1);
+    BOOST_CHECK(f1(boost::move(om1)) == 1);
+
+    function <only_movable(BOOST_RV_REF(only_movable))>  f2 = two;
+
+    only_movable om2(2);
+    only_movable om2_2 = f2(boost::move(om2));
+    BOOST_CHECK(om2_2.get_value() == 2);
+    BOOST_CHECK(om2.is_moved());
+
+    {
+        function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))>  f2_sum = two_sum;
+        only_movable om1_sum(1), om2_sum(2);
+        only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
+        BOOST_CHECK(om2_sum_2.get_value() == 3);
+    }
+
+    {
+        sum_struct s;
+        function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))>  f2_sum = s;
+        only_movable om1_sum(1), om2_sum(2);
+        only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
+        BOOST_CHECK(om2_sum_2.get_value() == 3);
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    function <int(std::string&&)>               f3 = three;
+    function <std::string&& (std::string&& s)>  f4 = four;
+
+    f3(std::string("Hello"));
+    BOOST_CHECK(f4(std::string("world")) == "world");
+#endif
+
+    return 0;
+}
--- a/test/stateless_test.cpp
+++ b/test/stateless_test.cpp
@ -7,16 +7,18 @@

 // 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)
+  void* operator new(std::size_t n)
  {
-    throw std::runtime_error("Cannot allocate a stateless_integer_add");
+    BOOST_ERROR( "stateless_integer_add incorrectly allocated" );
+    return ::operator new( n );
  }

  void* operator new(std::size_t, void* p)
@ -24,15 +26,17 @@ struct stateless_integer_add {
    return p;
  }

-  void operator delete(void*) throw()
+  void operator delete(void* p) throw()
  {
+    BOOST_ERROR( "stateless_integer_add incorrectly deallocated" );
+    return ::operator delete( p );
  }
 };

-int test_main(int, char*[])
+int main()
 {
  boost::function2<int, int, int> f;
  f = stateless_integer_add();

-  return 0;
+  return boost::report_errors();
 }
--- a/test/std_bind_cxx98.cpp
+++ b/test/std_bind_cxx98.cpp
@ -20,11 +20,12 @@ int X::foo(int x) { return -x; }

 int main()
 {
+#ifndef BOOST_NO_CXX98_BINDERS
      boost::function<int (int)> f;
  X x;
  f = std::bind1st(
        std::mem_fun(&X::foo), &x);
  f(5); // Call x.foo(5)
-
+#endif
    return 0;
 }
--- a/test/std_bind_portable.cpp
+++ b/test/std_bind_portable.cpp
@ -20,11 +20,12 @@ 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;
 }
--- a/test/test_bad_function_call.cpp
+++ b/test/test_bad_function_call.cpp
@ -0,0 +1,14 @@
+
+// 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();
+}
--- a/test/test_mixed_cxxstd.cpp
+++ b/test/test_mixed_cxxstd.cpp
@ -0,0 +1,48 @@
+
+// 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();
+}
--- a/test/throw_bad_function_call.cpp
+++ b/test/throw_bad_function_call.cpp
@ -0,0 +1,17 @@
+
+// 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();
+}