Update dependency list in cmake_subdir_test

Performance improvement

.drone.jsonnet

@@ -0,0 +1,415 @@
+# Copyright 2022 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+local library = "function";
+
+local triggers =
+{
+    branch: [ "master", "develop", "feature/*" ]
+};
+
+local ubsan = { UBSAN: '1', UBSAN_OPTIONS: 'print_stacktrace=1' };
+local asan = { ASAN: '1' };
+
+local linux_pipeline(name, image, environment, packages = "", sources = [], arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "docker",
+    trigger: triggers,
+    platform:
+    {
+        os: "linux",
+        arch: arch
+    },
+    steps:
+    [
+        {
+            name: "everything",
+            image: image,
+            environment: environment,
+            commands:
+            [
+                'set -e',
+                'uname -a',
+                'echo $DRONE_STAGE_MACHINE',
+                'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
+            ] +
+            (if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
+            (if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
+            [
+                'export LIBRARY=' + library,
+                './.drone/drone.sh',
+            ]
+        }
+    ]
+};
+
+local macos_pipeline(name, environment, xcode_version = "12.2", osx_version = "catalina", arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "exec",
+    trigger: triggers,
+    platform: {
+        "os": "darwin",
+        "arch": arch
+    },
+    node: {
+        "os": osx_version
+    },
+    steps: [
+        {
+            name: "everything",
+            environment: environment + { "DEVELOPER_DIR": "/Applications/Xcode-" + xcode_version + ".app/Contents/Developer" },
+            commands:
+            [
+                'export LIBRARY=' + library,
+                './.drone/drone.sh',
+            ]
+        }
+    ]
+};
+
+local windows_pipeline(name, image, environment, arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "docker",
+    trigger: triggers,
+    platform:
+    {
+        os: "windows",
+        arch: arch
+    },
+    "steps":
+    [
+        {
+            name: "everything",
+            image: image,
+            environment: environment,
+            commands:
+            [
+                'cmd /C .drone\\\\drone.bat ' + library,
+            ]
+        }
+    ]
+};
+
+[
+    linux_pipeline(
+        "Linux 16.04 GCC 4.7 32/64",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '0x', ADDRMD: '32,64' },
+        "g++-4.7-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 4.8 32/64",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.8', CXXSTD: '11', ADDRMD: '32,64' },
+        "g++-4.8-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 4.9 32/64",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '11', ADDRMD: '32,64' },
+        "g++-4.9-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 5* 32/64",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 6 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '11,14', ADDRMD: '32,64' },
+        "g++-6-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 7* 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 8 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '11,14,17', ADDRMD: '32,64' },
+        "g++-8-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* 32/64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* ARM64 UBSAN",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a' } + ubsan,
+        arch="arm64",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* ARM64 ASAN",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a' } + asan,
+        arch="arm64",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* S390x UBSAN",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a' } + ubsan,
+        arch="s390x",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 10 32/64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '11,14,17,20', ADDRMD: '32,64' },
+        "g++-10-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 11* 32/64",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 32/64",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '32,64' },
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 GCC 13 32/64",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '32,64' },
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 14 32/64 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b', ADDRMD: '32,64' } + ubsan,
+        "g++-14-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 14 32/64 ASAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b', ADDRMD: '32,64' } + asan,
+        "g++-14-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.5",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.5', CXXSTD: '11' },
+        "clang-3.5",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.6",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.6', CXXSTD: '11,14' },
+        "clang-3.6",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.7",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.7', CXXSTD: '11,14' },
+        "clang-3.7",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.8",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.8', CXXSTD: '11,14' },
+        "clang-3.8",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 3.9",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.9', CXXSTD: '11,14' },
+        "clang-3.9",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 4.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-4.0', CXXSTD: '11,14' },
+        "clang-4.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 5.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-5.0', CXXSTD: '11,14,1z' },
+        "clang-5.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 6.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '11,14,17' },
+        "clang-6.0",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 7",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '11,14,17' },
+        "clang-7",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 8",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '11,14,17' },
+        "clang-8",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 9",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '11,14,17,2a' },
+        "clang-9",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 10",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '11,14,17,2a' },
+        "clang-10",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 11",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '11,14,17,2a' },
+        "clang-11",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 12",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '11,14,17,2a' },
+        "clang-12",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 13",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '11,14,17,20' },
+        "clang-13",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 14",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '11,14,17,20,2b' },
+        "clang-14",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 15",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '11,14,17,20,2b' },
+        "clang-15",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 Clang 16",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '11,14,17,20,2b' },
+        "clang-16",
+    ),
+
+    linux_pipeline(
+        "Linux 23.10 Clang 17 UBSAN",
+        "cppalliance/droneubuntu2310:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        "clang-17",
+    ),
+
+    linux_pipeline(
+        "Linux 23.10 Clang 17 ASAN",
+        "cppalliance/droneubuntu2310:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + asan,
+        "clang-17",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 Clang 18 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        "clang-18",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 Clang 18 ASAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' } + asan,
+        "clang-18",
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 UBSAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,17,2a' } + ubsan,
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 ASAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,17,2a' } + asan,
+    ),
+
+    macos_pipeline(
+        "MacOS 12.4 Xcode 13.4.1 UBSAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
+    ),
+
+    macos_pipeline(
+        "MacOS 12.4 Xcode 13.4.1 ASAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,17,20,2b' } + asan,
+        xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
+    ),
+
+    windows_pipeline(
+        "Windows VS2015 msvc-14.0",
+        "cppalliance/dronevs2015",
+        { TOOLSET: 'msvc-14.0', CXXSTD: '14,latest', B2_DONT_EMBED_MANIFEST: '1' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2017 msvc-14.1",
+        "cppalliance/dronevs2017",
+        { TOOLSET: 'msvc-14.1', CXXSTD: '14,17,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2019 msvc-14.2",
+        "cppalliance/dronevs2019",
+        { TOOLSET: 'msvc-14.2', CXXSTD: '14,17,20,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2022 msvc-14.3",
+        "cppalliance/dronevs2022:1",
+        { TOOLSET: 'msvc-14.3', CXXSTD: '14,17,20,latest' },
+    ),
+]

.drone/drone.bat

@@ -0,0 +1,23 @@
+@REM Copyright 2022 Peter Dimov
+@REM Distributed under the Boost Software License, Version 1.0.
+@REM https://www.boost.org/LICENSE_1_0.txt
+
+@ECHO ON
+
+set LIBRARY=%1
+set DRONE_BUILD_DIR=%CD%
+
+set BOOST_BRANCH=develop
+if "%DRONE_BRANCH%" == "master" set BOOST_BRANCH=master
+cd ..
+git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/boostdep
+xcopy /s /e /q %DRONE_BUILD_DIR% libs\%LIBRARY%\
+python tools/boostdep/depinst/depinst.py -I example %LIBRARY%
+cmd /c bootstrap
+b2 -d0 headers
+
+if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+b2 -j3 libs/%LIBRARY%/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker

.drone/drone.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+# Copyright 2022 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+set -ex
+export PATH=~/.local/bin:/usr/local/bin:$PATH
+
+DRONE_BUILD_DIR=$(pwd)
+
+BOOST_BRANCH=develop
+if [ "$DRONE_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
+
+cd ..
+git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/boostdep
+cp -r $DRONE_BUILD_DIR/* libs/$LIBRARY
+python tools/boostdep/depinst/depinst.py -I example $LIBRARY
+./bootstrap.sh
+./b2 -d0 headers
+
+echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+./b2 -j3 libs/$LIBRARY/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${ADDRMD:+address-model=$ADDRMD} ${UBSAN:+undefined-sanitizer=norecover debug-symbols=on} ${ASAN:+address-sanitizer=norecover debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}

.github/workflows/ci.yml

@@ -0,0 +1,646 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+      - feature/**
+
+env:
+  UBSAN_OPTIONS: print_stacktrace=1
+
+jobs:
+  posix:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: gcc-4.7
+            cxxstd: "11"
+            container: ubuntu:16.04
+            os: ubuntu-latest
+            install: g++-4.7-multilib
+            address-model: 32,64
+          - toolset: gcc-4.8
+            cxxstd: "11"
+            container: ubuntu:16.04
+            os: ubuntu-latest
+            install: g++-4.8-multilib
+            address-model: 32,64
+          - toolset: gcc-4.9
+            cxxstd: "11"
+            container: ubuntu:16.04
+            os: ubuntu-latest
+            install: g++-4.9-multilib
+            address-model: 32,64
+          - toolset: gcc-5
+            cxxstd: "11,14,1z"
+            container: ubuntu:18.04
+            os: ubuntu-latest
+            install: g++-5-multilib
+            address-model: 32,64
+          - toolset: gcc-6
+            cxxstd: "11,14,1z"
+            container: ubuntu:18.04
+            os: ubuntu-latest
+            install: g++-6-multilib
+            address-model: 32,64
+          - toolset: gcc-7
+            cxxstd: "11,14,17"
+            os: ubuntu-20.04
+            install: g++-7-multilib
+            address-model: 32,64
+          - toolset: gcc-8
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-8-multilib
+            address-model: 32,64
+          - toolset: gcc-9
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-9-multilib
+            address-model: 32,64
+          - toolset: gcc-10
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-10-multilib
+            address-model: 32,64
+          - toolset: gcc-11
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: g++-11-multilib
+            address-model: 32,64
+          - toolset: gcc-12
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: g++-12-multilib
+            address-model: 32,64
+          - toolset: gcc-13
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:23.04
+            os: ubuntu-latest
+            install: g++-13-multilib
+            address-model: 32,64
+          - toolset: gcc-14
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: g++-14-multilib
+            address-model: 32,64
+          - toolset: clang
+            compiler: clang++-3.9
+            cxxstd: "11,14"
+            container: ubuntu:18.04
+            os: ubuntu-latest
+            install: clang-3.9
+          - toolset: clang
+            compiler: clang++-4.0
+            cxxstd: "11,14"
+            container: ubuntu:18.04
+            os: ubuntu-latest
+            install: clang-4.0
+          - toolset: clang
+            compiler: clang++-5.0
+            cxxstd: "11,14,1z"
+            container: ubuntu:18.04
+            os: ubuntu-latest
+            install: clang-5.0
+          - toolset: clang
+            compiler: clang++-6.0
+            cxxstd: "11,14,17"
+            os: ubuntu-20.04
+            install: clang-6.0
+          - toolset: clang
+            compiler: clang++-7
+            cxxstd: "11,14,17"
+            os: ubuntu-20.04
+            install: clang-7
+          - toolset: clang
+            compiler: clang++-8
+            cxxstd: "11,14,17"
+            os: ubuntu-20.04
+            install: clang-8
+          - toolset: clang
+            compiler: clang++-9
+            cxxstd: "11,14,17"
+            os: ubuntu-20.04
+            install: clang-9
+          - toolset: clang
+            compiler: clang++-10
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-11
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-12
+            cxxstd: "11,14,17,20"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-13
+            cxxstd: "11,14,17,20"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-13
+          - toolset: clang
+            compiler: clang++-14
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-14
+          - toolset: clang
+            compiler: clang++-15
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-15
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:23.04
+            os: ubuntu-latest
+            install: clang-16
+          - toolset: clang
+            compiler: clang++-17
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:23.10
+            os: ubuntu-latest
+            install: clang-17
+          - toolset: clang
+            compiler: clang++-18
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-18
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-12
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-13
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-14
+
+    runs-on: ${{matrix.os}}
+    container: ${{matrix.container}}
+
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+      - name: Enable Node 16
+        run: |
+          echo "ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION=true" >> $GITHUB_ENV
+
+      - uses: actions/checkout@v3
+
+      - name: Setup container environment
+        if: matrix.container
+        run: |
+          apt-get update
+          apt-get -y install sudo python3 git g++
+
+      - name: Install packages
+        if: matrix.install
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python3 tools/boostdep/depinst/depinst.py $LIBRARY
+          ./bootstrap.sh
+          ./b2 -d0 headers
+
+      - name: Create user-config.jam
+        if: matrix.compiler
+        run: |
+          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
+
+      - name: Run tests
+        run: |
+          cd ../boost-root
+          export ADDRMD=${{matrix.address-model}}
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} variant=debug,release
+
+  windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: msvc-14.0
+            cxxstd: 14,latest
+            addrmd: 32,64
+            os: windows-2019
+          - toolset: msvc-14.2
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2019
+          - toolset: msvc-14.3
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: clang-win
+            cxxstd: "14,17,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: gcc
+            cxxstd: "11,14,17,2a"
+            addrmd: 64
+            os: windows-2019
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+          cmd /c bootstrap
+          b2 -d0 headers
+
+      - name: Run tests
+        shell: cmd
+        run: |
+          cd ../boost-root
+          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release embed-manifest-via=linker
+
+  posix-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-12
+          - os: macos-13
+          - os: macos-14
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Use library with add_subdirectory
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-12
+          - os: macos-13
+          - os: macos-14
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
+
+      - name: Install
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-12
+          - os: macos-13
+          - os: macos-14
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
+
+      - name: Build tests
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests
+
+      - name: Run tests
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error
+
+  windows-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Use library with add_subdirectory (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use library with add_subdirectory (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+
+      - name: Install (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Debug
+
+      - name: Install (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Release
+
+      - name: Use the installed library (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use the installed library (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DBUILD_TESTING=ON ..
+
+      - name: Build tests (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests --config Debug
+
+      - name: Run tests (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Build tests (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests --config Release
+
+      - name: Run tests (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Release

.travis.yml

@@ -0,0 +1,362 @@
+# Copyright 2016-2019 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+dist: xenial
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - 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
+      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++-9
+      env: TOOLSET=gcc CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - g++-9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: bionic
+      compiler: g++-10
+      env: UBSAN=1 TOOLSET=gcc CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
+      addons:
+        apt:
+          packages:
+            - g++-10
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: /usr/bin/clang++
+      env: TOOLSET=clang CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.3
+
+    - os: linux
+      dist: trusty
+      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
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - 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
+
+    - 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
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - 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
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - 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
+
+    - 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-xenial-7
+
+    - os: linux
+      compiler: clang++-8
+      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-xenial-8
+
+    - os: linux
+      dist: bionic
+      compiler: clang++-9
+      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-9
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+
+    - os: linux
+      dist: bionic
+      compiler: clang++-10
+      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-10
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+
+    - os: linux
+      dist: bionic
+      compiler: clang++-11
+      env: TOOLSET=clang CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-11
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-11 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+
+    - os: linux
+      dist: bionic
+      compiler: clang++-12
+      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
+      addons:
+        apt:
+          packages:
+            - clang-12
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-12 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+
+    - os: linux
+      dist: trusty
+      compiler: clang++-libc++
+      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: linux
+      dist: bionic
+      compiler: clang++-libc++
+      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: osx
+      compiler: clang++
+      env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
+
+    - os: linux
+      env: CMAKE_TEST=1
+      script:
+        - mkdir __build__ && cd __build__
+        - cmake -DBOOST_ENABLE_CMAKE=1 -DBUILD_TESTING=ON -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=function ..
+        - ctest --output-on-failure -R boost_function
+
+    - os: linux
+      env: CMAKE_SUBDIR_TEST=1
+      script:
+      - cd libs/function/test/cmake_subdir_test && mkdir __build__ && cd __build__
+      - cmake ..
+      - cmake --build .
+      - cmake --build . --target check
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/boostdep
+  - cp -r $TRAVIS_BUILD_DIR/* libs/function
+  - python tools/boostdep/depinst/depinst.py function
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $TRAVIS_COMPILER ;" > ~/user-config.jam
+  - ./b2 -j3 libs/function/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
+
+notifications:
+  email:
+    on_success: always

CMakeLists.txt

@@ -0,0 +1,30 @@
+# Generated by `boostdep --cmake function`
+# Copyright 2020, 2021 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.8...3.20)
+
+project(boost_function VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_function INTERFACE)
+add_library(Boost::function ALIAS boost_function)
+
+target_include_directories(boost_function INTERFACE include)
+
+target_link_libraries(boost_function
+  INTERFACE
+    Boost::assert
+    Boost::bind
+    Boost::config
+    Boost::core
+    Boost::throw_exception
+)
+
+target_compile_features(boost_function INTERFACE cxx_std_11)
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()

README.md

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

appveyor.yml

@@ -0,0 +1,67 @@
+# Copyright 2016-2019 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-12.0,msvc-14.0
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      CXXSTD: 14,17
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: clang-win
+      CXXSTD: 14,17,latest
+      ADDRMD: 64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      TOOLSET: clang-win
+      CXXSTD: 14,17,latest
+      ADDRMD: 64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\cygwin\bin;
+      TOOLSET: gcc
+      CXXSTD: 11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\cygwin64\bin;
+      TOOLSET: gcc
+      CXXSTD: 11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\mingw\bin;
+      TOOLSET: gcc
+      CXXSTD: 11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      TOOLSET: gcc
+      CXXSTD: 11,14,1z
+
+install:
+  - set BOOST_BRANCH=develop
+  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
+  - cd ..
+  - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/boostdep
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\function\
+  - python tools/boostdep/depinst/depinst.py function
+  - cmd /c bootstrap
+  - b2 -d0 headers
+
+build: off
+
+test_script:
+  - PATH=%ADDPATH%%PATH%
+  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+  - b2 -j3 libs/function/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker

build.jam

@@ -0,0 +1,24 @@
+# Copyright 2023-2024 René Ferdinand Rivera Morell
+# Copyright 2024 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/assert//boost_assert
+    /boost/bind//boost_bind
+    /boost/config//boost_config
+    /boost/core//boost_core
+    /boost/throw_exception//boost_throw_exception
+    ;
+
+project /boost/function ;
+
+explicit
+    [ alias boost_function : : : : <include>include <library>$(boost_dependencies) ]
+    [ alias all : boost_function example test ]
+    ;
+
+call-if : boost-library function
+    ;

doc/Jamfile.v2

@@ -3,8 +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 ;
+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 ;

doc/history.xml

@@ -13,6 +13,51 @@
 
 <itemizedlist spacing="compact">
 
+  <listitem><para><bold>Version 1.52.0</bold>: </para>
+    <itemizedlist spacing="compact">
+      <listitem><para>Move constructors and move assignment 
+      operators added (only for compilers with C++11 rvalue 
+      references support). Original patch
+      contributed by Antony Polukhin.</para></listitem>
+    </itemizedlist>
+  </listitem>
+
+  <listitem><para><bold>Version 1.37.0</bold>: </para>
+    <itemizedlist spacing="compact">
+      <listitem><para>Improved the performance of Boost.Function's
+      swap() operation for large function objects. Original patch
+      contributed by Niels Dekker.</para></listitem>
+
+      <listitem><para>Added a new header &lt;boost/function/function_typeof.hpp&gt; that provides support for using the Boost.Typeof library on Boost.Function objects.</para></listitem>
+
+      <listitem><para>Added a new header &lt;boost/function/function_fwd.hpp&gt; that provides support for using the Boost.Typeof library on Boost.Function objects.</para></listitem>
+
+      <listitem><para>The <methodname alt="boost::function::target">target</methodname>()
+      function now respects the cv-qualifiers of function objects
+      stored by reference
+      (using <classname>boost::reference_wrapper</classname>), such
+      that a reference to a <code>const</code> function object cannot
+      be accessed as a reference to a non-<code>const</code> function
+      object.</para></listitem>
+    </itemizedlist>
+  </listitem>
+
+  <listitem><para><bold>Version 1.36.0</bold>: </para>
+    <itemizedlist spacing="compact">
+      <listitem><para>Boost.Function now implements allocator support
+      in the same way that is is provided in C++0x, based on C++
+      committee
+      proposal <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2308.html">N2308</ulink>. This
+      change removes the <computeroutput>Allocator</computeroutput>
+      template parameter of <classname>boost::function</classname> in
+      favor of a constructor that takes an argument. While this is a
+      backward-incompatible change, it is likely to affect only a few
+      users. This change to Function was contributed by Emil
+      Dotchevski, which also authored the corresponding C++ committee
+      proposal.</para></listitem>
+    </itemizedlist>
+  </listitem>
+
   <listitem><para><bold>Version 1.34.0</bold>: </para> 
     <itemizedlist spacing="compact">
       <listitem><para>Boost.Function now implements a small buffer optimization, which can drastically improve the performance when copying or construction Boost.Function objects storing small function objects. For instance, <code>bind(&amp;X:foo, &amp;x, _1, _2)</code> requires no heap allocation when placed into a Boost.Function object. Note that some exception-safety guarantees have changed: assignment provides the basic exception guarantee and <code>swap()</code> may throw.</para></listitem>

doc/misc.xml

@@ -24,7 +24,7 @@
 <para> And, of course, function pointers have several advantages over Boost.Function:
 
 <itemizedlist spacing="compact">
-    <listitem><para> Function pointers are smaller (the size of one pointer instead of three) </para></listitem>
+    <listitem><para> Function pointers are smaller (the size of one pointer instead of four or more) </para></listitem>
     <listitem><para> Function pointers are faster (Boost.Function may require two calls through function pointers) </para></listitem>
     <listitem><para> Function pointers are backward-compatible with C libraries.</para></listitem>
     <listitem><para> More readable error messages. </para></listitem>
@@ -37,12 +37,12 @@
 
 <section>
   <title>Function object wrapper size</title>
-<para> Function object wrappers will be the size of two function pointers plus one function pointer or data pointer (whichever is larger). On common 32-bit platforms, this amounts to 12 bytes per wrapper. Additionally, the function object target will be allocated on the heap.</para>
+  <para> Function object wrappers will be the size of a struct containing a member function pointer and two data pointers. The actual size can vary significantly depending on the underlying platform; on 32-bit Mac OS X with GCC, this amounts to 16 bytes, while it is 32 bytes Windows with Visual C++. Additionally, the function object target may be allocated on the heap, if it cannot be placed into the small-object buffer in the <code>boost::function</code> object.</para>
 </section>
 
 <section>
   <title>Copying efficiency</title>
-<para> Copying function object wrappers may require allocating memory for a copy of the function object target. The default allocator may be replaced with a faster custom allocator or one may choose to allow the function object wrappers to only store function object targets by reference (using <computeroutput>ref</computeroutput>) if the cost of this cloning becomes prohibitive.</para>
+  <para> Copying function object wrappers may require allocating memory for a copy of the function object target. The default allocator may be replaced with a faster custom allocator or one may choose to allow the function object wrappers to only store function object targets by reference (using <computeroutput>ref</computeroutput>) if the cost of this cloning becomes prohibitive. Small function objects can be stored within the <code>boost::function</code> object itself, improving copying efficiency.</para>
  </section>
 
 <section>

doc/reference.xml

@@ -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>
@@ -141,9 +141,6 @@
       <template-type-parameter name="T2"/>
       <template-varargs/>
       <template-type-parameter name="TN"/>
-      <template-type-parameter name="Allocator">
-        <default><classname>std::allocator</classname>&lt;void&gt;</default>
-      </template-type-parameter>
     </template>
 
     <inherit access="public"><classname>function_base</classname></inherit>
@@ -160,7 +157,6 @@
     </description>
 
     <typedef name="result_type"><type>R</type></typedef>
-    <typedef name="allocator_type"><type>Allocator</type></typedef>
     <typedef name="argument_type">
       <type>T1</type><purpose>If N == 1</purpose>
     </typedef>
@@ -207,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"/>
@@ -216,6 +221,19 @@
       <postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-&gt;<methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
     </constructor>
 
+    <constructor>
+      <template>
+        <template-type-parameter name="F"/>
+        <template-type-parameter name="Allocator"/>
+      </template>
+      <parameter name="f"><paramtype>F</paramtype></parameter>
+      <parameter name="alloc"><paramtype>Allocator</paramtype></parameter>
+      <requires><simpara>F is a function object Callable from <code>this</code>, Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw.</simpara></requires>
+      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-&gt;<methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
+
+      <effects><simpara>If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory.</simpara></effects>
+    </constructor>
+
     <destructor>
       <effects><simpara>If <code>!this-&gt;<methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
 
@@ -227,6 +245,15 @@
       </parameter>
       <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
     </copy-assignment>
+    
+    <copy-assignment>
+      <parameter name="f">
+        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
+      </parameter>
+      <requires><simpara>C++11 compatible compiler.</simpara></requires>
+      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
+      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
+    </copy-assignment>
 
     <method-group name="modifiers">
       <method name="swap">
@@ -324,11 +351,10 @@
           <template-type-parameter name="T2"/>
           <template-varargs/>
           <template-type-parameter name="TN"/>
-          <template-type-parameter name="Allocator"/>
         </template>
         <type>void</type>
-        <parameter name="f1"><paramtype><classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
-        <parameter name="f2"><paramtype><classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+        <parameter name="f1"><paramtype><classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
+        <parameter name="f2"><paramtype><classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
         <effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
       </function>
     </free-function-group>
@@ -341,11 +367,10 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
           <parameter name="g"><paramtype>Functor</paramtype></parameter>
         </signature>
         <signature>
@@ -354,12 +379,11 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
           <parameter name="g"><paramtype>Functor</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
         </signature>        
         <signature>
           <template>
@@ -367,11 +391,10 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
           <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
         </signature>
         <signature>
@@ -380,12 +403,11 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
           <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
         </signature>        
         <signature>
           <template>
@@ -393,16 +415,14 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator1"/>
             <template-type-parameter name="U1"/>
             <template-type-parameter name="U2"/>
             <template-varargs/>
             <template-type-parameter name="UN"/>
-            <template-type-parameter name="Allocator2"/>
           </template>
           <type>void</type>
-          <parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator1&gt;&amp;</paramtype></parameter>
-          <parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN, Allocator2&gt;&amp;</paramtype></parameter>
+          <parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
+          <parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN&gt;&amp;</paramtype></parameter>
         </signature>
 
         <returns><simpara>True when <code>f</code> stores an object of
@@ -442,11 +462,10 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
           <parameter name="g"><paramtype>Functor</paramtype></parameter>
         </signature>
         <signature>
@@ -455,12 +474,11 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
           <parameter name="g"><paramtype>Functor</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
         </signature>        
         <signature>
           <template>
@@ -468,11 +486,10 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
           <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
         </signature>
         <signature>
@@ -481,12 +498,11 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
           <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
         </signature>        
         <signature>
           <template>
@@ -494,16 +510,14 @@
             <template-type-parameter name="T2"/>
             <template-varargs/>
             <template-type-parameter name="TN"/>
-            <template-type-parameter name="Allocator1"/>
             <template-type-parameter name="U1"/>
             <template-type-parameter name="U2"/>
             <template-varargs/>
             <template-type-parameter name="UN"/>
-            <template-type-parameter name="Allocator2"/>
           </template>
           <type>void</type>
-          <parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator1&gt;&amp;</paramtype></parameter>
-          <parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN, Allocator2&gt;&amp;</paramtype></parameter>
+          <parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN&gt;&amp;</paramtype></parameter>
+          <parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN&gt;&amp;</paramtype></parameter>
         </signature>
 
         <returns><simpara>True when <code>f</code> does not store an
@@ -543,11 +557,8 @@
       <template-type-parameter name="Signature">
         <purpose>Function type R (T1, T2, ..., TN)</purpose>
       </template-type-parameter>
-      <template-type-parameter name="Allocator">
-        <default><classname>std::allocator</classname>&lt;void&gt;</default>
-      </template-type-parameter>
     </template>
-    <inherit access="public"><classname>functionN</classname>&lt;R, T1, T2, ..., TN, Allocator&gt;</inherit>
+    <inherit access="public"><classname>functionN</classname>&lt;R, T1, T2, ..., TN&gt;</inherit>
 
     <purpose>A generalized function pointer that can be used for
     callbacks or wrapping function objects.</purpose>
@@ -569,7 +580,6 @@
     </description>
 
     <typedef name="result_type"><type>R</type></typedef>
-    <typedef name="allocator_type"><type>Allocator</type></typedef>
     <typedef name="argument_type">
       <type>T1</type><purpose>If N == 1</purpose>
     </typedef>
@@ -615,7 +625,16 @@
       <postconditions><simpara>Contains a copy of the <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
       <throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
     </constructor>
-
+        
+    <constructor>
+      <parameter name="f">
+        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
+      </parameter>
+      <requires><simpara>C++11 compatible compiler.</simpara></requires>
+      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
+      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
+    </constructor>
+    
     <constructor>
       <parameter name="f">
         <paramtype>const <classname>function</classname>&amp;</paramtype>
@@ -624,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"/>
@@ -633,6 +661,19 @@
       <postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-&gt;<methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
     </constructor>
 
+    <constructor>
+      <template>
+        <template-type-parameter name="F"/>
+        <template-type-parameter name="Allocator"/>
+      </template>
+      <parameter name="f"><paramtype>F</paramtype></parameter>
+      <parameter name="alloc"><paramtype>Allocator</paramtype></parameter>
+      <requires><simpara>F is a function object Callable from <code>this</code>, Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw.</simpara></requires>
+      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-&gt;<methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
+
+      <effects><simpara>If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory.</simpara></effects>
+    </constructor>
+
     <destructor>
       <effects><simpara>If <code>!this-&gt;<methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
 
@@ -640,10 +681,19 @@
 
     <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">
@@ -652,6 +702,15 @@
       <postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
       <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></throws>
     </copy-assignment>
+    
+    <copy-assignment>
+      <parameter name="f">
+        <paramtype><classname>function</classname>&amp;&amp;</paramtype>
+      </parameter>
+      <requires><simpara>C++11 compatible compiler.</simpara></requires>
+      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
+      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
+    </copy-assignment>
 
     <method-group name="modifiers">
       <method name="swap">
@@ -745,11 +804,10 @@
       <function name="swap">
         <template>
           <template-type-parameter name="Signature"/>
-          <template-type-parameter name="Allocator"/>
         </template>
         <type>void</type>
-        <parameter name="f1"><paramtype><classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
-        <parameter name="f2"><paramtype><classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+        <parameter name="f1"><paramtype><classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
+        <parameter name="f2"><paramtype><classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
         <effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
       </function>
     </free-function-group>
@@ -759,53 +817,47 @@
         <signature>
           <template>
             <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
           <parameter name="g"><paramtype>Functor</paramtype></parameter>
         </signature>
         <signature>
           <template>
             <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
           <parameter name="g"><paramtype>Functor</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
         </signature>        
         <signature>
           <template>
             <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
           <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
         </signature>
         <signature>
           <template>
             <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
           <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
         </signature>        
         <signature>
           <template>
             <template-type-parameter name="Signature1"/>
-            <template-type-parameter name="Allocator1"/>
             <template-type-parameter name="Signature2"/>
-            <template-type-parameter name="Allocator2"/>
           </template>
           <type>void</type>
-          <parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1, Allocator1&gt;&amp;</paramtype></parameter>
-          <parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2, Allocator2&gt;&amp;</paramtype></parameter>
+          <parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1&gt;&amp;</paramtype></parameter>
+          <parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2&gt;&amp;</paramtype></parameter>
         </signature>
 
         <returns><simpara>True when <code>f</code> stores an object of
@@ -840,53 +892,47 @@
         <signature>
           <template>
             <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
           <parameter name="g"><paramtype>Functor</paramtype></parameter>
         </signature>
         <signature>
           <template>
             <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
           <parameter name="g"><paramtype>Functor</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
         </signature>        
         <signature>
           <template>
             <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
           <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
         </signature>
         <signature>
           <template>
             <template-type-parameter name="Signature"/>
-            <template-type-parameter name="Allocator"/>
             <template-type-parameter name="Functor"/>
           </template>
           <type>bool</type>
           <parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
-          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
+          <parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature&gt;&amp;</paramtype></parameter>
         </signature>        
         <signature>
           <template>
             <template-type-parameter name="Signature1"/>
-            <template-type-parameter name="Allocator1"/>
             <template-type-parameter name="Signature2"/>
-            <template-type-parameter name="Allocator2"/>
           </template>
           <type>void</type>
-          <parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1, Allocator1&gt;&amp;</paramtype></parameter>
-          <parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2, Allocator2&gt;&amp;</paramtype></parameter>
+          <parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1&gt;&amp;</paramtype></parameter>
+          <parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2&gt;&amp;</paramtype></parameter>
         </signature>
 
         <returns><simpara>True when <code>f</code> does not store an

doc/tutorial.xml

@@ -35,12 +35,12 @@ form to use for your compiler.
         <row>
           <entry>
             <itemizedlist spacing="compact">
-              <listitem><simpara>GNU C++ 2.95.x, 3.0.x, 3.1.x</simpara></listitem>
+              <listitem><simpara>GNU C++ 2.95.x, 3.0.x and later versions</simpara></listitem>
               <listitem><simpara>Comeau C++ 4.2.45.2</simpara></listitem>
               <listitem><simpara>SGI MIPSpro 7.3.0</simpara></listitem>
               <listitem><simpara>Intel C++ 5.0, 6.0</simpara></listitem>
               <listitem><simpara>Compaq's cxx 6.2</simpara></listitem>
-	      <listitem><simpara>Microsoft Visual C++ 7.1</simpara></listitem>
+	      <listitem><simpara>Microsoft Visual C++ 7.1 and later versions</simpara></listitem>
             </itemizedlist>
           </entry>
           <entry>

example/Jamfile

@@ -0,0 +1,18 @@
+# Boost.Function Library example Jamfile
+#
+# Copyright (c) 2008 James E. King III
+#
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt
+
+require-b2 5.0.1 ;
+import-search /boost/config/checks ;
+import config : requires ;
+import testing ;
+
+project : requirements <library>/boost/function//boost_function ;
+
+run bind1st.cpp : : : [ requires cxx98_binders ] ;
+run int_div.cpp ;
+run sum_avg.cpp ;

include/boost/function.hpp

@@ -1,3 +1,6 @@
+#ifndef BOOST_FUNCTION_HPP_INCLUDED
+#define BOOST_FUNCTION_HPP_INCLUDED
+
 // Boost.Function library
 
 //  Copyright Douglas Gregor 2001-2003. Use, modification and
@@ -10,57 +13,6 @@
 // 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/function/function_template.hpp>
 
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/detail/workaround.hpp>
-
-#ifndef BOOST_FUNCTION_MAX_ARGS
-#  define BOOST_FUNCTION_MAX_ARGS 10
-#endif // BOOST_FUNCTION_MAX_ARGS
-
-// Include the prologue here so that the use of file-level iteration
-// in anything that may be included by function_template.hpp doesn't break
-#include <boost/function/detail/prologue.hpp>
-
-// Visual Age C++ doesn't handle the file iteration well
-#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
-#  if BOOST_FUNCTION_MAX_ARGS >= 0
-#    include <boost/function/function0.hpp>
-#  endif
-#  if BOOST_FUNCTION_MAX_ARGS >= 1
-#    include <boost/function/function1.hpp>
-#  endif
-#  if BOOST_FUNCTION_MAX_ARGS >= 2
-#    include <boost/function/function2.hpp>
-#  endif
-#  if BOOST_FUNCTION_MAX_ARGS >= 3
-#    include <boost/function/function3.hpp>
-#  endif
-#  if BOOST_FUNCTION_MAX_ARGS >= 4
-#    include <boost/function/function4.hpp>
-#  endif
-#  if BOOST_FUNCTION_MAX_ARGS >= 5
-#    include <boost/function/function5.hpp>
-#  endif
-#  if BOOST_FUNCTION_MAX_ARGS >= 6
-#    include <boost/function/function6.hpp>
-#  endif
-#  if BOOST_FUNCTION_MAX_ARGS >= 7
-#    include <boost/function/function7.hpp>
-#  endif
-#  if BOOST_FUNCTION_MAX_ARGS >= 8
-#    include <boost/function/function8.hpp>
-#  endif
-#  if BOOST_FUNCTION_MAX_ARGS >= 9
-#    include <boost/function/function9.hpp>
-#  endif
-#  if BOOST_FUNCTION_MAX_ARGS >= 10
-#    include <boost/function/function10.hpp>
-#  endif
-#else
-// What is the '3' for?
-#  define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_FUNCTION_MAX_ARGS,<boost/function/detail/function_iterate.hpp>))
-#  include BOOST_PP_ITERATE()
-#  undef BOOST_PP_ITERATION_PARAMS_1
-#endif
+#endif // #ifndef BOOST_FUNCTION_HPP_INCLUDED

include/boost/function/detail/function_iterate.hpp

@@ -1,16 +0,0 @@
-// Boost.Function library
-
-//  Copyright Douglas Gregor 2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org
-#if !defined(BOOST_PP_IS_ITERATING)
-# error Boost.Function - do not include this file!
-#endif
-
-#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
-#include <boost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
-

include/boost/function/detail/gen_maybe_include.pl

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

include/boost/function/detail/maybe_include.hpp

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

include/boost/function/detail/prologue.hpp

@@ -1,25 +0,0 @@
-// Boost.Function library
-
-//  Copyright Douglas Gregor 2002-2003. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-// For more information, see http://www.boost.org
-
-#ifndef BOOST_FUNCTION_PROLOGUE_HPP
-#define BOOST_FUNCTION_PROLOGUE_HPP
-#  include <cassert>
-#  include <algorithm>
-#  include <functional> // unary_function, binary_function
-#  include <boost/throw_exception.hpp>
-#  include <boost/config.hpp>
-#  include <boost/function/function_base.hpp>
-#  include <boost/mem_fn.hpp>
-#  include <boost/type_traits/is_integral.hpp>
-#  include <boost/preprocessor/enum.hpp>
-#  include <boost/preprocessor/enum_params.hpp>
-#  include <boost/preprocessor/cat.hpp>
-#  include <boost/preprocessor/repeat.hpp>
-#  include <boost/preprocessor/inc.hpp>
-#endif // BOOST_FUNCTION_PROLOGUE_HPP

include/boost/function/function0.hpp

@@ -7,6 +7,4 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 0
-#include <boost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#include <boost/function/function_template.hpp>

include/boost/function/function1.hpp

@@ -7,6 +7,4 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 1
-#include <boost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#include <boost/function/function_template.hpp>

include/boost/function/function10.hpp

@@ -7,6 +7,4 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 10
-#include <boost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#include <boost/function/function_template.hpp>

include/boost/function/function2.hpp

@@ -7,6 +7,4 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 2
-#include <boost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#include <boost/function/function_template.hpp>

include/boost/function/function3.hpp

@@ -7,6 +7,4 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 3
-#include <boost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#include <boost/function/function_template.hpp>

include/boost/function/function4.hpp

@@ -7,6 +7,4 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 4
-#include <boost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#include <boost/function/function_template.hpp>

include/boost/function/function5.hpp

@@ -7,6 +7,4 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 5
-#include <boost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#include <boost/function/function_template.hpp>

include/boost/function/function6.hpp

@@ -7,6 +7,4 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 6
-#include <boost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#include <boost/function/function_template.hpp>

include/boost/function/function7.hpp

@@ -7,6 +7,4 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 7
-#include <boost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#include <boost/function/function_template.hpp>

include/boost/function/function8.hpp

@@ -7,6 +7,4 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 8
-#include <boost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#include <boost/function/function_template.hpp>

include/boost/function/function9.hpp

@@ -7,6 +7,4 @@
 
 // For more information, see http://www.boost.org
 
-#define BOOST_FUNCTION_NUM_ARGS 9
-#include <boost/function/detail/maybe_include.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#include <boost/function/function_template.hpp>

include/boost/function/function_base.hpp

@@ -1,8 +1,9 @@
 // Boost.Function library
 
-//  Copyright Douglas Gregor 2001-2006. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  Copyright Douglas Gregor 2001-2006
+//  Copyright Emil Dotchevski 2007
+//  Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+//  (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 // For more information, see http://www.boost.org
@@ -10,110 +11,30 @@
 #ifndef BOOST_FUNCTION_BASE_HEADER
 #define BOOST_FUNCTION_BASE_HEADER
 
+#include <boost/function/function_fwd.hpp>
+#include <boost/function_equal.hpp>
+#include <boost/core/typeinfo.hpp>
+#include <boost/core/ref.hpp>
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
 #include <stdexcept>
 #include <string>
 #include <memory>
 #include <new>
-#include <typeinfo>
-#include <boost/config.hpp>
-#include <boost/assert.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/composite_traits.hpp>
-#include <boost/ref.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-#ifndef BOOST_NO_SFINAE
-#  include "boost/utility/enable_if.hpp"
-#else
-#  include "boost/mpl/bool.hpp"
-#endif
-#include <boost/function_equal.hpp>
+#include <type_traits>
 
 #if defined(BOOST_MSVC)
 #   pragma warning( push )
 #   pragma warning( disable : 4793 ) // complaint about native code generation
-#endif       
-
-// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
-#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
-// Embedded VC++ does not have type_info in namespace std
-#  define BOOST_FUNCTION_STD_NS
-#else
-#  define BOOST_FUNCTION_STD_NS std
+#   pragma warning( disable : 4127 ) // "conditional expression is constant"
 #endif
 
-// Borrowed from Boost.Python library: determines the cases where we
-// need to use std::type_info::name to compare instead of operator==.
-# if (defined(__GNUC__) && __GNUC__ >= 3) \
- || defined(_AIX) \
- || (   defined(__sgi) && defined(__host_mips))
-#  include <cstring>
-#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
-     (std::strcmp((X).name(),(Y).name()) == 0)
-# else
-#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
-#endif
+// retained because used in a test
+#define BOOST_FUNCTION_TARGET_FIX(x)
 
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
-#  define BOOST_FUNCTION_TARGET_FIX(x) x
-#else
-#  define BOOST_FUNCTION_TARGET_FIX(x)
-#endif // not MSVC
-
-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
-// Work around a compiler bug.
-// boost::python::objects::function has to be seen by the compiler before the
-// boost::function class template.
-namespace boost { namespace python { namespace objects {
-  class function;
-}}}
-#endif
-
-#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
- || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
- || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
-#  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
-#endif
-
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
-#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
-      typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
-                            (::boost::is_integral<Functor>::value)>::value), \
-                           Type>::type
-#else
-// BCC doesn't recognize this depends on a template argument and complains
-// about the use of 'typename'
-#  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)     \
-      ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
-                   (::boost::is_integral<Functor>::value)>::value), \
-                       Type>::type
-#endif
-
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-namespace boost {
-
-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
-// The library shipping with MIPSpro 7.3.1.3m has a broken allocator<void>
-class function_base;
-
-template<typename Signature,
-         typename Allocator = std::allocator<function_base> >
-class function;
-#else
-template<typename Signature, typename Allocator = std::allocator<void> >
-class function;
-#endif
-
-template<typename Signature, typename Allocator>
-inline void swap(function<Signature, Allocator>& f1,
-                 function<Signature, Allocator>& f2)
-{
-  f1.swap(f2);
-}
-
-} // end namespace boost
-#endif // have partial specialization
+#define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
+  typename std::enable_if< !std::is_integral<Functor>::value, Type>::type
 
 namespace boost {
   namespace detail {
@@ -126,17 +47,31 @@ 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
-        void* obj_ptr;
+        typedef void* obj_ptr_t;
+        mutable obj_ptr_t obj_ptr;
 
         // For pointers to std::type_info objects
-        // (get_functor_type_tag, check_functor_type_tag).
-        const void* const_obj_ptr;
+        struct type_t {
+          // (get_functor_type_tag, check_functor_type_tag).
+          const boost::core::typeinfo* type;
+
+          // Whether the type is const-qualified.
+          bool const_qualified;
+          // Whether the type is volatile-qualified.
+          bool volatile_qualified;
+        } type;
 
         // For function pointers of all kinds
-        mutable void (*func_ptr)();
+        typedef void (*func_ptr_t)();
+        mutable func_ptr_t func_ptr;
+
+#if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
+# pragma warning(push)
+# pragma warning(disable: 5243)
+#endif
 
         // For bound member pointers
         struct bound_memfunc_ptr_t {
@@ -144,37 +79,32 @@ namespace boost {
           void* obj_ptr;
         } bound_memfunc_ptr;
 
+#if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
+# pragma warning(pop)
+#endif
+
+        // For references to function objects. We explicitly keep
+        // track of the cv-qualifiers on the object referenced.
+        struct obj_ref_t {
+          mutable void* obj_ptr;
+          bool is_const_qualified;
+          bool is_volatile_qualified;
+        } obj_ref;
+      };
+
+      union BOOST_SYMBOL_VISIBLE function_buffer
+      {
+        // Type-specific union members
+        mutable function_buffer_members members;
+
         // To relax aliasing constraints
-        mutable char data;
-      };
-
-      /**
-       * The unusable class is a placeholder for unused function arguments
-       * It is also completely unusable except that it constructable from
-       * anything. This helps compilers without partial specialization to
-       * handle Boost.Function objects returning void.
-       */
-      struct unusable
-      {
-        unusable() {}
-        template<typename T> unusable(const T&) {}
-      };
-
-      /* Determine the return type. This supports compilers that do not support
-       * void returns or partial specialization by silently changing the return
-       * type to "unusable".
-       */
-      template<typename T> struct function_return_type { typedef T type; };
-
-      template<>
-      struct function_return_type<void>
-      {
-        typedef unusable type;
+        mutable char data[sizeof(function_buffer_members)];
       };
 
       // The operation type to perform on the given functor/function pointer
       enum functor_manager_operation_type {
         clone_functor_tag,
+        move_functor_tag,
         destroy_functor_tag,
         check_functor_type_tag,
         get_functor_type_tag
@@ -189,15 +119,15 @@ namespace boost {
       template<typename F>
       class get_function_tag
       {
-        typedef typename mpl::if_c<(is_pointer<F>::value),
+        typedef typename std::conditional<std::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 std::conditional<std::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 std::conditional<is_reference_wrapper<F>::value,
                                    function_obj_ref_tag,
                                    ptr_or_obj_or_mem_tag>::type or_ref_tag;
 
@@ -211,34 +141,42 @@ namespace boost {
       struct reference_manager
       {
         static inline void
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op)
         {
           switch (op) {
-          case clone_functor_tag: 
-            out_buffer.obj_ptr = in_buffer.obj_ptr;
+          case clone_functor_tag:
+            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
+            return;
+
+          case move_functor_tag:
+            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
+            in_buffer.members.obj_ref.obj_ptr = 0;
             return;
 
           case destroy_functor_tag:
-            out_buffer.obj_ptr = 0;
+            out_buffer.members.obj_ref.obj_ptr = 0;
             return;
 
           case check_functor_type_tag:
             {
-              // DPG TBD: Since we're only storing a pointer, it's
-              // possible that the user could ask for a base class or
-              // derived class. Is that okay?
-              const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-                *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
-                out_buffer.obj_ptr = in_buffer.obj_ptr;
+              // Check whether we have the same type. We can add
+              // cv-qualifiers, but we can't take them away.
+              if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(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.const_obj_ptr = &typeid(F);
+            out_buffer.members.type.type = &BOOST_CORE_TYPEID(F);
+            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;
           }
         }
@@ -252,121 +190,148 @@ namespace boost {
       struct function_allows_small_object_optimization
       {
         BOOST_STATIC_CONSTANT
-          (bool, 
+          (bool,
            value = ((sizeof(F) <= sizeof(function_buffer) &&
-                     (alignment_of<function_buffer>::value 
-                      % alignment_of<F>::value == 0))));
+                     (std::alignment_of<function_buffer>::value
+                      % std::alignment_of<F>::value == 0))));
+      };
+
+      template <typename F,typename A>
+      struct functor_wrapper: public F, public A
+      {
+        functor_wrapper( F f, A a ):
+          F(f),
+          A(a)
+        {
+        }
+
+        functor_wrapper(const functor_wrapper& f) :
+          F(static_cast<const F&>(f)),
+          A(static_cast<const A&>(f))
+        {
+        }
       };
 
       /**
        * The functor_manager class contains a static function "manage" which
        * can clone or destroy the given function/function object pointer.
        */
-      template<typename Functor, typename Allocator>
-      struct functor_manager
+      template<typename Functor>
+      struct functor_manager_common
       {
-      private:
         typedef Functor functor_type;
 
-        // For function pointers, the manager is trivial
+        // Function pointers
         static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
-                functor_manager_operation_type op, function_ptr_tag)
+        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op)
         {
           if (op == clone_functor_tag)
-            out_buffer.func_ptr = in_buffer.func_ptr;
-          else if (op == destroy_functor_tag)
-            out_buffer.func_ptr = 0;
-          else /* op == check_functor_type_tag */ {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
-              out_buffer.obj_ptr = &in_buffer.func_ptr;
+            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
+          else if (op == move_functor_tag) {
+            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
+            in_buffer.members.func_ptr = 0;
+          } else if (op == destroy_functor_tag)
+            out_buffer.members.func_ptr = 0;
+          else if (op == check_functor_type_tag) {
+            if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(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.members.type.type = &BOOST_CORE_TYPEID(Functor);
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
           }
         }
 
         // 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_)
+        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op)
         {
           if (op == clone_functor_tag) {
-            const functor_type* in_functor = 
-              reinterpret_cast<const functor_type*>(&in_buffer.data);
-            new ((void*)&out_buffer.data) functor_type(*in_functor);
+            const functor_type* in_functor =
+              reinterpret_cast<const functor_type*>(in_buffer.data);
+            new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor);
+
+          } else if (op == move_functor_tag) {
+              functor_type* f = reinterpret_cast<functor_type*>(in_buffer.data);
+              new (reinterpret_cast<void*>(out_buffer.data)) functor_type(std::move(*f));
+              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();
-          } else /* op == check_functor_type_tag */ {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
-              out_buffer.obj_ptr = &in_buffer.data;
+             functor_type* f = reinterpret_cast<functor_type*>(out_buffer.data);
+             (void)f; // suppress warning about the value of f not being used (MSVC)
+             f->~Functor();
+          } else if (op == check_functor_type_tag) {
+             if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(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.members.type.type = &BOOST_CORE_TYPEID(Functor);
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
           }
         }
-        
+      };
+
+      template<typename Functor>
+      struct functor_manager
+      {
+      private:
+        typedef Functor functor_type;
+
+        // Function pointers
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_ptr_tag)
+        {
+          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
+        }
+
+        // Function objects that fit in the small-object buffer.
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, std::true_type)
+        {
+          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
+        }
+
         // Function objects that require heap allocation
         static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
-                functor_manager_operation_type op, mpl::false_)
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, std::false_type)
         {
-#ifndef BOOST_NO_STD_ALLOCATOR
-          typedef typename Allocator::template rebind<functor_type>::other
-            allocator_type;
-          typedef typename allocator_type::pointer pointer_type;
-#else
-          typedef functor_type* pointer_type;
-#endif // BOOST_NO_STD_ALLOCATOR
-
-#  ifndef BOOST_NO_STD_ALLOCATOR
-          allocator_type allocator;
-#  endif // BOOST_NO_STD_ALLOCATOR
-
           if (op == clone_functor_tag) {
+            // 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);
-
-            // Clone the functor
-#  ifndef BOOST_NO_STD_ALLOCATOR
-            pointer_type copy = allocator.allocate(1);
-            allocator.construct(copy, *f);
-
-            // Get back to the original pointer type
-            functor_type* new_f = static_cast<functor_type*>(copy);
-#  else
+              static_cast<const functor_type*>(in_buffer.members.obj_ptr);
             functor_type* new_f = new functor_type(*f);
-#  endif // BOOST_NO_STD_ALLOCATOR
-            out_buffer.obj_ptr = new_f;
+            out_buffer.members.obj_ptr = new_f;
+          } else if (op == move_functor_tag) {
+            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            in_buffer.members.obj_ptr = 0;
           } else if (op == destroy_functor_tag) {
             /* Cast from the void pointer to the functor pointer type */
             functor_type* f =
-              static_cast<functor_type*>(out_buffer.obj_ptr);
-
-#  ifndef BOOST_NO_STD_ALLOCATOR
-            /* Cast from the functor pointer type to the allocator's pointer
-               type */
-            pointer_type victim = static_cast<pointer_type>(f);
-
-            // Destroy and deallocate the functor
-            allocator.destroy(victim);
-            allocator.deallocate(victim, 1);
-#  else
+              static_cast<functor_type*>(out_buffer.members.obj_ptr);
             delete f;
-#  endif // BOOST_NO_STD_ALLOCATOR
-            out_buffer.obj_ptr = 0;
-          } else /* op == check_functor_type_tag */ {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
-              out_buffer.obj_ptr = in_buffer.obj_ptr;
+            out_buffer.members.obj_ptr = 0;
+          } else if (op == check_functor_type_tag) {
+            if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(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.members.type.type = &BOOST_CORE_TYPEID(Functor);
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
           }
         }
 
@@ -374,38 +339,132 @@ namespace boost {
         // object can use the small-object optimization buffer or
         // whether we need to allocate it on the heap.
         static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                 functor_manager_operation_type op, function_obj_tag)
         {
           manager(in_buffer, out_buffer, op,
-                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+                  std::integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
         }
 
-        // For member pointers, we treat them as function objects with
-        // the small-object optimization always enabled.
+        // For member pointers, we use the small-object optimization buffer.
         static inline void
-        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                 functor_manager_operation_type op, member_ptr_tag)
         {
-          manager(in_buffer, out_buffer, op, mpl::true_());
+          manager(in_buffer, out_buffer, op, std::true_type());
         }
 
       public:
         /* Dispatch to an appropriate manager based on whether we have a
            function pointer or a function object pointer. */
         static inline void
-        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op)
         {
           typedef typename get_function_tag<functor_type>::type tag_type;
-          switch (op) {
-          case get_functor_type_tag:
-            out_buffer.const_obj_ptr = &typeid(functor_type);
-            return;
-
-          default:
+          if (op == get_functor_type_tag) {
+            out_buffer.members.type.type = &BOOST_CORE_TYPEID(functor_type);
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
+          } else {
+            manager(in_buffer, out_buffer, op, tag_type());
+          }
+        }
+      };
+
+      template<typename Functor, typename Allocator>
+      struct functor_manager_a
+      {
+      private:
+        typedef Functor functor_type;
+
+        // Function pointers
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_ptr_tag)
+        {
+          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
+        }
+
+        // Function objects that fit in the small-object buffer.
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, std::true_type)
+        {
+          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
+        }
+
+        // Function objects that require heap allocation
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, std::false_type)
+        {
+          typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
+
+          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;
+
+          if (op == clone_functor_tag) {
+            // Clone the functor
+            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
+            // can't do the static_cast that we should do.
+            const functor_wrapper_type* f =
+              static_cast<const functor_wrapper_type*>(in_buffer.members.obj_ptr);
+            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
+            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+            std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, *f);
+
+            // Get back to the original pointer type
+            functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+            out_buffer.members.obj_ptr = new_f;
+          } else if (op == move_functor_tag) {
+            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            in_buffer.members.obj_ptr = 0;
+          } else if (op == destroy_functor_tag) {
+            /* Cast from the void pointer to the functor_wrapper_type */
+            functor_wrapper_type* victim =
+              static_cast<functor_wrapper_type*>(in_buffer.members.obj_ptr);
+            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
+            std::allocator_traits<wrapper_allocator_type>::destroy(wrapper_allocator, victim);
+            wrapper_allocator.deallocate(victim,1);
+            out_buffer.members.obj_ptr = 0;
+          } else if (op == check_functor_type_tag) {
+            if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor))
+              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            else
+              out_buffer.members.obj_ptr = 0;
+          } else /* op == get_functor_type_tag */ {
+            out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor);
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
+          }
+        }
+
+        // For function objects, we determine whether the function
+        // object can use the small-object optimization buffer or
+        // whether we need to allocate it on the heap.
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_obj_tag)
+        {
+          manager(in_buffer, out_buffer, op,
+                  std::integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
+        }
+
+      public:
+        /* Dispatch to an appropriate manager based on whether we have a
+           function pointer or a function object pointer. */
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+               functor_manager_operation_type op)
+        {
+          typedef typename get_function_tag<functor_type>::type tag_type;
+          if (op == get_functor_type_tag) {
+            out_buffer.members.type.type = &BOOST_CORE_TYPEID(functor_type);
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
+          } else {
             manager(in_buffer, out_buffer, op, tag_type());
-            return;
           }
         }
       };
