Compare commits

..

3 Commits

Author SHA1 Message Date
Peter Dimov
f8f7bdb699 Remove unnecessary Travis configurations 2018-09-24 20:38:21 +03:00
Peter Dimov
7c0dafc88e Merge branch 'feature/use-lwtest' into feature/lwtest-and-travis 2018-09-24 20:31:03 +03:00
Peter Dimov
267243aa5c Update .travis.yml 2018-09-24 19:48:47 +03:00
65 changed files with 1671 additions and 2712 deletions

View File

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

View File

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

View File

@@ -1,25 +0,0 @@
#!/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}

View File

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

View File

@@ -1,10 +1,12 @@
# Copyright 2016-2019 Peter Dimov # Copyright 2016, 2017, 2018 Peter Dimov
# Distributed under the Boost Software License, Version 1.0. # 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) # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
language: cpp language: cpp
dist: xenial sudo: false
python: "2.7"
branches: branches:
only: only:
@@ -22,9 +24,13 @@ matrix:
- env: BOGUS_JOB=true - env: BOGUS_JOB=true
include: include:
- os: linux
compiler: g++
env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
- os: linux - os: linux
compiler: g++-4.4 compiler: g++-4.4
env: TOOLSET=gcc CXXSTD=98,0x env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
addons: addons:
apt: apt:
packages: packages:
@@ -34,7 +40,7 @@ matrix:
- os: linux - os: linux
compiler: g++-4.6 compiler: g++-4.6
env: TOOLSET=gcc CXXSTD=03,0x env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
addons: addons:
apt: apt:
packages: packages:
@@ -44,7 +50,7 @@ matrix:
- os: linux - os: linux
compiler: g++-4.7 compiler: g++-4.7
env: TOOLSET=gcc CXXSTD=03,11 env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
addons: addons:
apt: apt:
packages: packages:
@@ -54,7 +60,7 @@ matrix:
- os: linux - os: linux
compiler: g++-4.8 compiler: g++-4.8
env: TOOLSET=gcc CXXSTD=03,11 env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
addons: addons:
apt: apt:
packages: packages:
@@ -63,7 +69,7 @@ matrix:
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
- os: linux - os: linux
compiler: g++-4.9 compiler: g++-4.9
env: TOOLSET=gcc CXXSTD=03,11 env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
addons: addons:
apt: apt:
packages: packages:
@@ -73,7 +79,7 @@ matrix:
- os: linux - os: linux
compiler: g++-5 compiler: g++-5
env: TOOLSET=gcc CXXSTD=03,11,14,1z env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
addons: addons:
apt: apt:
packages: packages:
@@ -83,7 +89,7 @@ matrix:
- os: linux - os: linux
compiler: g++-6 compiler: g++-6
env: TOOLSET=gcc CXXSTD=03,11,14,1z env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
addons: addons:
apt: apt:
packages: packages:
@@ -93,7 +99,7 @@ matrix:
- os: linux - os: linux
compiler: g++-7 compiler: g++-7
env: TOOLSET=gcc CXXSTD=03,11,14,17 env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
addons: addons:
apt: apt:
packages: packages:
@@ -103,7 +109,7 @@ matrix:
- os: linux - os: linux
compiler: g++-8 compiler: g++-8
env: TOOLSET=gcc CXXSTD=03,11,14,17,2a env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
addons: addons:
apt: apt:
packages: packages:
@@ -112,39 +118,30 @@ matrix:
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
- os: linux - os: linux
compiler: g++-9 compiler: g++-8
env: TOOLSET=gcc CXXSTD=03,11,14,17,2a env: UBSAN=1 TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
addons: addons:
apt: apt:
packages: packages:
- g++-9 - g++-8
sources: sources:
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
- os: linux - os: linux
dist: bionic compiler: clang++
compiler: g++-10 env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
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 - os: linux
dist: trusty
compiler: /usr/bin/clang++ compiler: /usr/bin/clang++
env: TOOLSET=clang CXXSTD=03,11 env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
addons: addons:
apt: apt:
packages: packages:
- clang-3.3 - clang-3.3
- os: linux - os: linux
dist: trusty
compiler: /usr/bin/clang++ compiler: /usr/bin/clang++
env: TOOLSET=clang CXXSTD=03,11 env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
addons: addons:
apt: apt:
packages: packages:
@@ -152,171 +149,120 @@ matrix:
- os: linux - os: linux
compiler: clang++-3.5 compiler: clang++-3.5
env: TOOLSET=clang CXXSTD=03,11,14,1z env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
addons: addons:
apt: apt:
packages: packages:
- clang-3.5 - clang-3.5
- libstdc++-4.9-dev
sources: sources:
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.5
- os: linux - os: linux
compiler: clang++-3.6 compiler: clang++-3.6
env: TOOLSET=clang CXXSTD=03,11,14,1z env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
addons: addons:
apt: apt:
packages: packages:
- clang-3.6 - clang-3.6
- libstdc++-4.9-dev
sources: sources:
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.6
- os: linux - os: linux
compiler: clang++-3.7 compiler: clang++-3.7
env: TOOLSET=clang CXXSTD=03,11,14,1z env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
addons: addons:
apt: apt:
packages: packages:
- clang-3.7 - clang-3.7
- libstdc++-4.9-dev
sources: sources:
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.7
- os: linux - os: linux
compiler: clang++-3.8 compiler: clang++-3.8
env: TOOLSET=clang CXXSTD=03,11,14,1z env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
addons: addons:
apt: apt:
packages: packages:
- clang-3.8 - clang-3.8
- libstdc++-4.9-dev
sources: sources:
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.8
- os: linux - os: linux
compiler: clang++-3.9 compiler: clang++-3.9
env: TOOLSET=clang CXXSTD=03,11,14,1z env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
addons: addons:
apt: apt:
packages: packages:
- clang-3.9 - clang-3.9
- libstdc++-4.9-dev
sources: sources:
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.9
- os: linux - os: linux
compiler: clang++-4.0 compiler: clang++-4.0
env: TOOLSET=clang CXXSTD=03,11,14,1z env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
addons: addons:
apt: apt:
packages: packages:
- clang-4.0 - clang-4.0
sources: sources:
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
- llvm-toolchain-trusty-4.0
- os: linux - os: linux
compiler: clang++-5.0 compiler: clang++-5.0
env: TOOLSET=clang CXXSTD=03,11,14,1z env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
addons: addons:
apt: apt:
packages: packages:
- clang-5.0 - clang-5.0
sources: sources:
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
- llvm-toolchain-trusty-5.0
- os: linux - os: linux
compiler: clang++-6.0 compiler: clang++-6.0
env: TOOLSET=clang CXXSTD=03,11,14,17,2a env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
addons: addons:
apt: apt:
packages: packages:
- clang-6.0 - clang-6.0
sources: sources:
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
- llvm-toolchain-trusty-6.0
- os: linux - os: linux
compiler: clang++-7 compiler: clang++-6.0
env: TOOLSET=clang CXXSTD=03,11,14,17,2a env: UBSAN=1 TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
addons: addons:
apt: apt:
packages: packages:
- clang-7 - clang-6.0
- libstdc++-5-dev
sources: sources:
- ubuntu-toolchain-r-test - ubuntu-toolchain-r-test
- llvm-toolchain-xenial-7 - llvm-toolchain-trusty-6.0
- os: linux - 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++ compiler: clang++-libc++
env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1 env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
addons: addons:
apt: apt:
packages: packages:
- libc++-dev - libc++-dev
- os: linux - os: linux
dist: bionic
compiler: clang++-libc++ compiler: clang++-libc++
env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1 env: UBSAN=1 TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
addons: addons:
apt: apt:
packages: packages:
@@ -324,28 +270,15 @@ matrix:
- os: osx - os: osx
compiler: clang++ compiler: clang++
env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1 env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
- 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: install:
- BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
- cd .. - cd ..
- git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
- cd boost-root - cd boost-root
- git submodule update --init tools/build
- git submodule update --init libs/config
- git submodule update --init tools/boostdep - git submodule update --init tools/boostdep
- cp -r $TRAVIS_BUILD_DIR/* libs/function - cp -r $TRAVIS_BUILD_DIR/* libs/function
- python tools/boostdep/depinst/depinst.py function - python tools/boostdep/depinst/depinst.py function
@@ -354,8 +287,8 @@ install:
script: script:
- |- - |-
echo "using $TOOLSET : : $TRAVIS_COMPILER ;" > ~/user-config.jam echo "using $TOOLSET : : $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} - ./b2 -j3 libs/function/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
notifications: notifications:
email: email:

View File

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

11
Jamfile Normal file
View File

@@ -0,0 +1,11 @@
# Boost.Function Library Jamfile
#
# Copyright (c) 2018 James E. King III
#
# Use, modification, and distribution are subject to the
# Boost Software License, Version 1.0. (See accompanying file
# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
# please order by name to ease maintenance
build-project example ;
build-project test ;

23
LICENSE Normal file
View File

@@ -0,0 +1,23 @@
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

View File

@@ -1,18 +1,34 @@
# Boost.Function, a polymorphic function wrapper Function, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), contains a family of class templates that are function object wrappers.
[Boost.Function](http://boost.org/libs/function), part of the ### License
[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 Distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
* g++ 4.7 or later ### Properties
* clang++ 3.9 or later
* Visual Studio 2013-2022
Tested on [Github Actions](https://github.com/boostorg/function/actions) and [Appveyor](https://ci.appveyor.com/project/pdimov/function/). * C++03
* Header-Only
## License ### Build Status
Branch | Travis | Appveyor | Coverity Scan | codecov.io | Deps | Docs | Tests |
:-------------: | ------ | -------- | ------------- | ---------- | ---- | ---- | ----- |
[`master`](https://github.com/boostorg/function/tree/master) | [![Build Status](https://travis-ci.org/boostorg/function.svg?branch=master)](https://travis-ci.org/boostorg/function) | [![Build status](https://ci.appveyor.com/api/projects/status/7tgx4ac44fikr87d/branch/master?svg=true)](https://ci.appveyor.com/project/jeking3/function-d036y/branch/master) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/15843/badge.svg)](https://scan.coverity.com/projects/boostorg-function) | [![codecov](https://codecov.io/gh/boostorg/function/branch/master/graph/badge.svg)](https://codecov.io/gh/boostorg/function/branch/master)| [![Deps](https://img.shields.io/badge/deps-master-brightgreen.svg)](https://pdimov.github.io/boostdep-report/master/function.html) | [![Documentation](https://img.shields.io/badge/docs-master-brightgreen.svg)](http://www.boost.org/doc/libs/master/doc/html/function.html) | [![Enter the Matrix](https://img.shields.io/badge/matrix-master-brightgreen.svg)](http://www.boost.org/development/tests/master/developer/function.html)
[`develop`](https://github.com/boostorg/function/tree/develop) | [![Build Status](https://travis-ci.org/boostorg/function.svg?branch=develop)](https://travis-ci.org/boostorg/function) | [![Build status](https://ci.appveyor.com/api/projects/status/7tgx4ac44fikr87d/branch/develop?svg=true)](https://ci.appveyor.com/project/jeking3/function-d036y/branch/develop) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/15843/badge.svg)](https://scan.coverity.com/projects/boostorg-function) | [![codecov](https://codecov.io/gh/boostorg/function/branch/develop/graph/badge.svg)](https://codecov.io/gh/boostorg/function/branch/develop) | [![Deps](https://img.shields.io/badge/deps-develop-brightgreen.svg)](https://pdimov.github.io/boostdep-report/develop/function.html) | [![Documentation](https://img.shields.io/badge/docs-develop-brightgreen.svg)](http://www.boost.org/doc/libs/develop/doc/html/function.html) | [![Enter the Matrix](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](http://www.boost.org/development/tests/develop/developer/function.html)
### Directories
| Name | Purpose |
| ----------- | ------------------------------ |
| `doc` | documentation |
| `example` | examples |
| `include` | headers |
| `test` | unit tests |
### More information
* [Ask questions](http://stackoverflow.com/questions/ask?tags=c%2B%2B,boost,boost-function)
* [Report bugs](https://github.com/boostorg/function/issues): Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
* Discussions about the library are held on the [Boost developers mailing list](http://www.boost.org/community/groups.html#main). Be sure to read the [discussion policy](http://www.boost.org/community/policy.html) before posting and add the `[function]` tag at the beginning of the subject line.
Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).

View File

@@ -1,4 +1,5 @@
# Copyright 2016-2019 Peter Dimov # Copyright 2016, 2017 Peter Dimov
# Copyright (C) 2017, 2018 James E. King III
# Distributed under the Boost Software License, Version 1.0. # 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) # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
@@ -8,60 +9,73 @@ shallow_clone: true
branches: branches:
only: only:
- master
- develop - develop
- /feature\/.*/ - master
matrix:
allow_failures:
- MAYFAIL: true
environment: environment:
global:
# see: http://www.boost.org/build/doc/html/bbv2/overview/invocation.html#bbv2.overview.invocation.properties
# to use the default for a given environment, comment it out; recommend you build debug and release however..
# on Windows it is important to exercise all the possibilities, especially shared vs static
# B2_ADDRESS_MODEL: address-model=64,32
# B2_LINK: link=shared,static
# B2_THREADING: threading=multi,single
B2_VARIANT: variant=release,debug
CXXSTD: 03
matrix: matrix:
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 - FLAVOR: Visual Studio 2017
TOOLSET: msvc-12.0,msvc-14.0 APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
ADDRMD: 32,64
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TOOLSET: msvc-14.1 TOOLSET: msvc-14.1
CXXSTD: 14,17 B2_ADDRESS_MODEL: address-model=64,32
ADDRMD: 32,64 - FLAVOR: Visual Studio 2015
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: clang-win TOOLSET: msvc-14.0
CXXSTD: 14,17,latest B2_ADDRESS_MODEL: address-model=64,32
ADDRMD: 64 - FLAVOR: Visual Studio 2010, 2012, 2013
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019 APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
TOOLSET: clang-win TOOLSET: msvc-10.0,msvc-11.0,msvc-12.0
CXXSTD: 14,17,latest - FLAVOR: cygwin (32-bit)
ADDRMD: 64 APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
ADDPATH: C:\cygwin\bin; ADDPATH: C:\cygwin\bin;
B2_ADDRESS_MODEL: address-model=32
# https://github.com/boostorg/test/issues/144
DEFINES: define=_POSIX_C_SOURCE=200112L
THREADING: threadapi=pthread
TOOLSET: gcc TOOLSET: gcc
CXXSTD: 11,14,1z - FLAVOR: cygwin (64-bit)
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
ADDPATH: C:\cygwin64\bin; ADDPATH: C:\cygwin64\bin;
B2_ADDRESS_MODEL: address-model=64
# https://github.com/boostorg/test/issues/144
DEFINES: define=_POSIX_C_SOURCE=200112L
THREADING: threadapi=pthread
TOOLSET: gcc TOOLSET: gcc
CXXSTD: 11,14,1z - FLAVOR: mingw32
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
ADDPATH: C:\mingw\bin; ARCH: i686
TOOLSET: gcc B2_ADDRESS_MODEL: address-model=32
CXXSTD: 11,14,1z SCRIPT: ci\appveyor\mingw.bat
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 - FLAVOR: mingw64
ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin; APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TOOLSET: gcc ARCH: x86_64
CXXSTD: 11,14,1z B2_ADDRESS_MODEL: address-model=64
SCRIPT: ci\appveyor\mingw.bat
install: install:
- set BOOST_BRANCH=develop - set SELF=%APPVEYOR_PROJECT_NAME:-=_%
- if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master - git clone https://github.com/jeking3/boost-ci.git C:\boost-ci
- cd .. - xcopy /s /e /q /i C:\boost-ci\ci .\ci
- git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root - ci\appveyor\install.bat
- 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 build: off
test_script: test_script:
- set SELF=%APPVEYOR_PROJECT_NAME:-=_%
- PATH=%ADDPATH%%PATH% - PATH=%ADDPATH%%PATH%
- if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD% - IF DEFINED SCRIPT (call libs\%SELF%\%SCRIPT%) ELSE (b2 libs/%SELF% toolset=%TOOLSET% cxxstd=%CXXSTD% %CXXFLAGS% %DEFINES% %THREADING% %B2_ADDRESS_MODEL% %B2_LINK% %B2_THREADING% %B2_VARIANT% -j3)
- if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
- b2 -j3 libs/function/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker

