Update test/cmake_subdir_test

[skip ci] Add "cxxstd" json field

.drone.jsonnet

@@ -0,0 +1,382 @@
+# 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',
+                '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 14.04 GCC 4.4",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.4', CXXSTD: '98,0x' },
+        "g++-4.4",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.6 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98,0x', ADDRMD: '32,64' },
+        "g++-4.6-multilib",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.7 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98,0x', ADDRMD: '32,64' },
+        "g++-4.7-multilib",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.8* 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.9 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11', ADDRMD: '32,64' },
+        "g++-4.9-multilib",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 5* 32/64",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 6 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '03,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: '03,11,14,17', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 8 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '03,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: '03,11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* ARM64",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        arch="arm64",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* S390x",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        arch="s390x",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 10 32/64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,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: '03,11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 32 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32' } + asan,
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 64 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '64' } + asan,
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.5",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.5', CXXSTD: '03,11' },
+        "clang-3.5",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.6",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.6', CXXSTD: '03,11,14' },
+        "clang-3.6",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.7",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.7', CXXSTD: '03,11,14' },
+        "clang-3.7",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.8",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.8', CXXSTD: '03,11,14' },
+        "clang-3.8",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 3.9",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.9', CXXSTD: '03,11,14' },
+        "clang-3.9",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 4.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-4.0', CXXSTD: '03,11,14' },
+        "clang-4.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 5.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-5.0', CXXSTD: '03,11,14,1z' },
+        "clang-5.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 6.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '03,11,14,17' },
+        "clang-6.0",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 7",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '03,11,14,17' },
+        "clang-7",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 8",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '03,11,14,17' },
+        "clang-8",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 9",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '03,11,14,17,2a' },
+        "clang-9",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 10",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '03,11,14,17,2a' },
+        "clang-10",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 11",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '03,11,14,17,2a' },
+        "clang-11",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 12",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '03,11,14,17,2a' },
+        "clang-12",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 13",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20' },
+        "clang-13",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 14 UBSAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
+        "clang-14",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 14 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + asan,
+        "clang-14",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 15",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '03,11,14,17,20,2b' },
+        "clang-15",
+        ["deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"],
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 UBSAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,2a' } + ubsan,
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 ASAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,2a' } + asan,
+    ),
+
+    macos_pipeline(
+        "MacOS 12.4 Xcode 13.4.1 UBSAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,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: '03,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' },
+    ),
+
+    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,392 @@
+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.8
+            cxxstd: "03,11"
+            os: ubuntu-18.04
+            install: g++-4.8-multilib
+            address-model: 32,64
+          - toolset: gcc-5
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-18.04
+            install: g++-5-multilib
+            address-model: 32,64
+          - toolset: gcc-6
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-18.04
+            install: g++-6-multilib
+            address-model: 32,64
+          - toolset: gcc-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+            install: g++-7-multilib
+            address-model: 32,64
+          - toolset: gcc-8
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-18.04
+            install: g++-8-multilib
+            address-model: 32,64
+          - toolset: gcc-9
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-9-multilib
+            address-model: 32,64
+          - toolset: gcc-10
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-10-multilib
+            address-model: 32,64
+          - toolset: gcc-11
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: g++-11-multilib
+            address-model: 32,64
+          - toolset: gcc-12
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: g++-12-multilib
+            address-model: 32,64
+          - toolset: clang
+            compiler: clang++-3.9
+            cxxstd: "03,11,14"
+            os: ubuntu-18.04
+            install: clang-3.9
+          - toolset: clang
+            compiler: clang++-4.0
+            cxxstd: "03,11,14"
+            os: ubuntu-18.04
+            install: clang-4.0
+          - toolset: clang
+            compiler: clang++-5.0
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-18.04
+            install: clang-5.0
+          - toolset: clang
+            compiler: clang++-6.0
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+            install: clang-6.0
+          - toolset: clang
+            compiler: clang++-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+            install: clang-7
+          - toolset: clang
+            compiler: clang++-8
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-8
+          - toolset: clang
+            compiler: clang++-9
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-9
+          - toolset: clang
+            compiler: clang++-10
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-11
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-12
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-13
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-22.04
+            install: clang-13
+          - toolset: clang
+            compiler: clang++-14
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: clang-14
+          - toolset: clang
+            compiler: clang++-15
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: clang-15
+          - toolset: clang
+            cxxstd: "03,11,14,17,2a"
+            os: macos-11
+          - toolset: clang
+            cxxstd: "03,11,14,17,20,2b"
+            os: macos-12
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt 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
+          ./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: "03,11,14,17,2a"
+            addrmd: 64
+            os: windows-2019
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - 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-11
+          - os: macos-12
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt 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-11
+          - os: macos-12
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt 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-11
+          - os: macos-12
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt 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

.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,32 @@
+# 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.5...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::preprocessor
+    Boost::throw_exception
+    Boost::type_index
+    Boost::type_traits
+    Boost::typeof
+)
+
+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.8 or later
+* clang++ 3.9 or later
+* Visual Studio 2005-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,70 @@
+# Copyright 2016-2019 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
+      ADDRMD: 32
+    - 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: 03,11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\cygwin64\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\mingw\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,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: 03,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

doc/Jamfile.v2

@@ -0,0 +1,25 @@
+#   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
+  
+#   Distributed under the Boost Software License, Version 1.0.
+#   (See accompanying file LICENSE_1_0.txt or copy at
+#   http://www.boost.org/LICENSE_1_0.txt)
+project function/doc ;
+import boostbook : boostbook ;
+
+boostbook function-doc 
+    : 
+    function.xml 
+    :
+        <xsl:param>boost.root=../../../..
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
+    ;
+
+###############################################################################
+alias boostdoc
+    : function.xml
+    :
+    :
+    : ;
+explicit boostdoc ;
+alias boostrelease ;
+explicit boostrelease ;

doc/faq.html

@@ -1,47 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>Boost.Function Frequently Asked Questions</title>
-  </head>
-
-  <body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080">
-<h1><IMG SRC="../../../c++boost.gif" WIDTH="276" HEIGHT="86">boost::function Frequently Asked Questions</h1>
-
-<h2>Q: I see void pointers; is this [mess] type safe?</h2>
-<p>Yes, <code>boost::function</code> is type safe even though it uses void pointers and pointers to functions returning void and taking no arguments. Essentially, all type information is encoded in the functions that manage and invoke function pointers and function objects. Only these functions are instantiated with the exact type that is pointed to by the void pointer or pointer to void function. The reason that both are required is that one may cast between void pointers and object pointers safely or between different types of function pointers (provided you don't invoke a function pointer with the wrong type). 
-
-<h2>Q: Why are there workarounds for void returns? C++ allows them!</h2>
-<p>Void returns are permitted by the C++ standard, as in this code snippet:
-<pre>
-void f();
-void g() { return f(); }
-</pre>
-
-<p> One reason for not using void returns is that not all compilers support them. In fact, very few compilers seem to support this trivial feature. Additionally, <code>boost::function</code> is more flexible because it does not use void returns. Consider the following code:
-<pre>
-int do_something(int);
-
-boost::function<void, int> f;
-f = do_something;
-</pre>
-<p> This is a valid usage of <code>boost::function</code> because void returns are not used. With void returns, we would attempting to compile ill-formed code similar to:
-<pre>
-int f();
-void g() { return f(); }
-</pre>
-<p> In essence, not using void returns allows <code>boost::function</code> to swallow a return value. This is consistent with allowing the user to assign and invoke functions and function objects with parameters that don't exactly match.
-
-<h2>Q: Why (function) cloning? </h2>
-<p> In November and December of 2000, the issue of cloning vs. reference counting was debated at length and it was decided that cloning gave more predictable semantics. I won't rehash the discussion here, but if it cloning is incorrect for a particular application a reference-counting allocator could be used. 
-
-<h2>Q: How do I assign from a member function?</h2>
-<p> Member function assignments are not included directly in <code>boost::function</code> because they do not conform to the syntax of function objects. Several libraries exist to wrap member functions in a function object and/or bind the first argument to the member function (the <code>this</code> pointer). A few libraries are <a href="tutorial.html#member_func">described</a> in the <a href="../index.html">Boost.Function</a> documentation.
-
-    <hr>
-    <address><a href="mailto:gregod@cs.rpi.edu">Doug Gregor</a></address>
-<!-- Created: Fri Feb 16 09:30:41 EST 2001 -->
-<!-- hhmts start -->
-Last modified: Sat Jul 14 16:00:11 EDT 2001
-<!-- hhmts end -->
-  </body>
-</html>

doc/faq.xml

@@ -0,0 +1,163 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
+  
+   Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or copy at
+   http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
+  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
+<section id="function.faq" last-revision="$Date$">
+  <title>Frequently Asked Questions</title>
+
+<qandaset>
+  <qandaentry>
+    <question><para>Why can't I compare
+    <classname>boost::function</classname> objects with
+    <code>operator==</code> or
+    <code>operator!=</code>?</para></question>
+
+    <answer>
+      <para>Comparison between <classname>boost::function</classname>
+      objects cannot be implemented "well", and therefore will not be
+      implemented. The typical semantics requested for <code>f ==
+      g</code> given <classname>boost::function</classname> objects
+      <code>f</code> and <code>g</code> are:</para>
+        <itemizedlist>
+          <listitem><simpara>If <code>f</code> and <code>g</code>
+          store function objects of the same type, use that type's
+          <code>operator==</code> to compare
+          them.</simpara></listitem> 
+
+          <listitem><simpara>If <code>f</code> and <code>g</code>
+          store function objects of different types, return
+          <code>false</code>.</simpara></listitem>
+        </itemizedlist>
+      <para>The problem occurs when the type of the function objects
+      stored by both <code>f</code> and <code>g</code> doesn't have an
+      <code>operator==</code>: we would like the expression <code>f ==
+      g</code> to fail to compile, as occurs with, e.g., the standard
+      containers. However, this is not implementable for
+      <classname>boost::function</classname> because it necessarily
+      "erases" some type information after it has been assigned a
+      function object, so it cannot try to call
+      <code>operator==</code> later: it must either find a way to call
+      <code>operator==</code> now, or it will never be able to call it
+      later. Note, for instance, what happens if you try to put a
+      <code>float</code> value into a
+      <classname>boost::function</classname> object: you will get an
+      error at the assignment operator or constructor, not in
+      <code>operator()</code>, because the function-call expression
+      must be bound in the constructor or assignment operator.</para>
+
+      <para>The most promising approach is to find a method of
+      determining if <code>operator==</code> can be called for a
+      particular type, and then supporting it only when it is
+      available; in other situations, an exception would be
+      thrown. However, to date there is no known way to detect if an
+      arbitrary operator expression <code>f == g</code> is suitably
+      defined. The best solution known has the following undesirable
+      qualities:</para>
+
+      <orderedlist>
+        <listitem><simpara>Fails at compile-time for objects where
+        <code>operator==</code> is not accessible (e.g., because it is
+        <code>private</code>).</simpara></listitem>
+
+        <listitem><simpara>Fails at compile-time if calling
+        <code>operator==</code> is ambiguous.</simpara></listitem>
+
+        <listitem><simpara>Appears to be correct if the
+        <code>operator==</code> declaration is correct, even though
+        <code>operator==</code> may not compile.</simpara></listitem>
+      </orderedlist>
+
+      <para>All of these problems translate into failures in the
+      <classname>boost::function</classname> constructors or
+      assignment operator, <emphasis>even if the user never invokes
+      operator==</emphasis>. We can't do that to users.</para>
+
+      <para>The other option is to place the burden on users that want
+      to use <code>operator==</code>, e.g., by providing an
+      <code>is_equality_comparable</code> trait they may
+      specialize. This is a workable solution, but is dangerous in
+      practice, because forgetting to specialize the trait will result
+      in unexpected exceptions being thrown from
+      <classname>boost::function</classname>'s
+      <code>operator==</code>. This essentially negates the usefulness
+      of <code>operator==</code> in the context in which it is most
+      desired: multitarget callbacks. The
+      <libraryname>Signals</libraryname> library has a way around
+      this.</para>
+    </answer>
+  </qandaentry>
+
+  <qandaentry>
+    <question><para>I see void pointers; is this [mess] type safe?</para></question>
+    <answer>
+<para>Yes, <computeroutput>boost::function</computeroutput> is type
+safe even though it uses void pointers and pointers to functions
+returning void and taking no arguments. Essentially, all type
+information is encoded in the functions that manage and invoke
+function pointers and function objects. Only these functions are
+instantiated with the exact type that is pointed to by the void
+pointer or pointer to void function. The reason that both are required
+is that one may cast between void pointers and object pointers safely
+or between different types of function pointers (provided you don't
+invoke a function pointer with the wrong type).  </para>
+    </answer>
+  </qandaentry>
+
+  <qandaentry>
+    <question><para>Why are there workarounds for void returns? C++ allows them!</para></question>
+    <answer><para>Void returns are permitted by the C++ standard, as in this code snippet:
+<programlisting>void f();
+void g() { return f(); }</programlisting>
+    </para>
+
+    <para> This is a valid usage of <computeroutput>boost::function</computeroutput> because void returns are not used. With void returns, we would attempting to compile ill-formed code similar to:
+<programlisting>int f();
+void g() { return f(); }</programlisting>
+</para>
+
+<para> In essence, not using void returns allows
+<computeroutput>boost::function</computeroutput> to swallow a return value. This is
+consistent with allowing the user to assign and invoke functions and
+function objects with parameters that don't exactly match.</para>
+
+    </answer>
+  </qandaentry>
+
+  <qandaentry>
+    <question><para>Why (function) cloning?</para></question>
+    <answer>
+      <para>In November and December of 2000, the issue of cloning
+      vs. reference counting was debated at length and it was decided
+      that cloning gave more predictable semantics. I won't rehash the
+      discussion here, but if it cloning is incorrect for a particular
+      application a reference-counting allocator could be used.</para>
+    </answer>
+  </qandaentry>
+
+  <qandaentry>
+    <question><para>How much overhead does a call through <code><classname>boost::function</classname></code> incur?</para></question>
+    <answer>
+      <para>The cost of <code>boost::function</code> can be reasonably
+      consistently measured at around 20ns +/- 10 ns on a modern >2GHz
+      platform versus directly inlining the code.</para>
+
+      <para>However, the performance of your application may benefit
+      from or be disadvantaged by <code>boost::function</code>
+      depending on how your C++ optimiser optimises.  Similar to a
+      standard function pointer, differences of order of 10% have been
+      noted to the benefit or disadvantage of using
+      <code>boost::function</code> to call a function that contains a
+      tight loop depending on your compilation circumstances.</para>
+     
+      <para>[Answer provided by Matt Hurd. See <ulink url="http://article.gmane.org/gmane.comp.lib.boost.devel/33278"/>]</para>
+    </answer>
+  </qandaentry>
+</qandaset> 
+
+</section>

doc/function.xml

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
+  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
+<library name="Function" dirname="function" id="function" 
+         last-revision="$Date$" 
+         xmlns:xi="http://www.w3.org/2001/XInclude">
+<libraryinfo>
+  <author>
+    <firstname>Douglas</firstname>
+    <surname>Gregor</surname>
+    <email>dgregor -at- cs.indiana.edu</email>
+  </author>
+
+  <copyright>
+    <year>2001</year>
+    <year>2002</year>
+    <year>2003</year>
+    <year>2004</year>
+    <holder>Douglas Gregor</holder>
+  </copyright>
+
+  <legalnotice>
+    <para>Use, modification and distribution is subject to the Boost
+    Software License, Version 1.0. (See accompanying file
+    <filename>LICENSE_1_0.txt</filename> or copy at <ulink
+    url="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</ulink>)</para>
+  </legalnotice>
+
+  <librarypurpose>Function object wrappers for deferred calls or callbacks</librarypurpose>
+  <librarycategory name="category:higher-order"/>
+</libraryinfo>
+
+<title>Boost.Function</title>
+
+<section id="function.intro">
+<title>Introduction</title> 
+<para>The Boost.Function library contains a family of class templates
+that are function object wrappers. The notion is similar to a
+generalized callback. It shares features with function pointers in
+that both define a call interface (e.g., a function taking two integer
+arguments and returning a floating-point value) through which some
+implementation can be called, and the implementation that is invoked
+may change throughout the course of the program.</para>
+
+<para> Generally, any place in which a function pointer would be used
+to defer a call or make a callback, Boost.Function can be used instead
+to allow the user greater flexibility in the implementation of the
+target. Targets can be any 'compatible' function object (or function
+pointer), meaning that the arguments to the interface designated by
+Boost.Function can be converted to the arguments of the target
+function object.</para>
+</section>
+
+<xi:include href="history.xml"/>
+<xi:include href="tutorial.xml"/>
+<xi:include href="reference.xml"/>
+<xi:include href="faq.xml"/>
+<xi:include href="misc.xml"/>
+<xi:include href="tests.xml"/>
+
+</library>

doc/history.xml

@@ -0,0 +1,146 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
+  
+   Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or copy at
+   http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
+  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
+<section id="function.history" last-revision="$Date$">
+  <title>History &amp; Compatibility Notes</title>
+
+<itemizedlist spacing="compact">
+
+  <listitem><para><bold>Version 1.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>
+    </itemizedlist>
+  </listitem>
+
+  <listitem><para><bold>Version 1.30.0</bold>: </para> 
+    <itemizedlist spacing="compact">
+      <listitem><para>All features deprecated in version 1.29.0 have
+      been removed from Boost.Function.</para></listitem>
+ 
+      <listitem><para><code><classname>boost::function</classname></code>
+      and <code><classname>boost::functionN</classname></code> objects
+      can be assigned to 0 (semantically equivalent to calling
+      <code><methodname
+      alt="boost::function::clear">clear</methodname>()</code>) and
+      compared against 0 (semantically equivalent to calling
+      <code><methodname
+      alt="boost::function::empty">empty</methodname>()</code>).</para></listitem>
+
+      <listitem><para>The Boost.Function code is now generated
+      entirely by the <libraryname>Preprocessor</libraryname> library,
+      so it is now possible to generate
+      <code><classname>boost::function</classname></code> and
+      <code><classname>boost::functionN</classname></code> class
+      templates for any number of arguments.</para></listitem>
+
+      <listitem><para>The
+      <classname>boost::bad_function_call</classname> exception class
+      was introduced.</para></listitem>
+      </itemizedlist>
+  </listitem>
+
+  <listitem><para><bold>Version 1.29.0</bold>:
+  Boost.Function has been partially redesigned to minimize the
+  interface and make it cleaner. Several seldom- or never-used
+  features of the older Boost.Function have been deprecated and will
+  be removed in the near future. Here is a list of features that have
+  been deprecated, the likely impact of the deprecations, and how to
+  adjust your code:
+
+<itemizedlist spacing="compact">
+  <listitem><para>The <computeroutput>boost::function</computeroutput> class template syntax has
+  changed. The old syntax, e.g., <computeroutput>boost::function&lt;int, float,
+  double, std::string&gt;</computeroutput>, has been changed to a more natural
+  syntax <computeroutput>boost::function&lt;int (float, double,
+  std::string)&gt;</computeroutput>, where all return and argument types are
+  encoded in a single function type parameter. Any other template
+  parameters (e.g., the <computeroutput>Allocator</computeroutput>) follow this single
+  parameter.</para>
+
+  <para> The resolution to this change depends on the
+  abilities of your compiler: if your compiler supports template
+  partial specialization and can parse function types (most do), modify 
+  your code to use the newer
+  syntax (preferable) or directly use one of the
+  <computeroutput>functionN</computeroutput> classes whose syntax has not
+  changed. If your compiler does not support template partial
+  specialization or function types, you must take the latter option and 
+  use the numbered Boost.Function classes. This option merely requires 
+  changing types such as <computeroutput>boost::function&lt;void, int, int&gt;</computeroutput>
+  to <computeroutput>boost::function2&lt;void, int, int&gt;</computeroutput> (adding the number of
+  function arguments to the end of the class name).</para>
+
+  <para> Support for the old syntax with the
+  <computeroutput>boost::function</computeroutput> class template will persist for a short
+  while, but will eventually be removed so that we can provide better
+  error messages and link compatibility. </para></listitem> 
+
+  <listitem><para>The invocation
+  policy template parameter (<computeroutput>Policy</computeroutput>) has been deprecated
+  and will be removed. There is no direct equivalent to this rarely
+  used feature.</para></listitem> 
+
+  <listitem><para>The mixin template parameter
+  (<computeroutput>Mixin</computeroutput>) has been deprecated and will be removed. There
+  is not direct equivalent to this rarely used feature.</para></listitem> 
+
+  <listitem><para>The
+  <computeroutput>set</computeroutput> methods have been deprecated and will be
+  removed. Use the assignment operator instead.</para></listitem>
+</itemizedlist>
+</para>
+</listitem>
+</itemizedlist>
+</section>

doc/misc.xml

@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
+  
+   Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or copy at
+   http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
+  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
+<section id="function.misc" last-revision="$Date$">
+  <title>Miscellaneous Notes</title>
+
+  <section>
+    <title>Boost.Function vs. Function Pointers</title>
+<para>Boost.Function has several advantages over function pointers, namely:
+
+<itemizedlist spacing="compact">
+   <listitem><para>Boost.Function allows arbitrary compatible function objects to be targets (instead of requiring an exact function signature).</para></listitem>
+   <listitem><para>Boost.Function may be used with argument-binding and other function object construction libraries.</para></listitem>
+   <listitem><para>Boost.Function has predictible behavior when an empty function object is called. </para></listitem>
+</itemizedlist></para>
+
+<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 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>
+</itemizedlist>
+</para>
+  </section>
+
+  <section>
+    <title>Performance</title>
+
+<section>
+  <title>Function object wrapper size</title>
+  <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. Small function objects can be stored within the <code>boost::function</code> object itself, improving copying efficiency.</para>
+ </section>
+
+<section>
+  <title>Invocation efficiency</title>
+<para> With a properly inlining compiler, an invocation of a function object requires one call through a function pointer. If the call is to a free function pointer, an additional call must be made to that function pointer (unless the compiler has very powerful interprocedural analysis).</para>
+  </section>
+</section>
+
+  <section>
+    <title>Combatting virtual function "bloat"</title>
+<para> The use of virtual functions tends to cause 'code bloat' on many compilers. When a class contains a virtual function, it is necessary to emit an additional function that classifies the type of the object. It has been our experience that these auxiliary functions increase the size of the executable significantly when many <computeroutput>boost::function</computeroutput> objects are used. </para>
+
+<para> In Boost.Function, an alternative but equivalent approach was taken using free functions instead of virtual functions. The Boost.Function object essentially holds two pointers to make a valid target call: a void pointer to the function object it contains and a void pointer to an "invoker" that can call the function object, given the function pointer. This invoker function performs the argument and return value conversions Boost.Function provides. A third pointer points to a free function called the "manager", which handles the cloning and destruction of function objects. The scheme is typesafe because the only functions that actually handle the function object, the invoker and the manager, are instantiated given the type of the function object, so they can safely cast the incoming void pointer (the function object pointer) to the appropriate type.</para>
+  </section>
+
+  <section>
+    <title>Acknowledgements</title> 
+
+    <para> Many people were involved in the construction of this
+    library. William Kempf, Jesse Jones and Karl Nelson were all
+    extremely helpful in isolating an interface and scope for the
+    library. John Maddock managed the formal review, and many
+    reviewers gave excellent comments on interface, implementation,
+    and documentation. Peter Dimov led us to the function
+    declarator-based syntax.</para>
+  </section>
+</section>

doc/reference.html

@@ -1,239 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>Boost.Function Reference Manual</title>
-  </head>
-
-  <body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080">
-
-  <h1><IMG SRC="../../../c++boost.gif" WIDTH="276" HEIGHT="86">Boost.Function Reference Manual</h1>
-
-<h2><a name="header">Header <code>&lt;<a href="../../../boost/function.hpp">boost/function.hpp</a>&gt;</code> synopsis</a></h2>
-<p> Here <code><i>MAX_ARGS</i></code> is an implementation-defined constant that defines the maximum number of function arguments supported by Boost.Function and will be at least 10. The <code><i>MAX_ARGS</i></code> constant referred to in this document need not have any direct representation in the library.
-
-<pre>
-<b>namespace</b> boost {
-  <b>class</b> <a href="#function_base">function_base</a>
-  {
-    <a href="#empty"><b>bool</b> empty() <b>const</b></a>;
-    <a href="#bool"><b>operator</b> <b>bool</b>() <b>const</b></a>;
-  };
-
-  // For <i>N</i> in [0, <i>MAX_ARGS</i>]
-  <b>template</b>&lt;<b>typename</b> ResultType,
-           <b>typename</b> Arg1,
-	   <b>typename</b> Arg2,
-           <i>...</i>
-           <b>typename</b> Arg<i>N</i>,
-	   <b>typename</b> Policy    = empty_function_policy,
-	   <b>typename</b> Mixin     = empty_function_mixin,
-	   <b>typename</b> Allocator = std::allocator&lt;function_base&gt; &gt;
-  <b>class</b> <a href="#functionN">function<i>N</i></a> : <b>public</b> <a href="#function_base">function_base</a>, <b>public</b> Mixin
-  {
-    <b>typedef</b> ResultType result_type;
-    <b>typedef</b> Policy     policy_type;
-    <b>typedef</b> Mixin      mixin_type;
-    <b>typedef</b> Allocator  allocator_type;
-
-    <b>typedef</b> Arg1 argument_type;        <i>// If N == 1</i>
-
-    <b>typedef</b> Arg1 first_argument_type;  <i>// If N == 2</i>
-    <b>typedef</b> Arg2 second_argument_type; <i>// If N == 2</i>
-
-    <i>// Construction</i>
-    <a href="#functionN_default"><b>explicit</b> function<i>N</i>(<b>const</b> Mixin<b>&amp;</b> = Mixin())</a>;
-    <a href="#functionN_copy">function<i>N</i>(<b>const</b> function<i>N</i><b>&amp;</b>)</a>;
-    <a href="#functionN_target"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(<b>const</b> F<b>&amp;</b>, <b>const</b> Mixin<b>&amp;</b> = Mixin())</a>;
-    
-    <i>// Assignment</i>
-    <a href="#functionN_copy_assn">function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&amp;</b>)</a>;
-    <a href="#functionN_target_assn"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> F<b>&amp;</b>)</a>;
-    <a href="#functionN_copy_set"><b>void</b> set(<b>const</b> function<i>N</i><b>&amp;</b>)</a>;
-    <a href="#functionN_target_set"><b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(<b>const</b> F<b>&amp;</b>)</a>;
-    <a href="#functionN_swap"><b>void</b> swap(function<i>N</i><b>&amp;</b>)</a>;
-    <a href="#functionN_clear"><b>void</b> clear()</a>;
-
-    <i>// Invocation</i>
-    <a href="#functionN_call_const">result_type <b>operator</b>()(Arg1 a1, Arg2 a2, <i>...</i>, Arg<i>N</i> a<i>N</i>) <b>const</b></a>;
-  };
-
-  <b>template</b>&lt;<b>typename</b> ResultType,
-           <b>typename</b> Arg1,
-	   <b>typename</b> Arg2,
-           <i>...</i>
-	   <b>typename</b> Arg<i>N</i>,
-           <b>typename</b> Policy,
-           <b>typename</b> Mixin,
-           <b>typename</b> Allocator&gt;
-  <b>void</b> <a href="#swap_functionN">swap</a>(<b>const</b> function&lt;Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b>,
-            <b>const</b> function&lt;Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b>);
-
-  // For any <i>N</i> in [0, <i>MAX_ARGS</i>]
-  <b>template</b>&lt;<b>typename</b> ResultType,
-           <b>typename</b> Arg1,
-	   <b>typename</b> Arg2,
-           <i>...</i>
-           <b>typename</b> Arg<i>N</i>,
-           <b>typename</b> Arg<i>N+1</i> = <i>implementation-defined</i>,
-           <b>typename</b> Arg<i>N+2</i> = <i>implementation-defined</i>,
-	   <i>...</i>
-	   <b>typename</b> Arg<i>MAX_ARGS</i> = <i>implementation-defined</i>&gt;
-  <b>class</b> <a href="#function">function</a> : <b>public</b> <a href="#functionN">function<i>N</i></a>&lt;Arg1, Arg2, <i>...</i>, Arg<i>N</i>&gt;
-  {
-    <i>// Construction</i>
-    function();
-    function(<b>const</b> function<b>&amp;</b>);
-    function<i>N</i>(<b>const</b> function<i>N</i><b>&amp;</b>);
-    <b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(<b>const</b> F<b>&amp;</b>);
-    
-    <i>// Assignment</i>
-    function<b>&amp;</b> <b>operator</b>=(<b>const</b> function<b>&amp;</b>);
-    function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&amp;</b>);
-    <b>template</b>&lt;<b>typename</b> F&gt; function<b>&amp;</b> <b>operator</b>=(<b>const</b> F<b>&amp;</b>);
-    <b>void</b> set(<b>const</b> function<b>&amp;</b>);
-    <b>void</b> set(<b>const</b> function<i>N</i><b>&amp;</b>);
-    <b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(<b>const</b> F<b>&amp;</b>);
-  };
-
-  <b>template</b>&lt;<b>typename</b> ResultType,
-           <b>typename</b> Arg1,
-	   <b>typename</b> Arg2,
-           <i>...</i>
-	   <b>typename</b> Arg<i>MAX_ARGS</i>&gt;
-  <b>void</b> <a href="#swap_function">swap</a>(<b>const</b> function&lt;Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b>,
-            <b>const</b> function&lt;Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b>);
-}	   
-</pre>
-
-<h2><a name="function_base">Class <code>function_base</code></a></h2>
-<p> Class <code>function_base</code> is the common base class for all Boost.Function objects. Objects of type <code>function_base</code> may not be created directly. 
-
-<p> <a name="empty"><code><b>bool</b> empty() <b>const</b></code></a>
-<ul>
-  <li><b>Returns</b>: <code>true</code> if the function object has a target, <code>false</code> otherwise.</li>
-  <li><b>Throws</b>: will not throw.</li>
-</ul>
-
-<p> <a name="bool"><code><b>operator</b> <b>bool</b>() <b>const</b></code></a>
-<ul>
-  <li><b>Returns</b>: <code>!<a href="#empty">empty</a>()</code></li>
-  <li><b>Throws</b>: will not throw.</li>
-</ul>
-
-<h2><a name="functionN">Class template <code>function<i>N</i></code></a></h2>
-<p> Class template <code>function<i>N</i></code> is actually a family of related classes <code>function0</code>, <code>function1</code>, etc., up to some implementation-defined maximum. In this context, <code><i>N</i></code> refers to the number of parameters and <code>f</code> refers to the implicit object parameter.
-
-<p> <a name="functionN_default"><code><b>explicit</b> function<i>N</i>(<b>const</b> Mixin<b>&amp;</b> = Mixin());</code></a>
-<ul>
-  <li><b>Effects</b>: Constructs the <code>Mixin</code> subobject with the given mixin.</li>
-  <li><b>Postconditions</b>: <code>f.<a href="#empty">empty</a>()</code>.</li>
-  <li><b>Throws</b>: will not throw.</li>
-</ul>
-
-<p> <a name="functionN_copy"><code>function<i>N</i>(<b>const</b> function<i>N</i><b>&amp;</b> g);</code></a>
-<ul>
-  <li><b>Postconditions</b>: <code>f</code> contains a copy of the <code>g</code>'s target, if it has one, or is empty if <code>g.<a href="#empty">empty</a>()</code>. The mixin for the <code>f</code> is copy-constructed from the mixin of <code>g</code>.</li>
-</ul>
-
-<p> <a name="functionN_target"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(<b>const</b> F<b>&amp;</b> g, <b>const</b> Mixin<b>&amp;</b> = Mixin());</code></a>
-<ul>
-  <li><b>Requires</b>: <code>g</code> is a compatible function object.</li>
-  <li><b>Effects</b>: Constructs the <code>Mixin</code> subobject from the given mixin.</li>
-  <li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code> if <code>g</code> is nonempty, or <code>f.<a href="#empty">empty</a>()</code> if <code>g</code> is empty.</li>
-  <li><b>Rationale</b>: <code>g</code> is a reference-to-<code><b>const</b></code> because it is a portable, efficient, and concise way to accept any function object or function pointer. In the case of a function pointer, the type of <code>g</code> is reference-to-<code><b>const</b></code> pointer-to-function.</li>
-</ul>
-
-<p> <a name="functionN_copy_assn"><code>function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&amp;</b> g);</code></a>
-<ul>
-  <li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code>'s target, if it has one, or is empty if <code>g.<a href="#empty">empty</a>()</code>. The mixin for <code>f</code> is assigned the value of the mixin for <code>g</code>.</li>
-  <li><b>Returns</b>: <code>*this</code>.</li>
-</ul>
-
-<p> <a name="functionN_target_assn"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> F<b>&amp;</b> g);</code></a>
-<ul>
-  <li><b>Requires</b>: <code>g</code> is a compatible function object.</li>
-  <li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code> if <code>g</code> is nonempty, or <code>f.<a href="#empty">empty</a>()</code> if <code>g</code> is empty.</li>
-  <li><b>Returns</b>: <code>*this</code>.</li>
-  <li><b>Rationale</b>: <code>g</code> is a reference-to-<code><b>const</b></code> because it is a portable, efficient, and concise way to accept any function object or function pointer. In the case of a function pointer, the type of <code>g</code> is reference-to-<code><b>const</b></code> pointer-to-function.</li>
-</ul>
-
-<p> <a name="functionN_copy_set"><code><b>void</b> set(<b>const</b> function<i>N</i><b>&amp;</b> g);</code></a>
-<ul>
-  <li><b>Effects</b>: <code><a href="#functionN_copy_assn">*this = g</a></code>.</li>
-</ul>
-
-<p> <a name="functionN_target_set"><code><b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(<b>const</b> F<b>&amp;</b> g);</code></a>
-<ul>
-  <li><b>Effects</b>: <code><a href="#functionN_target_assn">*this = g</a></code>.</li>
-</ul>
-
-<p> <a name="functionN_swap"><code><b>void</b> swap(function<i>N</i><b>&amp;</b> g);</code></a>
-<ul>
-  <li><b>Effects</b>: interchanges the targets of <code>f</code> and <code>g</code> and swaps the mixins of <code>f</code> and <code>g</code>.</li>
-  <li><b>Throws</b>: will not throw.</li>
-</ul>
-
-<p> <a name="functionN_clear"><code><b>void</b> clear(); </code></a>
-<ul>
-  <li><b>Effects</b>: If <code>!<a href="#empty">empty</a>()</code>, deallocates current target.</li>
-  <li><b>Postconditions</b>: <code><a href="#empty">empty</a>()</code>.</li>
-</ul>
-
-<p> <a name="functionN_call_const"><code> result_type <b>operator</b>()(Arg1 a1, Arg2 a2, <i>...</i>, Arg<i>N</i> a<i>N</i>) <b>const</b>;</code></a>
-<ul>
-  <li><b>Requires</b>: <code>!<a href="#empty">empty</a>()</code>.</li>
-  <li><b>Effects</b>: <i>target</i> is the underlying function target. It is not <code><b>const</b></code> or <code><b>volatile</b></code> qualified.
-    <ol>
-      <li><code>policy_type policy;</code></li>
-      <li><code>policy.precall(this);</code></li>
-      <li><code><i>target</i>(a1, a2, <i>...</i>, a<i>N</i>);</code></li>
-      <li><code>policy.postcall(this);</code></li>
-    </ol>
-  <li><b>Returns</b>: the value returned by <i>target</i>.</li>
-</ul>
-
-<h2><a name="function">Class template <code>function</code></a></h2>
-<p> Class template <code>function</code> is a thin wrapper around the numbered class templates <code>function0</code>, <code>function1</code>, etc. It accepts up to <i>MAX_ARGS</i> arguments, but when passed <i>N</i> arguments it will derive from <code>function<i>N</i></code> specialized with the arguments it receives.
-
-<p> The semantics of all operations in class template <code>function</code> are equivalent to that of the underlying <code>function<i>N</i></code> object, although additional member functions are required to allow proper copy construction and copy assignment of <code>function</code> objects.
-
-<h2><a name="operations">Operations</a></h2>
-<p>
-<pre>
-<b>template</b>&lt;<b>typename</b> ResultType,
-         <b>typename</b> Arg1,
-	 <b>typename</b> Arg2,
-         <i>...</i>
-	 <b>typename</b> Arg<i>N</i>,
-         <b>typename</b> Policy,
-         <b>typename</b> Mixin,
-         <b>typename</b> Allocator&gt;
-<b>void</b> <a name="swap_functionN">swap</a>(<b>const</b> function<i>N</i>&lt;Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b> f,
-          <b>const</b> function<i>N</i>&lt;Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b> g);
-</pre>
-<ul>
-  <li><b>Effects</b>: <code>f.<a href="#functionN_swap">swap</a>(g);</code></li>
-</ul>
-
-<p>
-<pre>
-<b>template</b>&lt;<b>typename</b> ResultType,
-         <b>typename</b> Arg1,
-	 <b>typename</b> Arg2,
-         <i>...</i>
-	 <b>typename</b> Arg<i>MAX_ARGS</i>&gt;
-<b>void</b> <a name="swap_function">swap</a>(<b>const</b> function&lt;Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b> f,
-          <b>const</b> function&lt;Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b> g);
-</pre>
-<ul>
-  <li><b>Effects</b>: <code>f.<a href="#functionN_swap">swap</a>(g);</code></li>
-</ul>
-
-    <hr>
-    <address><a href="mailto:gregod@cs.rpi.edu">Douglas Gregor</a></address>
-<!-- Created: Fri Jul 13 10:57:20 EDT 2001 -->
-<!-- hhmts start -->
-Last modified: Sun Jul 22 01:29:50 EDT 2001
-<!-- hhmts end -->
-  </body>
-</html>