@@ -413,73 +472,14 @@ namespace boost {
       // A type that is only used for comparisons against zero
       struct useless_clear_type {};
 
-#ifdef BOOST_NO_SFINAE
-      // These routines perform comparisons between a Boost.Function
-      // object and an arbitrary function object (when the last
-      // parameter is mpl::bool_<false>) or against zero (when the
-      // last parameter is mpl::bool_<true>). They are only necessary
-      // for compilers that don't support SFINAE.
-      template<typename Function, typename Functor>
-        bool
-        compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
-        { return f.empty(); }
-
-      template<typename Function, typename Functor>
-        bool
-        compare_not_equal(const Function& f, const Functor&, int,
-                          mpl::bool_<true>)
-        { return !f.empty(); }
-
-      template<typename Function, typename Functor>
-        bool
-        compare_equal(const Function& f, const Functor& g, long,
-                      mpl::bool_<false>)
-        {
-          if (const Functor* fp = f.template target<Functor>())
-            return function_equal(*fp, g);
-          else return false;
-        }
-
-      template<typename Function, typename Functor>
-        bool
-        compare_equal(const Function& f, const reference_wrapper<Functor>& g,
-                      int, mpl::bool_<false>)
-        {
-          if (const Functor* fp = f.template target<Functor>())
-            return fp == g.get_pointer();
-          else return false;
-        }
-
-      template<typename Function, typename Functor>
-        bool
-        compare_not_equal(const Function& f, const Functor& g, long,
-                          mpl::bool_<false>)
-        {
-          if (const Functor* fp = f.template target<Functor>())
-            return !function_equal(*fp, g);
-          else return true;
-        }
-
-      template<typename Function, typename Functor>
-        bool
-        compare_not_equal(const Function& f,
-                          const reference_wrapper<Functor>& g, int,
-                          mpl::bool_<false>)
-        {
-          if (const Functor* fp = f.template target<Functor>())
-            return fp != g.get_pointer();
-          else return true;
-        }
-#endif // BOOST_NO_SFINAE
-
       /**
        * Stores the "manager" portion of the vtable for a
        * boost::function object.
        */
       struct vtable_base
       {
-        void (*manager)(const function_buffer& in_buffer, 
-                        function_buffer& out_buffer, 
+        void (*manager)(const function_buffer& in_buffer,
+                        function_buffer& out_buffer,
                         functor_manager_operation_type op);
       };
     } // end namespace function
@@ -499,15 +499,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 typeid(void)
+  /** Retrieve the type of the stored function object, or type_id<void>()
       if this is empty. */
-  const BOOST_FUNCTION_STD_NS::type_info& target_type() const
+  const boost::core::typeinfo& target_type() const
   {
-    if (!vtable) return typeid(void);
+    if (!vtable) return BOOST_CORE_TYPEID(void);
 
     detail::function::function_buffer type;
-    vtable->manager(functor, type, detail::function::get_functor_type_tag);
-    return *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(type.const_obj_ptr);
+    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
+    return *type.members.type.type;
   }
 
   template<typename Functor>
@@ -516,38 +516,35 @@ public:
       if (!vtable) return 0;
 
       detail::function::function_buffer type_result;
-      type_result.const_obj_ptr = &typeid(Functor);
-      vtable->manager(functor, type_result, 
+      type_result.members.type.type = &BOOST_CORE_TYPEID(Functor);
+      type_result.members.type.const_qualified = std::is_const<Functor>::value;
+      type_result.members.type.volatile_qualified = std::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.const_obj_ptr = &typeid(Functor);
-      vtable->manager(functor, type_result, 
+      type_result.members.type.type = &BOOST_CORE_TYPEID(Functor);
+      type_result.members.type.const_qualified = true;
+      type_result.members.type.volatile_qualified = std::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
+    typename std::enable_if< !std::is_function<F>::value, bool >::type
+    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 {
@@ -555,45 +552,50 @@ public:
       }
     }
 
-#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
-  // GCC 3.3 and newer cannot copy with the global operator==, due to
-  // problems with instantiation of function return types before it
-  // has been verified that the argument types match up.
-  template<typename Functor>
-    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
-    operator==(Functor g) const
+  template<typename Fn>
+    typename std::enable_if< std::is_function<Fn>::value, bool >::type
+    contains(Fn& f) const
     {
-      if (const Functor* fp = target<Functor>())
-        return function_equal(*fp, g);
-      else return false;
+      typedef Fn* F;
+      if (const F* fp = this->template target<F>())
+      {
+        return function_equal(*fp, &f);
+      } else {
+        return false;
+      }
     }
 
-  template<typename Functor>
-    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
-    operator!=(Functor g) const
-    {
-      if (const Functor* fp = target<Functor>())
-        return !function_equal(*fp, g);
-      else return true;
-    }
-#endif
-
 public: // should be protected, but GCC 2.95.3 will fail to allow access
-  const detail::function::vtable_base* vtable;
+  detail::function::vtable_base* get_vtable() const {
+    return reinterpret_cast<detail::function::vtable_base*>(
+             reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+  }
+
+  bool has_trivial_copy_and_destroy() const {
+    return reinterpret_cast<std::size_t>(vtable) & 0x01;
+  }
+
+  detail::function::vtable_base* vtable;
   mutable detail::function::function_buffer functor;
 };
 
+#if defined(BOOST_CLANG)
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
 /**
  * The bad_function_call exception class is thrown when a boost::function
  * object is invoked
  */
-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,
                        detail::function::useless_clear_type*)
 {
@@ -617,43 +619,10 @@ inline bool operator!=(detail::function::useless_clear_type*,
 {
   return !f.empty();
 }
-#endif
 
-#ifdef BOOST_NO_SFINAE
-// Comparisons between boost::function objects and arbitrary function objects
-template<typename Functor>
-  inline bool operator==(const function_base& f, Functor g)
-  {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
-    return detail::function::compare_equal(f, g, 0, integral());
-  }
-
-template<typename Functor>
-  inline bool operator==(Functor g, const function_base& f)
-  {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
-    return detail::function::compare_equal(f, g, 0, integral());
-  }
-
-template<typename Functor>
-  inline bool operator!=(const function_base& f, Functor g)
-  {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
-    return detail::function::compare_not_equal(f, g, 0, integral());
-  }
-
-template<typename Functor>
-  inline bool operator!=(Functor g, const function_base& f)
-  {
-    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
-    return detail::function::compare_not_equal(f, g, 0, integral());
-  }
-#else
-
-#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
 // Comparisons between boost::function objects and arbitrary function
-// objects. GCC 3.3 and before has an obnoxious bug that prevents this
-// from working.
+// objects.
+
 template<typename Functor>
   BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
   operator==(const function_base& f, Functor g)
@@ -689,7 +658,6 @@ template<typename Functor>
       return !function_equal(g, *fp);
     else return true;
   }
-#  endif
 
 template<typename Functor>
   BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
@@ -727,8 +695,6 @@ template<typename Functor>
     else return true;
   }
 
-#endif // Compiler supporting SFINAE
-
 namespace detail {
   namespace function {
     inline bool has_empty_target(const function_base* f)
@@ -752,10 +718,9 @@ namespace detail {
 } // end namespace boost
 
 #undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
-#undef BOOST_FUNCTION_COMPARE_TYPE_ID
 
 #if defined(BOOST_MSVC)
 #   pragma warning( pop )
-#endif       
+#endif
 
 #endif // BOOST_FUNCTION_BASE_HEADER

include/boost/function/function_fwd.hpp

@@ -0,0 +1,64 @@
+// Boost.Function library
+//  Copyright (C) Douglas Gregor 2008
+//
+//  Use, modification and distribution is subject to the Boost
+//  Software License, Version 1.0.  (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org
+#ifndef BOOST_FUNCTION_FWD_HPP
+#define BOOST_FUNCTION_FWD_HPP
+#include <boost/config.hpp>
+
+namespace boost {
+  class bad_function_call;
+
+  // Preferred syntax
+  template<typename Signature> class function;
+
+  template<typename Signature>
+  inline void swap(function<Signature>& f1, function<Signature>& f2)
+  {
+    f1.swap(f2);
+  }
+
+  // Portable syntax
+  template<typename R, typename... T> class function_n;
+
+  template<typename R, typename... T> using function0 = function_n<R, T...>;
+  template<typename R, typename... T> using function1 = function_n<R, T...>;
+  template<typename R, typename... T> using function2 = function_n<R, T...>;
+  template<typename R, typename... T> using function3 = function_n<R, T...>;
+  template<typename R, typename... T> using function4 = function_n<R, T...>;
+  template<typename R, typename... T> using function5 = function_n<R, T...>;
+  template<typename R, typename... T> using function6 = function_n<R, T...>;
+  template<typename R, typename... T> using function7 = function_n<R, T...>;
+  template<typename R, typename... T> using function8 = function_n<R, T...>;
+  template<typename R, typename... T> using function9 = function_n<R, T...>;
+
+  template<typename R, typename... T> using function10 = function_n<R, T...>;
+  template<typename R, typename... T> using function11 = function_n<R, T...>;
+  template<typename R, typename... T> using function12 = function_n<R, T...>;
+  template<typename R, typename... T> using function13 = function_n<R, T...>;
+  template<typename R, typename... T> using function14 = function_n<R, T...>;
+  template<typename R, typename... T> using function15 = function_n<R, T...>;
+  template<typename R, typename... T> using function16 = function_n<R, T...>;
+  template<typename R, typename... T> using function17 = function_n<R, T...>;
+  template<typename R, typename... T> using function18 = function_n<R, T...>;
+  template<typename R, typename... T> using function19 = function_n<R, T...>;
+
+  template<typename R, typename... T> using function20 = function_n<R, T...>;
+  template<typename R, typename... T> using function21 = function_n<R, T...>;
+  template<typename R, typename... T> using function22 = function_n<R, T...>;
+  template<typename R, typename... T> using function23 = function_n<R, T...>;
+  template<typename R, typename... T> using function24 = function_n<R, T...>;
+  template<typename R, typename... T> using function25 = function_n<R, T...>;
+  template<typename R, typename... T> using function26 = function_n<R, T...>;
+  template<typename R, typename... T> using function27 = function_n<R, T...>;
+  template<typename R, typename... T> using function28 = function_n<R, T...>;
+  template<typename R, typename... T> using function29 = function_n<R, T...>;
+
+  template<typename R, typename... T> using function30 = function_n<R, T...>;
+}
+
+#endif

include/boost/function/function_typeof.hpp

@@ -0,0 +1,15 @@
+// Boost.Function library - Typeof support
+//  Copyright (C) Douglas Gregor 2008
+//
+//  Use, modification and distribution is subject to the Boost
+//  Software License, Version 1.0.  (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org
+#ifndef BOOST_FUNCTION_TYPEOF_HPP
+#define BOOST_FUNCTION_TYPEOF_HPP
+#include <boost/function/function_fwd.hpp>
+
+// This header is no longer necessary and is only retained for compatibility
+
+#endif

include/boost/function/gen_function_N.pl

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

meta/libraries.json

@@ -0,0 +1,19 @@
+{
+    "key": "function",
+    "name": "Function",
+    "authors": [
+        "Doug Gregor"
+    ],
+    "description": "Function object wrappers for deferred calls or callbacks.",
+    "std": [
+        "tr1"
+    ],
+    "category": [
+        "Function-objects",
+        "Programming"
+    ],
+    "maintainers": [
+        "Peter Dimov <pdimov -at- gmail.com>"
+    ],
+    "cxxstd": "11"
+}

test/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright 2018, 2019 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
+
+if(HAVE_BOOST_TEST)
+
+boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::function Boost::core Boost::lambda)
+
+endif()

test/Jamfile.v2

@@ -7,57 +7,89 @@
 
 # For more information, see http://www.boost.org/
 
-project
-    : source-location $(BOOST_ROOT)
-    ;
-
-# bring in rules for testing
 import testing ;
 
-{
+project
+  : default-build
+    <warnings>extra
+  : requirements
+    <toolset>msvc:<warnings-as-errors>on
+    <toolset>gcc:<warnings-as-errors>on
+    <toolset>clang:<warnings-as-errors>on
+    <library>/boost/function//boost_function
+    <library>/boost/typeof//boost_typeof
+  ;
 
-  test-suite function
-    : 
-  [ run libs/function/test/function_test.cpp :  :  :  : lib_function_test ]
+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,<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
+  : : : <library>/boost/lambda//boost_lambda ;
+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
+  : : : <library>/boost/move//boost_move ;
+compile function_typeof_test.cpp
+  : <cxxstd>03:<build>no <cxxstd>98:<build>no <cxxstd>0x:<build>no ;
+run result_arg_types_test.cpp ;
+run result_arg_n_types_test.cpp ;
 
-  [ run libs/function/test/function_n_test.cpp :  :  :  :  ]
+lib throw_bad_function_call : throw_bad_function_call.cpp : <link>shared:<define>THROW_BAD_FUNCTION_CALL_DYN_LINK=1 ;
 
-  [ run libs/function/test/allocator_test.cpp ../../../libs/test/build//boost_test_exec_monitor :  :  :  :  ]
+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/stateless_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/lambda_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 ;
 
-  [ 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 :  :  :  :  ]
+local check14 = [ check-target-builds mixed_cxxstd/<cxxstd>14 : : <build>no ] ;
 
-  [ compile libs/function/test/function_30.cpp :  :  :  :  ] 
+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 ;
 
-  [ run libs/function/test/function_arith_cxx98.cpp :  :  :  :  ]
+lib return_function : return_function.cpp : <link>shared:<define>RETURN_FUNCTION_DYN_LINK=1 ;
 
-  [ run libs/function/test/function_arith_portable.cpp :  :  :  :  ]
+run test_return_function.cpp return_function : : : <link>shared : return_function_shared ;
+run test_return_function.cpp return_function : : : <link>static : return_function_static ;
 
-  [ run libs/function/test/sum_avg_cxx98.cpp :  :  :  :  ]
+run test_return_function.cpp return_function/<cxxstd>0x : : : <link>shared : return_function_shared_0x ;
+run test_return_function.cpp return_function/<cxxstd>0x : : : <link>static : return_function_static_0x ;
 
-  [ run libs/function/test/sum_avg_portable.cpp :  :  :  :  ]
+run test_return_function.cpp return_function/<cxxstd>14 : : : <link>shared $(check14) : return_function_shared_14 ;
+run test_return_function.cpp return_function/<cxxstd>14 : : : <link>static $(check14) : return_function_static_14 ;
 
-  [ run libs/function/test/mem_fun_cxx98.cpp :  :  :  :  ]
+run quick.cpp ;
 
-  [ run libs/function/test/mem_fun_portable.cpp :  :  :  :  ]
+compile issue_42.cpp ;
 
-  [ run libs/function/test/std_bind_cxx98.cpp :  :  :  :  ]
+run fn_eq_bind_test.cpp ;
 
-  [ run libs/function/test/std_bind_portable.cpp :  :  :  :  ]
+# /usr/include/c++/4.4/bits/shared_ptr.h:146: error: cannot use typeid with -fno-rtti
+run contains_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : contains_test_no_rtti ;
+run contains2_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : contains2_test_no_rtti ;
 
-  [ 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 contains3_test.cpp ;
+run contains3_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : contains3_test_no_rtti ;

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;
@@ -27,6 +27,14 @@ struct counting_allocator : public std::allocator<T>
     typedef counting_allocator<U> other;
   };
 
+  counting_allocator()
+  {
+  }
+
+  template<typename U>
+  counting_allocator( counting_allocator<U> )
+  {
+  }
 
   T* allocate(std::size_t n)
   {
@@ -41,54 +49,88 @@ struct counting_allocator : public std::allocator<T>
   }
 };
 
-struct plus_int
+struct enable_small_object_optimization
+{
+};
+
+struct disable_small_object_optimization
+{
+  int unused_state_data[32];
+};
+
+template <typename base>
+struct plus_int: base
 {
   int operator()(int x, int y) const { return x + y; }
-
-  int unused_state_data[32];
 };
 
 static int do_minus(int x, int y) { return x-y; }
 
-struct DoNothing
+template <typename base>
+struct DoNothing: base
 {
   void operator()() const {}
-
-  int unused_state_data[32];
 };
 
 static void do_nothing() {}
 
-int
-test_main(int, char*[])
+int main()
 {
-  function2<int, int, int, counting_allocator<int> > f;
-  f = plus_int();
+  function2<int, int, int> f;
+  f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<int>() );
   f.clear();
-  BOOST_CHECK(alloc_count == 1);
-  BOOST_CHECK(dealloc_count == 1);
-
+  BOOST_TEST_EQ( alloc_count, 1 );
+  BOOST_TEST_EQ( dealloc_count, 1 );
   alloc_count = 0;
   dealloc_count = 0;
-  f = &do_minus;
+  f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
+  f.clear();
+  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>() );
   f.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
-
-  function0<void, counting_allocator<int> > fv;
-  alloc_count = 0;
-  dealloc_count = 0;
-  fv = DoNothing();
-  fv.clear();
-  BOOST_CHECK(alloc_count == 1);
-  BOOST_CHECK(dealloc_count == 1);
 
   alloc_count = 0;
   dealloc_count = 0;
-  fv = &do_nothing;
-  fv.clear();
-  BOOST_CHECK(alloc_count == 0);
-  BOOST_CHECK(dealloc_count == 0);
+  f.assign( &do_minus, counting_allocator<int>() );
+  f.clear();
+  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_TEST_EQ( dealloc_count, 0 );
+  f.assign( &do_minus, std::allocator<int>() );
+  f.clear();
 
-  return 0;
+  function0<void> fv;
+  alloc_count = 0;
+  dealloc_count = 0;
+  fv.assign( DoNothing<disable_small_object_optimization>(), counting_allocator<int>() );
+  fv.clear();
+  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_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>() );
+  fv.clear();
+
+  alloc_count = 0;
+  dealloc_count = 0;
+  fv.assign( &do_nothing, counting_allocator<int>() );
+  fv.clear();
+  BOOST_TEST_EQ( alloc_count, 0 );
+  BOOST_TEST_EQ( dealloc_count, 0 );
+  fv.assign( &do_nothing, std::allocator<int>() );
+  fv.clear();
+  
+  function0<void> fv2;
+  fv.assign(&do_nothing, std::allocator<int>() );
+  fv2.assign(fv, std::allocator<int>() );
+
+  return boost::report_errors();
 }