View File

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

View File

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

20
example/Jamfile.v2 Normal file
View File

@@ -0,0 +1,20 @@
# Boost.Function Library example Jamfile
#
# Copyright (c) 2008 James E. King III
#
# Distributed under the Boost Software License, Version 1.0. (See accompany-
# ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
import os ;
import testing ;
project
: requirements
;
test-suite "function-examples"
: [ run bind1st.cpp ]
[ run int_div.cpp ]
[ run sum_avg.cpp ]
;

View File

@@ -1,6 +1,3 @@
#ifndef BOOST_FUNCTION_HPP_INCLUDED
#define BOOST_FUNCTION_HPP_INCLUDED
// Boost.Function library // Boost.Function library
// Copyright Douglas Gregor 2001-2003. Use, modification and // Copyright Douglas Gregor 2001-2003. Use, modification and
@@ -13,6 +10,65 @@
// William Kempf, Jesse Jones and Karl Nelson were all very helpful in the // William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
// design of this library. // design of this library.
#include <boost/function/function_template.hpp> #ifndef BOOST_FUNCTION_MAX_ARGS
# define BOOST_FUNCTION_MAX_ARGS 10
#endif // BOOST_FUNCTION_MAX_ARGS
#endif // #ifndef BOOST_FUNCTION_HPP_INCLUDED #if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) || (BOOST_FUNCTION_MAX_ARGS_DEFINED != BOOST_FUNCTION_MAX_ARGS)
#if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED)
#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
#endif
#include <functional> // unary_function, binary_function
#include <boost/preprocessor/iterate.hpp>
#include <boost/config/workaround.hpp>
// Include the prologue here so that the use of file-level iteration
// in anything that may be included by function_template.hpp doesn't break
#include <boost/function/detail/prologue.hpp>
// 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
// What is the '3' for?
# define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_FUNCTION_MAX_ARGS,<boost/function/detail/function_iterate.hpp>))
# include BOOST_PP_ITERATE()
# undef BOOST_PP_ITERATION_PARAMS_1
#endif
#endif // !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) || (BOOST_FUNCTION_MAX_ARGS_DEFINED != BOOST_FUNCTION_MAX_ARGS)

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -11,18 +11,31 @@
#ifndef BOOST_FUNCTION_BASE_HEADER #ifndef BOOST_FUNCTION_BASE_HEADER
#define BOOST_FUNCTION_BASE_HEADER #define BOOST_FUNCTION_BASE_HEADER
#include <boost/function/function_fwd.hpp>
#include <boost/function_equal.hpp>
#include <boost/core/typeinfo.hpp>
#include <boost/core/ref.hpp>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/config/workaround.hpp>
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
#include <memory> #include <memory>
#include <new> #include <new>
#include <type_traits> #include <boost/config.hpp>
#include <boost/assert.hpp>
#include <boost/integer.hpp>
#include <boost/type_index.hpp>
#include <boost/type_traits/has_trivial_copy.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/composite_traits.hpp>
#include <boost/ref.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/config/workaround.hpp>
#include <boost/type_traits/alignment_of.hpp>
#ifndef BOOST_NO_SFINAE
#include <boost/type_traits/enable_if.hpp>
#else
#include <boost/type_traits/integral_constant.hpp>
#endif
#include <boost/function_equal.hpp>
#include <boost/function/function_fwd.hpp>
#if defined(BOOST_MSVC) #if defined(BOOST_MSVC)
# pragma warning( push ) # pragma warning( push )
@@ -30,11 +43,16 @@
# pragma warning( disable : 4127 ) // "conditional expression is constant" # pragma warning( disable : 4127 ) // "conditional expression is constant"
#endif #endif
// retained because used in a test #if defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
#define BOOST_FUNCTION_TARGET_FIX(x) # define BOOST_FUNCTION_TARGET_FIX(x) x
#else
# define BOOST_FUNCTION_TARGET_FIX(x)
#endif // __ICL etc
#define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \ # define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
typename std::enable_if< !std::is_integral<Functor>::value, Type>::type typename ::boost::enable_if_< \
!(::boost::is_integral<Functor>::value), \
Type>::type
namespace boost { namespace boost {
namespace detail { namespace detail {
@@ -56,7 +74,7 @@ namespace boost {
// For pointers to std::type_info objects // For pointers to std::type_info objects
struct type_t { struct type_t {
// (get_functor_type_tag, check_functor_type_tag). // (get_functor_type_tag, check_functor_type_tag).
const boost::core::typeinfo* type; const boost::typeindex::type_info* type;
// Whether the type is const-qualified. // Whether the type is const-qualified.
bool const_qualified; bool const_qualified;
@@ -68,21 +86,12 @@ namespace boost {
typedef void (*func_ptr_t)(); typedef void (*func_ptr_t)();
mutable func_ptr_t func_ptr; mutable func_ptr_t func_ptr;
#if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
# pragma warning(push)
# pragma warning(disable: 5243)
#endif
// For bound member pointers // For bound member pointers
struct bound_memfunc_ptr_t { struct bound_memfunc_ptr_t {
void (X::*memfunc_ptr)(int); void (X::*memfunc_ptr)(int);
void* obj_ptr; void* obj_ptr;
} bound_memfunc_ptr; } bound_memfunc_ptr;
#if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
# pragma warning(pop)
#endif
// For references to function objects. We explicitly keep // For references to function objects. We explicitly keep
// track of the cv-qualifiers on the object referenced. // track of the cv-qualifiers on the object referenced.
struct obj_ref_t { struct obj_ref_t {
@@ -92,7 +101,7 @@ namespace boost {
} obj_ref; } obj_ref;
}; };
union BOOST_SYMBOL_VISIBLE function_buffer union function_buffer
{ {
// Type-specific union members // Type-specific union members
mutable function_buffer_members members; mutable function_buffer_members members;
@@ -101,6 +110,30 @@ namespace boost {
mutable char data[sizeof(function_buffer_members)]; mutable char data[sizeof(function_buffer_members)];
}; };
/**
* The unusable class is a placeholder for unused function arguments
* It is also completely unusable except that it constructable from
* anything. This helps compilers without partial specialization to
* handle Boost.Function objects returning void.
*/
struct unusable
{
unusable() {}
template<typename T> unusable(const T&) {}
};
/* Determine the return type. This supports compilers that do not support
* void returns or partial specialization by silently changing the return
* type to "unusable".
*/
template<typename T> struct function_return_type { typedef T type; };
template<>
struct function_return_type<void>
{
typedef unusable type;
};
// The operation type to perform on the given functor/function pointer // The operation type to perform on the given functor/function pointer
enum functor_manager_operation_type { enum functor_manager_operation_type {
clone_functor_tag, clone_functor_tag,
@@ -119,15 +152,15 @@ namespace boost {
template<typename F> template<typename F>
class get_function_tag class get_function_tag
{ {
typedef typename std::conditional<std::is_pointer<F>::value, typedef typename conditional<(is_pointer<F>::value),
function_ptr_tag, function_ptr_tag,
function_obj_tag>::type ptr_or_obj_tag; function_obj_tag>::type ptr_or_obj_tag;
typedef typename std::conditional<std::is_member_pointer<F>::value, typedef typename conditional<(is_member_pointer<F>::value),
member_ptr_tag, member_ptr_tag,
ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag; ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
typedef typename std::conditional<is_reference_wrapper<F>::value, typedef typename conditional<(is_reference_wrapper<F>::value),
function_obj_ref_tag, function_obj_ref_tag,
ptr_or_obj_or_mem_tag>::type or_ref_tag; ptr_or_obj_or_mem_tag>::type or_ref_tag;
@@ -162,7 +195,7 @@ namespace boost {
{ {
// Check whether we have the same type. We can add // Check whether we have the same type. We can add
// cv-qualifiers, but we can't take them away. // cv-qualifiers, but we can't take them away.
if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(F) if (*out_buffer.members.type.type == boost::typeindex::type_id<F>()
&& (!in_buffer.members.obj_ref.is_const_qualified && (!in_buffer.members.obj_ref.is_const_qualified
|| out_buffer.members.type.const_qualified) || out_buffer.members.type.const_qualified)
&& (!in_buffer.members.obj_ref.is_volatile_qualified && (!in_buffer.members.obj_ref.is_volatile_qualified
@@ -174,7 +207,7 @@ namespace boost {
return; return;
case get_functor_type_tag: case get_functor_type_tag:
out_buffer.members.type.type = &BOOST_CORE_TYPEID(F); out_buffer.members.type.type = &boost::typeindex::type_id<F>().type_info();
out_buffer.members.type.const_qualified = in_buffer.members.obj_ref.is_const_qualified; out_buffer.members.type.const_qualified = in_buffer.members.obj_ref.is_const_qualified;
out_buffer.members.type.volatile_qualified = in_buffer.members.obj_ref.is_volatile_qualified; out_buffer.members.type.volatile_qualified = in_buffer.members.obj_ref.is_volatile_qualified;
return; return;
@@ -192,8 +225,8 @@ namespace boost {
BOOST_STATIC_CONSTANT BOOST_STATIC_CONSTANT
(bool, (bool,
value = ((sizeof(F) <= sizeof(function_buffer) && value = ((sizeof(F) <= sizeof(function_buffer) &&
(std::alignment_of<function_buffer>::value (alignment_of<function_buffer>::value
% std::alignment_of<F>::value == 0)))); % alignment_of<F>::value == 0))));
}; };
template <typename F,typename A> template <typename F,typename A>
@@ -234,12 +267,12 @@ namespace boost {
} else if (op == destroy_functor_tag) } else if (op == destroy_functor_tag)
out_buffer.members.func_ptr = 0; out_buffer.members.func_ptr = 0;
else if (op == check_functor_type_tag) { else if (op == check_functor_type_tag) {
if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor)) if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
out_buffer.members.obj_ptr = &in_buffer.members.func_ptr; out_buffer.members.obj_ptr = &in_buffer.members.func_ptr;
else else
out_buffer.members.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} else /* op == get_functor_type_tag */ { } else /* op == get_functor_type_tag */ {
out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor); out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
out_buffer.members.type.const_qualified = false; out_buffer.members.type.const_qualified = false;
out_buffer.members.type.volatile_qualified = false; out_buffer.members.type.volatile_qualified = false;
} }
@@ -250,27 +283,28 @@ namespace boost {
manage_small(const function_buffer& in_buffer, function_buffer& out_buffer, manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op) functor_manager_operation_type op)
{ {
if (op == clone_functor_tag) { if (op == clone_functor_tag || op == move_functor_tag) {
const functor_type* in_functor = const functor_type* in_functor =
reinterpret_cast<const functor_type*>(in_buffer.data); reinterpret_cast<const functor_type*>(in_buffer.data);
new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor); new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor);
} else if (op == move_functor_tag) { if (op == move_functor_tag) {
functor_type* f = reinterpret_cast<functor_type*>(in_buffer.data); functor_type* f = reinterpret_cast<functor_type*>(in_buffer.data);
new (reinterpret_cast<void*>(out_buffer.data)) functor_type(std::move(*f)); (void)f; // suppress warning about the value of f not being used (MSVC)
f->~Functor(); f->~Functor();
}
} else if (op == destroy_functor_tag) { } else if (op == destroy_functor_tag) {
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type. // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
functor_type* f = reinterpret_cast<functor_type*>(out_buffer.data); functor_type* f = reinterpret_cast<functor_type*>(out_buffer.data);
(void)f; // suppress warning about the value of f not being used (MSVC) (void)f; // suppress warning about the value of f not being used (MSVC)
f->~Functor(); f->~Functor();
} else if (op == check_functor_type_tag) { } else if (op == check_functor_type_tag) {
if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor)) if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
out_buffer.members.obj_ptr = in_buffer.data; out_buffer.members.obj_ptr = in_buffer.data;
else else
out_buffer.members.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} else /* op == get_functor_type_tag */ { } else /* op == get_functor_type_tag */ {
out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor); out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
out_buffer.members.type.const_qualified = false; out_buffer.members.type.const_qualified = false;
out_buffer.members.type.volatile_qualified = false; out_buffer.members.type.volatile_qualified = false;
} }
@@ -294,7 +328,7 @@ namespace boost {
// Function objects that fit in the small-object buffer. // Function objects that fit in the small-object buffer.
static inline void static inline void
manager(const function_buffer& in_buffer, function_buffer& out_buffer, manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, std::true_type) functor_manager_operation_type op, true_type)
{ {
functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op); functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
} }
@@ -302,7 +336,7 @@ namespace boost {
// Function objects that require heap allocation // Function objects that require heap allocation
static inline void static inline void
manager(const function_buffer& in_buffer, function_buffer& out_buffer, manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, std::false_type) functor_manager_operation_type op, false_type)
{ {
if (op == clone_functor_tag) { if (op == clone_functor_tag) {
// Clone the functor // Clone the functor
@@ -324,12 +358,12 @@ namespace boost {
delete f; delete f;
out_buffer.members.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} else if (op == check_functor_type_tag) { } else if (op == check_functor_type_tag) {
if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor)) if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
out_buffer.members.obj_ptr = in_buffer.members.obj_ptr; out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
else else
out_buffer.members.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} else /* op == get_functor_type_tag */ { } else /* op == get_functor_type_tag */ {
out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor); out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
out_buffer.members.type.const_qualified = false; out_buffer.members.type.const_qualified = false;
out_buffer.members.type.volatile_qualified = false; out_buffer.members.type.volatile_qualified = false;
} }
@@ -343,7 +377,7 @@ namespace boost {
functor_manager_operation_type op, function_obj_tag) functor_manager_operation_type op, function_obj_tag)
{ {
manager(in_buffer, out_buffer, op, manager(in_buffer, out_buffer, op,
std::integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>()); integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
} }
// For member pointers, we use the small-object optimization buffer. // For member pointers, we use the small-object optimization buffer.
@@ -351,7 +385,7 @@ namespace boost {
manager(const function_buffer& in_buffer, function_buffer& out_buffer, manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, member_ptr_tag) functor_manager_operation_type op, member_ptr_tag)
{ {
manager(in_buffer, out_buffer, op, std::true_type()); manager(in_buffer, out_buffer, op, true_type());
} }
public: public:
@@ -362,12 +396,16 @@ namespace boost {
functor_manager_operation_type op) functor_manager_operation_type op)
{ {
typedef typename get_function_tag<functor_type>::type tag_type; typedef typename get_function_tag<functor_type>::type tag_type;
if (op == get_functor_type_tag) { switch (op) {
out_buffer.members.type.type = &BOOST_CORE_TYPEID(functor_type); case get_functor_type_tag:
out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
out_buffer.members.type.const_qualified = false; out_buffer.members.type.const_qualified = false;
out_buffer.members.type.volatile_qualified = false; out_buffer.members.type.volatile_qualified = false;
} else { return;
default:
manager(in_buffer, out_buffer, op, tag_type()); manager(in_buffer, out_buffer, op, tag_type());
return;
} }
} }
}; };
@@ -389,7 +427,7 @@ namespace boost {
// Function objects that fit in the small-object buffer. // Function objects that fit in the small-object buffer.
static inline void static inline void
manager(const function_buffer& in_buffer, function_buffer& out_buffer, manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, std::true_type) functor_manager_operation_type op, true_type)
{ {
functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op); functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
} }
@@ -397,12 +435,17 @@ namespace boost {
// Function objects that require heap allocation // Function objects that require heap allocation
static inline void static inline void
manager(const function_buffer& in_buffer, function_buffer& out_buffer, manager(const function_buffer& in_buffer, function_buffer& out_buffer,
functor_manager_operation_type op, std::false_type) functor_manager_operation_type op, false_type)
{ {
typedef functor_wrapper<Functor,Allocator> functor_wrapper_type; typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
#if defined(BOOST_NO_CXX11_ALLOCATOR)
typedef typename Allocator::template rebind<functor_wrapper_type>::other
wrapper_allocator_type;
typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
#else
using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>; using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer; using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
#endif
if (op == clone_functor_tag) { if (op == clone_functor_tag) {
// Clone the functor // Clone the functor
@@ -412,7 +455,11 @@ namespace boost {
static_cast<const functor_wrapper_type*>(in_buffer.members.obj_ptr); static_cast<const functor_wrapper_type*>(in_buffer.members.obj_ptr);
wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f)); wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1); wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
#if defined(BOOST_NO_CXX11_ALLOCATOR)
wrapper_allocator.construct(copy, *f);
#else
std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, *f); std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, *f);
#endif
// Get back to the original pointer type // Get back to the original pointer type
functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy); functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
@@ -425,16 +472,20 @@ namespace boost {
functor_wrapper_type* victim = functor_wrapper_type* victim =
static_cast<functor_wrapper_type*>(in_buffer.members.obj_ptr); static_cast<functor_wrapper_type*>(in_buffer.members.obj_ptr);
wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim)); wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
#if defined(BOOST_NO_CXX11_ALLOCATOR)
wrapper_allocator.destroy(victim);
#else
std::allocator_traits<wrapper_allocator_type>::destroy(wrapper_allocator, victim); std::allocator_traits<wrapper_allocator_type>::destroy(wrapper_allocator, victim);
#endif
wrapper_allocator.deallocate(victim,1); wrapper_allocator.deallocate(victim,1);
out_buffer.members.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} else if (op == check_functor_type_tag) { } else if (op == check_functor_type_tag) {
if (*out_buffer.members.type.type == BOOST_CORE_TYPEID(Functor)) if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
out_buffer.members.obj_ptr = in_buffer.members.obj_ptr; out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
else else
out_buffer.members.obj_ptr = 0; out_buffer.members.obj_ptr = 0;
} else /* op == get_functor_type_tag */ { } else /* op == get_functor_type_tag */ {
out_buffer.members.type.type = &BOOST_CORE_TYPEID(Functor); out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
out_buffer.members.type.const_qualified = false; out_buffer.members.type.const_qualified = false;
out_buffer.members.type.volatile_qualified = false; out_buffer.members.type.volatile_qualified = false;
} }
@@ -448,7 +499,7 @@ namespace boost {
functor_manager_operation_type op, function_obj_tag) functor_manager_operation_type op, function_obj_tag)
{ {
manager(in_buffer, out_buffer, op, manager(in_buffer, out_buffer, op,
std::integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>()); integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
} }
public: public:
@@ -459,12 +510,16 @@ namespace boost {
functor_manager_operation_type op) functor_manager_operation_type op)
{ {
typedef typename get_function_tag<functor_type>::type tag_type; typedef typename get_function_tag<functor_type>::type tag_type;
if (op == get_functor_type_tag) { switch (op) {
out_buffer.members.type.type = &BOOST_CORE_TYPEID(functor_type); case get_functor_type_tag:
out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
out_buffer.members.type.const_qualified = false; out_buffer.members.type.const_qualified = false;
out_buffer.members.type.volatile_qualified = false; out_buffer.members.type.volatile_qualified = false;
} else { return;
default:
manager(in_buffer, out_buffer, op, tag_type()); manager(in_buffer, out_buffer, op, tag_type());
return;
} }
} }
}; };
@@ -472,6 +527,65 @@ namespace boost {
// A type that is only used for comparisons against zero // A type that is only used for comparisons against zero
struct useless_clear_type {}; struct useless_clear_type {};
#ifdef BOOST_NO_SFINAE
// These routines perform comparisons between a Boost.Function
// object and an arbitrary function object (when the last
// parameter is false_type) or against zero (when the
// last parameter is true_type). They are only necessary
// for compilers that don't support SFINAE.
template<typename Function, typename Functor>
bool
compare_equal(const Function& f, const Functor&, int, true_type)
{ return f.empty(); }
template<typename Function, typename Functor>
bool
compare_not_equal(const Function& f, const Functor&, int,
true_type)
{ return !f.empty(); }
template<typename Function, typename Functor>
bool
compare_equal(const Function& f, const Functor& g, long,
false_type)
{
if (const Functor* fp = f.template target<Functor>())
return function_equal(*fp, g);
else return false;
}
template<typename Function, typename Functor>
bool
compare_equal(const Function& f, const reference_wrapper<Functor>& g,
int, false_type)
{
if (const Functor* fp = f.template target<Functor>())
return fp == g.get_pointer();
else return false;
}
template<typename Function, typename Functor>
bool
compare_not_equal(const Function& f, const Functor& g, long,
false_type)
{
if (const Functor* fp = f.template target<Functor>())
return !function_equal(*fp, g);
else return true;
}
template<typename Function, typename Functor>
bool
compare_not_equal(const Function& f,
const reference_wrapper<Functor>& g, int,
false_type)
{
if (const Functor* fp = f.template target<Functor>())
return fp != g.get_pointer();
else return true;
}
#endif // BOOST_NO_SFINAE
/** /**
* Stores the "manager" portion of the vtable for a * Stores the "manager" portion of the vtable for a
* boost::function object. * boost::function object.
@@ -501,9 +615,9 @@ public:
/** Retrieve the type of the stored function object, or type_id<void>() /** Retrieve the type of the stored function object, or type_id<void>()
if this is empty. */ if this is empty. */
const boost::core::typeinfo& target_type() const const boost::typeindex::type_info& target_type() const
{ {
if (!vtable) return BOOST_CORE_TYPEID(void); if (!vtable) return boost::typeindex::type_id<void>().type_info();
detail::function::function_buffer type; detail::function::function_buffer type;
get_vtable()->manager(functor, type, detail::function::get_functor_type_tag); get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
@@ -516,9 +630,9 @@ public:
if (!vtable) return 0; if (!vtable) return 0;
detail::function::function_buffer type_result; detail::function::function_buffer type_result;
type_result.members.type.type = &BOOST_CORE_TYPEID(Functor); type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
type_result.members.type.const_qualified = std::is_const<Functor>::value; type_result.members.type.const_qualified = is_const<Functor>::value;
type_result.members.type.volatile_qualified = std::is_volatile<Functor>::value; type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
get_vtable()->manager(functor, type_result, get_vtable()->manager(functor, type_result,
detail::function::check_functor_type_tag); detail::function::check_functor_type_tag);
return static_cast<Functor*>(type_result.members.obj_ptr); return static_cast<Functor*>(type_result.members.obj_ptr);
@@ -530,9 +644,9 @@ public:
if (!vtable) return 0; if (!vtable) return 0;
detail::function::function_buffer type_result; detail::function::function_buffer type_result;
type_result.members.type.type = &BOOST_CORE_TYPEID(Functor); type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
type_result.members.type.const_qualified = true; type_result.members.type.const_qualified = true;
type_result.members.type.volatile_qualified = std::is_volatile<Functor>::value; type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
get_vtable()->manager(functor, type_result, get_vtable()->manager(functor, type_result,
detail::function::check_functor_type_tag); detail::function::check_functor_type_tag);
// GCC 2.95.3 gets the CV qualifiers wrong here, so we // GCC 2.95.3 gets the CV qualifiers wrong here, so we
@@ -541,8 +655,7 @@ public:
} }
template<typename F> template<typename F>
typename std::enable_if< !std::is_function<F>::value, bool >::type bool contains(const F& f) const
contains(const F& f) const
{ {
if (const F* fp = this->template target<F>()) if (const F* fp = this->template target<F>())
{ {
@@ -552,19 +665,29 @@ public:
} }
} }
template<typename Fn> #if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
typename std::enable_if< std::is_function<Fn>::value, bool >::type // GCC 3.3 and newer cannot copy with the global operator==, due to
contains(Fn& f) const // problems with instantiation of function return types before it
// has been verified that the argument types match up.
template<typename Functor>
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
operator==(Functor g) const
{ {
typedef Fn* F; if (const Functor* fp = target<Functor>())
if (const F* fp = this->template target<F>()) return function_equal(*fp, g);
{ else return false;
return function_equal(*fp, &f);
} else {
return false;
}
} }
template<typename Functor>
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
operator!=(Functor g) const
{
if (const Functor* fp = target<Functor>())
return !function_equal(*fp, g);
else return true;
}
#endif
public: // should be protected, but GCC 2.95.3 will fail to allow access public: // should be protected, but GCC 2.95.3 will fail to allow access
detail::function::vtable_base* get_vtable() const { detail::function::vtable_base* get_vtable() const {
return reinterpret_cast<detail::function::vtable_base*>( return reinterpret_cast<detail::function::vtable_base*>(
@@ -587,7 +710,7 @@ public: // should be protected, but GCC 2.95.3 will fail to allow access
* The bad_function_call exception class is thrown when a boost::function * The bad_function_call exception class is thrown when a boost::function
* object is invoked * object is invoked
*/ */
class BOOST_SYMBOL_VISIBLE bad_function_call : public std::runtime_error class bad_function_call : public std::runtime_error
{ {
public: public:
bad_function_call() : std::runtime_error("call to empty boost::function") {} bad_function_call() : std::runtime_error("call to empty boost::function") {}
@@ -596,6 +719,7 @@ public:
# pragma clang diagnostic pop # pragma clang diagnostic pop
#endif #endif
#ifndef BOOST_NO_SFINAE
inline bool operator==(const function_base& f, inline bool operator==(const function_base& f,
detail::function::useless_clear_type*) detail::function::useless_clear_type*)
{ {
@@ -619,10 +743,43 @@ inline bool operator!=(detail::function::useless_clear_type*,
{ {
return !f.empty(); return !f.empty();
} }
#endif
#ifdef BOOST_NO_SFINAE
// Comparisons between boost::function objects and arbitrary function objects
template<typename Functor>
inline bool operator==(const function_base& f, Functor g)
{
typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
return detail::function::compare_equal(f, g, 0, integral());
}
template<typename Functor>
inline bool operator==(Functor g, const function_base& f)
{
typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
return detail::function::compare_equal(f, g, 0, integral());
}
template<typename Functor>
inline bool operator!=(const function_base& f, Functor g)
{
typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
return detail::function::compare_not_equal(f, g, 0, integral());
}
template<typename Functor>
inline bool operator!=(Functor g, const function_base& f)
{
typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
return detail::function::compare_not_equal(f, g, 0, integral());
}
#else
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
// Comparisons between boost::function objects and arbitrary function // Comparisons between boost::function objects and arbitrary function
// objects. // objects. GCC 3.3 and before has an obnoxious bug that prevents this
// from working.
template<typename Functor> template<typename Functor>
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
operator==(const function_base& f, Functor g) operator==(const function_base& f, Functor g)
@@ -658,6 +815,7 @@ template<typename Functor>
return !function_equal(g, *fp); return !function_equal(g, *fp);
else return true; else return true;
} }
# endif
template<typename Functor> template<typename Functor>
BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool) BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
@@ -695,6 +853,8 @@ template<typename Functor>
else return true; else return true;
} }
#endif // Compiler supporting SFINAE
namespace detail { namespace detail {
namespace function { namespace function {
inline bool has_empty_target(const function_base* f) inline bool has_empty_target(const function_base* f)

View File

@@ -10,9 +10,24 @@
#define BOOST_FUNCTION_FWD_HPP #define BOOST_FUNCTION_FWD_HPP
#include <boost/config.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 { namespace boost {
class bad_function_call; class bad_function_call;
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
// Preferred syntax // Preferred syntax
template<typename Signature> class function; template<typename Signature> class function;
@@ -21,44 +36,34 @@ namespace boost {
{ {
f1.swap(f2); f1.swap(f2);
} }
#endif // have partial specialization
// Portable syntax // Portable syntax
template<typename R, typename... T> class function_n; template<typename R> class function0;
template<typename R, typename T1> class function1;
template<typename R, typename... T> using function0 = function_n<R, T...>; template<typename R, typename T1, typename T2> class function2;
template<typename R, typename... T> using function1 = function_n<R, T...>; template<typename R, typename T1, typename T2, typename T3> class function3;
template<typename R, typename... T> using function2 = function_n<R, T...>; template<typename R, typename T1, typename T2, typename T3, typename T4>
template<typename R, typename... T> using function3 = function_n<R, T...>; class function4;
template<typename R, typename... T> using function4 = function_n<R, T...>; template<typename R, typename T1, typename T2, typename T3, typename T4,
template<typename R, typename... T> using function5 = function_n<R, T...>; typename T5>
template<typename R, typename... T> using function6 = function_n<R, T...>; class function5;
template<typename R, typename... T> using function7 = function_n<R, T...>; template<typename R, typename T1, typename T2, typename T3, typename T4,
template<typename R, typename... T> using function8 = function_n<R, T...>; typename T5, typename T6>
template<typename R, typename... T> using function9 = function_n<R, T...>; class function6;
template<typename R, typename T1, typename T2, typename T3, typename T4,
template<typename R, typename... T> using function10 = function_n<R, T...>; typename T5, typename T6, typename T7>
template<typename R, typename... T> using function11 = function_n<R, T...>; class function7;
template<typename R, typename... T> using function12 = function_n<R, T...>; template<typename R, typename T1, typename T2, typename T3, typename T4,
template<typename R, typename... T> using function13 = function_n<R, T...>; typename T5, typename T6, typename T7, typename T8>
template<typename R, typename... T> using function14 = function_n<R, T...>; class function8;
template<typename R, typename... T> using function15 = function_n<R, T...>; template<typename R, typename T1, typename T2, typename T3, typename T4,
template<typename R, typename... T> using function16 = function_n<R, T...>; typename T5, typename T6, typename T7, typename T8, typename T9>
template<typename R, typename... T> using function17 = function_n<R, T...>; class function9;
template<typename R, typename... T> using function18 = function_n<R, T...>; template<typename R, typename T1, typename T2, typename T3, typename T4,
template<typename R, typename... T> using function19 = function_n<R, T...>; typename T5, typename T6, typename T7, typename T8, typename T9,
typename T10>
template<typename R, typename... T> using function20 = function_n<R, T...>; class function10;
template<typename R, typename... T> using function21 = function_n<R, T...>;
template<typename R, typename... T> using function22 = function_n<R, T...>;
template<typename R, typename... T> using function23 = function_n<R, T...>;
template<typename R, typename... T> using function24 = function_n<R, T...>;
template<typename R, typename... T> using function25 = function_n<R, T...>;
template<typename R, typename... T> using function26 = function_n<R, T...>;
template<typename R, typename... T> using function27 = function_n<R, T...>;
template<typename R, typename... T> using function28 = function_n<R, T...>;
template<typename R, typename... T> using function29 = function_n<R, T...>;
template<typename R, typename... T> using function30 = function_n<R, T...>;
} }
#endif #endif

File diff suppressed because it is too large Load Diff

View File

@@ -9,7 +9,37 @@
#ifndef BOOST_FUNCTION_TYPEOF_HPP #ifndef BOOST_FUNCTION_TYPEOF_HPP
#define BOOST_FUNCTION_TYPEOF_HPP #define BOOST_FUNCTION_TYPEOF_HPP
#include <boost/function/function_fwd.hpp> #include <boost/function/function_fwd.hpp>
#include <boost/typeof/typeof.hpp>
// This header is no longer necessary and is only retained for compatibility #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 #endif

View File

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

View File

@@ -13,7 +13,6 @@
"Programming" "Programming"
], ],
"maintainers": [ "maintainers": [
"Peter Dimov <pdimov -at- gmail.com>" "Douglas Gregor <dgregor -at- cs.indiana.edu>"
], ]
"cxxstd": "11"
} }

View File

@@ -1,11 +0,0 @@
# Copyright 2018, 2019 Peter Dimov
# Distributed under the Boost Software License, Version 1.0.
# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
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 Boost::move)
endif()

View File

@@ -9,25 +9,12 @@
import testing ; import testing ;
project
: default-build
<warnings>extra
: requirements
<toolset>msvc:<warnings-as-errors>on
<toolset>gcc:<warnings-as-errors>on
<toolset>clang:<warnings-as-errors>on
<library>/boost/function//boost_function
<library>/boost/typeof//boost_typeof
;
run function_test.cpp ; run function_test.cpp ;
# /usr/include/c++/4.4/bits/shared_ptr.h:146: error: cannot use typeid with -fno-rtti run function_test.cpp : : : <rtti>off <toolset>gcc-4.4.7,<cxxstd>0x:<build>no : function_test_no_rtti ;
run function_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : function_test_no_rtti ;
run function_n_test.cpp ; run function_n_test.cpp ;
run allocator_test.cpp ; run allocator_test.cpp ;
run stateless_test.cpp ; run stateless_test.cpp ;
run lambda_test.cpp run lambda_test.cpp ;
: : : <library>/boost/lambda//boost_lambda ;
compile-fail function_test_fail1.cpp ; compile-fail function_test_fail1.cpp ;
compile-fail function_test_fail2.cpp ; compile-fail function_test_fail2.cpp ;
compile function_30.cpp ; compile function_30.cpp ;
@@ -45,53 +32,6 @@ run function_ref_portable.cpp ;
run contains_test.cpp ; run contains_test.cpp ;
run contains2_test.cpp ; run contains2_test.cpp ;
run nothrow_swap.cpp ; run nothrow_swap.cpp ;
run rvalues_test.cpp run rvalues_test.cpp ;
: : : <library>/boost/move//boost_move ; compile function_typeof_test.cpp ;
compile function_typeof_test.cpp
: <cxxstd>03:<build>no <cxxstd>98:<build>no <cxxstd>0x:<build>no ;
run result_arg_types_test.cpp ; run result_arg_types_test.cpp ;
run result_arg_n_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>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>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 ;
# /usr/include/c++/4.4/bits/shared_ptr.h:146: error: cannot use typeid with -fno-rtti
run contains_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : contains_test_no_rtti ;
run contains2_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : contains2_test_no_rtti ;
run contains3_test.cpp ;
run contains3_test.cpp : : : <rtti>off <toolset>gcc-4.4,<cxxstd>0x:<build>no : contains3_test_no_rtti ;
compile issue_53.cpp ;

View File

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

View File

@@ -1,22 +0,0 @@
// 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 );
}

View File

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

View File

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

View File

@@ -5,12 +5,10 @@
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at // 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt) // http://www.boost.org/LICENSE_1_0.txt)
#include <boost/test/minimal.hpp>
#include <boost/function.hpp> #include <boost/function.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/ref.hpp> #include <boost/ref.hpp>
#define BOOST_CHECK BOOST_TEST
static int forty_two() { return 42; } static int forty_two() { return 42; }
struct Seventeen struct Seventeen
@@ -33,7 +31,7 @@ bool operator==(const ReturnInt& x, const ReturnInt& y)
bool operator!=(const ReturnInt& x, const ReturnInt& y) bool operator!=(const ReturnInt& x, const ReturnInt& y)
{ return x.value != y.value; } { return x.value != y.value; }
namespace contains_test { namespace contain_test {
struct ReturnIntFE struct ReturnIntFE
{ {
@@ -44,10 +42,34 @@ struct ReturnIntFE
int 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) bool function_equal(const ReturnIntFE& x, const ReturnIntFE& y)
{ return x.value == y.value; } { return x.value == y.value; }
# else
} // namespace contains_test 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() static void target_test()
{ {
@@ -84,8 +106,10 @@ static void equal_test()
f = &forty_two; f = &forty_two;
BOOST_CHECK(f == &forty_two); BOOST_CHECK(f == &forty_two);
BOOST_CHECK(f != ReturnInt(17)); BOOST_CHECK(f != ReturnInt(17));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(&forty_two == f); BOOST_CHECK(&forty_two == f);
BOOST_CHECK(ReturnInt(17) != f); BOOST_CHECK(ReturnInt(17) != f);
#endif
BOOST_CHECK(f.contains(&forty_two)); BOOST_CHECK(f.contains(&forty_two));
@@ -93,37 +117,47 @@ static void equal_test()
BOOST_CHECK(f != &forty_two); BOOST_CHECK(f != &forty_two);
BOOST_CHECK(f == ReturnInt(17)); BOOST_CHECK(f == ReturnInt(17));
BOOST_CHECK(f != ReturnInt(16)); BOOST_CHECK(f != ReturnInt(16));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(&forty_two != f); BOOST_CHECK(&forty_two != f);
BOOST_CHECK(ReturnInt(17) == f); BOOST_CHECK(ReturnInt(17) == f);
BOOST_CHECK(ReturnInt(16) != f); BOOST_CHECK(ReturnInt(16) != f);
#endif
BOOST_CHECK(f.contains(ReturnInt(17))); BOOST_CHECK(f.contains(ReturnInt(17)));
f = contains_test::ReturnIntFE(17); f = contain_test::ReturnIntFE(17);
BOOST_CHECK(f != &forty_two); BOOST_CHECK(f != &forty_two);
BOOST_CHECK(f == contains_test::ReturnIntFE(17)); BOOST_CHECK(f == contain_test::ReturnIntFE(17));
BOOST_CHECK(f != contains_test::ReturnIntFE(16)); BOOST_CHECK(f != contain_test::ReturnIntFE(16));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(&forty_two != f); BOOST_CHECK(&forty_two != f);
BOOST_CHECK(contains_test::ReturnIntFE(17) == f); BOOST_CHECK(contain_test::ReturnIntFE(17) == f);
BOOST_CHECK(contains_test::ReturnIntFE(16) != f); BOOST_CHECK(contain_test::ReturnIntFE(16) != f);
#endif
BOOST_CHECK(f.contains(contains_test::ReturnIntFE(17))); BOOST_CHECK(f.contains(contain_test::ReturnIntFE(17)));
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
boost::function<int(void)> g; boost::function<int(void)> g;
g = &forty_two; g = &forty_two;
BOOST_CHECK(g == &forty_two); BOOST_CHECK(g == &forty_two);
BOOST_CHECK(g != ReturnInt(17)); BOOST_CHECK(g != ReturnInt(17));
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(&forty_two == g); BOOST_CHECK(&forty_two == g);
BOOST_CHECK(ReturnInt(17) != g); BOOST_CHECK(ReturnInt(17) != g);
# endif
g = ReturnInt(17); g = ReturnInt(17);
BOOST_CHECK(g != &forty_two); BOOST_CHECK(g != &forty_two);
BOOST_CHECK(g == ReturnInt(17)); BOOST_CHECK(g == ReturnInt(17));
BOOST_CHECK(g != ReturnInt(16)); BOOST_CHECK(g != ReturnInt(16));
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(&forty_two != g); BOOST_CHECK(&forty_two != g);
BOOST_CHECK(ReturnInt(17) == g); BOOST_CHECK(ReturnInt(17) == g);
BOOST_CHECK(ReturnInt(16) != g); BOOST_CHECK(ReturnInt(16) != g);
# endif
#endif
} }
static void ref_equal_test() static void ref_equal_test()
@@ -139,8 +173,10 @@ static void ref_equal_test()
BOOST_CHECK(!(f != boost::ref(ri))); BOOST_CHECK(!(f != boost::ref(ri)));
BOOST_CHECK(!(f != ri)); BOOST_CHECK(!(f != ri));
BOOST_CHECK(!(boost::ref(ri) != f)); BOOST_CHECK(!(boost::ref(ri) != f));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(ri == f); BOOST_CHECK(ri == f);
BOOST_CHECK(!(ri != f)); BOOST_CHECK(!(ri != f));
#endif
// Values equal, references inequal // Values equal, references inequal
ReturnInt ri2(17); ReturnInt ri2(17);
@@ -150,10 +186,13 @@ static void ref_equal_test()
BOOST_CHECK(!(f != ri2)); BOOST_CHECK(!(f != ri2));
BOOST_CHECK(!(f == boost::ref(ri2))); BOOST_CHECK(!(f == boost::ref(ri2)));
BOOST_CHECK(!(boost::ref(ri2) == f)); BOOST_CHECK(!(boost::ref(ri2) == f));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(ri2 == f); BOOST_CHECK(ri2 == f);
BOOST_CHECK(!(ri2 != f)); BOOST_CHECK(!(ri2 != f));
#endif
} }
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
{ {
ReturnInt ri(17); ReturnInt ri(17);
boost::function<int(void)> f = boost::ref(ri); boost::function<int(void)> f = boost::ref(ri);
@@ -165,8 +204,10 @@ static void ref_equal_test()
BOOST_CHECK(!(f != boost::ref(ri))); BOOST_CHECK(!(f != boost::ref(ri)));
BOOST_CHECK(!(f != ri)); BOOST_CHECK(!(f != ri));
BOOST_CHECK(!(boost::ref(ri) != f)); BOOST_CHECK(!(boost::ref(ri) != f));
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(ri == f); BOOST_CHECK(ri == f);
BOOST_CHECK(!(ri != f)); BOOST_CHECK(!(ri != f));
# endif
// Values equal, references inequal // Values equal, references inequal
ReturnInt ri2(17); ReturnInt ri2(17);
@@ -176,16 +217,19 @@ static void ref_equal_test()
BOOST_CHECK(!(f != ri2)); BOOST_CHECK(!(f != ri2));
BOOST_CHECK(!(f == boost::ref(ri2))); BOOST_CHECK(!(f == boost::ref(ri2)));
BOOST_CHECK(!(boost::ref(ri2) == f)); BOOST_CHECK(!(boost::ref(ri2) == f));
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(ri2 == f); BOOST_CHECK(ri2 == f);
BOOST_CHECK(!(ri2 != f)); BOOST_CHECK(!(ri2 != f));
# endif
} }
#endif
} }
int main() int test_main(int, char*[])
{ {
target_test(); target_test();
equal_test(); equal_test();
ref_equal_test(); ref_equal_test();
return boost::report_errors(); return 0;
} }

View File

@@ -1,87 +0,0 @@
// 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();
}