doc/reference.xml

@@ -0,0 +1,992 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
+  
+   Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or copy at
+   http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
+  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
+
+<library-reference id="function.reference" last-revision="$Date$">
+
+<section id="function.definitions">
+  <title>Definitions</title>
+<para>
+  <itemizedlist>
+    <listitem>
+      <para>A function object <computeroutput>f</computeroutput> is
+      <emphasis>compatible</emphasis> if for the given set of argument
+      types <computeroutput>Arg1</computeroutput>,
+      <computeroutput>Arg2</computeroutput>, ...,
+      <computeroutput>ArgN</computeroutput> and a
+      return type <computeroutput>ResultType</computeroutput>, the
+      appropriate following function is well-formed:
+<programlisting>
+  <emphasis>// if ResultType is not <emphasis role="bold">void</emphasis></emphasis>
+  ResultType foo(Arg1 arg1, Arg2 arg2, ..., Arg<emphasis>N</emphasis> arg<emphasis>N</emphasis>)
+  {
+    <emphasis role="bold">return</emphasis> f(arg1, arg2, ..., arg<emphasis>N</emphasis>);
+  }
+
+  <emphasis>// if ResultType is <emphasis role="bold">void</emphasis></emphasis>
+  ResultType foo(Arg1 arg1, Arg2 arg2, ..., Arg<emphasis>N</emphasis> arg<emphasis>N</emphasis>)
+  {
+    f(arg1, arg2, ..., arg<emphasis>N</emphasis>);
+  }
+</programlisting></para>
+
+      <para> A special provision is made for pointers to member
+      functions. Though they are not function objects, Boost.Function
+      will adapt them internally to function objects. This requires
+      that a pointer to member function of the form <code>R
+      (X::*mf)(Arg1, Arg2, ..., ArgN)
+      cv-quals</code> be adapted to a
+      function object with the following function call operator
+      overloads:
+<programlisting>
+  <emphasis role="bold">template</emphasis>&lt;<emphasis role="bold">typename P</emphasis>&gt;
+  R <emphasis role="bold">operator</emphasis>()(<emphasis>cv-quals</emphasis> P&amp; x, Arg1 arg1, Arg2 arg2, ..., Arg<emphasis>N</emphasis> arg<emphasis>N</emphasis>) <emphasis role="bold">const</emphasis>
+  {
+    <emphasis role="bold">return</emphasis> (*x).*mf(arg1, arg2, ..., arg<emphasis>N</emphasis>);
+  }
+</programlisting>
+</para>
+    </listitem>
+    <listitem>
+      <para>A function object <code>f</code> of
+      type <code>F</code> is
+      <emphasis>stateless</emphasis> if it is a function pointer or if
+      <code><classname>boost::is_stateless</classname>&lt;F&gt;</code>
+      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.
+      </para>
+    </listitem>
+  </itemizedlist>
+</para>
+</section>
+
+<header name="boost/function.hpp">
+<namespace name="boost">
+  <class name="bad_function_call">
+    <inherit access="public"><classname>std::runtime_error</classname></inherit>
+    <purpose>An exception type thrown when an instance of a <code>function</code> object is empty when invoked.</purpose>
+    <constructor>
+      <effects><simpara>Constructs a <code><classname>bad_function_call</classname></code> exception object.</simpara></effects>
+    </constructor>
+  </class>
+
+  <class name="function_base">
+    <purpose>The common base class for all Boost.Function
+    objects. Objects of type function_base may not be created
+    directly.</purpose>
+
+    <method-group name="capacity">
+      <method name="empty" cv="const">
+        <type>bool</type>
+        <returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+    </method-group>
+
+    <method-group name="target access">
+      <overloaded-method name="target">
+        <signature>
+          <template> 
+            <template-type-parameter name="Functor"/>
+          </template>
+          <type>Functor*</type>
+        </signature>
+        <signature cv="const">
+          <template> 
+            <template-type-parameter name="Functor"/>
+          </template>
+          <type>const Functor*</type>
+        </signature>
+
+        <returns><simpara>If <code>this</code> stores a target of type
+        <code>Functor</code>, returns the address of the
+        target. Otherwise, returns the NULL
+        pointer.</simpara></returns>
+
+        <throws><simpara>Will not throw.</simpara></throws>
+      </overloaded-method>
+
+      <method name="contains" cv="const">
+        <template>
+          <template-type-parameter name="Functor"/>
+        </template>
+        <type>bool</type>
+        <parameter name="f">
+          <paramtype>const Functor&amp;</paramtype>
+        </parameter>
+        <returns><simpara><code>true</code> if <code>this-&gt;<methodname>target</methodname>&lt;Functor&gt;()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this-&gt;target&lt;Functor&gt;()), f)</code></simpara></returns>
+ 
+      </method>
+
+      <method name="target_type" cv="const">
+        <type>const std::type_info&amp;</type>
+        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>. Works even with RTTI off.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+    </method-group>
+  </class>
+
+  <class name="functionN">
+    <template>
+      <template-type-parameter name="R"/>
+      <template-type-parameter name="T1"/>
+      <template-type-parameter name="T2"/>
+      <template-varargs/>
+      <template-type-parameter name="TN"/>
+    </template>
+
+    <inherit access="public"><classname>function_base</classname></inherit>
+
+    <purpose>A set of generalized function pointers that can be used for callbacks or wrapping function objects.</purpose>
+
+    <description>
+      <para>Class template <classname>functionN</classname> is
+      actually a family of related classes <classname
+      alt="functionN">function0</classname>, <classname
+      alt="functionN">function1</classname>, etc., up to some
+      implementation-defined maximum. In this context, <code>N</code>
+      refers to the number of parameters.</para>
+    </description>
+
+    <typedef name="result_type"><type>R</type></typedef>
+    <typedef name="argument_type">
+      <type>T1</type><purpose>If N == 1</purpose>
+    </typedef>
+    <typedef name="first_argument_type">
+      <type>T1</type>
+      <purpose>If N == 2</purpose>
+    </typedef>
+    <typedef name="second_argument_type">
+      <type>T2</type>
+      <purpose>If N == 2</purpose>
+    </typedef>
+    <typedef name="arg1_type"><type>T1</type></typedef>
+    <typedef name="arg2_type"><type>T2</type></typedef>
+    <typedef name="..."><type/></typedef>
+    <typedef name="argN_type"><type>TN</type></typedef>
+
+    <static-constant name="arity">
+      <type>int</type>
+      <default>N</default>
+    </static-constant>
+
+    <struct name="sig">
+      <template>
+        <template-type-parameter name="Args"/>
+      </template>
+
+      <purpose>
+        <simpara><libraryname>Lambda</libraryname> library support</simpara>
+      </purpose>
+
+      <typedef name="type"><type>result_type</type></typedef>
+    </struct>
+
+    <constructor>
+      <postconditions><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></postconditions>
+      <throws><simpara>Will not throw.</simpara></throws>
+    </constructor>
+
+    <constructor>
+      <parameter name="f">
+        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
+      </parameter>
+      <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>
+      <template>
+        <template-type-parameter name="F"/>
+      </template>
+      <parameter name="f"><paramtype>F</paramtype></parameter>
+      <requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
+      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-&gt;<methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
+    </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>
+
+    </destructor>
+
+    <copy-assignment>
+      <parameter name="f">
+        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
+      </parameter>
+      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
+    </copy-assignment>
+    
+    <copy-assignment>
+      <parameter name="f">
+        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
+      </parameter>
+      <requires><simpara>C++11 compatible compiler.</simpara></requires>
+      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
+      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
+    </copy-assignment>
+
+    <method-group name="modifiers">
+      <method name="swap">
+        <type>void</type>
+        <parameter name="f"><paramtype>const <classname>functionN</classname>&amp;</paramtype></parameter>
+        <effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
+      </method>
+
+      <method name="clear">
+        <type>void</type>
+        <postconditions><simpara>this-&gt;<methodname>empty</methodname>()</simpara></postconditions>
+      </method>
+    </method-group>
+
+    <method-group name="capacity">
+      <method name="empty" cv="const">
+        <type>bool</type>
+        <returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+
+      <method name="conversion-operator" cv="const">
+        <type>safe_bool</type>
+        <returns><simpara>A <code>safe_bool</code> that evaluates <code>false</code> in a boolean context when <code>this-&gt;<methodname>empty</methodname>()</code>, and <code>true</code> otherwise.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+
+      <method name="operator!" cv="const">
+        <type>bool</type>
+        <returns><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+    </method-group>
+
+    <method-group name="target access">
+      <overloaded-method name="target">
+        <signature>
+          <template> 
+            <template-type-parameter name="Functor"/>
+          </template>
+          <type>Functor*</type>
+        </signature>
+        <signature cv="const">
+          <template> 
+            <template-type-parameter name="Functor"/>
+          </template>
+          <type>const Functor*</type>
+        </signature>
+
+        <returns><simpara>If <code>this</code> stores a target of type
+        <code>Functor</code>, returns the address of the
+        target. Otherwise, returns the NULL
+        pointer.</simpara></returns>
+
+        <throws><simpara>Will not throw.</simpara></throws>
+      </overloaded-method>
+
+      <method name="contains" cv="const">
+        <template>
+          <template-type-parameter name="Functor"/>
+        </template>
+        <type>bool</type>
+        <parameter name="f">
+          <paramtype>const Functor&amp;</paramtype>
+        </parameter>
+        <returns><simpara><code>true</code> if <code>this-&gt;<methodname>target</methodname>&lt;Functor&gt;()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this-&gt;target&lt;Functor&gt;()), f)</code></simpara></returns>
+ 
+      </method>
+
+      <method name="target_type" cv="const">
+        <type>const std::type_info&amp;</type>
+        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+
+    </method-group>
+
+    <method-group name="invocation">
+      <method name="operator()" cv="const">
+        <type>result_type</type>
+        <parameter name="a1"><paramtype>arg1_type</paramtype></parameter>
+        <parameter name="a2"><paramtype>arg2_type</paramtype></parameter>
+        <parameter><paramtype>...</paramtype></parameter>
+        <parameter name="aN"><paramtype>argN_type</paramtype></parameter>
+        <effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
+        <returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
+        <throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-&gt;<methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
+      </method>
+    </method-group>
+
+    <free-function-group name="specialized algorithms">
+      <function name="swap">
+        <template>
+          <template-type-parameter name="T1"/>
+          <template-type-parameter name="T2"/>
+          <template-varargs/>
+          <template-type-parameter name="TN"/>
+        </template>
+        <type>void</type>
+        <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>
+
+    <free-function-group name="comparison operators">
+      <overloaded-function name="operator==">
+        <signature>
+          <template>
+            <template-type-parameter name="T1"/>
+            <template-type-parameter name="T2"/>
+            <template-varargs/>
+            <template-type-parameter name="TN"/>
+            <template-type-parameter name="Functor"/>
+          </template>
+          <type>bool</type>
+          <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>
+          <template>
+            <template-type-parameter name="T1"/>
+            <template-type-parameter name="T2"/>
+            <template-varargs/>
+            <template-type-parameter name="TN"/>
+            <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&gt;&amp;</paramtype></parameter>
+        </signature>        
+        <signature>
+          <template>
+            <template-type-parameter name="T1"/>
+            <template-type-parameter name="T2"/>
+            <template-varargs/>
+            <template-type-parameter name="TN"/>
+            <template-type-parameter name="Functor"/>
+          </template>
+          <type>bool</type>
+          <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>
+          <template>
+            <template-type-parameter name="T1"/>
+            <template-type-parameter name="T2"/>
+            <template-varargs/>
+            <template-type-parameter name="TN"/>
+            <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&gt;&amp;</paramtype></parameter>
+        </signature>        
+        <signature>
+          <template>
+            <template-type-parameter name="T1"/>
+            <template-type-parameter name="T2"/>
+            <template-varargs/>
+            <template-type-parameter name="TN"/>
+            <template-type-parameter name="U1"/>
+            <template-type-parameter name="U2"/>
+            <template-varargs/>
+            <template-type-parameter name="UN"/>
+          </template>
+          <type>void</type>
+          <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
+        type <code>Functor</code> and one of the following conditions applies:
+          <itemizedlist>
+
+            <listitem><simpara><code>g</code> is of type
+            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
+            and <code>f.target&lt;Functor&gt;() == g.<methodname
+            alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
+
+            <listitem><simpara><code>g</code> is not of type
+            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
+            and
+            <code><functionname>function_equal</functionname>(*(f.target&lt;Functor&gt;()),
+            g)</code>.</simpara></listitem>
+
+          </itemizedlist>
+          </simpara></returns>
+
+        <notes><simpara><code><classname>functionN</classname></code>
+        objects are not
+        <conceptname>EqualityComparable</conceptname>.</simpara></notes>
+
+        <rationale><simpara>The <code>safe_bool</code> conversion
+        opens a loophole whereby two <code>functionN</code>
+        instances can be compared via <code>==</code>, although this
+        is not feasible to implement. The undefined <code>void
+        operator==</code> closes the loophole and ensures a
+        compile-time or link-time error.</simpara></rationale>
+      </overloaded-function>
+
+      <overloaded-function name="operator!=">
+        <signature>
+          <template>
+            <template-type-parameter name="T1"/>
+            <template-type-parameter name="T2"/>
+            <template-varargs/>
+            <template-type-parameter name="TN"/>
+            <template-type-parameter name="Functor"/>
+          </template>
+          <type>bool</type>
+          <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>
+          <template>
+            <template-type-parameter name="T1"/>
+            <template-type-parameter name="T2"/>
+            <template-varargs/>
+            <template-type-parameter name="TN"/>
+            <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&gt;&amp;</paramtype></parameter>
+        </signature>        
+        <signature>
+          <template>
+            <template-type-parameter name="T1"/>
+            <template-type-parameter name="T2"/>
+            <template-varargs/>
+            <template-type-parameter name="TN"/>
+            <template-type-parameter name="Functor"/>
+          </template>
+          <type>bool</type>
+          <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>
+          <template>
+            <template-type-parameter name="T1"/>
+            <template-type-parameter name="T2"/>
+            <template-varargs/>
+            <template-type-parameter name="TN"/>
+            <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&gt;&amp;</paramtype></parameter>
+        </signature>        
+        <signature>
+          <template>
+            <template-type-parameter name="T1"/>
+            <template-type-parameter name="T2"/>
+            <template-varargs/>
+            <template-type-parameter name="TN"/>
+            <template-type-parameter name="U1"/>
+            <template-type-parameter name="U2"/>
+            <template-varargs/>
+            <template-type-parameter name="UN"/>
+          </template>
+          <type>void</type>
+          <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
+        object of type <code>Functor</code> or it stores an object of
+        type <code>Functor</code> and one of the following conditions
+        applies:
+          <itemizedlist>
+
+            <listitem><simpara><code>g</code> is of type
+            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
+            and <code>f.target&lt;Functor&gt;() != g.<methodname
+            alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
+
+            <listitem><simpara><code>g</code> is not of type
+            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
+            and <code>!<functionname>function_equal</functionname>(*(f.target&lt;Functor&gt;()), g)</code>.</simpara></listitem>
+
+          </itemizedlist>
+          </simpara></returns>
+
+        <notes><simpara><code><classname>functionN</classname></code>
+        objects are not
+        <conceptname>EqualityComparable</conceptname>.</simpara></notes>
+
+        <rationale><simpara>The <code>safe_bool</code> conversion
+        opens a loophole whereby two <code>functionN</code>
+        instances can be compared via <code>!=</code>, although this
+        is not feasible to implement. The undefined <code>void
+        operator!=</code> closes the loophole and ensures a
+        compile-time or link-time error.</simpara></rationale>
+      </overloaded-function>
+    </free-function-group>
+  </class>
+
+  <class name="function">
+    <template>
+      <template-type-parameter name="Signature">
+        <purpose>Function type R (T1, T2, ..., TN)</purpose>
+      </template-type-parameter>
+    </template>
+    <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>
+
+    <description>
+      <para>Class template <classname>function</classname> is a thin
+      wrapper around the numbered class templates <classname
+      alt="functionN">function0</classname>, <classname
+      alt="functionN">function1</classname>, etc. It accepts a
+      function type with N arguments and will will derive from
+      <classname>functionN</classname> instantiated with the arguments
+      it receives.</para>
+
+      <para>The semantics of all operations in class template
+      <classname>function</classname> are equivalent to that of the
+      underlying <classname>functionN</classname> object, although
+      additional member functions are required to allow proper copy
+      construction and copy assignment of function objects.</para>
+    </description>
+
+    <typedef name="result_type"><type>R</type></typedef>
+    <typedef name="argument_type">
+      <type>T1</type><purpose>If N == 1</purpose>
+    </typedef>
+    <typedef name="first_argument_type">
+      <type>T1</type>
+      <purpose>If N == 2</purpose>
+    </typedef>
+    <typedef name="second_argument_type">
+      <type>T2</type>
+      <purpose>If N == 2</purpose>
+    </typedef>
+    <typedef name="arg1_type"><type>T1</type></typedef>
+    <typedef name="arg2_type"><type>T2</type></typedef>
+    <typedef name="..."><type/></typedef>
+    <typedef name="argN_type"><type>TN</type></typedef>
+
+    <static-constant name="arity">
+      <type>int</type>
+      <default>N</default>
+    </static-constant>
+
+    <struct name="sig">
+      <template>
+        <template-type-parameter name="Args"/>
+      </template>
+
+      <purpose>
+        <simpara><libraryname>Lambda</libraryname> library support</simpara>
+      </purpose>
+
+      <typedef name="type"><type>result_type</type></typedef>
+    </struct>
+
+    <constructor>
+      <postconditions><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></postconditions>
+      <throws><simpara>Will not throw.</simpara></throws>
+    </constructor>
+
+    <constructor>
+      <parameter name="f">
+        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
+      </parameter>
+      <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>
+      </parameter>
+      <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>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"/>
+      </template>
+      <parameter name="f"><paramtype>F</paramtype></parameter>
+      <requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
+      <postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-&gt;<methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
+    </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>
+
+    </destructor>
+
+    <copy-assignment>
+      <parameter name="f">
+        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
+      </parameter>
+      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
+    </copy-assignment>
+    
+    <copy-assignment>
+      <parameter name="f">
+        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
+      </parameter>
+      <requires><simpara>C++11 compatible compiler.</simpara></requires>
+      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
+      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
+    </copy-assignment>
+
+    <copy-assignment>
+      <parameter name="f">
+        <paramtype>const <classname>function</classname>&amp;</paramtype>
+      </parameter>
+      <postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
+      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></throws>
+    </copy-assignment>
+    
+    <copy-assignment>
+      <parameter name="f">
+        <paramtype><classname>function</classname>&amp;&amp;</paramtype>
+      </parameter>
+      <requires><simpara>C++11 compatible compiler.</simpara></requires>
+      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
+      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
+    </copy-assignment>
+
+    <method-group name="modifiers">
+      <method name="swap">
+        <type>void</type>
+        <parameter name="f"><paramtype>const <classname>function</classname>&amp;</paramtype></parameter>
+        <effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
+      </method>
+
+      <method name="clear">
+        <type>void</type>
+        <postconditions><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></postconditions>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+    </method-group>
+
+    <method-group name="capacity">
+      <method name="empty" cv="const">
+        <type>bool</type>
+        <returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+
+      <method name="conversion-operator" cv="const">
+        <type>safe_bool</type>
+        <returns><simpara>A <code>safe_bool</code> that evaluates <code>false</code> in a boolean context when <code>this-&gt;<methodname>empty</methodname>()</code>, and <code>true</code> otherwise.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+
+      <method name="operator!" cv="const">
+        <type>bool</type>
+        <returns><simpara><code>this-&gt;<methodname>empty</methodname>()</code></simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+    </method-group>
+
+    <method-group name="target access">
+      <overloaded-method name="target">
+        <signature>
+          <template> 
+            <template-type-parameter name="Functor"/>
+          </template>
+          <type>Functor*</type>
+        </signature>
+        <signature cv="const">
+          <template> 
+            <template-type-parameter name="Functor"/>
+          </template>
+          <type>const Functor*</type>
+        </signature>
+
+        <returns><simpara>If <code>this</code> stores a target of type
+        <code>Functor</code>, returns the address of the
+        target. Otherwise, returns the NULL
+        pointer.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </overloaded-method>
+
+      <method name="contains" cv="const">
+        <template>
+          <template-type-parameter name="Functor"/>
+        </template>
+        <type>bool</type>
+        <parameter name="f">
+          <paramtype>const Functor&amp;</paramtype>
+        </parameter>
+        <returns><simpara><code>true</code> if <code>this-&gt;<methodname>target</methodname>&lt;Functor&gt;()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this-&gt;target&lt;Functor&gt;()), f)</code></simpara></returns>
+ 
+      </method>
+
+      <method name="target_type" cv="const">
+        <type>const std::type_info&amp;</type>
+        <returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></returns>
+        <throws><simpara>Will not throw.</simpara></throws>
+      </method>
+    </method-group>
+
+    <method-group name="invocation">
+      <method name="operator()" cv="const">
+        <type>result_type</type>
+        <parameter name="a1"><paramtype>arg1_type</paramtype></parameter>
+        <parameter name="a2"><paramtype>arg2_type</paramtype></parameter>
+        <parameter><paramtype>...</paramtype></parameter>
+        <parameter name="aN"><paramtype>argN_type</paramtype></parameter>
+        <effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
+        <returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
+        <throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-&gt;<methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
+      </method>
+    </method-group>
+
+    <free-function-group name="specialized algorithms">
+      <function name="swap">
+        <template>
+          <template-type-parameter name="Signature"/>
+        </template>
+        <type>void</type>
+        <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>
+
+    <free-function-group name="comparison operators">
+      <overloaded-function name="operator==">
+        <signature>
+          <template>
+            <template-type-parameter name="Signature"/>
+            <template-type-parameter name="Functor"/>
+          </template>
+          <type>bool</type>
+          <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="Functor"/>
+          </template>
+          <type>bool</type>
+          <parameter name="g"><paramtype>Functor</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="Functor"/>
+          </template>
+          <type>bool</type>
+          <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="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&gt;&amp;</paramtype></parameter>
+        </signature>        
+        <signature>
+          <template>
+            <template-type-parameter name="Signature1"/>
+            <template-type-parameter name="Signature2"/>
+          </template>
+          <type>void</type>
+          <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
+        type <code>Functor</code> and one of the following conditions applies:
+          <itemizedlist>
+
+            <listitem><simpara><code>g</code> is of type
+            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
+            and <code>f.target&lt;Functor&gt;() == g.<methodname
+            alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
+
+            <listitem><simpara><code>g</code> is not of type
+            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
+            and <code><functionname>function_equals</functionname>(*(f.target&lt;Functor&gt;()), g)</code>.</simpara></listitem>
+
+          </itemizedlist>
+          </simpara></returns>
+
+        <notes><simpara><code><classname>function</classname></code>
+        objects are not
+        <conceptname>EqualityComparable</conceptname>.</simpara></notes>
+
+        <rationale><simpara>The <code>safe_bool</code> conversion
+        opens a loophole whereby two <code>function</code>
+        instances can be compared via <code>==</code>, although this
+        is not feasible to implement. The undefined <code>void
+        operator==</code> closes the loophole and ensures a
+        compile-time or link-time error.</simpara></rationale>
+      </overloaded-function>
+
+      <overloaded-function name="operator!=">
+        <signature>
+          <template>
+            <template-type-parameter name="Signature"/>
+            <template-type-parameter name="Functor"/>
+          </template>
+          <type>bool</type>
+          <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="Functor"/>
+          </template>
+          <type>bool</type>
+          <parameter name="g"><paramtype>Functor</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="Functor"/>
+          </template>
+          <type>bool</type>
+          <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="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&gt;&amp;</paramtype></parameter>
+        </signature>        
+        <signature>
+          <template>
+            <template-type-parameter name="Signature1"/>
+            <template-type-parameter name="Signature2"/>
+          </template>
+          <type>void</type>
+          <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
+        object of type <code>Functor</code> or it stores an object of
+        type <code>Functor</code> and one of the following conditions
+        applies:
+          <itemizedlist>
+
+            <listitem><simpara><code>g</code> is of type
+            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
+            and <code>f.target&lt;Functor&gt;() != g.<methodname
+            alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
+
+            <listitem><simpara><code>g</code> is not of type
+            <code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
+            and <code>!<functionname>function_equals</functionname>(*(f.target&lt;Functor&gt;()), g)</code>.</simpara></listitem>
+
+          </itemizedlist>
+          </simpara></returns>
+
+        <notes><simpara><code><classname>function</classname></code>
+        objects are not
+        <conceptname>EqualityComparable</conceptname>.</simpara></notes>
+
+        <rationale><simpara>The <code>safe_bool</code> conversion
+        opens a loophole whereby two <code>function</code>
+        instances can be compared via <code>!=</code>, although this
+        is not feasible to implement. The undefined <code>void
+        operator!=</code> closes the loophole and ensures a
+        compile-time or link-time error.</simpara></rationale>
+      </overloaded-function>
+    </free-function-group>
+  </class>
+</namespace>
+</header>
+
+<header name="boost/function_equal.hpp">
+  <namespace name="boost">
+  <function name="function_equal">
+    <template>
+      <template-type-parameter name="F"/>
+      <template-type-parameter name="G"/>
+    </template>
+    <type>bool</type>
+    <parameter name="f">
+      <paramtype>const F&amp;</paramtype>
+    </parameter>
+    <parameter name="g">
+      <paramtype>const G&amp;</paramtype>
+    </parameter>
+    <purpose><simpara>Compare two function objects for equality.</simpara></purpose>
+    <returns><simpara><code>f == g</code>.</simpara></returns>
+    <throws><simpara>Only if <code>f == g</code> throws.</simpara></throws>
+  </function>
+  </namespace>
+</header>
+</library-reference>