test/cmake_install_test/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Copyright 2018, 2019 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(cmake_install_test LANGUAGES CXX)
+
+find_package(boost_function REQUIRED)
+
+add_executable(main main.cpp)
+target_link_libraries(main Boost::function)
+
+enable_testing()
+add_test(main main)
+
+add_custom_target(check VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/cmake_install_test/main.cpp

@@ -0,0 +1,22 @@
+// Copyright 2017, 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+// See library home page at http://www.boost.org/libs/function
+
+#include <boost/function.hpp>
+#include <cassert>
+
+#define BOOST_TEST(expr) assert(expr)
+#define BOOST_TEST_EQ(x1, x2) assert((x1)==(x2))
+
+int add( int x, int y )
+{
+    return x + y;
+}
+
+int main()
+{
+    boost::function<int(int, int)> fn( &add );
+    BOOST_TEST_EQ( fn( 1, 2 ), 3 );
+}

test/cmake_subdir_test/CMakeLists.txt

@@ -0,0 +1,40 @@
+# Copyright 2018, 2019 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.20)
+
+project(cmake_subdir_test LANGUAGES CXX)
+
+add_subdirectory(../.. boostorg/function)
+
+set(deps
+
+# Primary dependencies
+
+assert
+bind
+config
+core
+throw_exception
+
+# Secondary dependencies
+
+static_assert
+)
+
+foreach(dep IN LISTS deps)
+
+  add_subdirectory(../../../${dep} boostorg/${dep})
+
+endforeach()
+
+# --target check
+
+add_executable(quick ../quick.cpp)
+target_link_libraries(quick Boost::function Boost::core)
+
+enable_testing()
+add_test(quick quick)
+
+add_custom_target(check VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/contains2_test.cpp

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

test/contains3_test.cpp

@@ -0,0 +1,33 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+static int f()
+{
+    return 1;
+}
+
+static int g()
+{
+    return 2;
+}
+
+int main()
+{
+    {
+        boost::function<int()> fn;
+        BOOST_TEST( !fn.contains( f ) );
+        BOOST_TEST( !fn.contains( g ) );
+    }
+
+    {
+        boost::function<int()> fn( f );
+        BOOST_TEST( fn.contains( f ) );
+        BOOST_TEST( !fn.contains( g ) );
+    }
+
+    return boost::report_errors();
+}

test/contains_test.cpp

@@ -5,10 +5,12 @@
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/test/minimal.hpp>
 #include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/ref.hpp>
 
+#define BOOST_CHECK BOOST_TEST
+
 static int forty_two() { return 42; }
 
 struct Seventeen
@@ -31,7 +33,7 @@ bool operator==(const ReturnInt& x, const ReturnInt& y)
 bool operator!=(const ReturnInt& x, const ReturnInt& y)
 { return x.value != y.value; }
 
-namespace contain_test {
+namespace contains_test {
 
 struct ReturnIntFE
 {
@@ -42,34 +44,10 @@ struct ReturnIntFE
   int value;
 };
 
-}
-
-#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-
-namespace contain_test {
-# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 bool function_equal(const ReturnIntFE& x, const ReturnIntFE& y)
 { return x.value == y.value; }
-# else
-bool function_equal_impl(const ReturnIntFE& x, const ReturnIntFE& y, int)
-{ return x.value == y.value; }
-# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-}
-#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-namespace boost {
-# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-bool 
-function_equal(const contain_test::ReturnIntFE& x, 
-               const contain_test::ReturnIntFE& y)
-{ return x.value == y.value; }
-# else
-bool 
-function_equal_impl(const contain_test::ReturnIntFE& x, 
-                    const contain_test::ReturnIntFE& y, int)
-{ return x.value == y.value; }
-# endif
-}
-#endif
+
+} // namespace contains_test
 
 static void target_test()
 {
@@ -88,6 +66,15 @@ static void target_test()
   BOOST_CHECK(!f.target<int (*)()>());
   BOOST_CHECK(f.target<Seventeen>());
   BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);
+
+  const Seventeen const_seventeen = this_seventeen;
+  f = boost::ref(const_seventeen);
+  BOOST_CHECK(!f.target<int (*)()>());
+  BOOST_CHECK(f.target<const Seventeen>());
+  BOOST_CHECK(f.target<const Seventeen>() == &const_seventeen);
+  BOOST_CHECK(f.target<const volatile Seventeen>());
+  BOOST_CHECK(!f.target<Seventeen>());
+  BOOST_CHECK(!f.target<volatile Seventeen>());
 }
 
 static void equal_test()
@@ -97,10 +84,8 @@ static void equal_test()
   f = &forty_two;
   BOOST_CHECK(f == &forty_two);
   BOOST_CHECK(f != ReturnInt(17));
-#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
   BOOST_CHECK(&forty_two == f);
   BOOST_CHECK(ReturnInt(17) != f);
-#endif
 
   BOOST_CHECK(f.contains(&forty_two));
 
@@ -108,47 +93,37 @@ static void equal_test()
   BOOST_CHECK(f != &forty_two);
   BOOST_CHECK(f == ReturnInt(17));
   BOOST_CHECK(f != ReturnInt(16));
-#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
   BOOST_CHECK(&forty_two != f);
   BOOST_CHECK(ReturnInt(17) == f);
   BOOST_CHECK(ReturnInt(16) != f);
-#endif
 
   BOOST_CHECK(f.contains(ReturnInt(17)));
 
-  f = contain_test::ReturnIntFE(17);
+  f = contains_test::ReturnIntFE(17);
   BOOST_CHECK(f != &forty_two);
-  BOOST_CHECK(f == contain_test::ReturnIntFE(17));
-  BOOST_CHECK(f != contain_test::ReturnIntFE(16));
-#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
+  BOOST_CHECK(f == contains_test::ReturnIntFE(17));
+  BOOST_CHECK(f != contains_test::ReturnIntFE(16));
   BOOST_CHECK(&forty_two != f);
-  BOOST_CHECK(contain_test::ReturnIntFE(17) == f);
-  BOOST_CHECK(contain_test::ReturnIntFE(16) != f);
-#endif
+  BOOST_CHECK(contains_test::ReturnIntFE(17) == f);
+  BOOST_CHECK(contains_test::ReturnIntFE(16) != f);
 
-  BOOST_CHECK(f.contains(contain_test::ReturnIntFE(17)));
+  BOOST_CHECK(f.contains(contains_test::ReturnIntFE(17)));
 
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
   boost::function<int(void)> g;
 
   g = &forty_two;
   BOOST_CHECK(g == &forty_two);
   BOOST_CHECK(g != ReturnInt(17));
-#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
   BOOST_CHECK(&forty_two == g);
   BOOST_CHECK(ReturnInt(17) != g);
-#  endif
 
   g = ReturnInt(17);
   BOOST_CHECK(g != &forty_two);
   BOOST_CHECK(g == ReturnInt(17));
   BOOST_CHECK(g != ReturnInt(16));
-#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
   BOOST_CHECK(&forty_two != g);
   BOOST_CHECK(ReturnInt(17) == g);
   BOOST_CHECK(ReturnInt(16) != g);
-#  endif
-#endif
 }
 
 static void ref_equal_test()