View File

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

View File

@@ -7,20 +7,12 @@
// For more information, see http://www.boost.org // For more information, see http://www.boost.org
#if defined(__clang__) && defined(__has_warning) #include <boost/test/minimal.hpp>
# if __has_warning( "-Wself-assign-overloaded" )
# pragma clang diagnostic ignored "-Wself-assign-overloaded"
# endif
#endif
#include <boost/function.hpp> #include <boost/function.hpp>
#include <boost/core/lightweight_test.hpp>
#include <functional> #include <functional>
#include <string> #include <string>
#include <utility> #include <utility>
#define BOOST_CHECK BOOST_TEST
using boost::function; using boost::function;
using std::string; using std::string;
@@ -632,7 +624,7 @@ test_ref()
boost::function<int (int, int)> f(boost::ref(atc)); boost::function<int (int, int)> f(boost::ref(atc));
BOOST_CHECK(f(1, 3) == 4); BOOST_CHECK(f(1, 3) == 4);
} }
catch(std::runtime_error const&) { catch(std::runtime_error e) {
BOOST_ERROR("Nonthrowing constructor threw an exception"); BOOST_ERROR("Nonthrowing constructor threw an exception");
} }
} }
@@ -659,14 +651,14 @@ static void test_empty_ref()
f2(); f2();
BOOST_ERROR("Exception didn't throw for reference to empty function."); BOOST_ERROR("Exception didn't throw for reference to empty function.");
} }
catch(std::runtime_error const&) {} catch(std::runtime_error e) {}
f1 = dummy; f1 = dummy;
try { try {
f2(); f2();
} }
catch(std::runtime_error const&) { catch(std::runtime_error e) {
BOOST_ERROR("Error calling referenced function."); BOOST_ERROR("Error calling referenced function.");
} }
} }
@@ -681,7 +673,7 @@ static void test_exception()
f(5, 4); f(5, 4);
BOOST_CHECK(false); BOOST_CHECK(false);
} }
catch(boost::bad_function_call const&) { catch(boost::bad_function_call) {
// okay // okay
} }
} }
@@ -754,6 +746,7 @@ static void test_move_semantics()
BOOST_CHECK(!f1.empty()); BOOST_CHECK(!f1.empty());
BOOST_CHECK(global_int == 1); BOOST_CHECK(global_int == 1);
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
// Testing rvalue constructors // Testing rvalue constructors
f1_type f2(static_cast<f1_type&&>(f1)); f1_type f2(static_cast<f1_type&&>(f1));
BOOST_CHECK(f1.empty()); BOOST_CHECK(f1.empty());
@@ -795,9 +788,11 @@ static void test_move_semantics()
BOOST_CHECK(global_int == 5); BOOST_CHECK(global_int == 5);
f4 = static_cast<f1_type&&>(f5); f4 = static_cast<f1_type&&>(f5);
BOOST_CHECK(global_int == 4); BOOST_CHECK(global_int == 4);
#endif
} }
int main() int test_main(int, char* [])
{ {
test_zero_args(); test_zero_args();
test_one_arg(); test_one_arg();
@@ -812,5 +807,5 @@ int main()
test_move_semantics<function<void()> >(); test_move_semantics<function<void()> >();
test_move_semantics<boost::function0<void> >(); test_move_semantics<boost::function0<void> >();
return boost::report_errors(); return 0;
} }