doc/tests.xml

@@ -0,0 +1,258 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
+  
+   Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or copy at
+   http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
+  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
+<testsuite id="function.testsuite" last-revision="$Date$">
+  <run-test filename="function_test.cpp" name="lib_function_test">
+    <purpose><para>Test the capabilities of the <classname>boost::function</classname> class template.</para></purpose>
+    <if-fails><para>The <classname>boost::function</classname> class template may not be usable on your compiler. However, the library may still be usable via the <classname>boost::functionN</classname> class templates.</para></if-fails>
+  </run-test>
+
+  <run-test filename="function_n_test.cpp">
+    <purpose><para>Test the capabilities of the <classname>boost::functionN</classname> class templates.</para></purpose>
+  </run-test>
+
+  <run-test filename="allocator_test.cpp">
+    <purpose><para>Test the use of custom allocators.</para></purpose>
+    <if-fails><para>Allocators are ignored by the implementation.</para></if-fails>
+  </run-test>
+
+  <run-test filename="stateless_test.cpp">
+    <purpose><para>Test the optimization of stateless function objects in the Boost.Function library.</para></purpose>
+    <if-fails><para>The exception-safety and performance guarantees given for stateless function objects may not be met by the implementation.</para></if-fails>
+  </run-test>
+
+  <run-test filename="lambda_test.cpp">
+    <purpose><para>Test the interaction between Boost.Function and Boost.Lambda.</para></purpose>
+    <if-fails><para>Either Boost.Lambda does not work on the platform, or Boost.Function cannot safely be applied without the use of <functionname>boost::unlambda</functionname>.</para></if-fails>
+  </run-test>
+
+  <run-test filename="contains_test.cpp">
+    <purpose><para>Test the operation of the
+    <code><methodname>target</methodname></code> member function and the
+    equality operators.</para></purpose>
+  </run-test>
+
+  <compile-fail-test filename="function_test_fail1.cpp">
+    <purpose><para>Test the (incorrect!) use of comparisons between Boost.Function function objects.</para></purpose>
+    <if-fails><para>Intuitive (but incorrect!) code may compile and will give meaningless results.</para></if-fails>
+  </compile-fail-test>
+
+  <compile-fail-test filename="function_test_fail2.cpp">
+    <purpose><para>Test the use of an incompatible function object with Boost.Function</para></purpose>
+    <if-fails><para>Incorrect code may compile (with potentially unexpected results).</para></if-fails>
+  </compile-fail-test>
+
+  <compile-test filename="function_30.cpp">
+    <purpose><para>Test the generation of a Boost.Function function object adaptor accepting 30 arguments.</para></purpose>
+    <if-fails><para>The Boost.Function library may work for function object adaptors of up to 10 parameters, but will be unable to generate adaptors for an arbitrary number of parameters. Failure often indicates an error in the compiler's preprocessor.</para></if-fails>
+  </compile-test> 
+
+  <run-test filename="function_arith_cxx98.cpp">
+    <source>
+    <![CDATA[
+#include <boost/function.hpp>
+#include <iostream>
+]]>
+
+<snippet name="function.tutorial.mul_ints"/>
+<snippet name="function.tutorial.int_div"/>
+
+int main()
+{
+    <snippet name="function.tutorial.arith.cxx98"/>
+    <snippet name="function.tutorial.use_int_div"/>
+    <snippet name="function.tutorial.call_int_div"/>
+    <snippet name="function.tutorial.check_empty"/>
+    <snippet name="function.tutorial.clear"/>
+    <snippet name="function.tutorial.use_mul_ints"/>
+  
+    return 0;
+}
+</source>
+    <purpose><para>Test the first tutorial example.</para></purpose>
+  </run-test>
+
+  <run-test filename="function_arith_portable.cpp">
+    <source>
+    <![CDATA[
+#include <boost/function.hpp>
+#include <iostream>
+]]>
+<snippet name="function.tutorial.mul_ints"/>
+<snippet name="function.tutorial.int_div"/>
+int main()
+{
+    <snippet name="function.tutorial.arith.portable"/>
+    <snippet name="function.tutorial.use_int_div"/>
+    <snippet name="function.tutorial.call_int_div"/>
+    <snippet name="function.tutorial.check_empty"/>
+    <snippet name="function.tutorial.clear"/>
+    <snippet name="function.tutorial.use_mul_ints"/>
+
+    return 0;
+}
+</source>
+    <purpose><para>Test the first tutorial example.</para></purpose>
+  </run-test>
+
+  <run-test filename="sum_avg_cxx98.cpp">
+    <source>
+    <![CDATA[
+#include <boost/function.hpp>
+#include <iostream>
+]]>
+<snippet name="function.tutorial.sum_avg"/>
+int main()
+{
+    <snippet name="function.tutorial.sum_avg_decl.cxx98"/>
+    <snippet name="function.tutorial.use_sum_avg"/>
+
+    return 0;
+}
+</source>
+    <purpose><para>Test the second tutorial example.</para></purpose>
+  </run-test>
+
+  <run-test filename="sum_avg_portable.cpp">
+    <source>
+    <![CDATA[
+#include <boost/function.hpp>
+#include <iostream>
+]]>
+<snippet name="function.tutorial.sum_avg"/>
+int main()
+{
+    <snippet name="function.tutorial.sum_avg_decl.portable"/>
+    <snippet name="function.tutorial.use_sum_avg"/>
+
+    return 0;
+}
+</source>
+    <purpose><para>Test the second tutorial example.</para></purpose>
+  </run-test>
+
+  <run-test filename="mem_fun_cxx98.cpp">
+    <source>
+    <![CDATA[
+#include <boost/function.hpp>
+#include <iostream>
+#include <functional>
+]]>
+<snippet name="function.tutorial.X"/>
+int X::foo(int x) { return -x; }
+
+int main()
+{
+    <snippet name="function.tutorial.mem_fun.cxx98"/>
+
+    return 0;
+}
+</source>    
+    <purpose><para>Test member function example from tutorial.</para></purpose>
+  </run-test>
+
+  <run-test filename="mem_fun_portable.cpp">
+    <source>
+    <![CDATA[
+#include <boost/function.hpp>
+#include <iostream>
+#include <functional>
+]]>
+<snippet name="function.tutorial.X"/>
+int X::foo(int x) { return -x; }
+
+int main()
+{
+    <snippet name="function.tutorial.mem_fun.portable"/>
+
+    return 0;
+}
+</source>    
+    <purpose><para>Test member function example from tutorial.</para></purpose>
+  </run-test>
+
+  <run-test filename="std_bind_cxx98.cpp">
+    <source>
+    <![CDATA[
+#include <boost/function.hpp>
+#include <iostream>
+#include <functional>
+]]>
+<snippet name="function.tutorial.X"/>
+int X::foo(int x) { return -x; }
+
+int main()
+{
+    <snippet name="function.tutorial.std_bind.cxx98"/>
+
+    return 0;
+}
+</source>
+    <purpose><para>Test standard binders example from tutorial.</para></purpose>
+  </run-test>
+
+  <run-test filename="std_bind_portable.cpp">
+    <source>
+    <![CDATA[
+#include <boost/function.hpp>
+#include <iostream>
+#include <functional>
+]]>
+<snippet name="function.tutorial.X"/>
+int X::foo(int x) { return -x; }
+
+int main()
+{
+    <snippet name="function.tutorial.std_bind.portable"/>
+
+    return 0;
+}
+</source>
+    <purpose><para>Test standard binders example from tutorial.</para></purpose>
+  </run-test>
+
+  <run-test filename="function_ref_cxx98.cpp">
+    <source>
+<![CDATA[
+#include <boost/function.hpp>
+#include <iostream>
+]]>
+
+struct stateful_type { int operator()(int) const { return 0; } };
+
+int main()
+{
+  <snippet name="function.tutorial.ref.cxx98"/>
+
+    return 0;
+}
+</source>
+    <purpose><para>Test <functionname>boost::ref</functionname> example from tutorial.</para></purpose>
+  </run-test>
+
+  <run-test filename="function_ref_portable.cpp">
+    <source>
+<![CDATA[
+#include <boost/function.hpp>
+#include <iostream>
+]]>
+
+struct stateful_type { int operator()(int) const { return 0; } };
+
+int main()
+{
+  <snippet name="function.tutorial.ref.portable"/>
+
+    return 0;
+}
+</source>
+    <purpose><para>Test <functionname>boost::ref</functionname> example from tutorial.</para></purpose>
+  </run-test>
+</testsuite>