@@ -164,10 +139,8 @@ static void ref_equal_test()
     BOOST_CHECK(!(f != boost::ref(ri)));
     BOOST_CHECK(!(f != ri));
     BOOST_CHECK(!(boost::ref(ri) != f));
-#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
     BOOST_CHECK(ri == f);
     BOOST_CHECK(!(ri != f));
-#endif
 
     // Values equal, references inequal
     ReturnInt ri2(17);
@@ -177,13 +150,10 @@ static void ref_equal_test()
     BOOST_CHECK(!(f != ri2));
     BOOST_CHECK(!(f == boost::ref(ri2)));
     BOOST_CHECK(!(boost::ref(ri2) == f));
-#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
     BOOST_CHECK(ri2 == f);
     BOOST_CHECK(!(ri2 != f));
-#endif 
   }
 
-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
   {
     ReturnInt ri(17);
     boost::function<int(void)> f = boost::ref(ri);
@@ -195,10 +165,8 @@ static void ref_equal_test()
     BOOST_CHECK(!(f != boost::ref(ri)));
     BOOST_CHECK(!(f != ri));
     BOOST_CHECK(!(boost::ref(ri) != f));
-#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
     BOOST_CHECK(ri == f);
     BOOST_CHECK(!(ri != f));
-#  endif
 
     // Values equal, references inequal
     ReturnInt ri2(17);
@@ -208,19 +176,16 @@ static void ref_equal_test()
     BOOST_CHECK(!(f != ri2));
     BOOST_CHECK(!(f == boost::ref(ri2)));
     BOOST_CHECK(!(boost::ref(ri2) == f));
-#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
     BOOST_CHECK(ri2 == f);
     BOOST_CHECK(!(ri2 != f));
-#  endif
   }