View File

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

View File

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

View File

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

View File

@@ -1,20 +0,0 @@
// Copyright 2024 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/53
#include <boost/bind/apply.hpp>
#include <boost/bind/bind.hpp>
#include <boost/function.hpp>
int TestArg( int, double )
{
return 0;
}
void f()
{
boost::function<int(int)> fn = boost::bind( &TestArg, boost::placeholders::_1, 1.0 );
}

View File

@@ -28,13 +28,13 @@ int main()
using namespace boost::lambda; using namespace boost::lambda;
function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2); function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
BOOST_TEST_EQ( f1(true, 2.0), 30u ); BOOST_TEST_EQ( f1(true, 2.0), 30 );
function <unsigned(double)> f2 = boost::lambda::bind(f1, false, _1); function <unsigned(double)> f2 = boost::lambda::bind(f1, false, _1);
BOOST_TEST_EQ( f2(2.0), 60u ); BOOST_TEST_EQ( f2(2.0), 60 );
function <unsigned()> f3 = boost::lambda::bind(f2, 4.0); function <unsigned()> f3 = boost::lambda::bind(f2, 4.0);
BOOST_TEST_EQ( f3(), 120u ); BOOST_TEST_EQ( f3(), 120 );
return boost::report_errors(); return boost::report_errors();
} }