doc/tutorial.html

@@ -1,167 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>Boost.Function Tutorial</title>
-  </head>
-
-  <body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080">
-
-    <h1><IMG SRC="../../../c++boost.gif" WIDTH="276" HEIGHT="86">Boost.Function Tutorial</h1>
-
-<h2><a name="usage">Basic usage</a></h2>
-<p> A function wrapper is defined simply by instantiating the <code>function</code> class template with the desired return type and argument types. Any number of arguments may be supplied, up to some implementation-defined limit (10 is the default maximum). The following declares a function object wrapper <code>f</code> that takes two <code>int</code> parameters and returns a <code>float</code>:
-<pre>
-boost::<a href="reference.html#function">function</a>&lt;float, int, int&gt; f;
-</pre>
-
-<p> By default, function object wrappers are empty, so we can create a 
-function object to assign to <code>f</code>:
-<pre>
-struct int_div { 
-  float operator()(int x, int y) const { return ((float)x)/y; }; 
-};
-
-f = int_div();
-</pre>
-
-<p> Now we can use <code>f</code> to execute the underlying function object
-<code>int_div</code>:
-<pre>
-std::cout << f(5, 3) << std::endl;
-</pre>
-
-<p> We are free to assign any compatible function object to <code>f</code>. If <code>int_div</code> had been declared to take two <code>long</code> operands,
-the implicit conversions would have been applied to the arguments without any user interference. The only limit on the types of arguments is that they be CopyConstructible, so we can even use references and arrays:
-<pre>
-boost::function&lt;void, int[], int, int&, float&&gt; sum_avg;
-
-void do_sum_avg(int values[], int n, int& sum, float&amp; avg)
-{
-  sum = 0;
-  for (int i = 0; i < n; i++)
-    sum += values[i];
-  avg = (float)sum / n;
-}
-
-sum_avg = &do_sum_avg;
-</pre>
-
-<p> Invoking a function object wrapper that does not actually contain a function object is a precondition violation, much like trying to call through a null function pointer. We can check for an empty function object wrapper by querying its <code><a href="reference.html#empty">empty</a>()</code> method or, more succinctly, by using it in a boolean context: if it evaluates true, it contains a function object target, i.e.,
-<pre>
-if (f)
-  std::cout << f(5, 3) << std::endl;
-else
-  std::cout << "f has no target, so it is unsafe to call" << std::endl;
-</pre>
-
-<p> We can clear out a function target using the <code><a href="reference.html#functionN_clear">clear</a>()</code> member function.
-
-<h3>Free functions</h3>
-<p> Free function pointers can be considered singleton function objects with const function call operators, and can therefore be directly used with the function object wrappers:
-<pre>
-  float mul_ints(int x, int y) { return ((float)x) * y; }
-  f = &mul_ints;
-</pre>
-
-<h3>Member functions</h3>
-<a name="member_func">
-<p> In many systems, callbacks often call to member functions of a particular
-object. Handling argument binding is beyond the scope of Boost.Function. However, there are several libraries that perform 'argument binding', including
-<ul>
-  <li> The C++ Standard library. Using <code>std::bind1st</code> and <code>std::mem_fun</code> together one can bind the object of a pointer-to-member function for use with Boost.Function:
-<pre>
-  struct X {
-    int foo(int);
-  };
-
-  boost::function&lt;int, int&gt; f;
-  X x;
-  f = std::bind1st(std::mem_fun(&X::foo), &x);
-
-  f(5); // Call x.foo(5)</pre></li>
-
-  <li><a href="http://lambda.cs.utu.fi/">The Lambda library</a>. This library provides a powerful composition mechanism to construct function objects that uses very natural C++ syntax. Lambda requires a compiler that is reasonably conformant to the C++ standard. Note that it is not a Boost library.</li>
-
-  <li>Peter Dimov's <a href="http://groups.yahoo.com/group/boost/files/bind/bind.hpp">bind</a> library. It has a smaller scope than the Lambda Library but is more tolerant of broken compilers. It is an unreviewed library in development.</li>
-</ul>
-
-<h2><a name="family">The <code>function</code> family</a></h2>
-<p> The header &lt;<a href="../../../boost/function.hpp">boost/function.hpp</a>&gt; defines the primary entry point to the function object wrappers, the class template <code>boost::function</code>. This class template is essentially a thin wrapper around a set of similar numbered function object wrappers, <code>boost::function0</code>, <code>boost::function1</code>, etc., where the number indicates the number of arguments passed to the function object target. The declaration of <code>f</code> above could also be written as:
-<pre>
-boost::function2&lt;float, int, int&gt; f;
-</pre>
-
-<p> The numbered class templates contain most of the implementation and are each distinct class templates. They may be helpful if used in shared libraries, where the number of arguments supported by Boost.Function may change between revisions. Additionally, some compilers (e.g., Microsoft Visual C++ 6.0) have been known to be incapable of compiling <code>boost::function</code> in some instances but are able to handle the numbered variants.
-
-<h2><a name="advanced">Advanced usage</a></h2>
-<p> The <code>boost::function</code> family supports additional customization by means of policies, mixins, and allocators. The specific usage of each of these will be explained in later sections, but they share a common problem: how to replace each default with your own version. 
-
-<p> With <code>boost::function</code> it is not so clear, because support for an arbitrary number of parameters means that it is impossible to specify just the last parameter, but not 5 of the parameters in between. Therefore, <code>boost::function</code> doubles as a generative interface for the underlying numbered class templates that uses named template parameters. For instance, to specify both a policy and an allocator for a function object wrapper <code>f</code> taking an <code>int</code> and returning an <code>int</code>, use:
-<pre>
-  function&lt;int, int&gt;::policy&lt;MyPolicy&gt;::allocator&lt;MyAllocator&gt;::type f;
-</pre>
-
-<p> The named template parameters <code>policy</code>, <code>mixin</code> and <code>allocator</code> each take one template parameter (the replacement class) and may be nested as above to generate a function object wrapper. The <code>::type</code> at the end accesses the actual type that fits the given properties.
-
-<h3><a name="policies">Policies</a></h3>
-<p> Policies define what happens directly before and directly after an invocation of a function object target is made. A policy must have two member functions, <code>precall</code> and <code>postcall</code>, each of which must be able to accept a <code>const</code> function object wrapper pointer. The following policy will print "before" prior to execution and "after" afterwards:
-
-<pre>
-struct print_policy {
-  void precall(const boost::function_base*) { std::cout << "before"; }
-  void postcall(const boost::function_base*) { std::cout << "after"; }
-};
-</pre>
-
-<p> A new instance of the policy class will be created prior to calling the function object target and will be preserved until after the call has returned. Therefore, for any invocation the <code>precall</code> and <code>postcall</code> will be executed on the same policy class instance; however, policy class instances will not be kept between target invocations.
-
-<p> Policies are further <a href="../../../more/generic_programming.html#policy">described</a> in the Boost discussion on <a href="../../../more/generic_programming.html">generic programming techniques</a>.
-
-<h3><a name="mixins">Mixins</a></h3>
-<p> The function object wrappers allow any class to be "mixed in" as a base class. This allows extra members and/or functionality to be included by the user. This can be used, for instance, to overcome the limitations of policies by storing data between invocations in a base class instead of in a <code>static</code> member of a policy class. 
-
-<h3><a name="allocators">Allocators</a></h3>
-<p> The function object wrappers allow the user to specify a new allocator to handle the cloning of function object targets (when the wrappers are copied). The allocators used are the same as the C++ standard library allocators. The wrappers assume the allocators are stateless, and will create a new instance each time they are used (because they are rebound very often). This shares the semantics of most standard library implementations, and is explicitly allowed by the C++ standard.
-
-<h3><a name="synchronizing">Example: Synchronized callbacks</a></h3>
-<p> Synchronization of callbacks in a multithreaded environment is extremely important. Using mixins and policies, a Boost.Function object may implement its own synchronization policy that ensures that only one thread can be in the callback function at any given point in time.
-
-<p> We will use the prototype Boost.Threads library for its <code>recursive_mutex</code>. Since the mutex is on a per-callback basis, we will add a mutex to the <code>boost::function</code> by mixin it in with this mixin class:
-<pre>
-class SynchronizedMixin {
-  mutable boost::recursive_mutex mutex;
-};
-</pre>
-
-<p> Next, we create a policy that obtains a lock before the target is called (via the <code>precall</code> function) and releases the lock after the target has been called (via the <code>postcall</code> function):
-
-<pre>
-class SynchronizedPolicy {
-  std::auto_ptr&lt;boost::recursive_mutex::lock&gt; lock;
-
-  void precall(const SynchronizedMixin* f) 
-  {
-    lock.reset(new boost::recursive_mutex::lock(f->mutex));
-  }
-
-  void postcall(const SynchronizedMixin* f)
-  {
-    lock.reset();
-  }
-};
-</pre>
-
-<p>The use of <code>std::auto_ptr</code> ensures that the lock will be destroyed (and therefore released) if an exception is thrown by the target function. Now we can use the policy and mixin together to create a synchronized callback:
-
-<pre>
-boost::function2&lt;float, int, int, SynchronizedPolicy, SynchronizedMixin&gt; f;
-</pre>
-
-    <hr>
-    <address><a href="mailto:gregod@cs.rpi.edu">Douglas Gregor</a></address>
-<!-- Created: Fri Jul 13 12:47:11 EDT 2001 -->
-<!-- hhmts start -->
-Last modified: Fri Jul 13 23:58:17 EDT 2001
-<!-- hhmts end -->
-  </body>
-</html>

doc/tutorial.xml

@@ -0,0 +1,364 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
+  
+   Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or copy at
+   http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
+  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
+<section xmlns:xi="http://www.w3.org/2001/XInclude" id="function.tutorial"
+         last-revision="$Date$">
+<title>Tutorial</title>
+
+<using-namespace name="boost"/>
+
+<para> Boost.Function has two syntactical forms: the preferred form
+and the portable form. The preferred form fits more closely with the
+C++ language and reduces the number of separate template parameters
+that need to be considered, often improving readability; however, the
+preferred form is not supported on all platforms due to compiler
+bugs. The compatible form will work on all compilers supported by
+Boost.Function. Consult the table below to determine which syntactic
+form to use for your compiler.
+
+  <informaltable>
+    <tgroup cols="2" align="left">
+      <thead>
+        <row>
+          <entry>Preferred syntax</entry>
+          <entry>Portable syntax</entry>
+        </row>
+      </thead>
+      <tbody>
+        <row>
+          <entry>
+            <itemizedlist spacing="compact">
+              <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 and later versions</simpara></listitem>
+            </itemizedlist>
+          </entry>
+          <entry>
+            <itemizedlist spacing="compact">
+              <listitem><simpara><emphasis>Any compiler supporting the preferred syntax</emphasis></simpara></listitem>
+              <listitem><simpara>Microsoft Visual C++ 6.0, 7.0</simpara></listitem>
+              <listitem><simpara>Borland C++ 5.5.1</simpara></listitem>
+              <listitem><simpara>Sun WorkShop 6 update 2 C++ 5.3</simpara></listitem>
+              <listitem><simpara>Metrowerks CodeWarrior 8.1</simpara></listitem>
+            </itemizedlist>
+          </entry>
+        </row>
+      </tbody>
+    </tgroup>
+  </informaltable>
+
+</para>
+
+<para> If your compiler does not appear in this list, please try the preferred syntax and report your results to the Boost list so that we can keep this table up-to-date.</para>
+
+<using-class name="boost::function"/>
+
+<section>
+<title>Basic Usage</title> <para> A function wrapper is defined simply
+by instantiating the <computeroutput>function</computeroutput> class
+template with the desired return type and argument types, formulated
+as a C++ function type. Any number of arguments may be supplied, up to
+some implementation-defined limit (10 is the default maximum). The
+following declares a function object wrapper
+<computeroutput>f</computeroutput> that takes two
+<computeroutput>int</computeroutput> parameters and returns a
+<computeroutput>float</computeroutput>:
+
+  <informaltable>
+    <tgroup cols="2" align="left">
+      <thead>
+        <row>
+          <entry>Preferred syntax</entry>
+          <entry>Portable syntax</entry>
+        </row>
+      </thead>
+      <tbody>
+        <row>
+          <entry>
+<programlisting name="function.tutorial.arith.cxx98"><classname>boost::function</classname>&lt;float (int x, int y)&gt; f;</programlisting>
+</entry>
+<entry>
+<programlisting name="function.tutorial.arith.portable"><classname alt="functionN">boost::function2</classname>&lt;float, int, int&gt; f;</programlisting>
+</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </informaltable>
+</para>
+
+<para> By default, function object wrappers are empty, so we can create a 
+function object to assign to <computeroutput>f</computeroutput>:
+
+<programlisting name="function.tutorial.int_div">struct int_div { 
+  float operator()(int x, int y) const { return ((float)x)/y; }; 
+};</programlisting>
+<programlisting name="function.tutorial.use_int_div">f = int_div();</programlisting>
+</para>
+
+<para> Now we can use <computeroutput>f</computeroutput> to execute
+the underlying function object
+<computeroutput>int_div</computeroutput>:
+
+<programlisting name="function.tutorial.call_int_div">std::cout &lt;&lt; f(5, 3) &lt;&lt; std::endl;</programlisting>
+</para>
+
+<para> We are free to assign any compatible function object to
+<computeroutput>f</computeroutput>. If
+<computeroutput>int_div</computeroutput> had been declared to take two
+<computeroutput>long</computeroutput> operands, the implicit
+conversions would have been applied to the arguments without any user
+interference. The only limit on the types of arguments is that they be
+CopyConstructible, so we can even use references and arrays:
+
+  <informaltable>
+    <tgroup cols="1" align="left">
+      <thead><row><entry>Preferred syntax</entry></row></thead>
+      <tbody>
+        <row>
+          <entry>
+<programlisting name="function.tutorial.sum_avg_decl.cxx98"><classname>boost::function</classname>&lt;void (int values[], int n, int&amp; sum, float&amp; avg)&gt; sum_avg;</programlisting>
+</entry>
+        </row>
+      </tbody>
+    </tgroup> 
+  </informaltable>
+  <informaltable>
+    <tgroup cols="1" align="left">
+      <thead><row><entry>Portable syntax</entry></row></thead>
+      <tbody>
+        <row>
+<entry>
+<programlisting name="function.tutorial.sum_avg_decl.portable"><classname alt="functionN">boost::function4</classname>&lt;void, int*, int, int&amp;, float&amp;&gt; sum_avg;</programlisting>
+</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </informaltable>
+
+<programlisting name="function.tutorial.sum_avg">void do_sum_avg(int values[], int n, int&amp; sum, float&amp; avg)
+{
+  sum = 0;
+  for (int i = 0; i &lt; n; i++)
+    sum += values[i];
+  avg = (float)sum / n;
+}</programlisting>
+
+
+<programlisting name="function.tutorial.use_sum_avg">sum_avg = &amp;do_sum_avg;</programlisting>
+</para>
+
+<para> Invoking a function object wrapper that does not actually
+contain a function object is a precondition violation, much like
+trying to call through a null function pointer, and will throw a <classname>bad_function_call</classname> exception). We can check for an
+empty function object wrapper by using it in a boolean context (it evaluates <computeroutput>true</computeroutput> if the wrapper is not empty) or compare it against <computeroutput>0</computeroutput>. For instance:
+<programlisting name="function.tutorial.check_empty">if (f)
+  std::cout &lt;&lt; f(5, 3) &lt;&lt; std::endl;
+else
+  std::cout &lt;&lt; "f has no target, so it is unsafe to call" &lt;&lt; std::endl;</programlisting>
+</para>
+
+<para> Alternatively,
+<computeroutput><methodname>empty</methodname>()</computeroutput>
+method will return whether or not the wrapper is empty.  </para>
+
+<para> Finally, we can clear out a function target by assigning it to <computeroutput>0</computeroutput> or by calling the <computeroutput><methodname>clear</methodname>()</computeroutput> member function, e.g., 
+<programlisting name="function.tutorial.clear">f = 0;</programlisting>
+</para>
+
+</section>
+
+<section>
+  <title>Free functions</title>
+<para> Free function pointers can be considered singleton function objects with const function call operators, and can therefore be directly used with the function object wrappers: 
+<programlisting name="function.tutorial.mul_ints">float mul_ints(int x, int y) { return ((float)x) * y; }</programlisting>
+<programlisting name="function.tutorial.use_mul_ints">f = &amp;mul_ints;</programlisting>
+</para>
+
+<para> Note that the <computeroutput>&amp;</computeroutput> isn't really necessary unless you happen to be using Microsoft Visual C++ version 6. </para>
+</section>
+
+<section>
+  <title>Member functions</title>
+
+<para> In many systems, callbacks often call to member functions of a
+particular object. This is often referred to as "argument binding",
+and is beyond the scope of Boost.Function. The use of member functions
+directly, however, is supported, so the following code is valid:
+
+<programlisting name="function.tutorial.X">struct X {
+  int foo(int);
+};</programlisting>
+
+  <informaltable>
+    <tgroup cols="2" align="left">
+      <thead>
+        <row>
+          <entry>Preferred syntax</entry>
+          <entry>Portable syntax</entry>
+        </row>
+      </thead>
+      <tbody>
+        <row>
+          <entry>
+<programlisting name="function.tutorial.mem_fun.cxx98"><classname>boost::function</classname>&lt;int (X*, int)&gt; f;
+
+f = &amp;X::foo;
+  
+X x;
+f(&amp;x, 5);</programlisting>
+</entry>
+<entry>
+<programlisting name="function.tutorial.mem_fun.portable"><classname alt="functionN">boost::function2</classname>&lt;int, X*, int&gt; f;
+
+f = &amp;X::foo;
+  
+X x;
+f(&amp;x, 5);</programlisting>
+</entry>
+</row>
+</tbody>
+</tgroup>
+</informaltable>
+</para>
+
+<para> Several libraries exist that support argument binding. Three such libraries are summarized below:
+<itemizedlist>
+  <listitem> <para><libraryname>Bind</libraryname>. This library allows binding of
+  arguments for any function object. It is lightweight and very
+  portable.</para></listitem>
+
+  <listitem> <para>The C++ Standard library. Using
+  <computeroutput>std::bind1st</computeroutput> and
+  <computeroutput>std::mem_fun</computeroutput> together one can bind
+  the object of a pointer-to-member function for use with
+  Boost.Function:
+
+  <informaltable>
+    <tgroup cols="2" align="left">
+      <thead>
+        <row>
+          <entry>Preferred syntax</entry>
+          <entry>Portable syntax</entry>
+        </row>
+      </thead>
+      <tbody>
+        <row>
+          <entry>
+<programlisting name="function.tutorial.std_bind.cxx98">  <classname>boost::function</classname>&lt;int (int)&gt; f;
+X x;
+f = std::bind1st(
+      std::mem_fun(&amp;X::foo), &amp;x);
+f(5); // Call x.foo(5)</programlisting>
+</entry>
+<entry>
+<programlisting name="function.tutorial.std_bind.portable">  <classname alt="functionN">boost::function1</classname>&lt;int, int&gt; f;
+X x;
+f = std::bind1st(
+      std::mem_fun(&amp;X::foo), &amp;x);
+f(5); // Call x.foo(5)</programlisting>
+</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </informaltable>
+</para>
+</listitem>
+
+  <listitem><para>The <libraryname>Lambda</libraryname> library. This library provides a powerful composition mechanism to construct function objects that uses very natural C++ syntax. Lambda requires a compiler that is reasonably conformant to the C++ standard. </para></listitem>
+</itemizedlist>
+</para>
+
+</section>
+
+<section>
+  <title>References to Function Objects</title> <para> In some cases it is
+  expensive (or semantically incorrect) to have Boost.Function clone a
+  function object. In such cases, it is possible to request that
+  Boost.Function keep only a reference to the actual function
+  object. This is done using the <computeroutput>ref</computeroutput>
+  and <computeroutput>cref</computeroutput> functions to wrap a
+  reference to a function object:
+
+  <informaltable>
+    <tgroup cols="2" align="left">
+      <thead>
+        <row>
+          <entry>Preferred syntax</entry>
+          <entry>Portable syntax</entry>
+        </row>
+      </thead>
+      <tbody>
+        <row>
+          <entry>
+<programlisting name="function.tutorial.ref.cxx98">stateful_type a_function_object;
+<classname>boost::function</classname>&lt;int (int)&gt; f;
+f = <functionname>boost::ref</functionname>(a_function_object);
+
+<classname>boost::function</classname>&lt;int (int)&gt; f2(f);</programlisting>
+</entry>
+<entry>
+<programlisting name="function.tutorial.ref.portable">stateful_type a_function_object;
+<classname alt="functionN">boost::function1</classname>&lt;int, int&gt; f;
+f = <functionname>boost::ref</functionname>(a_function_object);
+
+<classname alt="functionN">boost::function1</classname>&lt;int, int&gt; f2(f);</programlisting>
+</entry>
+          </row>
+        </tbody>
+      </tgroup>
+    </informaltable>
+</para>
+
+<para> Here, <computeroutput>f</computeroutput> will not make a copy
+of <computeroutput>a_function_object</computeroutput>, nor will
+<computeroutput>f2</computeroutput> when it is targeted to
+<computeroutput>f</computeroutput>'s reference to
+<computeroutput>a_function_object</computeroutput>. Additionally, when
+using references to function objects, Boost.Function will not throw
+exceptions during assignment or construction.
+</para>
+</section>
+
+<section>
+  <title>Comparing Boost.Function function objects</title>
+
+  <para>Function object wrappers can be compared via <code>==</code>
+  or <code>!=</code> against any function object that can be stored
+  within the wrapper. If the function object wrapper contains a
+  function object of that type, it will be compared against the given
+  function object (which must be either be
+  <conceptname>EqualityComparable</conceptname> or have an overloaded <functionname>boost::function_equal</functionname>). For instance:</para>
+  
+  <programlisting name="function.tutorial.compare">int compute_with_X(X*, int);
+
+f = &amp;X::foo;
+assert(f == &amp;X::foo);
+assert(&amp;compute_with_X != f);</programlisting>
+
+   <para>When comparing against an instance of
+   <code><classname>reference_wrapper</classname></code>, the address
+   of the object in the
+   <code><classname>reference_wrapper</classname></code> is compared
+   against the address of the object stored by the function object
+   wrapper:</para>
+
+  <programlisting name="function.tutorial.compare-ref">a_stateful_object so1, so2;
+f = <functionname>boost::ref</functionname>(so1);
+assert(f == <functionname>boost::ref</functionname>(so1));
+assert(f == so1); <emphasis>// Only if a_stateful_object is <conceptname>EqualityComparable</conceptname></emphasis>
+assert(f != <functionname>boost::ref</functionname>(so2));</programlisting>
+
+</section>
+
+</section>
+