-#endif
 }
 
-int test_main(int, char*[])
+int main()
 {
   target_test();
   equal_test();
   ref_equal_test();
 
-  return 0;
+  return boost::report_errors();
 }

test/fn_eq_bind_test.cpp

@@ -0,0 +1,87 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/function.hpp>
+#include <boost/bind/bind.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::placeholders;
+
+int f1() { return 1; }
+int f2() { return 2; }
+
+int main()
+{
+    {
+        boost::function<int()> fn( boost::bind( f1 ) );
+
+        BOOST_TEST( fn == boost::bind( f1 ) );
+        BOOST_TEST( fn != boost::bind( f2 ) );
+    }
+
+    {
+        boost::function<int(int)> fn( boost::bind( f1 ) );
+
+        BOOST_TEST( fn == boost::bind( f1 ) );
+        BOOST_TEST( fn != boost::bind( f2 ) );
+    }
+
+    {
+        boost::function<int(int, int)> fn( boost::bind( f1 ) );
+
+        BOOST_TEST( fn == boost::bind( f1 ) );
+        BOOST_TEST( fn != boost::bind( f2 ) );
+    }
+
+    {
+        boost::function<int(int, int, int)> fn( boost::bind( f1 ) );
+
+        BOOST_TEST( fn == boost::bind( f1 ) );
+        BOOST_TEST( fn != boost::bind( f2 ) );
+    }
+
+    {
+        boost::function<int(int, int, int, int)> fn( boost::bind( f1 ) );
+
+        BOOST_TEST( fn == boost::bind( f1 ) );
+        BOOST_TEST( fn != boost::bind( f2 ) );
+    }
+
+    {
+        boost::function<int(int, int, int, int, int)> fn( boost::bind( f1 ) );
+
+        BOOST_TEST( fn == boost::bind( f1 ) );
+        BOOST_TEST( fn != boost::bind( f2 ) );
+    }
+
+    {
+        boost::function<int(int, int, int, int, int, int)> fn( boost::bind( f1 ) );
+
+        BOOST_TEST( fn == boost::bind( f1 ) );
+        BOOST_TEST( fn != boost::bind( f2 ) );
+    }
+
+    {
+        boost::function<int(int, int, int, int, int, int, int)> fn( boost::bind( f1 ) );
+
+        BOOST_TEST( fn == boost::bind( f1 ) );
+        BOOST_TEST( fn != boost::bind( f2 ) );
+    }
+
+    {
+        boost::function<int(int, int, int, int, int, int, int, int)> fn( boost::bind( f1 ) );
+
+        BOOST_TEST( fn == boost::bind( f1 ) );
+        BOOST_TEST( fn != boost::bind( f2 ) );
+    }
+
+    {
+        boost::function<int(int, int, int, int, int, int, int, int, int)> fn( boost::bind( f1 ) );
+
+        BOOST_TEST( fn == boost::bind( f1 ) );
+        BOOST_TEST( fn != boost::bind( f2 ) );
+    }
+
+    return boost::report_errors();
+}

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