View File

@@ -16,7 +16,7 @@
struct Y { struct Y {
Y(int y = 0) : y_(y) {} Y(int y = 0) : y_(y) {}
bool operator==(const Y& rhs) const { return y_ == rhs.y_; } bool operator==(const Y& rhs) { return y_ == rhs.y_; }
private: private:
int y_; int y_;
}; };

View File

@@ -16,7 +16,7 @@
struct Y { struct Y {
Y(int y = 0) : y_(y) {} Y(int y = 0) : y_(y) {}
bool operator==(const Y& rhs) const { return y_ == rhs.y_; } bool operator==(const Y& rhs) { return y_ == rhs.y_; }
private: private:
int y_; int y_;
}; };

View File

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

View File

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

View File

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

View File

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

View File

@@ -8,6 +8,7 @@
// http://www.boost.org/LICENSE_1_0.txt) // http://www.boost.org/LICENSE_1_0.txt)
#include <boost/function.hpp> #include <boost/function.hpp>
#include <boost/core/is_same.hpp>
#include <boost/core/lightweight_test_trait.hpp> #include <boost/core/lightweight_test_trait.hpp>
struct X struct X
@@ -26,14 +27,14 @@ int main()
{ {
typedef boost::function<X(Y)> F1; typedef boost::function<X(Y)> F1;
BOOST_TEST_TRAIT_SAME(F1::result_type, X); BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F1::result_type, X> ));
BOOST_TEST_TRAIT_SAME(F1::argument_type, Y); BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F1::argument_type, Y> ));
typedef boost::function<X(Y, Z)> F2; typedef boost::function<X(Y, Z)> F2;
BOOST_TEST_TRAIT_SAME(F2::result_type, X); BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F2::result_type, X> ));
BOOST_TEST_TRAIT_SAME(F2::first_argument_type, Y); BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F2::first_argument_type, Y> ));
BOOST_TEST_TRAIT_SAME(F2::second_argument_type, Z); BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F2::second_argument_type, Z> ));
return boost::report_errors(); return boost::report_errors();
} }