example/Jamfile

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

example/bind1st.cpp

@@ -1,15 +1,9 @@
 // Boost.Function library examples
 
-// Copyright (C) 2001 Doug 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.
+//  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
 
@@ -29,7 +23,7 @@ struct X {
 int
 main()
 {
-  boost::function<int, int> f;
+  boost::function<int (int)> f;
   X x(7);
   f = std::bind1st(std::mem_fun(&X::foo), &x);
 

example/int_div.cpp

@@ -1,29 +1,23 @@
 // Boost.Function library examples
 
-// Copyright (C) 2001 Doug 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.
+//  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
 
 #include <iostream>
 #include <boost/function.hpp>
 
-struct int_div { 
-  float operator()(int x, int y) const { return ((float)x)/y; }; 
+struct int_div {
+  float operator()(int x, int y) const { return ((float)x)/y; };
 };
 
 int
 main()
 {
-  boost::function<float, int, int> f;
+  boost::function<float (int, int)> f;
   f = int_div();
 
   std::cout << f(5, 3) << std::endl; // 1.66667

example/sum_avg.cpp

@@ -1,15 +1,9 @@
 // Boost.Function library examples
 
-// Copyright (C) 2001 Doug 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.
+//  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
 
@@ -27,7 +21,9 @@ void do_sum_avg(int values[], int n, int& sum, float& avg)
 int
 main()
 {
-  boost::function<void, int[], int, int&, float&> sum_avg;
+  // The second parameter should be int[], but some compilers (e.g., GCC)
+  // complain about this
+  boost::function<void (int*, int, int&, float&)> sum_avg;
 
   sum_avg = &do_sum_avg;
 

include/boost/function.hpp

@@ -1,539 +1,76 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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
- 
+//  Copyright Douglas Gregor 2001-2003. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org/libs/function
+
 // William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
 // design of this library.
 
-#ifndef BOOST_FUNCTION_HPP
-#define BOOST_FUNCTION_HPP
+#ifndef BOOST_FUNCTION_MAX_ARGS
+#  define BOOST_FUNCTION_MAX_ARGS 10
+#endif // BOOST_FUNCTION_MAX_ARGS
 
-#include <boost/function/function_base.hpp>
-#include <boost/function/function0.hpp>
-#include <boost/function/function1.hpp>
-#include <boost/function/function2.hpp>
-#include <boost/function/function3.hpp>
-#include <boost/function/function4.hpp>
-#include <boost/function/function5.hpp>
-#include <boost/function/function6.hpp>
-#include <boost/function/function7.hpp>
-#include <boost/function/function8.hpp>
-#include <boost/function/function9.hpp>
-#include <boost/function/function10.hpp>
+#if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) || (BOOST_FUNCTION_MAX_ARGS_DEFINED != BOOST_FUNCTION_MAX_ARGS)
 
-namespace boost {
-  namespace detail {
-    namespace function {
-      // Choose the appropriate underlying implementation
-      template<int Args> struct real_get_function_impl {};
+#if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED)
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
+#endif
 
-      template<>
-      struct real_get_function_impl<0>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function0<R, Policy, Mixin, Allocator> type;
-        };
-      };
+#include <functional> // unary_function, binary_function
 
-      template<>
-      struct real_get_function_impl<1>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function1<R, T1, Policy, Mixin, Allocator> type;
-        };
-      };
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/config/workaround.hpp>
 
-      template<>
-      struct real_get_function_impl<2>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function2<R, T1, T2, Policy, Mixin, Allocator> type;
-        };
-      };
+// 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>
 
-      template<>
-      struct real_get_function_impl<3>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function3<R, T1, T2, T3, Policy, Mixin, Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<4>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function4<R, T1, T2, T3, T4, Policy, Mixin, Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<5>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function5<R, T1, T2, T3, T4, T5, Policy, Mixin, Allocator> 
-          type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<6>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function6<R, T1, T2, T3, T4, T5, T6, Policy, Mixin, Allocator>
-          type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<7>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function7<R, T1, T2, T3, T4, T5, T6, T7, Policy, Mixin, 
-                            Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<8>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function8<R, T1, T2, T3, T4, T5, T6, T7, T8, Policy, Mixin, 
-                            Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<9>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, Policy, 
-                            Mixin, Allocator> type;
-        };
-      };
-
-      template<>
-      struct real_get_function_impl<10>
-      {
-        template<
-          typename R, 
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
-        >
-        struct params
-        {
-          typedef function10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 
-                             Policy, Mixin, Allocator> type;
-        };
-      };
-
-      template<
-        typename R, 
-        typename T1, 
-        typename T2, 
-        typename T3, 
-        typename T4,
-        typename T5, 
-        typename T6, 
-        typename T7, 
-        typename T8, 
-        typename T9,
-        typename T10,
-        typename Policy = empty_function_policy,
-        typename Mixin = empty_function_mixin,
-        typename Allocator = std::allocator<function_base> 
-      >
-      struct get_function_impl
-      {
-        typedef typename real_get_function_impl<
-          (count_used_args<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value)
-          >::template params<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 
-                             Policy, Mixin, Allocator>::type
-        type;
-      };
-
-  template<
-    typename R, 
-    typename T1, 
-    typename T2, 
-    typename T3, 
-    typename T4,
-    typename T5, 
-    typename T6, 
-    typename T7, 
-    typename T8, 
-    typename T9,
-    typename T10,
-    typename MyPolicy = empty_function_policy,
-    typename MyMixin = empty_function_mixin,
-    typename MyAllocator = std::allocator<function_base> 
-  >
-  struct function_traits_builder
-  {
-    typedef typename get_function_impl<R, T1, T2, T3, T4, T5, T6, T7, 
-                                       T8, T9, T10, MyPolicy, MyMixin, 
-                                       MyAllocator>::type
-      type;
-
-    typedef MyPolicy    policy_type;
-    typedef MyMixin     mixin_type;
-    typedef MyAllocator allocator_type;
-
-#ifndef BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
-    template<typename Policy>
-    struct policy : 
-        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
-                                       T10, Policy, mixin_type, 
-                                       allocator_type> {};
-
-    template<typename Mixin>
-    struct mixin : 
-        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
-                                       T10, policy_type, Mixin, 
-                                       allocator_type> {};
-
-    template<typename Allocator>
-    struct allocator : 
-        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
-                                       T10, policy_type, mixin_type, 
-                                       Allocator> {};
+// Older Visual Age C++ version do not handle the file iteration well
+#if BOOST_WORKAROUND(__IBMCPP__, >= 500) && BOOST_WORKAROUND(__IBMCPP__, < 800)
+#  if BOOST_FUNCTION_MAX_ARGS >= 0
+#    include <boost/function/function0.hpp>
+#  endif
+#  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
-    template<typename Policy>
-    struct policy 
-    {
-      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
-                                               T8, T9, T10, Policy, 
-                                               mixin_type, 
-                                               allocator_type>::type
-        type;
-    };
-
-    template<typename Mixin>
-    struct mixin
-    {
-      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
-                                               T8, T9, T10, policy_type, Mixin,
-                                               allocator_type>::type
-        type;
-    };
-
-    template<typename Allocator>
-    struct allocator
-    {
-      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
-                                               T8, T9, T10, policy_type, 
-                                               mixin_type, Allocator>::type
-        type;
-    };
+// 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
-  };
 
-    } // end namespace function
-  } // end namespace detail
+#include <boost/function/detail/epilogue.hpp>
 
-  template<
-    typename R, 
-    typename T1 = detail::function::unusable, 
-    typename T2 = detail::function::unusable,
-    typename T3 = detail::function::unusable,
-    typename T4 = detail::function::unusable,
-    typename T5 = detail::function::unusable,
-    typename T6 = detail::function::unusable,
-    typename T7 = detail::function::unusable,
-    typename T8 = detail::function::unusable,
-    typename T9 = detail::function::unusable,
-    typename T10 = detail::function::unusable
-  >
-  class function :
-    public detail::function::get_function_impl<R, T1, T2, T3, T4, T5, T6, T7, 
-                                               T8, T9, T10>::type,
-    public detail::function::function_traits_builder<R, T1, T2, T3, T4, T5, T6,
-                                                     T7, T8, T9, T10>
-  {
-    typedef typename detail::function::get_function_impl<R, T1, T2, T3, T4, T5,
-                                                         T6, T7, T8, T9, T10
-                                                         >::type 
-      base_type;
-
-  public:
-    typedef typename base_type::policy_type policy_type;
-    typedef typename base_type::mixin_type mixin_type;
-    typedef typename base_type::allocator_type allocator_type;              
-    typedef function self_type;                                     
-                                                                            
-    function() : base_type() {}                                     
-                                                                            
-    template<typename Functor>                                              
-    function(const Functor& f) : base_type(f) {}
-                      
-#ifdef __BORLANDC__
-    template<typename Functor>
-    function(Functor* f) : base_type(f) {}
-#endif // __BORLANDC__
-                                                      
-    function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
-         
-    template<typename Functor>
-    function& operator=(const Functor& f)
-    {
-      self_type(f).swap(*this);
-      return *this;
-    }
-
-#ifdef __BORLANDC__
-    template<typename Functor>
-    self_type& operator=(Functor* f)
-    {
-      self_type(f).swap(*this);
-      return *this;
-    }
-#endif // __BORLANDC__
-
-    self_type& operator=(const base_type& f)
-    {
-      self_type(f).swap(*this);
-      return *this;
-    }
-
-    self_type& operator=(const self_type& f)                                  
-    {   
-      self_type(f).swap(*this);
-      return *this;                                                         
-    }                                                           
-
-    template<typename Functor>
-    void set(const Functor& f)
-    {
-      self_type(f).swap(*this);
-    }
-
-#ifdef __BORLANDC__
-    template<typename Functor>
-    void set(Functor* f)
-    {
-      self_type(f).swap(*this);
-    }
-#endif // __BORLANDC__
- 
-    void set(const base_type& f)
-    {
-      self_type(f).swap(*this);
-    }
-
-    void set(const self_type& f)                             
-    {
-      self_type(f).swap(*this);
-    }   
-  };
-
-  template<typename R,
-           typename T1, 
-           typename T2,
-           typename T3,
-           typename T4,
-           typename T5,
-           typename T6,
-           typename T7,
-           typename T8,
-           typename T9,
-           typename T10>
-  inline void swap(function<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& f1,
-                   function<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& f2)
-  {
-    f1.swap(f2);
-  }
-}
-
-#endif
+#endif // !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) || (BOOST_FUNCTION_MAX_ARGS_DEFINED != BOOST_FUNCTION_MAX_ARGS)

include/boost/function/detail/epilogue.hpp

@@ -0,0 +1,39 @@
+// Boost.Function library
+
+#ifndef BOOST_FUNCTION_EPILOGUE_HPP
+#define BOOST_FUNCTION_EPILOGUE_HPP
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+// Resolve C++20 issue with fn == bind(...)
+// https://github.com/boostorg/function/issues/45
+
+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+
+namespace boost
+{
+
+namespace _bi
+{
+
+template<class R, class F, class L> class bind_t;
+
+} // namespace _bi
+
+template<class S, class R, class F, class L> bool operator==( function<S> const& f, _bi::bind_t<R, F, L> const& b )
+{
+    return f.contains( b );
+}
+
+template<class S, class R, class F, class L> bool operator!=( function<S> const& f, _bi::bind_t<R, F, L> const& b )
+{
+    return !f.contains( b );
+}
+
+} // namespace boost
+
+#endif // #if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+
+#endif // #ifndef BOOST_FUNCTION_EPILOGUE_HPP

include/boost/function/detail/function_iterate.hpp

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

@@ -0,0 +1,39 @@
+#!/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 "#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED\n";
+    print OUT "#  define BOOST_FUNCTION_MAX_ARGS_DEFINED $on_arg\n";
+    print OUT "#  ifndef BOOST_FUNCTION_$on_arg\n";
+    print OUT "#    define BOOST_FUNCTION_$on_arg\n";
+    print OUT "#    include <boost/function/function_template.hpp>\n";
+    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

@@ -0,0 +1,369 @@
+// 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
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
+#  ifndef BOOST_FUNCTION_0
+#    define BOOST_FUNCTION_0
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 1
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 1
+#  ifndef BOOST_FUNCTION_1
+#    define BOOST_FUNCTION_1
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 2
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 2
+#  ifndef BOOST_FUNCTION_2
+#    define BOOST_FUNCTION_2
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 3
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 3
+#  ifndef BOOST_FUNCTION_3
+#    define BOOST_FUNCTION_3
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 4
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 4
+#  ifndef BOOST_FUNCTION_4
+#    define BOOST_FUNCTION_4
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 5
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 5
+#  ifndef BOOST_FUNCTION_5
+#    define BOOST_FUNCTION_5
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 6
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 6
+#  ifndef BOOST_FUNCTION_6
+#    define BOOST_FUNCTION_6
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 7
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 7
+#  ifndef BOOST_FUNCTION_7
+#    define BOOST_FUNCTION_7
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 8
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 8
+#  ifndef BOOST_FUNCTION_8
+#    define BOOST_FUNCTION_8
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 9
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 9
+#  ifndef BOOST_FUNCTION_9
+#    define BOOST_FUNCTION_9
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 10
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 10
+#  ifndef BOOST_FUNCTION_10
+#    define BOOST_FUNCTION_10
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 11
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 11
+#  ifndef BOOST_FUNCTION_11
+#    define BOOST_FUNCTION_11
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 12
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 12
+#  ifndef BOOST_FUNCTION_12
+#    define BOOST_FUNCTION_12
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 13
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 13
+#  ifndef BOOST_FUNCTION_13
+#    define BOOST_FUNCTION_13
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 14
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 14
+#  ifndef BOOST_FUNCTION_14
+#    define BOOST_FUNCTION_14
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 15
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 15
+#  ifndef BOOST_FUNCTION_15
+#    define BOOST_FUNCTION_15
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 16
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 16
+#  ifndef BOOST_FUNCTION_16
+#    define BOOST_FUNCTION_16
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 17
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 17
+#  ifndef BOOST_FUNCTION_17
+#    define BOOST_FUNCTION_17
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 18
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 18
+#  ifndef BOOST_FUNCTION_18
+#    define BOOST_FUNCTION_18
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 19
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 19
+#  ifndef BOOST_FUNCTION_19
+#    define BOOST_FUNCTION_19
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 20
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 20
+#  ifndef BOOST_FUNCTION_20
+#    define BOOST_FUNCTION_20
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 21
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 21
+#  ifndef BOOST_FUNCTION_21
+#    define BOOST_FUNCTION_21
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 22
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 22
+#  ifndef BOOST_FUNCTION_22
+#    define BOOST_FUNCTION_22
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 23
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 23
+#  ifndef BOOST_FUNCTION_23
+#    define BOOST_FUNCTION_23
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 24
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 24
+#  ifndef BOOST_FUNCTION_24
+#    define BOOST_FUNCTION_24
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 25
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 25
+#  ifndef BOOST_FUNCTION_25
+#    define BOOST_FUNCTION_25
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 26
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 26
+#  ifndef BOOST_FUNCTION_26
+#    define BOOST_FUNCTION_26
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 27
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 27
+#  ifndef BOOST_FUNCTION_27
+#    define BOOST_FUNCTION_27
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 28
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 28
+#  ifndef BOOST_FUNCTION_28
+#    define BOOST_FUNCTION_28
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 29
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 29
+#  ifndef BOOST_FUNCTION_29
+#    define BOOST_FUNCTION_29
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 30
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 30
+#  ifndef BOOST_FUNCTION_30
+#    define BOOST_FUNCTION_30
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 31
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 31
+#  ifndef BOOST_FUNCTION_31
+#    define BOOST_FUNCTION_31
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 32
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 32
+#  ifndef BOOST_FUNCTION_32
+#    define BOOST_FUNCTION_32
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 33
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 33
+#  ifndef BOOST_FUNCTION_33
+#    define BOOST_FUNCTION_33
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 34
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 34
+#  ifndef BOOST_FUNCTION_34
+#    define BOOST_FUNCTION_34
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 35
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 35
+#  ifndef BOOST_FUNCTION_35
+#    define BOOST_FUNCTION_35
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 36
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 36
+#  ifndef BOOST_FUNCTION_36
+#    define BOOST_FUNCTION_36
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 37
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 37
+#  ifndef BOOST_FUNCTION_37
+#    define BOOST_FUNCTION_37
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 38
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 38
+#  ifndef BOOST_FUNCTION_38
+#    define BOOST_FUNCTION_38
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 39
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 39
+#  ifndef BOOST_FUNCTION_39
+#    define BOOST_FUNCTION_39
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 40
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 40
+#  ifndef BOOST_FUNCTION_40
+#    define BOOST_FUNCTION_40
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 41
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 41
+#  ifndef BOOST_FUNCTION_41
+#    define BOOST_FUNCTION_41
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 42
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 42
+#  ifndef BOOST_FUNCTION_42
+#    define BOOST_FUNCTION_42
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 43
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 43
+#  ifndef BOOST_FUNCTION_43
+#    define BOOST_FUNCTION_43
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 44
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 44
+#  ifndef BOOST_FUNCTION_44
+#    define BOOST_FUNCTION_44
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 45
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 45
+#  ifndef BOOST_FUNCTION_45
+#    define BOOST_FUNCTION_45
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 46
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 46
+#  ifndef BOOST_FUNCTION_46
+#    define BOOST_FUNCTION_46
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 47
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 47
+#  ifndef BOOST_FUNCTION_47
+#    define BOOST_FUNCTION_47
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 48
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 48
+#  ifndef BOOST_FUNCTION_48
+#    define BOOST_FUNCTION_48
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 49
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 49
+#  ifndef BOOST_FUNCTION_49
+#    define BOOST_FUNCTION_49
+#    include <boost/function/function_template.hpp>
+#  endif
+#elif BOOST_FUNCTION_NUM_ARGS == 50
+#  undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#  define BOOST_FUNCTION_MAX_ARGS_DEFINED 50
+#  ifndef BOOST_FUNCTION_50
+#    define BOOST_FUNCTION_50
+#    include <boost/function/function_template.hpp>
+#  endif
+#else
+#  error Cannot handle Boost.Function objects that accept more than 50 arguments!
+#endif

include/boost/function/detail/prologue.hpp

@@ -0,0 +1,26 @@
+// 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 <boost/config/no_tr1/functional.hpp> // 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>
+#  include <boost/type_traits/is_void.hpp>
+#endif // BOOST_FUNCTION_PROLOGUE_HPP

include/boost/function/function0.hpp

@@ -1,59 +1,12 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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_FUNCTION0_HPP
-#define BOOST_FUNCTION0_HPP
-
-#include <boost/function/function_base.hpp>
-
 #define BOOST_FUNCTION_NUM_ARGS 0