test/function_n_test.cpp

@@ -7,12 +7,20 @@
 
 // For more information, see http://www.boost.org
 
-#include <boost/test/minimal.hpp>
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning( "-Wself-assign-overloaded" )
+#  pragma clang diagnostic ignored "-Wself-assign-overloaded"
+# endif
+#endif
+
 #include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <functional>
 #include <cassert>
 #include <string>
 
+#define BOOST_CHECK BOOST_TEST
+
 using namespace boost;
 using std::string;
 using std::negate;
@@ -631,12 +639,60 @@ 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");
   }
 }
 
-int test_main(int, char* [])
+static unsigned construction_count = 0;
+static unsigned destruction_count = 0;
+
+struct MySmallFunctor {
+  MySmallFunctor() { ++construction_count; }
+  MySmallFunctor(const MySmallFunctor &) { ++construction_count; }
+  ~MySmallFunctor() { ++destruction_count; }
+  int operator()() { return 0; }
+ };
+
+struct MyLargeFunctor {
+  MyLargeFunctor() { ++construction_count; }
+  MyLargeFunctor(const MyLargeFunctor &) { ++construction_count; }
+  ~MyLargeFunctor() { ++destruction_count; }
+  int operator()() { return 0; }
+
+  float data[128];
+ };
+
+void test_construct_destroy_count()
+{
+  {
+    boost::function0<int> f;
+    boost::function0<int> g;
+    f = MySmallFunctor();
+    g = MySmallFunctor();
+    f.swap(g);
+  }
+
+  // MySmallFunctor objects should be constructed as many times as
+  // they are destroyed.
+  BOOST_CHECK(construction_count == destruction_count);
+ 
+  construction_count = 0;
+  destruction_count = 0;
+  {
+    boost::function0<int> f;
+    boost::function0<int> g;
+    f = MyLargeFunctor();
+    g = MyLargeFunctor();
+    f.swap(g);
+   }
+
+   // MyLargeFunctor objects should be constructed as many times as
+   // they are destroyed.
+   BOOST_CHECK(construction_count == destruction_count);
+}
+
+int main()
 {
   test_zero_args();
   test_one_arg();
@@ -644,5 +700,6 @@ int test_main(int, char* [])
   test_emptiness();
   test_member_functions();
   test_ref();
-  return 0;
+  test_construct_destroy_count();
+  return boost::report_errors();
 }