View File

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

View File

@@ -6,13 +6,12 @@
// For more information, see http://www.boost.org // 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 <iostream>
#include <cstdlib> #include <cstdlib>
#define BOOST_CHECK BOOST_TEST #include <boost/test/minimal.hpp>
#include <boost/function.hpp>
#include <boost/move/move.hpp>
class only_movable { class only_movable {
private: private:
@@ -59,10 +58,12 @@ struct sum_struct {
} }
}; };
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
int three(std::string&&) { return 1; } int three(std::string&&) { return 1; }
std::string&& four(std::string&& s) { return boost::move(s); } std::string&& four(std::string&& s) { return boost::move(s); }
#endif
int main() int test_main(int, char*[])
{ {
using boost::function; using boost::function;
@@ -93,11 +94,13 @@ int main()
BOOST_CHECK(om2_sum_2.get_value() == 3); BOOST_CHECK(om2_sum_2.get_value() == 3);
} }
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
function <int(std::string&&)> f3 = three; function <int(std::string&&)> f3 = three;
function <std::string&& (std::string&& s)> f4 = four; function <std::string&& (std::string&& s)> f4 = four;
f3(std::string("Hello")); f3(std::string("Hello"));
BOOST_CHECK(f4(std::string("world")) == "world"); BOOST_CHECK(f4(std::string("world")) == "world");
#endif
return boost::report_errors(); return 0;
} }

View File

@@ -8,16 +8,7 @@
// For more information, see http://www.boost.org/ // 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 <boost/function.hpp>
#include <iostream> #include <iostream>
#include <functional> #include <functional>

View File

@@ -8,16 +8,7 @@
// For more information, see http://www.boost.org/ // 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 <boost/function.hpp>
#include <iostream> #include <iostream>
#include <functional> #include <functional>

View File

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

View File

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

View File

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

View File

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