-#define BOOST_FUNCTION_COMMA 
-#define BOOST_FUNCTION_TEMPLATE_PARMS 
-#define BOOST_FUNCTION_TEMPLATE_ARGS 
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS 
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS 
-#define BOOST_FUNCTION_PARMS 
-#define BOOST_FUNCTION_ARGS 
-#define BOOST_FUNCTION_FUNCTION function0
-#define BOOST_FUNCTION_BASE function0_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base0
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker0
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker0
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker0
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker0
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker0
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker0
-
-#include <boost/function/function_template.hpp>
-
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-
-#endif // BOOST_FUNCTION0_HPP

include/boost/function/function1.hpp

@@ -1,59 +1,12 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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_FUNCTION1_HPP
-#define BOOST_FUNCTION1_HPP
-
-#include <boost/function/function_base.hpp>
-
 #define BOOST_FUNCTION_NUM_ARGS 1
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1
-#define BOOST_FUNCTION_PARMS T1 a1
-#define BOOST_FUNCTION_ARGS a1
-#define BOOST_FUNCTION_FUNCTION function1
-#define BOOST_FUNCTION_BASE function1_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base1
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker1
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker1
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker1
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker1
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker1
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker1
-
-#include <boost/function/function_template.hpp>
-
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-
-#endif // BOOST_FUNCTION1_HPP

include/boost/function/function10.hpp

@@ -1,59 +1,12 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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_FUNCTION10_HPP
-#define BOOST_FUNCTION10_HPP
-
-#include <boost/function/function_base.hpp>
-
 #define BOOST_FUNCTION_NUM_ARGS 10
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5, typename OtherT6, typename OtherT7, typename OtherT8, typename OtherT9, typename OtherT10
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6, OtherT7, OtherT8, OtherT9, OtherT10
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9, T10 a10
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4, a5, a6, a7, a8, a9, a10
-#define BOOST_FUNCTION_FUNCTION function10
-#define BOOST_FUNCTION_BASE function10_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base10
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker10
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker10
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker10
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker10
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker10
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker10
-
-#include <boost/function/function_template.hpp>
-
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-
-#endif // BOOST_FUNCTION10_HPP

include/boost/function/function2.hpp

@@ -1,59 +1,12 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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_FUNCTION2_HPP
-#define BOOST_FUNCTION2_HPP
-
-#include <boost/function/function_base.hpp>
-
 #define BOOST_FUNCTION_NUM_ARGS 2
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2
-#define BOOST_FUNCTION_ARGS a1, a2
-#define BOOST_FUNCTION_FUNCTION function2
-#define BOOST_FUNCTION_BASE function2_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base2
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker2
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker2
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker2
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker2
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker2
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker2
-
-#include <boost/function/function_template.hpp>
-
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-
-#endif // BOOST_FUNCTION2_HPP

include/boost/function/function3.hpp

@@ -1,59 +1,12 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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_FUNCTION3_HPP
-#define BOOST_FUNCTION3_HPP
-
-#include <boost/function/function_base.hpp>
-
 #define BOOST_FUNCTION_NUM_ARGS 3
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3
-#define BOOST_FUNCTION_ARGS a1, a2, a3
-#define BOOST_FUNCTION_FUNCTION function3
-#define BOOST_FUNCTION_BASE function3_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base3
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker3
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker3
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker3
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker3
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker3
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker3
-
-#include <boost/function/function_template.hpp>
-
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-
-#endif // BOOST_FUNCTION3_HPP

include/boost/function/function4.hpp

@@ -1,59 +1,12 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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_FUNCTION4_HPP
-#define BOOST_FUNCTION4_HPP
-
-#include <boost/function/function_base.hpp>
-
 #define BOOST_FUNCTION_NUM_ARGS 4
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4
-#define BOOST_FUNCTION_FUNCTION function4
-#define BOOST_FUNCTION_BASE function4_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base4
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker4
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker4
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker4
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker4
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker4
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker4
-
-#include <boost/function/function_template.hpp>
-
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-
-#endif // BOOST_FUNCTION4_HPP

include/boost/function/function5.hpp

@@ -1,59 +1,12 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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_FUNCTION5_HPP
-#define BOOST_FUNCTION5_HPP
-
-#include <boost/function/function_base.hpp>
-
 #define BOOST_FUNCTION_NUM_ARGS 5
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4, a5
-#define BOOST_FUNCTION_FUNCTION function5
-#define BOOST_FUNCTION_BASE function5_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base5
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker5
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker5
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker5
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker5
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker5
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker5
-
-#include <boost/function/function_template.hpp>
-
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-
-#endif // BOOST_FUNCTION5_HPP

include/boost/function/function6.hpp

@@ -1,59 +1,12 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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_FUNCTION6_HPP
-#define BOOST_FUNCTION6_HPP
-
-#include <boost/function/function_base.hpp>
-
 #define BOOST_FUNCTION_NUM_ARGS 6
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5, typename OtherT6
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4, a5, a6
-#define BOOST_FUNCTION_FUNCTION function6
-#define BOOST_FUNCTION_BASE function6_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base6
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker6
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker6
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker6
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker6
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker6
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker6
-
-#include <boost/function/function_template.hpp>
-
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-
-#endif // BOOST_FUNCTION6_HPP

include/boost/function/function7.hpp

@@ -1,59 +1,12 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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_FUNCTION7_HPP
-#define BOOST_FUNCTION7_HPP
-
-#include <boost/function/function_base.hpp>
-
 #define BOOST_FUNCTION_NUM_ARGS 7
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5, typename OtherT6, typename OtherT7
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6, OtherT7
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4, a5, a6, a7
-#define BOOST_FUNCTION_FUNCTION function7
-#define BOOST_FUNCTION_BASE function7_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base7
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker7
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker7
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker7
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker7
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker7
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker7
-
-#include <boost/function/function_template.hpp>
-
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-
-#endif // BOOST_FUNCTION7_HPP

include/boost/function/function8.hpp

@@ -1,59 +1,12 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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_FUNCTION8_HPP
-#define BOOST_FUNCTION8_HPP
-
-#include <boost/function/function_base.hpp>
-
 #define BOOST_FUNCTION_NUM_ARGS 8
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7, T8
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5, typename OtherT6, typename OtherT7, typename OtherT8
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6, OtherT7, OtherT8
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4, a5, a6, a7, a8
-#define BOOST_FUNCTION_FUNCTION function8
-#define BOOST_FUNCTION_BASE function8_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base8
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker8
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker8
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker8
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker8
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker8
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker8
-
-#include <boost/function/function_template.hpp>
-
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-
-#endif // BOOST_FUNCTION8_HPP

include/boost/function/function9.hpp

@@ -1,59 +1,12 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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_FUNCTION9_HPP
-#define BOOST_FUNCTION9_HPP
-
-#include <boost/function/function_base.hpp>
-
 #define BOOST_FUNCTION_NUM_ARGS 9
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7, T8, T9
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5, typename OtherT6, typename OtherT7, typename OtherT8, typename OtherT9
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6, OtherT7, OtherT8, OtherT9
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4, a5, a6, a7, a8, a9
-#define BOOST_FUNCTION_FUNCTION function9
-#define BOOST_FUNCTION_BASE function9_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base9
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker9
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker9
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker9
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker9
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker9
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker9
-
-#include <boost/function/function_template.hpp>
-
+#include <boost/function/detail/maybe_include.hpp>
 #undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
-
-#endif // BOOST_FUNCTION9_HPP

include/boost/function/function_fwd.hpp

@@ -0,0 +1,69 @@
+// Boost.Function library
+//  Copyright (C) Douglas Gregor 2008
+//
+//  Use, modification and distribution is subject to the Boost
+//  Software License, Version 1.0.  (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org
+#ifndef BOOST_FUNCTION_FWD_HPP
+#define BOOST_FUNCTION_FWD_HPP
+#include <boost/config.hpp>
+
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
+// Work around a compiler bug.
+// boost::python::objects::function has to be seen by the compiler before the
+// boost::function class template.
+namespace boost { namespace python { namespace objects {
+  class function;
+}}}
+#endif
+
+#if defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
+ || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+#  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
+#endif
+
+namespace boost {
+  class bad_function_call;
+
+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+  // Preferred syntax
+  template<typename Signature> class function;
+
+  template<typename Signature>
+  inline void swap(function<Signature>& f1, function<Signature>& f2)
+  {
+    f1.swap(f2);
+  }
+#endif // have partial specialization
+
+  // Portable syntax
+  template<typename R> class function0;
+  template<typename R, typename T1> class function1;
+  template<typename R, typename T1, typename T2> class function2;
+  template<typename R, typename T1, typename T2, typename T3> class function3;
+  template<typename R, typename T1, typename T2, typename T3, typename T4> 
+    class function4;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5> 
+    class function5;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6> 
+    class function6;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7> 
+    class function7;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8> 
+    class function8;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8, typename T9> 
+    class function9;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8, typename T9,
+           typename T10> 
+    class function10;
+}
+
+#endif

include/boost/function/function_typeof.hpp

@@ -0,0 +1,45 @@
+// Boost.Function library - Typeof support
+//  Copyright (C) Douglas Gregor 2008
+//
+//  Use, modification and distribution is subject to the Boost
+//  Software License, Version 1.0.  (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org
+#ifndef BOOST_FUNCTION_TYPEOF_HPP
+#define BOOST_FUNCTION_TYPEOF_HPP
+#include <boost/function/function_fwd.hpp>
+#include <boost/typeof/typeof.hpp>
+
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TYPE(boost::bad_function_call)
+
+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function, (typename))
+#endif
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function0, (typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function1, (typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function2, (typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function3, 
+  (typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function4, 
+  (typename)(typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function5, 
+  (typename)(typename)(typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function6, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function7, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
+  (typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function8, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
+  (typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function9, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
+  (typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function10, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
+  (typename)(typename)(typename)(typename))
+#endif

include/boost/function/gen_function_N.pl

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

include/boost/function_equal.hpp

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

index.html

@@ -1,91 +1,20 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
-  <head>
-    <title>Boost.Function</title>
-  </head>
-
-  <body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080">
-
-  <h1><IMG SRC="../../c++boost.gif" WIDTH="276" HEIGHT="86">Header &lt;<a HREF="../../boost/function.hpp">boost/function.hpp</a>&gt;</h1>
-
-<p> The header &lt;<a HREF="../../boost/function.hpp">boost/function.hpp</a>&gt; includes a family of class templates that are function object wrappers. The notion is similar to a generalized callback. It shares features with function pointers in that both define a call interface (e.g., a function taking two integer arguments and returning a floating-point value) through which some implementation can be called, and the implementation that is invoked may change throughout the course of the program.
-
-<p> Generally, any place in which a function pointer would be used to defer a call or make a callback, Boost.Function can be used instead to allow the user greater flexibility in the implementation of the target. Targets can be any 'compatible' function object (or function pointer), meaning that the arguments to the interface designated by Boost.Function can be converted to the arguments of the target function object.
-
-<ul>
-  <li><a href="doc/tutorial.html">Tutorial</a></li>
-  <li><a href="doc/reference.html">Reference manual</a></li>
-  <li><a href="#vspointers">Boost.Function vs. Function Pointers</a></li>
-  <li><a href="#performance">Performance</a></li>
-  <li><a href="#portability">Portability</a></li>
-  <li><a href="#design">Design rationale</a></li>
-  <li><a href="#acknowledgements">Acknowledgements</a></li>
-  <li><a href="doc/faq.html">Frequently Asked Questions</a></li>
-</ul>
-
-<h2><a name="vspointers">Boost.Function vs. Function Pointers</a></h2>
-<p>Boost.Function has several advantages over function pointers, namely:
-
-<ul>
-   <li>Boost.Function allows arbitrary compatible function objects to be targets (instead of requiring an exact function signature).</li>
-   <li>Boost.Function may be used with argument-binding and other function object construction libraries.</li>
-   <li>Boost.Function has predictible debug behavior when an empty function object is called. </li>
-   <li>Boost.Function can be adapted to perform operations before and after each call, allowing, for instance, synchronization primitives to be made part of the function type.</li>
-</ul>
-
-And, of course, function pointers have several advantages over Boost.Function:
-
-<ul>
-    <li> Function pointers are smaller (the size of one pointer instead of three) </li>
-    <li> Function pointers are faster (Boost.Function may require two calls through function pointers) </li>
-    <li> Function pointers are backward-compatible with C libraries.</li>
-    <li> More readable error messages. </li>
-</ul>
-
-
-<p> The above two lists were adapted from comments made by Darin Adler.
-
-<h2><a name="performance">Performance</a></h2>
-<h3>Function object wrapper size</h3>
-<p> 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.
-
-<h3>Copying efficiency</h3>
-<p> Copying function object wrappers requires allocating member for a copy of the function object target. The default allocator may be replaced with a faster custom allocator if the cost of this cloning becomes prohibitive.
-
-<h3>Invocation efficiency</h3>
-<p> With a properly inlining compiler, an invocation of a function object requires one call through a function pointer. If the call is to a free function pointer, an additional call must be made to that function pointer (unless the compiler has very powerful interprocedural analysis).
-
-<h2><a name="portability">Portability</a></h2>
-<p> The function object wrappers have been designed to be as portable as possible, and to support many compilers even when they do not support the C++ standard well. The following compilers have passed all of the testcases included with <code>boost::function</code>.
-<ul>
-  <li>GCC 2.95.3</li>
-  <li>GCC 3.0</li>
-  <li>SGI MIPSpro 7.3.0</li>
-  <li>Borland C++ 5.5.1</li>
-  <li>Comeau C++ 4.2.45.2</li>
-  <li>Metrowerks Codewarrior 6.1</li>
-</ul>
-
-<p> The following compilers work with <code>boost::function</code>, but have some problems:
-<ul>
-  <li>Microsoft Visual C++ 6.0 (service pack 5): allocators not supported, some problems with <code>boost::function</code> class template (numbered variants seem to work)</li>
-  <li>Intel C++ 5.0: allocators not supported</li>
-</ul>
-
-<p> If your compiler is not listed, there is a small set of tests to stress the capabilities of the <code>boost::function</code> library. A standards-compliant compiler should compile the code without any modifications, but if you find you run into problems please submit a bug report.
-
-<h2><a name="design">Design rationale</a></h2>
-<h3>Combatting virtual function bloat</h3>
-<p> The use of virtual functions tends to cause 'code bloat' on many compilers. When a class contains a virtual function, it is necessary to emit an additional function that classifies the type of the object. It has been our experience that these auxiliary functions increase the size of the executable significantly when many <code>boost::function</code> objects are used. 
-
-<p> In Boost.Function, an alternative but equivalent approach was taken using free functions instead of virtual functions. The Boost.Function object essentially holds two pointers to make a valid target call: a void pointer to the function object it contains and a void pointer to an "invoker" that can call the function object, given the function pointer. This invoker function performs the argument and return value conversions Boost.Function provides. A third pointer points to a free function called the "manager", which handles the cloning and destruction of function objects. The scheme is typesafe because the only functions that actually handle the function object, the invoker and the manager, are instantiated given the type of the function object, so they can safely cast the incoming void pointer (the function object pointer) to the appropriate type.
-
-<p> A compiler with strong interprocedural analysis could significantly reduce the overhead associated with virtual function calls such that the alternative used by Boost.Function is less efficient. No compiler has yet been found where this is true, but when it does occur the BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS macro can be defined to revert to the simpler implementation based on virtual functions.
-
-<h2><a name="acknowledgements">Acknowledgements</a></h2>
-<p> Many people were involved in the construction of this library. William Kempf, Jesse Jones and Karl Nelson were all extremely helpful in isolating an interface and scope for the library. John Maddock managed the formal review, and many reviewers gave excellent comments on interface, implementation, and documentation. 
-
-    <hr>
-    <address><a href="mailto:gregod@cs.rpi.edu">Doug Gregor</a></address>
-  </body>
+<!--
+   Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
+  
+   Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or copy at
+   http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<head>
+<meta http-equiv="refresh" content="0; URL=../../doc/html/function.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../../doc/html/function.html">../../doc/html/function.html</a> &nbsp;<hr>
+<p><EFBFBD> Copyright Beman Dawes, 2001</p>
+<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
+file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
+at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
 </html>

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": "03"
+}

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

@@ -0,0 +1,88 @@
+# 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/
+
+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
+  ;
+
+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 ;
+compile-fail function_test_fail1.cpp ;
+compile-fail function_test_fail2.cpp ;
+compile function_30.cpp ;
+compile function_30_repeat.cpp ;
+run function_arith_cxx98.cpp ;
+run function_arith_portable.cpp ;
+run sum_avg_cxx98.cpp ;
+run sum_avg_portable.cpp ;
+run mem_fun_cxx98.cpp ;
+run mem_fun_portable.cpp ;
+run std_bind_cxx98.cpp ;
+run std_bind_portable.cpp ;
+run function_ref_cxx98.cpp ;
+run function_ref_portable.cpp ;
+run contains_test.cpp ;
+run contains2_test.cpp ;
+run nothrow_swap.cpp ;
+run rvalues_test.cpp ;
+compile function_typeof_test.cpp ;
+run result_arg_types_test.cpp ;
+
+lib throw_bad_function_call : throw_bad_function_call.cpp : <link>shared:<define>THROW_BAD_FUNCTION_CALL_DYN_LINK=1 ;
+
+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 ;
+
+lib mixed_cxxstd : mixed_cxxstd.cpp : <link>shared:<define>MIXED_CXXSTD_DYN_LINK=1 ;
+
+run test_mixed_cxxstd.cpp mixed_cxxstd : : : <link>shared : mixed_cxxstd_shared ;
+run test_mixed_cxxstd.cpp mixed_cxxstd : : : <link>static : mixed_cxxstd_static ;
+
+run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>98 : : : <link>shared : mixed_cxxstd_shared_98 ;
+run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>98 : : : <link>static : mixed_cxxstd_static_98 ;
+
+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 ;
+
+local check14 = [ check-target-builds mixed_cxxstd/<cxxstd>14 : : <build>no ] ;
+
+run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>14 : : : <link>shared $(check14) : mixed_cxxstd_shared_14 ;
+run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>14 : : : <link>static $(check14) : mixed_cxxstd_static_14 ;
+
+lib return_function : return_function.cpp : <link>shared:<define>RETURN_FUNCTION_DYN_LINK=1 ;
+
+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 test_return_function.cpp return_function/<cxxstd>98 : : : <link>shared : return_function_shared_98 ;
+run test_return_function.cpp return_function/<cxxstd>98 : : : <link>static : return_function_static_98 ;
+
+run test_return_function.cpp return_function/<cxxstd>0x : : : <link>shared : return_function_shared_0x ;
+run test_return_function.cpp return_function/<cxxstd>0x : : : <link>static : return_function_static_0x ;
+
+run test_return_function.cpp return_function/<cxxstd>14 : : : <link>shared $(check14) : return_function_shared_14 ;
+run test_return_function.cpp return_function/<cxxstd>14 : : : <link>static $(check14) : return_function_static_14 ;
+
+run quick.cpp ;
+
+compile issue_42.cpp ;
+
+run fn_eq_bind_test.cpp ;

test/allocator_test.cpp

@@ -1,23 +1,16 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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
 
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.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;
@@ -34,7 +27,15 @@ 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)
   {
     alloc_count++;
@@ -48,41 +49,88 @@ struct counting_allocator : public std::allocator<T>
   }
 };
 
+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; }
+};
+
 static int do_minus(int x, int y) { return x-y; }
 
-struct DoNothing
+template <typename base>
+struct DoNothing: base
 {
   void operator()() const {}
 };
 
 static void do_nothing() {}
 
-int
-test_main(int, char*[])
+int main()
 {
-  function<int, int, int>::allocator< counting_allocator<int> >::type f; 
-  f = plus<int>();
+  function2<int, int, int> f;
+  f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<int>() );
+  f.clear();
+  BOOST_TEST_EQ( alloc_count, 1 );
+  BOOST_TEST_EQ( dealloc_count, 1 );
+  alloc_count = 0;
+  dealloc_count = 0;
+  f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
+  f.clear();
+  BOOST_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_TEST(alloc_count == 1);
-  BOOST_TEST(dealloc_count == 1);
 
   alloc_count = 0;
   dealloc_count = 0;
-  f = &do_minus;
+  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();
 
-  function<void>::allocator< counting_allocator<int> >::type fv;
+  function0<void> fv;
   alloc_count = 0;
   dealloc_count = 0;
-  fv = DoNothing();
+  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();
-  BOOST_TEST(alloc_count == 1);
-  BOOST_TEST(dealloc_count == 1);
   
-  alloc_count = 0;
-  dealloc_count = 0;
-  fv = &do_nothing;
-  fv.clear();
+  function0<void> fv2;
+  fv.assign(&do_nothing, std::allocator<int>() );
+  fv2.assign(fv, std::allocator<int>() );
 
-  return 0;
+  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 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,47 @@
+# 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
+preprocessor
+throw_exception
+type_index
+type_traits
+typeof
+
+# Secondary dependencies
+
+static_assert
+container_hash
+describe
+mp11
+)
+
+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 COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/contains2_test.cpp

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

test/contains_test.cpp

@@ -0,0 +1,237 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2004. 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>
+#include <boost/ref.hpp>
+
+#define BOOST_CHECK BOOST_TEST
+
+static int forty_two() { return 42; }
+
+struct Seventeen
+{
+  int operator()() const { return 17; }
+};
+
+struct ReturnInt
+{
+  explicit ReturnInt(int value) : value(value) {}
+
+  int operator()() const { return value; }
+
+  int value;
+};
+
+bool operator==(const ReturnInt& x, const ReturnInt& y)
+{ return x.value == y.value; }
+
+bool operator!=(const ReturnInt& x, const ReturnInt& y)
+{ return x.value != y.value; }
+
+namespace contain_test {
+
+struct ReturnIntFE
+{
+  explicit ReturnIntFE(int value) : value(value) {}
+
+  int operator()() const { return value; }
+
+  int value;
+};
+
+}
+
+#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+
+namespace contain_test {
+# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+bool function_equal(const ReturnIntFE& x, const ReturnIntFE& y)
+{ return x.value == y.value; }
+# else
+bool function_equal_impl(const ReturnIntFE& x, const ReturnIntFE& y, int)
+{ return x.value == y.value; }
+# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+}
+#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+namespace boost {
+# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+bool 
+function_equal(const contain_test::ReturnIntFE& x, 
+               const contain_test::ReturnIntFE& y)
+{ return x.value == y.value; }
+# else
+bool 
+function_equal_impl(const contain_test::ReturnIntFE& x, 
+                    const contain_test::ReturnIntFE& y, int)
+{ return x.value == y.value; }
+# endif
+}
+#endif
+
+static void target_test()
+{
+  boost::function0<int> f;
+
+  f = &forty_two;
+  BOOST_CHECK(*f.target<int (*)()>() == &forty_two);
+  BOOST_CHECK(!f.target<Seventeen>());
+
+  f = Seventeen();
+  BOOST_CHECK(!f.target<int (*)()>());
+  BOOST_CHECK(f.target<Seventeen>());
+
+  Seventeen this_seventeen;
+  f = boost::ref(this_seventeen);
+  BOOST_CHECK(!f.target<int (*)()>());
+  BOOST_CHECK(f.target<Seventeen>());
+  BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);
+
+  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()
+{
+  boost::function0<int> f;
+
+  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));
+
+  f = ReturnInt(17);
+  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);
+  BOOST_CHECK(f != &forty_two);
+  BOOST_CHECK(f == contain_test::ReturnIntFE(17));
+  BOOST_CHECK(f != contain_test::ReturnIntFE(16));
+#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
+  BOOST_CHECK(&forty_two != f);
+  BOOST_CHECK(contain_test::ReturnIntFE(17) == f);
+  BOOST_CHECK(contain_test::ReturnIntFE(16) != f);
+#endif
+
+  BOOST_CHECK(f.contains(contain_test::ReturnIntFE(17)));
+
+#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()
+{
+  {
+    ReturnInt ri(17);
+    boost::function0<int> f = boost::ref(ri);
+
+    // References and values are equal
+    BOOST_CHECK(f == boost::ref(ri));
+    BOOST_CHECK(f == ri);
+    BOOST_CHECK(boost::ref(ri) == f);
+    BOOST_CHECK(!(f != boost::ref(ri)));
+    BOOST_CHECK(!(f != ri));
+    BOOST_CHECK(!(boost::ref(ri) != f));
+#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
+    BOOST_CHECK(ri == f);
+    BOOST_CHECK(!(ri != f));
+#endif
+
+    // Values equal, references inequal
+    ReturnInt ri2(17);
+    BOOST_CHECK(f == ri2);
+    BOOST_CHECK(f != boost::ref(ri2));
+    BOOST_CHECK(boost::ref(ri2) != f);
+    BOOST_CHECK(!(f != ri2));
+    BOOST_CHECK(!(f == boost::ref(ri2)));
+    BOOST_CHECK(!(boost::ref(ri2) == f));
+#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);
+
+    // References and values are equal
+    BOOST_CHECK(f == boost::ref(ri));
+    BOOST_CHECK(f == ri);
+    BOOST_CHECK(boost::ref(ri) == f);
+    BOOST_CHECK(!(f != boost::ref(ri)));
+    BOOST_CHECK(!(f != ri));
+    BOOST_CHECK(!(boost::ref(ri) != f));
+#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
+    BOOST_CHECK(ri == f);
+    BOOST_CHECK(!(ri != f));
+#  endif
+
+    // Values equal, references inequal
+    ReturnInt ri2(17);
+    BOOST_CHECK(f == ri2);
+    BOOST_CHECK(f != boost::ref(ri2));
+    BOOST_CHECK(boost::ref(ri2) != f);
+    BOOST_CHECK(!(f != ri2));
+    BOOST_CHECK(!(f == boost::ref(ri2)));
+    BOOST_CHECK(!(boost::ref(ri2) == f));
+#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
+    BOOST_CHECK(ri2 == f);
+    BOOST_CHECK(!(ri2 != f));
+#  endif
+  }
+#endif
+}
+
+int main()
+{
+  target_test();
+  equal_test();
+  ref_equal_test();
+
+  return boost::report_errors();
+}