test/function_test.cpp

@@ -7,14 +7,22 @@
 
 // For more information, see http://www.boost.org
 
-#include <boost/test/minimal.hpp>
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning( "-Wself-assign-overloaded" )
+#  pragma clang diagnostic ignored "-Wself-assign-overloaded"
+# endif
+#endif
+
 #include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <functional>
 #include <string>
 #include <utility>
 
-using namespace boost;
-using namespace std;
+#define BOOST_CHECK BOOST_TEST
+
+using boost::function;
+using std::string;
 
 int global_int;
 
@@ -525,7 +533,7 @@ test_zero_args()
 static void
 test_one_arg()
 {
-  negate<int> neg;
+  std::negate<int> neg;
 
   function<int (int)> f1(neg);
   BOOST_CHECK(f1(5) == -5);
@@ -607,12 +615,12 @@ struct add_with_throw_on_copy {
 
   add_with_throw_on_copy(const add_with_throw_on_copy&)
   {
-    throw runtime_error("But this CAN'T throw");
+    throw std::runtime_error("But this CAN'T throw");
   }
 
   add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
   {
-    throw runtime_error("But this CAN'T throw");
+    throw std::runtime_error("But this CAN'T throw");
   }
 };
 
@@ -621,14 +629,51 @@ test_ref()
 {
   add_with_throw_on_copy atc;
   try {
-    boost::function<int (int, int)> f(ref(atc));
+    boost::function<int (int, int)> f(boost::ref(atc));
     BOOST_CHECK(f(1, 3) == 4);
   }
-  catch(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()
+{
+  boost::function<void()> f1;
+  boost::function<void()> f2(boost::ref(f1));
+
+  try {
+    f2();
+    BOOST_ERROR("Exception didn't throw for reference to empty function.");
+  }
+  catch(std::runtime_error const&) {}
+
+  f1 = dummy;
+
+  try {
+    f2();
+  }
+  catch(std::runtime_error const&) {
+    BOOST_ERROR("Error calling referenced function.");
+  }
+}
+
+#endif
+
+
 static void test_exception()
 {
   boost::function<int (int, int)> f;
@@ -636,7 +681,7 @@ static void test_exception()
     f(5, 4);
     BOOST_CHECK(false);
   }
-  catch(boost::bad_function_call) {
+  catch(boost::bad_function_call const&) {
     // okay
   }
 }
@@ -666,7 +711,93 @@ static void test_call()
   test_call_cref(std::plus<int>());
 }
 
-int test_main(int, char* [])
+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);
+  
+  // 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);
+}
+
+int main()
 {
   test_zero_args();
   test_one_arg();
@@ -674,9 +805,12 @@ int test_main(int, char* [])
   test_emptiness();
   test_member_functions();
   test_ref();
+  test_empty_ref();
   test_exception();
   test_implicit();
   test_call();
+  test_move_semantics<function<void()> >();
+  test_move_semantics<boost::function0<void> >();
 
-  return 0;
+  return boost::report_errors();
 }

test/function_test_fail1.cpp

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

test/function_test_fail2.cpp

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