test/defarg_test.cpp

@@ -1,56 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug 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
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/function.hpp>
-#include <functional>
-#include <cassert>
-#include <string>
-
-using namespace std;
-using namespace boost;
-
-static int sub_ints(int x = 5, int y = 3, int z = 1) { return x-y-z; }
-
-static void 
-test_zero_args()
-{
-  function<int> one(&sub_ints);
-  BOOST_TEST(one() == 1);
-}
-
-static void
-test_one_arg()
-{
-  function<int, int> minus_four(&sub_ints);
-  BOOST_TEST(minus_four(7) == 3);
-}
-
-static void
-test_two_args()
-{
-  function<int, int, int> sub(&sub_ints);
-  BOOST_TEST(sub(10, 2) == 7);
-}
-
-int
-test_main(int, char* [])
-{
-  test_zero_args();
-  test_one_arg();
-  test_two_args();
-  return 0;
-}

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.cpp

@@ -0,0 +1,25 @@
+// 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 30
+#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_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_arith_cxx98.cpp

@@ -0,0 +1,34 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Use, modification and distribution is subject to the Boost Software 
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt) 
+
+// For more information, see http://www.boost.org/
+
+    
+#include <boost/function.hpp>
+#include <iostream>
+
+
+float mul_ints(int x, int y) { return ((float)x) * y; }
+struct int_div { 
+  float operator()(int x, int y) const { return ((float)x)/y; }; 
+};
+
+int main()
+{
+    boost::function<float (int x, int y)> f;
+    f = int_div();
+    std::cout << f(5, 3) << std::endl;
+    if (f)
+  std::cout << f(5, 3) << std::endl;
+else
+  std::cout << "f has no target, so it is unsafe to call" << std::endl;
+    f = 0;
+    f = &mul_ints;
+  
+    return 0;
+}

test/function_arith_portable.cpp

@@ -0,0 +1,32 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Use, modification and distribution is subject to the Boost Software 
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt) 
+
+// For more information, see http://www.boost.org/
+
+    
+#include <boost/function.hpp>
+#include <iostream>
+
+float mul_ints(int x, int y) { return ((float)x) * y; }
+struct int_div { 
+  float operator()(int x, int y) const { return ((float)x)/y; }; 
+};
+int main()
+{
+    boost::function2<float, int, int> f;
+    f = int_div();
+    std::cout << f(5, 3) << std::endl;
+    if (f)
+  std::cout << f(5, 3) << std::endl;
+else
+  std::cout << "f has no target, so it is unsafe to call" << std::endl;
+    f = 0;
+    f = &mul_ints;
+
+    return 0;
+}

test/function_n_test.cpp

@@ -1,25 +1,26 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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
 
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.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;
@@ -44,190 +45,199 @@ struct write_const_1_nonconst_2
   void operator()() const { global_int = 1; }
 };
 
+struct add_to_obj
+{
+  add_to_obj(int v) : value(v) {}
+
+  int operator()(int x) const { return value + x; }
+
+  int value;
+};
+
 static void
 test_zero_args()
 {
   typedef function0<void> func_void_type;
 
-  write_five_obj five;
-  write_three_obj three;
+  write_five_obj five = write_five_obj(); // Initialization for Borland C++ 5.5
+  write_three_obj three = write_three_obj(); // Ditto
 
   // Default construction
   func_void_type v1;
-  BOOST_TEST(v1.empty());
+  BOOST_CHECK(v1.empty());
 
-  // Assignment to an empty function 
+  // Assignment to an empty function
   v1 = five;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation of a function
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear() method
   v1.clear();
-  BOOST_TEST(v1.empty());
+  BOOST_CHECK(!v1);
 
   // Assignment to an empty function
   v1 = three;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation and self-assignment
   global_int = 0;
   v1 = v1;
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v1 = five;
 
   // Invocation and self-assignment
   global_int = 0;
-  v1.set(v1);
+  v1 = (v1);
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
-  // clear()
-  v1.clear();
-  BOOST_TEST(v1.empty());
+  // clear
+  v1 = 0;
+  BOOST_CHECK(v1.empty());
 
   // Assignment to an empty function from a free function
   v1 = &write_five;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v1 = &write_three;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v1 = five;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
-  v1 = &write_three;
-  BOOST_TEST(!v1.empty());
+  v1 = write_three;
+  BOOST_CHECK(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Construction from another function (that is empty)
   v1.clear();
   func_void_type v2(v1);
-  BOOST_TEST(!v2);
+  BOOST_CHECK(!v2? true : false);
 
   // Assignment to an empty function
   v2 = three;
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
-  v2.set(five);
+  v2 = (five);
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   v2.clear();
-  BOOST_TEST(v2.empty());
+  BOOST_CHECK(v2.empty());
 
   // Assignment to an empty function from a free function
-  v2.set(&write_five);
-  BOOST_TEST(v2);
+  v2 = (&write_five);
+  BOOST_CHECK(v2? true : false);
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v2 = &write_three;
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Swapping
   v1 = five;
   swap(v1, v2);
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
   swap(v1, v2);
   v1.clear();
 
   // Assignment
   v2 = five;
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v2 = &write_three;
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a function from an empty function
   v2 = v1;
-  BOOST_TEST(v2.empty()); 
-  
+  BOOST_CHECK(v2.empty());
+
   // Assignment to a function from a function with a functor
   v1 = three;
   v2 = v1;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v1.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assign to a function from a function with a function
   v2 = &write_five;
   v1 = v2;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v1.empty());
+  BOOST_CHECK(!v2.empty());
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Construct a function given another function containing a function
   func_void_type v3(v1);
@@ -235,20 +245,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 5);
-  
+  BOOST_CHECK(global_int == 5);
+
   // clear() method
   v3.clear();
-  BOOST_TEST(!v3);
+  BOOST_CHECK(!v3? true : false);
 
   // Assignment to an empty function
   v3 = three;
-  BOOST_TEST(!v3.empty());
+  BOOST_CHECK(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v3 = five;
@@ -256,38 +266,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear()
   v3.clear();
-  BOOST_TEST(v3.empty());
+  BOOST_CHECK(v3.empty());
 
   // Assignment to an empty function from a free function
   v3 = &write_five;
-  BOOST_TEST(!v3.empty());
+  BOOST_CHECK(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v3 = &write_three;
-  BOOST_TEST(!v3.empty());
+  BOOST_CHECK(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v3 = five;
-  BOOST_TEST(!v3.empty());
+  BOOST_CHECK(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Construction of a function from a function containing a functor
   func_void_type v4(v3);
@@ -295,20 +305,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 5);
-  
+  BOOST_CHECK(global_int == 5);
+
   // clear() method
   v4.clear();
-  BOOST_TEST(v4.empty());
+  BOOST_CHECK(v4.empty());
 
   // Assignment to an empty function
   v4 = three;
-  BOOST_TEST(!v4.empty());
+  BOOST_CHECK(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v4 = five;
@@ -316,38 +326,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear()
   v4.clear();
-  BOOST_TEST(v4.empty());
+  BOOST_CHECK(v4.empty());
 
   // Assignment to an empty function from a free function
   v4 = &write_five;
-  BOOST_TEST(!v4.empty());
+  BOOST_CHECK(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v4 = &write_three;
-  BOOST_TEST(!v4.empty());
+  BOOST_CHECK(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v4 = five;
-  BOOST_TEST(!v4.empty());
+  BOOST_CHECK(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Construction of a function from a functor
   func_void_type v5(five);
@@ -355,20 +365,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 5);
-  
+  BOOST_CHECK(global_int == 5);
+
   // clear() method
   v5.clear();
-  BOOST_TEST(v5.empty());
+  BOOST_CHECK(v5.empty());
 
   // Assignment to an empty function
   v5 = three;
-  BOOST_TEST(!v5.empty());
+  BOOST_CHECK(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v5 = five;
@@ -376,38 +386,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear()
   v5.clear();
-  BOOST_TEST(v5.empty());
+  BOOST_CHECK(v5.empty());
 
   // Assignment to an empty function from a free function
   v5 = &write_five;
-  BOOST_TEST(!v5.empty());
+  BOOST_CHECK(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v5 = &write_three;
-  BOOST_TEST(!v5.empty());
+  BOOST_CHECK(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v5 = five;
-  BOOST_TEST(!v5.empty());
+  BOOST_CHECK(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 5);  
+  BOOST_CHECK(global_int == 5);
 
   // Construction of a function from a function
   func_void_type v6(&write_five);
@@ -415,20 +425,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear() method
   v6.clear();
-  BOOST_TEST(v6.empty());
+  BOOST_CHECK(v6.empty());
 
   // Assignment to an empty function
   v6 = three;
-  BOOST_TEST(!v6.empty());
+  BOOST_CHECK(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v6 = five;
@@ -436,132 +446,260 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear()
   v6.clear();
-  BOOST_TEST(v6.empty());
+  BOOST_CHECK(v6.empty());
 
   // Assignment to an empty function from a free function
   v6 = &write_five;
-  BOOST_TEST(!v6.empty());
+  BOOST_CHECK(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v6 = &write_three;
-  BOOST_TEST(!v6.empty());
+  BOOST_CHECK(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v6 = five;
-  BOOST_TEST(!v6.empty());
+  BOOST_CHECK(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 5);  
+  BOOST_CHECK(global_int == 5);
 
   // Const vs. non-const
-  write_const_1_nonconst_2 one_or_two;
+  // Initialization for Borland C++ 5.5
+  write_const_1_nonconst_2 one_or_two = write_const_1_nonconst_2(); 
   const function0<void> v7(one_or_two);
-  function <void> v8(one_or_two);
+  function0<void> v8(one_or_two);
 
   global_int = 0;
   v7();
-  BOOST_TEST(global_int == 2);
-  
+  BOOST_CHECK(global_int == 2);
+
   global_int = 0;
   v8();
-  BOOST_TEST(global_int == 2);
+  BOOST_CHECK(global_int == 2);
+
+  // Test construction from 0 and comparison to 0
+  func_void_type v9(0);
+  BOOST_CHECK(v9 == 0);
+# if !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540 || defined(BOOST_STRICT_CONFIG)
+  BOOST_CHECK(0 == v9);
+#else
+  BOOST_CHECK(v9.empty());
+#endif
 
   // Test return values
   typedef function0<int> func_int_type;
-  generate_five_obj gen_five;
-  generate_three_obj gen_three;
-
+  // Initialization for Borland C++ 5.5
+  generate_five_obj gen_five = generate_five_obj();
+  generate_three_obj gen_three = generate_three_obj();
   func_int_type i0(gen_five);
 
-  BOOST_TEST(i0() == 5);
+  BOOST_CHECK(i0() == 5);
   i0 = gen_three;
-  BOOST_TEST(i0() == 3);
+  BOOST_CHECK(i0() == 3);
   i0 = &generate_five;
-  BOOST_TEST(i0() == 5);
+  BOOST_CHECK(i0() == 5);
   i0 = &generate_three;
-  BOOST_TEST(i0() == 3);
-  BOOST_TEST(i0);
+  BOOST_CHECK(i0() == 3);
+  BOOST_CHECK(i0? true : false);
   i0.clear();
-  BOOST_TEST(!i0);
+  BOOST_CHECK(!i0? true : false);
 
   // Test return values with compatible types
   typedef function0<long> func_long_type;
   func_long_type i1(gen_five);
 
-  BOOST_TEST(i1() == 5);
+  BOOST_CHECK(i1() == 5);
   i1 = gen_three;
-  BOOST_TEST(i1() == 3);
+  BOOST_CHECK(i1() == 3);
   i1 = &generate_five;
-  BOOST_TEST(i1() == 5);
+  BOOST_CHECK(i1() == 5);
   i1 = &generate_three;
-  BOOST_TEST(i1() == 3);
-  BOOST_TEST(i1);
+  BOOST_CHECK(i1() == 3);
+  BOOST_CHECK(i1? true : false);
   i1.clear();
-  BOOST_TEST(!i1);
+  BOOST_CHECK(!i1? true : false);
 }
 
 static void
 test_one_arg()
 {
-  negate<int> neg;
+  negate<int> neg = negate<int>(); // Initialization for Borland C++ 5.5
 
   function1<int, int> f1(neg);
-  BOOST_TEST(f1(5) == -5);
+  BOOST_CHECK(f1(5) == -5);
 
   function1<string, string> id(&identity_str);
-  BOOST_TEST(id("str") == "str");
+  BOOST_CHECK(id("str") == "str");
 
-  function1<std::string, char*> id2(&identity_str);
-  BOOST_TEST(id2("foo") == "foo");
+  function1<std::string, const char*> id2(&identity_str);
+  BOOST_CHECK(id2("foo") == "foo");
+
+  add_to_obj add_to(5);
+  function1<int, int> f2(add_to);
+  BOOST_CHECK(f2(3) == 8);
+
+  const function1<int, int> cf2(add_to);
+  BOOST_CHECK(cf2(3) == 8);
 }
 
 static void
 test_two_args()
 {
   function2<string, const string&, const string&> cat(&string_cat);
-  BOOST_TEST(cat("str", "ing") == "string");  
+  BOOST_CHECK(cat("str", "ing") == "string");
 
   function2<int, short, short> sum(&sum_ints);
-  BOOST_TEST(sum(2, 3) == 5);
+  BOOST_CHECK(sum(2, 3) == 5);
 }
 
 static void
 test_emptiness()
 {
   function0<float> f1;
-  BOOST_TEST(f1.empty());
+  BOOST_CHECK(f1.empty());
 
   function0<float> f2;
   f2 = f1;
-  BOOST_TEST(f2.empty());
+  BOOST_CHECK(f2.empty());
 
   function0<double> f3;
   f3 = f2;
-  BOOST_TEST(f3.empty());
+  BOOST_CHECK(f3.empty());
 }
 
-int
-test_main(int, char* [])
+struct X {
+  X(int v) : value(v) {}
+
+  int twice() const { return 2*value; }
+  int plus(int v) { return value + v; }
+
+  int value;
+};
+
+static void
+test_member_functions()
+{
+
+  boost::function1<int, X*> f1(&X::twice);
+
+  X one(1);
+  X five(5);
+
+  BOOST_CHECK(f1(&one) == 2);
+  BOOST_CHECK(f1(&five) == 10);
+
+  boost::function1<int, X*> f1_2;
+  f1_2 = &X::twice;
+
+  BOOST_CHECK(f1_2(&one) == 2);
+  BOOST_CHECK(f1_2(&five) == 10);
+
+  boost::function2<int, X&, int> f2(&X::plus);
+  BOOST_CHECK(f2(one, 3) == 4);
+  BOOST_CHECK(f2(five, 4) == 9);
+}
+
+struct add_with_throw_on_copy {
+  int operator()(int x, int y) const { return x+y; }
+
+  add_with_throw_on_copy() {}
+
+  add_with_throw_on_copy(const add_with_throw_on_copy&)
+  {
+    throw std::runtime_error("But this CAN'T throw");
+  }
+
+  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
+  {
+    throw std::runtime_error("But this CAN'T throw");
+  }
+};
+
+static void
+test_ref()
+{
+  add_with_throw_on_copy atc;
+  try {
+    boost::function2<int, int, int> f(ref(atc));
+    BOOST_CHECK(f(1, 3) == 4);
+  }
+  catch(std::runtime_error const&) {
+    BOOST_ERROR("Nonthrowing constructor threw an exception");
+  }
+}
+
+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();
   test_two_args();
   test_emptiness();
-  return 0;
+  test_member_functions();
+  test_ref();
+  test_construct_destroy_count();
+  return boost::report_errors();
 }

test/function_ref_cxx98.cpp

@@ -0,0 +1,27 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Use, modification and distribution is subject to the Boost Software 
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt) 
+
+// For more information, see http://www.boost.org/
+
+
+#include <boost/function.hpp>
+#include <iostream>
+
+
+struct stateful_type { int operator()(int) const { return 0; } };
+
+int main()
+{
+    stateful_type a_function_object;
+  boost::function<int (int)> f;
+  f = boost::ref(a_function_object);
+
+  boost::function<int (int)> f2(f);
+
+    return 0;
+}

test/function_ref_portable.cpp

@@ -0,0 +1,27 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Use, modification and distribution is subject to the Boost Software 
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt) 
+
+// For more information, see http://www.boost.org/
+
+
+#include <boost/function.hpp>
+#include <iostream>
+
+
+struct stateful_type { int operator()(int) const { return 0; } };
+
+int main()
+{
+    stateful_type a_function_object;
+  boost::function1<int, int> f;
+  f = boost::ref(a_function_object);
+
+  boost::function1<int, int> f2(f);
+
+    return 0;
+}

test/function_test.cpp

@@ -1,28 +1,28 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  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
 
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/function.hpp>
-#include <functional>
-#include <cassert>
-#include <string>
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning( "-Wself-assign-overloaded" )
+#  pragma clang diagnostic ignored "-Wself-assign-overloaded"
+# endif
+#endif
 
-using namespace boost;
+#include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <functional>
+#include <string>
+#include <utility>
+
+#define BOOST_CHECK BOOST_TEST
+
+using boost::function;
 using std::string;
-using std::negate;
 
 int global_int;
 
@@ -44,190 +44,199 @@ struct write_const_1_nonconst_2
   void operator()() const { global_int = 1; }
 };
 
+struct add_to_obj
+{
+  add_to_obj(int v) : value(v) {}
+
+  int operator()(int x) const { return value + x; }
+
+  int value;
+};
+
 static void
 test_zero_args()
 {
-  typedef function<void> func_void_type;
+  typedef function<void ()> func_void_type;
 
   write_five_obj five;
   write_three_obj three;
 
   // Default construction
   func_void_type v1;
-  BOOST_TEST(v1.empty());
+  BOOST_CHECK(v1.empty());
 
-  // Assignment to an empty function 
+  // Assignment to an empty function
   v1 = five;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(v1 != 0);
 
   // Invocation of a function
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear() method
   v1.clear();
-  BOOST_TEST(v1.empty());
+  BOOST_CHECK(v1 == 0);
 
   // Assignment to an empty function
   v1 = three;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation and self-assignment
   global_int = 0;
   v1 = v1;
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v1 = five;
 
   // Invocation and self-assignment
   global_int = 0;
-  v1.set(v1);
+  v1 = (v1);
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
-  // clear()
-  v1.clear();
-  BOOST_TEST(v1.empty());
+  // clear
+  v1 = 0;
+  BOOST_CHECK(0 == v1);
 
   // Assignment to an empty function from a free function
-  v1 = &write_five;
-  BOOST_TEST(!v1.empty());
+  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
+  BOOST_CHECK(0 != v1);
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
-  v1 = &write_three;
-  BOOST_TEST(!v1.empty());
+  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
+  BOOST_CHECK(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v1 = five;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v1 = &write_three;
-  BOOST_TEST(!v1.empty());
+  BOOST_CHECK(!v1.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Construction from another function (that is empty)
   v1.clear();
   func_void_type v2(v1);
-  BOOST_TEST(!v2);
+  BOOST_CHECK(!v2? true : false);
 
   // Assignment to an empty function
   v2 = three;
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
-  v2.set(five);
+  v2 = (five);
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   v2.clear();
-  BOOST_TEST(v2.empty());
+  BOOST_CHECK(v2.empty());
 
   // Assignment to an empty function from a free function
-  v2.set(&write_five);
-  BOOST_TEST(v2);
+  v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
+  BOOST_CHECK(v2? true : false);
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
-  v2 = &write_three;
-  BOOST_TEST(!v2.empty());
+  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Swapping
   v1 = five;
   swap(v1, v2);
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
   swap(v1, v2);
   v1.clear();
 
   // Assignment
   v2 = five;
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v2 = &write_three;
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a function from an empty function
   v2 = v1;
-  BOOST_TEST(v2.empty()); 
-  
+  BOOST_CHECK(v2.empty());
+
   // Assignment to a function from a function with a functor
   v1 = three;
   v2 = v1;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v1.empty());
+  BOOST_CHECK(!v2.empty());
 
   // Invocation
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assign to a function from a function with a function
-  v2 = &write_five;
+  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
   v1 = v2;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
+  BOOST_CHECK(!v1.empty());
+  BOOST_CHECK(!v2.empty());
   global_int = 0;
   v1();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
   global_int = 0;
   v2();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Construct a function given another function containing a function
   func_void_type v3(v1);
@@ -235,20 +244,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 5);
-  
+  BOOST_CHECK(global_int == 5);
+
   // clear() method
   v3.clear();
-  BOOST_TEST(!v3);
+  BOOST_CHECK(!v3? true : false);
 
   // Assignment to an empty function
   v3 = three;
-  BOOST_TEST(!v3.empty());
+  BOOST_CHECK(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v3 = five;
@@ -256,38 +265,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear()
   v3.clear();
-  BOOST_TEST(v3.empty());
+  BOOST_CHECK(v3.empty());
 
   // Assignment to an empty function from a free function
   v3 = &write_five;
-  BOOST_TEST(!v3.empty());
+  BOOST_CHECK(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v3 = &write_three;
-  BOOST_TEST(!v3.empty());
+  BOOST_CHECK(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v3 = five;
-  BOOST_TEST(!v3.empty());
+  BOOST_CHECK(!v3.empty());
 
   // Invocation
   global_int = 0;
   v3();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Construction of a function from a function containing a functor
   func_void_type v4(v3);
@@ -295,20 +304,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 5);
-  
+  BOOST_CHECK(global_int == 5);
+
   // clear() method
   v4.clear();
-  BOOST_TEST(v4.empty());
+  BOOST_CHECK(v4.empty());
 
   // Assignment to an empty function
   v4 = three;
-  BOOST_TEST(!v4.empty());
+  BOOST_CHECK(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v4 = five;
@@ -316,38 +325,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear()
   v4.clear();
-  BOOST_TEST(v4.empty());
+  BOOST_CHECK(v4.empty());
 
   // Assignment to an empty function from a free function
   v4 = &write_five;
-  BOOST_TEST(!v4.empty());
+  BOOST_CHECK(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v4 = &write_three;
-  BOOST_TEST(!v4.empty());
+  BOOST_CHECK(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v4 = five;
-  BOOST_TEST(!v4.empty());
+  BOOST_CHECK(!v4.empty());
 
   // Invocation
   global_int = 0;
   v4();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Construction of a function from a functor
   func_void_type v5(five);
@@ -355,20 +364,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 5);
-  
+  BOOST_CHECK(global_int == 5);
+
   // clear() method
   v5.clear();
-  BOOST_TEST(v5.empty());
+  BOOST_CHECK(v5.empty());
 
   // Assignment to an empty function
   v5 = three;
-  BOOST_TEST(!v5.empty());
+  BOOST_CHECK(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v5 = five;
@@ -376,38 +385,38 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear()
   v5.clear();
-  BOOST_TEST(v5.empty());
+  BOOST_CHECK(v5.empty());
 
   // Assignment to an empty function from a free function
   v5 = &write_five;
-  BOOST_TEST(!v5.empty());
+  BOOST_CHECK(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v5 = &write_three;
-  BOOST_TEST(!v5.empty());
+  BOOST_CHECK(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v5 = five;
-  BOOST_TEST(!v5.empty());
+  BOOST_CHECK(!v5.empty());
 
   // Invocation
   global_int = 0;
   v5();
-  BOOST_TEST(global_int == 5);  
+  BOOST_CHECK(global_int == 5);
 
   // Construction of a function from a function
   func_void_type v6(&write_five);
@@ -415,20 +424,20 @@ test_zero_args()
   // Invocation of a function
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear() method
   v6.clear();
-  BOOST_TEST(v6.empty());
+  BOOST_CHECK(v6.empty());
 
   // Assignment to an empty function
   v6 = three;
-  BOOST_TEST(!v6.empty());
+  BOOST_CHECK(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment to a non-empty function
   v6 = five;
@@ -436,132 +445,375 @@ test_zero_args()
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // clear()
   v6.clear();
-  BOOST_TEST(v6.empty());
+  BOOST_CHECK(v6.empty());
 
   // Assignment to an empty function from a free function
   v6 = &write_five;
-  BOOST_TEST(!v6.empty());
+  BOOST_CHECK(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 5);
+  BOOST_CHECK(global_int == 5);
 
   // Assignment to a non-empty function from a free function
   v6 = &write_three;
-  BOOST_TEST(!v6.empty());
+  BOOST_CHECK(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 3);
+  BOOST_CHECK(global_int == 3);
 
   // Assignment
   v6 = five;
-  BOOST_TEST(!v6.empty());
+  BOOST_CHECK(!v6.empty());
 
   // Invocation
   global_int = 0;
   v6();
-  BOOST_TEST(global_int == 5);  
+  BOOST_CHECK(global_int == 5);
 
   // Const vs. non-const
   write_const_1_nonconst_2 one_or_two;
-  const function<void> v7(one_or_two);
-  function <void> v8(one_or_two);
+  const function<void ()> v7(one_or_two);
+  function<void ()> v8(one_or_two);
 
   global_int = 0;
   v7();
-  BOOST_TEST(global_int == 2);
-  
+  BOOST_CHECK(global_int == 2);
+
   global_int = 0;
   v8();
-  BOOST_TEST(global_int == 2);
+  BOOST_CHECK(global_int == 2);
+
+  // Test construction from 0 and comparison to 0
+  func_void_type v9(0);
+  BOOST_CHECK(v9 == 0);
+  BOOST_CHECK(0 == v9);
 
   // Test return values
-  typedef function<int> func_int_type;
+  typedef function<int ()> func_int_type;
   generate_five_obj gen_five;
   generate_three_obj gen_three;
 
   func_int_type i0(gen_five);
 
-  BOOST_TEST(i0() == 5);
+  BOOST_CHECK(i0() == 5);
   i0 = gen_three;
-  BOOST_TEST(i0() == 3);
+  BOOST_CHECK(i0() == 3);
   i0 = &generate_five;
-  BOOST_TEST(i0() == 5);
+  BOOST_CHECK(i0() == 5);
   i0 = &generate_three;
-  BOOST_TEST(i0() == 3);
-  BOOST_TEST(i0);
+  BOOST_CHECK(i0() == 3);
+  BOOST_CHECK(i0? true : false);
   i0.clear();
-  BOOST_TEST(!i0);
+  BOOST_CHECK(!i0? true : false);
 
   // Test return values with compatible types
-  typedef function<long> func_long_type;
+  typedef function<long ()> func_long_type;
   func_long_type i1(gen_five);
 
-  BOOST_TEST(i1() == 5);
+  BOOST_CHECK(i1() == 5);
   i1 = gen_three;
-  BOOST_TEST(i1() == 3);
+  BOOST_CHECK(i1() == 3);
   i1 = &generate_five;
-  BOOST_TEST(i1() == 5);
+  BOOST_CHECK(i1() == 5);
   i1 = &generate_three;
-  BOOST_TEST(i1() == 3);
-  BOOST_TEST(i1);
+  BOOST_CHECK(i1() == 3);
+  BOOST_CHECK(i1? true : false);
   i1.clear();
-  BOOST_TEST(!i1);
+  BOOST_CHECK(!i1? true : false);
 }
 
 static void
 test_one_arg()
 {
-  negate<int> neg;
+  std::negate<int> neg;
 
-  function<int, int> f1(neg);
-  BOOST_TEST(f1(5) == -5);
+  function<int (int)> f1(neg);
+  BOOST_CHECK(f1(5) == -5);
 
-  function<string, string> id(&identity_str);
-  BOOST_TEST(id("str") == "str");
+  function<string (string)> id(&identity_str);
+  BOOST_CHECK(id("str") == "str");
 
-  function<std::string, char*> id2(&identity_str);
-  BOOST_TEST(id2("foo") == "foo");
+  function<string (const char*)> id2(&identity_str);
+  BOOST_CHECK(id2("foo") == "foo");
+
+  add_to_obj add_to(5);
+  function<int (int)> f2(add_to);
+  BOOST_CHECK(f2(3) == 8);
+
+  const function<int (int)> cf2(add_to);
+  BOOST_CHECK(cf2(3) == 8);
 }
 
 static void
 test_two_args()
 {
-  function<string, const string&, const string&> cat(&string_cat);
-  BOOST_TEST(cat("str", "ing") == "string");  
+  function<string (const string&, const string&)> cat(&string_cat);
+  BOOST_CHECK(cat("str", "ing") == "string");
 
-  function<int, short, short> sum(&sum_ints);
-  BOOST_TEST(sum(2, 3) == 5);
+  function<int (short, short)> sum(&sum_ints);
+  BOOST_CHECK(sum(2, 3) == 5);
 }
 
 static void
 test_emptiness()
 {
-  function<float> f1;
-  BOOST_TEST(f1.empty());
+  function<float ()> f1;
+  BOOST_CHECK(f1.empty());
 
-  function<float> f2;
+  function<float ()> f2;
   f2 = f1;
-  BOOST_TEST(f2.empty());
+  BOOST_CHECK(f2.empty());
 
-  function<double> f3;
+  function<double ()> f3;
   f3 = f2;
-  BOOST_TEST(f3.empty());
+  BOOST_CHECK(f3.empty());
 }
 
-int
-test_main(int, char* [])
+struct X {
+  X(int v) : value(v) {}
+
+  int twice() const { return 2*value; }
+  int plus(int v) { return value + v; }
+
+  int value;
+};
+
+static void
+test_member_functions()
+{
+  boost::function<int (X*)> f1(&X::twice);
+
+  X one(1);
+  X five(5);
+
+  BOOST_CHECK(f1(&one) == 2);
+  BOOST_CHECK(f1(&five) == 10);
+
+  boost::function<int (X*)> f1_2;
+  f1_2 = &X::twice;
+
+  BOOST_CHECK(f1_2(&one) == 2);
+  BOOST_CHECK(f1_2(&five) == 10);
+
+  boost::function<int (X&, int)> f2(&X::plus);
+  BOOST_CHECK(f2(one, 3) == 4);
+  BOOST_CHECK(f2(five, 4) == 9);
+}
+
+struct add_with_throw_on_copy {
+  int operator()(int x, int y) const { return x+y; }
+
+  add_with_throw_on_copy() {}
+
+  add_with_throw_on_copy(const add_with_throw_on_copy&)
+  {
+    throw std::runtime_error("But this CAN'T throw");
+  }
+
+  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
+  {
+    throw std::runtime_error("But this CAN'T throw");
+  }
+};
+
+static void
+test_ref()
+{
+  add_with_throw_on_copy atc;
+  try {
+    boost::function<int (int, int)> f(boost::ref(atc));
+    BOOST_CHECK(f(1, 3) == 4);
+  }
+  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;
+  try {
+    f(5, 4);
+    BOOST_CHECK(false);
+  }
+  catch(boost::bad_function_call const&) {
+    // okay
+  }
+}
+
+typedef boost::function< void * (void * reader) > reader_type;
+typedef std::pair<int, reader_type> mapped_type;
+
+static void test_implicit()
+{
+  mapped_type m;
+  m = mapped_type();
+}
+
+static void test_call_obj(boost::function<int (int, int)> f)
+{
+  BOOST_CHECK(!f.empty());
+}
+
+static void test_call_cref(const boost::function<int (int, int)>& f)
+{
+  BOOST_CHECK(!f.empty());
+}
+
+static void test_call()
+{
+  test_call_obj(std::plus<int>());
+  test_call_cref(std::plus<int>());
+}
+
+struct big_aggregating_structure {
+  int disable_small_objects_optimizations[32];
+    
+  big_aggregating_structure()
+  {
+    ++ global_int;
+  }
+    
+  big_aggregating_structure(const big_aggregating_structure&)
+  {
+    ++ global_int;
+  }
+
+  ~big_aggregating_structure()
+  {
+    -- global_int;
+  }
+    
+  void operator()() 
+  {
+    ++ global_int;
+  }
+
+  void operator()(int) 
+  {
+    ++ global_int;
+  }
+};
+
+template <class FunctionT>
+static void test_move_semantics() 
+{
+  typedef FunctionT f1_type;
+
+  big_aggregating_structure obj;
+  
+  f1_type f1 = obj;
+  global_int = 0;
+  f1();
+  
+  BOOST_CHECK(!f1.empty());
+  BOOST_CHECK(global_int == 1);
+  
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+  // Testing rvalue constructors
+  f1_type f2(static_cast<f1_type&&>(f1));
+  BOOST_CHECK(f1.empty());
+  BOOST_CHECK(!f2.empty());
+  BOOST_CHECK(global_int == 1);
+  f2();
+  BOOST_CHECK(global_int == 2);
+  
+  f1_type f3(static_cast<f1_type&&>(f2));
+  BOOST_CHECK(f1.empty());
+  BOOST_CHECK(f2.empty());
+  BOOST_CHECK(!f3.empty());
+  BOOST_CHECK(global_int == 2);
+  f3();
+  BOOST_CHECK(global_int == 3);
+    
+  // Testing move assignment
+  f1_type f4;
+  BOOST_CHECK(f4.empty());
+  f4 = static_cast<f1_type&&>(f3);
+  BOOST_CHECK(f1.empty());
+  BOOST_CHECK(f2.empty());
+  BOOST_CHECK(f3.empty());
+  BOOST_CHECK(!f4.empty());
+  BOOST_CHECK(global_int == 3);
+  f4();
+  BOOST_CHECK(global_int == 4);
+  
+  // Testing self move assignment
+  f4 = static_cast<f1_type&&>(f4);
+  BOOST_CHECK(!f4.empty());
+  BOOST_CHECK(global_int == 4);
+
+  // Testing, that no memory leaked when assigning to nonempty function
+  f4 = obj;
+  BOOST_CHECK(!f4.empty());
+  BOOST_CHECK(global_int == 4);
+  f1_type f5 = obj;
+  BOOST_CHECK(global_int == 5);
+  f4 = static_cast<f1_type&&>(f5);
+  BOOST_CHECK(global_int == 4);
+  
+#endif  
+}
+
+int main()
 {
   test_zero_args();
   test_one_arg();
   test_two_args();
   test_emptiness();
-  return 0;
+  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 boost::report_errors();
 }

test/function_test_fail1.cpp

@@ -1,35 +1,18 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  Copyright (C) Douglas Gregor 2001-2005. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
 
 // For more information, see http://www.boost.org
 
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
 #include <boost/function.hpp>
 
-using namespace std;
-using namespace boost;
-
-int
-test_main(int, char*[])
+void test()
 {
-  function<int> f1;
-  function<int> f2;
+    boost::function0<int> f1;
+    boost::function0<int> f2;
 
-  if (f1 == f2) {
-  }
-
-  BOOST_CRITICAL_ERROR("This should not have compiled.");
-
-  return 0;
+    if( f1 == f2 ) {}
 }

test/function_test_fail2.cpp

@@ -1,34 +1,18 @@
 // Boost.Function library
 
-// Copyright (C) 2001 Doug 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.
+//  Copyright (C) Douglas Gregor 2001-2005. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
 
 // For more information, see http://www.boost.org
 
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.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()
 {
-  function<int> f1;
-  f1 = bad_fn;
-
-  BOOST_CRITICAL_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

@@ -0,0 +1,40 @@
+// 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
+
+#include <boost/function.hpp>
+#include <boost/lambda/lambda.hpp>
+#include <boost/lambda/bind.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <iostream>
+#include <cstdlib>
+
+
+static unsigned
+func_impl(int arg1, bool arg2, double arg3)
+{
+  using namespace std;
+  return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
+}
+
+int main()
+{
+  using boost::function;
+  using namespace boost::lambda;
+
+  function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
+  BOOST_TEST_EQ( f1(true, 2.0), 30u );
+
+  function <unsigned(double)>       f2 = boost::lambda::bind(f1, false, _1);
+  BOOST_TEST_EQ( f2(2.0), 60u );
+
+  function <unsigned()>             f3 = boost::lambda::bind(f2, 4.0);
+  BOOST_TEST_EQ( f3(), 120u );
+
+  return boost::report_errors();
+}

test/mem_fun_cxx98.cpp

@@ -0,0 +1,45 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Use, modification and distribution is subject to the Boost Software 
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt) 
+
+// For more information, see http://www.boost.org/
+
+    
+#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;
+
+    X x;
+    BOOST_TEST(f(&x, 5) == -5);
+    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
+
+    return ::boost::report_errors();
+}

test/mem_fun_portable.cpp

@@ -0,0 +1,45 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Use, modification and distribution is subject to the Boost Software 
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt) 
+
+// For more information, see http://www.boost.org/
+
+    
+#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;
+
+    X x;
+    BOOST_TEST(f(&x, 5) == -5);
+    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
+
+    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/mixin_test.cpp

@@ -1,60 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug 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
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <cassert>
-#include <functional>
-#include <boost/function.hpp>
-
-struct id_mixin
-{	
-  id_mixin(const id_mixin& rhs) : id(rhs.id) {}
-  id_mixin& operator=(const id_mixin& rhs){id = rhs.id; return *this;}
-  id_mixin(int i = 0){ id = i;}
-  int id;
-};
-
-static int do_plus(int x, int y) { return x+y; }
-
-typedef boost::function<int,int,int>::mixin<id_mixin>::type func;
-
-int test_main(int, char*[])
-{
-  func f(id_mixin(3));  
-  f = std::plus<int>();
-  BOOST_TEST(f.id == 3);
-  
-  f = &do_plus;
-  BOOST_TEST(f.id == 3);
-
-  f.clear();
-  f.id = 7;    
-  BOOST_TEST(f.id == 7);
-    
-  func g(f);
-  BOOST_TEST(g.id == 7);
-
-  f.id = 21;    
-  BOOST_TEST(f.id == 21);
-	  
-  boost::swap(f,g);  
-  BOOST_TEST(f.id == 7);
-  BOOST_TEST(g.id == 21);
-
-  g = f;	  
-  BOOST_TEST(g.id == 7);  
-  return 0;
-}

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/policy_test.cpp

@@ -1,47 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug 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
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <cassert>
-#include <iostream>
-#include <functional>
-#include <boost/function.hpp>
-
-using namespace std;
-using namespace boost;
-
-struct counting_policy
-{
-  static int count;
-
-  void precall(const function_base*) { count++; }
-  void postcall(const function_base*) { count+=2; }
-};
-
-int counting_policy::count = 0;
-
-int
-test_main(int, char*[])
-{
-  function<int, int, int>::policy<counting_policy>::type f; 
-
-  f = plus<int>();
-
-  BOOST_TEST(5 == f(2,3));
-  BOOST_TEST(counting_policy::count==3);
-
-  return 0;
-}

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/regression.cfg

@@ -5,11 +5,10 @@
 
 
 run libs/function/test/allocator_test.cpp
-run libs/function/test/defarg_test.cpp
 run libs/function/test/function_n_test.cpp
 run libs/function/test/function_test.cpp
 compile-fail libs/function/test/function_test_fail1.cpp
 compile-fail libs/function/test/function_test_fail2.cpp
 run libs/function/test/mixin_test.cpp
 run libs/function/test/policy_test.cpp
-
+run libs/function/test/stateless_test.cpp

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

test/stateless_test.cpp

@@ -0,0 +1,42 @@
+// 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
+
+#include <boost/function.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <stdexcept>
+#include <new>
+
+struct stateless_integer_add {
+  int operator()(int x, int y) const { return x+y; }
+
+  void* operator new(std::size_t n)
+  {
+    BOOST_ERROR( "stateless_integer_add incorrectly allocated" );
+    return ::operator new( n );
+  }
+
+  void* operator new(std::size_t, void* p)
+  {
+    return p;
+  }
+
+  void operator delete(void* p) throw()
+  {
+    BOOST_ERROR( "stateless_integer_add incorrectly deallocated" );
+    return ::operator delete( p );
+  }
+};
+
+int main()
+{
+  boost::function2<int, int, int> f;
+  f = stateless_integer_add();
+
+  return boost::report_errors();
+}

test/std_bind_cxx98.cpp

@@ -0,0 +1,40 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Use, modification and distribution is subject to the Boost Software 
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt) 
+
+// For more information, see http://www.boost.org/
+
+#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>
+
+struct X {
+  int foo(int);
+};
+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

@@ -0,0 +1,40 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Use, modification and distribution is subject to the Boost Software 
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt) 
+
+// For more information, see http://www.boost.org/
+
+#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>
+
+struct X {
+  int foo(int);
+};
+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/sum_avg_cxx98.cpp

@@ -0,0 +1,28 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Use, modification and distribution is subject to the Boost Software 
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt) 
+
+// For more information, see http://www.boost.org/
+
+    
+#include <boost/function.hpp>
+#include <iostream>
+
+void do_sum_avg(int values[], int n, int& sum, float& avg)
+{
+  sum = 0;
+  for (int i = 0; i < n; i++)
+    sum += values[i];
+  avg = (float)sum / n;
+}
+int main()
+{
+    boost::function<void (int values[], int n, int& sum, float& avg)> sum_avg;
+    sum_avg = &do_sum_avg;
+
+    return 0;
+}

test/sum_avg_portable.cpp

@@ -0,0 +1,28 @@
+// Function library
+
+// Copyright (C) 2001-2003 Douglas Gregor
+
+// Use, modification and distribution is subject to the Boost Software 
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt) 
+
+// For more information, see http://www.boost.org/
+
+    
+#include <boost/function.hpp>
+#include <iostream>
+
+void do_sum_avg(int values[], int n, int& sum, float& avg)
+{
+  sum = 0;
+  for (int i = 0; i < n; i++)
+    sum += values[i];
+  avg = (float)sum / n;
+}
+int main()
+{
+    boost::function4<void, int*, int, int&, float&> sum_avg;
+    sum_avg = &do_sum_avg;
+
+    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();
+}