test/function_typeof_test.cpp

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

test/issue_42.cpp

@@ -0,0 +1,21 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+//
+// https://github.com/boostorg/function/issues/42
+
+#include <boost/function.hpp>
+
+struct F
+{
+    int operator()( int x ) const { return -x; }
+};
+
+struct X
+{
+    boost::function<int(int)> f_;
+    explicit X( boost::function<int(int)> f ): f_( f ) {}
+};
+
+F f2;
+X x( f2 ); // -Wuninitialized under GCC 12

test/lambda_test.cpp

@@ -7,32 +7,34 @@
 
 // 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>
-
-using namespace std;
-using namespace boost;
-using namespace boost::lambda;
 
 static unsigned
 func_impl(int arg1, bool arg2, double arg3)
 {
+  using namespace std;
   return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
 }
 
-int test_main(int, char*[])
+int main()
 {
+  using boost::function;
+  using namespace boost::lambda;
+
   function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
-  function <unsigned(double)>       f2 = bind(f1, false, _1);
-  function <unsigned()>             f3 = bind(f2, 4.0);
+  BOOST_TEST_EQ( f1(true, 2.0), 30u );
 
-  f3();
+  function <unsigned(double)>       f2 = boost::lambda::bind(f1, false, _1);
+  BOOST_TEST_EQ( f2(2.0), 60u );
 
-  return 0;
+  function <unsigned()>             f3 = boost::lambda::bind(f2, 4.0);
+  BOOST_TEST_EQ( f3(), 120u );
+
+  return boost::report_errors();
 }
-

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) const { 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;
 
-f = &X::foo;
-  
-X x;
-f(&x, 5);
+    X x;
+    BOOST_TEST(f(&x, 5) == -5);
+    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
 
-    return 0;
+    return ::boost::report_errors();
 }

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) const { 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;
 
-f = &X::foo;
-  
-X x;
-f(&x, 5);
+    X x;
+    BOOST_TEST(f(&x, 5) == -5);
+    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
 
-    return 0;
+    return ::boost::report_errors();
 }

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

test/nothrow_swap.cpp

@@ -0,0 +1,62 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2008. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+#include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#define BOOST_CHECK BOOST_TEST
+
+struct tried_to_copy { };
+
+struct MaybeThrowOnCopy {
+  MaybeThrowOnCopy(int value = 0) : value(value) { }
+
+  MaybeThrowOnCopy(const MaybeThrowOnCopy& other) : value(other.value) {
+    if (throwOnCopy)
+      throw tried_to_copy();
+  }
+
+  MaybeThrowOnCopy& operator=(const MaybeThrowOnCopy& other) {
+    if (throwOnCopy)
+      throw tried_to_copy();
+    value = other.value;
+    return *this;
+  }
+
+  int operator()() { return value; }
+
+  int value;
+
+  // Make sure that this function object doesn't trigger the
+  // small-object optimization in Function.
+  float padding[100];
+
+  static bool throwOnCopy;
+};
+
+bool MaybeThrowOnCopy::throwOnCopy = false;
+
+int main()
+{
+  boost::function0<int> f;
+  boost::function0<int> g;
+
+  MaybeThrowOnCopy::throwOnCopy = false;
+  f = MaybeThrowOnCopy(1);
+  g = MaybeThrowOnCopy(2);
+  BOOST_CHECK(f() == 1);
+  BOOST_CHECK(g() == 2);
+
+  MaybeThrowOnCopy::throwOnCopy = true;
+  f.swap(g);
+  BOOST_CHECK(f() == 2);
+  BOOST_CHECK(g() == 1);
+  
+  return boost::report_errors();
+}

test/quick.cpp

@@ -0,0 +1,21 @@
+// Copyright 2019 Peter Dimov
+
+// Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+static int f( int x )
+{
+    return x + 1;
+}
+
+int main()
+{
+    boost::function<int(int)> fn( f );
+
+    BOOST_TEST_EQ( fn( 5 ), 6 );
+
+    return boost::report_errors();
+}

test/result_arg_n_types_test.cpp

@@ -0,0 +1,146 @@
+// Copyright 2024 Peter Dimov
+// Use, modification and distribution is subject to
+// the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/function.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+struct R {};
+
+struct A1 {};
+struct A2 {};
+struct A3 {};
+struct A4 {};
+struct A5 {};
+struct A6 {};
+struct A7 {};
+struct A8 {};
+struct A9 {};
+struct A10 {};
+
+int main()
+{
+    {
+        typedef boost::function<R()> F;
+
+        BOOST_TEST_TRAIT_SAME(F::result_type, R);
+    }
+
+    {
+        typedef boost::function<R(A1)> F;
+
+        BOOST_TEST_TRAIT_SAME(F::result_type, R);
+        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
+    }
+
+    {
+        typedef boost::function<R(A1, A2)> F;
+
+        BOOST_TEST_TRAIT_SAME(F::result_type, R);
+        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
+        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
+    }
+
+    {
+        typedef boost::function<R(A1, A2, A3)> F;
+
+        BOOST_TEST_TRAIT_SAME(F::result_type, R);
+        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
+        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
+        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
+    }
+
+    {
+        typedef boost::function<R(A1, A2, A3, A4)> F;
+
+        BOOST_TEST_TRAIT_SAME(F::result_type, R);
+        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
+        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
+        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
+        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
+    }
+
+    {
+        typedef boost::function<R(A1, A2, A3, A4, A5)> F;
+
+        BOOST_TEST_TRAIT_SAME(F::result_type, R);
+        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
+        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
+        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
+        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
+        BOOST_TEST_TRAIT_SAME(F::arg5_type, A5);
+    }
+
+    {
+        typedef boost::function<R(A1, A2, A3, A4, A5, A6)> F;
+
+        BOOST_TEST_TRAIT_SAME(F::result_type, R);
+        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
+        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
+        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
+        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
+        BOOST_TEST_TRAIT_SAME(F::arg5_type, A5);
+        BOOST_TEST_TRAIT_SAME(F::arg6_type, A6);
+    }
+
+    {
+        typedef boost::function<R(A1, A2, A3, A4, A5, A6, A7)> F;
+
+        BOOST_TEST_TRAIT_SAME(F::result_type, R);
+        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
+        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
+        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
+        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
+        BOOST_TEST_TRAIT_SAME(F::arg5_type, A5);
+        BOOST_TEST_TRAIT_SAME(F::arg6_type, A6);
+        BOOST_TEST_TRAIT_SAME(F::arg7_type, A7);
+    }
+
+    {
+        typedef boost::function<R(A1, A2, A3, A4, A5, A6, A7, A8)> F;
+
+        BOOST_TEST_TRAIT_SAME(F::result_type, R);
+        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
+        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
+        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
+        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
+        BOOST_TEST_TRAIT_SAME(F::arg5_type, A5);
+        BOOST_TEST_TRAIT_SAME(F::arg6_type, A6);
+        BOOST_TEST_TRAIT_SAME(F::arg7_type, A7);
+        BOOST_TEST_TRAIT_SAME(F::arg8_type, A8);
+    }
+
+    {
+        typedef boost::function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> F;
+
+        BOOST_TEST_TRAIT_SAME(F::result_type, R);
+        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
+        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
+        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
+        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
+        BOOST_TEST_TRAIT_SAME(F::arg5_type, A5);
+        BOOST_TEST_TRAIT_SAME(F::arg6_type, A6);
+        BOOST_TEST_TRAIT_SAME(F::arg7_type, A7);
+        BOOST_TEST_TRAIT_SAME(F::arg8_type, A8);
+        BOOST_TEST_TRAIT_SAME(F::arg9_type, A9);
+    }
+
+    {
+        typedef boost::function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> F;
+
+        BOOST_TEST_TRAIT_SAME(F::result_type, R);
+        BOOST_TEST_TRAIT_SAME(F::arg1_type, A1);
+        BOOST_TEST_TRAIT_SAME(F::arg2_type, A2);
+        BOOST_TEST_TRAIT_SAME(F::arg3_type, A3);
+        BOOST_TEST_TRAIT_SAME(F::arg4_type, A4);
+        BOOST_TEST_TRAIT_SAME(F::arg5_type, A5);
+        BOOST_TEST_TRAIT_SAME(F::arg6_type, A6);
+        BOOST_TEST_TRAIT_SAME(F::arg7_type, A7);
+        BOOST_TEST_TRAIT_SAME(F::arg8_type, A8);
+        BOOST_TEST_TRAIT_SAME(F::arg9_type, A9);
+        BOOST_TEST_TRAIT_SAME(F::arg10_type, A10);
+    }
+
+    return boost::report_errors();
+}

test/result_arg_types_test.cpp

@@ -0,0 +1,39 @@
+// 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/lightweight_test_trait.hpp>
+
+struct X
+{
+};
+
+struct Y
+{
+};
+
+struct Z
+{
+};
+
+int main()
+{
+    typedef boost::function<X(Y)> F1;
+
+    BOOST_TEST_TRAIT_SAME(F1::result_type, X);
+    BOOST_TEST_TRAIT_SAME(F1::argument_type, Y);
+
+    typedef boost::function<X(Y, Z)> F2;
+
+    BOOST_TEST_TRAIT_SAME(F2::result_type, X);
+    BOOST_TEST_TRAIT_SAME(F2::first_argument_type, Y);
+    BOOST_TEST_TRAIT_SAME(F2::second_argument_type, Z);
+
+    return boost::report_errors();
+}

test/return_function.cpp

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

test/rvalues_test.cpp

@@ -0,0 +1,103 @@
+// Copyright 2014 Antony Polukhin.
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+#include <boost/function.hpp>
+#include <boost/move/move.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <iostream>
+#include <cstdlib>
+
+#define BOOST_CHECK BOOST_TEST
+
+class only_movable {
+private:
+    BOOST_MOVABLE_BUT_NOT_COPYABLE(only_movable)
+    int value_;
+    bool moved_;
+
+public:
+    only_movable(BOOST_RV_REF(only_movable) x)
+        : value_(x.value_)
+        , moved_(false)
+    {
+        x.moved_ = true;
+    }
+
+   only_movable& operator=(BOOST_RV_REF(only_movable) x) {
+        value_ = x.value_;
+        x.moved_ = true;
+        moved_ = false;
+        return *this;
+   }
+
+    explicit only_movable(int value = 0) : value_(value), moved_(false) {}
+    int get_value() const {  return value_;  }
+    bool is_moved() const { return moved_; }
+};
+
+
+int one(BOOST_RV_REF(only_movable) v) { return v.get_value(); }
+only_movable two(BOOST_RV_REF(only_movable) t) {
+    only_movable t1 = boost::move(t);
+    return BOOST_MOVE_RET(only_movable, t1);
+}
+
+only_movable two_sum(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) {
+    only_movable ret(t1.get_value() + t2.get_value());
+    return BOOST_MOVE_RET(only_movable, ret);
+}
+
+struct sum_struct {
+    only_movable operator()(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) const {
+        only_movable ret(t1.get_value() + t2.get_value());
+        return BOOST_MOVE_RET(only_movable, ret);
+    }
+};
+
+int three(std::string&&) { return 1; }
+std::string&& four(std::string&& s) { return boost::move(s); }
+
+int main()
+{
+    using boost::function;
+
+    function <int(BOOST_RV_REF(only_movable))>  f1 = one;
+
+    only_movable om1(1);
+    BOOST_CHECK(f1(boost::move(om1)) == 1);
+
+    function <only_movable(BOOST_RV_REF(only_movable))>  f2 = two;
+
+    only_movable om2(2);
+    only_movable om2_2 = f2(boost::move(om2));
+    BOOST_CHECK(om2_2.get_value() == 2);
+    BOOST_CHECK(om2.is_moved());
+
+    {
+        function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))>  f2_sum = two_sum;
+        only_movable om1_sum(1), om2_sum(2);
+        only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
+        BOOST_CHECK(om2_sum_2.get_value() == 3);
+    }
+
+    {
+        sum_struct s;
+        function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))>  f2_sum = s;
+        only_movable om1_sum(1), om2_sum(2);
+        only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
+        BOOST_CHECK(om2_sum_2.get_value() == 3);
+    }
+
+    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");
+
+    return boost::report_errors();
+}

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

test/std_bind_cxx98.cpp

@@ -8,7 +8,16 @@
 
 // For more information, see http://www.boost.org/
 
-    
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning( "-Wdeprecated-declarations" )
+#  pragma clang diagnostic ignored "-Wdeprecated-declarations"
+# endif
+#endif
+
+#if defined(__GNUC__) && __GNUC__ >= 12
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 #include <boost/function.hpp>
 #include <iostream>
 #include <functional>
@@ -20,11 +29,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;
 }

test/std_bind_portable.cpp

@@ -8,7 +8,16 @@
 
 // For more information, see http://www.boost.org/
 
-    
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning( "-Wdeprecated-declarations" )
+#  pragma clang diagnostic ignored "-Wdeprecated-declarations"
+# endif
+#endif
+
+#if defined(__GNUC__) && __GNUC__ >= 12
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 #include <boost/function.hpp>
 #include <iostream>
 #include <functional>
@@ -20,11 +29,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;
 }

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

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

test/test_return_function.cpp

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

test/throw_bad_function_call.cpp

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