mirror of
https://github.com/boostorg/function.git
synced 2025-06-25 20:11:37 +02:00
Compare commits
1 Commits
boost-1.79
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
| 922ce7b8ae |
355
.github/workflows/ci.yml
vendored
355
.github/workflows/ci.yml
vendored
@ -1,355 +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.8
|
||||
cxxstd: "03,11"
|
||||
os: ubuntu-18.04
|
||||
install: g++-4.8
|
||||
- toolset: gcc-5
|
||||
cxxstd: "03,11,14,1z"
|
||||
os: ubuntu-18.04
|
||||
install: g++-5
|
||||
- toolset: gcc-6
|
||||
cxxstd: "03,11,14,1z"
|
||||
os: ubuntu-18.04
|
||||
install: g++-6
|
||||
- toolset: gcc-7
|
||||
cxxstd: "03,11,14,17"
|
||||
os: ubuntu-18.04
|
||||
- toolset: gcc-8
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-18.04
|
||||
install: g++-8
|
||||
- toolset: gcc-9
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-20.04
|
||||
- toolset: gcc-10
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-20.04
|
||||
install: g++-10
|
||||
- toolset: gcc-11
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-20.04
|
||||
install: g++-11
|
||||
- toolset: clang
|
||||
compiler: clang++-3.9
|
||||
cxxstd: "03,11,14"
|
||||
os: ubuntu-18.04
|
||||
install: clang-3.9
|
||||
- toolset: clang
|
||||
compiler: clang++-4.0
|
||||
cxxstd: "03,11,14"
|
||||
os: ubuntu-18.04
|
||||
install: clang-4.0
|
||||
- toolset: clang
|
||||
compiler: clang++-5.0
|
||||
cxxstd: "03,11,14,1z"
|
||||
os: ubuntu-18.04
|
||||
install: clang-5.0
|
||||
- toolset: clang
|
||||
compiler: clang++-6.0
|
||||
cxxstd: "03,11,14,17"
|
||||
os: ubuntu-18.04
|
||||
install: clang-6.0
|
||||
- toolset: clang
|
||||
compiler: clang++-7
|
||||
cxxstd: "03,11,14,17"
|
||||
os: ubuntu-18.04
|
||||
install: clang-7
|
||||
- toolset: clang
|
||||
compiler: clang++-8
|
||||
cxxstd: "03,11,14,17"
|
||||
os: ubuntu-20.04
|
||||
install: clang-8
|
||||
- toolset: clang
|
||||
compiler: clang++-9
|
||||
cxxstd: "03,11,14,17"
|
||||
os: ubuntu-20.04
|
||||
install: clang-9
|
||||
- toolset: clang
|
||||
compiler: clang++-10
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-20.04
|
||||
- toolset: clang
|
||||
compiler: clang++-11
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-20.04
|
||||
- toolset: clang
|
||||
compiler: clang++-12
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-20.04
|
||||
- toolset: clang
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: macos-10.15
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
|
||||
- name: Install packages
|
||||
if: matrix.install
|
||||
run: sudo apt install ${{matrix.install}}
|
||||
|
||||
- name: Setup Boost
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
|
||||
LIBRARY=${GITHUB_REPOSITORY#*/}
|
||||
echo LIBRARY: $LIBRARY
|
||||
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
|
||||
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
|
||||
echo GITHUB_REF: $GITHUB_REF
|
||||
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
|
||||
REF=${REF#refs/heads/}
|
||||
echo REF: $REF
|
||||
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
|
||||
echo BOOST_BRANCH: $BOOST_BRANCH
|
||||
cd ..
|
||||
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
|
||||
git submodule update --init tools/boostdep
|
||||
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
|
||||
./bootstrap.sh
|
||||
./b2 -d0 headers
|
||||
|
||||
- name: Create user-config.jam
|
||||
if: matrix.compiler
|
||||
run: |
|
||||
echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
|
||||
|
||||
- name: Run tests
|
||||
run: |
|
||||
cd ../boost-root
|
||||
./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release
|
||||
|
||||
windows:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- toolset: msvc-14.0
|
||||
cxxstd: "14"
|
||||
addrmd: 32,64
|
||||
os: windows-2019
|
||||
- toolset: msvc-14.1
|
||||
cxxstd: "14,17,latest"
|
||||
addrmd: 32,64
|
||||
os: windows-2016
|
||||
- toolset: msvc-14.2
|
||||
cxxstd: "14,17,latest"
|
||||
addrmd: 32,64
|
||||
os: windows-2019
|
||||
- toolset: msvc-14.3
|
||||
cxxstd: "14,17,latest"
|
||||
addrmd: 32,64
|
||||
os: windows-2022
|
||||
- toolset: gcc
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
addrmd: 64
|
||||
os: windows-2019
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
|
||||
- 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
|
||||
|
||||
posix-cmake-subdir:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- os: ubuntu-18.04
|
||||
- os: ubuntu-20.04
|
||||
- os: macos-10.15
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
|
||||
- name: Install packages
|
||||
if: matrix.install
|
||||
run: sudo apt install ${{matrix.install}}
|
||||
|
||||
- name: Setup Boost
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
|
||||
LIBRARY=${GITHUB_REPOSITORY#*/}
|
||||
echo LIBRARY: $LIBRARY
|
||||
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
|
||||
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
|
||||
echo GITHUB_REF: $GITHUB_REF
|
||||
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
|
||||
REF=${REF#refs/heads/}
|
||||
echo REF: $REF
|
||||
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
|
||||
echo BOOST_BRANCH: $BOOST_BRANCH
|
||||
cd ..
|
||||
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
|
||||
git submodule update --init tools/boostdep
|
||||
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
|
||||
|
||||
- name: Use library with add_subdirectory
|
||||
run: |
|
||||
cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
|
||||
mkdir __build__ && cd __build__
|
||||
cmake ..
|
||||
cmake --build .
|
||||
ctest --output-on-failure --no-tests=error
|
||||
|
||||
posix-cmake-install:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- os: ubuntu-18.04
|
||||
- os: ubuntu-20.04
|
||||
- os: macos-10.15
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
|
||||
- name: Install packages
|
||||
if: matrix.install
|
||||
run: sudo apt install ${{matrix.install}}
|
||||
|
||||
- name: Setup Boost
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
|
||||
LIBRARY=${GITHUB_REPOSITORY#*/}
|
||||
echo LIBRARY: $LIBRARY
|
||||
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
|
||||
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
|
||||
echo GITHUB_REF: $GITHUB_REF
|
||||
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
|
||||
REF=${REF#refs/heads/}
|
||||
echo REF: $REF
|
||||
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
|
||||
echo BOOST_BRANCH: $BOOST_BRANCH
|
||||
cd ..
|
||||
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
|
||||
git submodule update --init tools/boostdep
|
||||
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
|
||||
|
||||
- name: Configure
|
||||
run: |
|
||||
cd ../boost-root
|
||||
mkdir __build__ && cd __build__
|
||||
cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
|
||||
|
||||
- name: Install
|
||||
run: |
|
||||
cd ../boost-root/__build__
|
||||
cmake --build . --target install
|
||||
|
||||
- name: Use the installed library
|
||||
run: |
|
||||
cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
|
||||
cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
|
||||
cmake --build .
|
||||
ctest --output-on-failure --no-tests=error
|
||||
|
||||
posix-cmake-test:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- os: ubuntu-18.04
|
||||
- os: ubuntu-20.04
|
||||
- os: macos-10.15
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
|
||||
- name: Install packages
|
||||
if: matrix.install
|
||||
run: sudo apt install ${{matrix.install}}
|
||||
|
||||
- name: Setup Boost
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
|
||||
LIBRARY=${GITHUB_REPOSITORY#*/}
|
||||
echo LIBRARY: $LIBRARY
|
||||
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
|
||||
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
|
||||
echo GITHUB_REF: $GITHUB_REF
|
||||
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
|
||||
REF=${REF#refs/heads/}
|
||||
echo REF: $REF
|
||||
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
|
||||
echo BOOST_BRANCH: $BOOST_BRANCH
|
||||
cd ..
|
||||
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
|
||||
git submodule update --init tools/boostdep
|
||||
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
|
||||
|
||||
- name: Configure
|
||||
run: |
|
||||
cd ../boost-root
|
||||
mkdir __build__ && cd __build__
|
||||
cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
|
||||
|
||||
- name: Build tests
|
||||
run: |
|
||||
cd ../boost-root/__build__
|
||||
cmake --build . --target tests
|
||||
|
||||
- name: Run tests
|
||||
run: |
|
||||
cd ../boost-root/__build__
|
||||
ctest --output-on-failure --no-tests=error
|
||||
362
.travis.yml
362
.travis.yml
@ -1,362 +0,0 @@
|
||||
# Copyright 2016-2019 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
|
||||
language: cpp
|
||||
|
||||
dist: xenial
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- develop
|
||||
- /feature\/.*/
|
||||
|
||||
env:
|
||||
matrix:
|
||||
- BOGUS_JOB=true
|
||||
|
||||
matrix:
|
||||
|
||||
exclude:
|
||||
- env: BOGUS_JOB=true
|
||||
|
||||
include:
|
||||
- os: linux
|
||||
compiler: g++-4.4
|
||||
env: TOOLSET=gcc CXXSTD=98,0x
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.4
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-4.6
|
||||
env: TOOLSET=gcc CXXSTD=03,0x
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-4.7
|
||||
env: TOOLSET=gcc CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-4.8
|
||||
env: TOOLSET=gcc CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- os: linux
|
||||
compiler: g++-4.9
|
||||
env: TOOLSET=gcc CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-5
|
||||
env: TOOLSET=gcc CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-5
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-6
|
||||
env: TOOLSET=gcc CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-7
|
||||
env: TOOLSET=gcc CXXSTD=03,11,14,17
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-8
|
||||
env: TOOLSET=gcc CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-9
|
||||
env: TOOLSET=gcc CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: bionic
|
||||
compiler: g++-10
|
||||
env: UBSAN=1 TOOLSET=gcc CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-10
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: /usr/bin/clang++
|
||||
env: TOOLSET=clang CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.3
|
||||
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: /usr/bin/clang++
|
||||
env: TOOLSET=clang CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.4
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.5
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.5
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.6
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.7
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.8
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.9
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-4.0
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-4.0
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-5.0
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-5.0
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-6.0
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-6.0
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-7
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-xenial-7
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-8
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-xenial-8
|
||||
|
||||
- os: linux
|
||||
dist: bionic
|
||||
compiler: clang++-9
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main'
|
||||
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
|
||||
|
||||
- os: linux
|
||||
dist: bionic
|
||||
compiler: clang++-10
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-10
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
|
||||
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
|
||||
|
||||
- os: linux
|
||||
dist: bionic
|
||||
compiler: clang++-11
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-11
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-11 main'
|
||||
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
|
||||
|
||||
- os: linux
|
||||
dist: bionic
|
||||
compiler: clang++-12
|
||||
env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-12
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-12 main'
|
||||
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
|
||||
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: clang++-libc++
|
||||
env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- libc++-dev
|
||||
|
||||
- os: linux
|
||||
dist: bionic
|
||||
compiler: clang++-libc++
|
||||
env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- libc++-dev
|
||||
|
||||
- os: osx
|
||||
compiler: clang++
|
||||
env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
|
||||
|
||||
- os: linux
|
||||
env: CMAKE_TEST=1
|
||||
script:
|
||||
- mkdir __build__ && cd __build__
|
||||
- cmake -DBOOST_ENABLE_CMAKE=1 -DBUILD_TESTING=ON -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=function ..
|
||||
- ctest --output-on-failure -R boost_function
|
||||
|
||||
- os: linux
|
||||
env: CMAKE_SUBDIR_TEST=1
|
||||
script:
|
||||
- cd libs/function/test/cmake_subdir_test && mkdir __build__ && cd __build__
|
||||
- cmake ..
|
||||
- cmake --build .
|
||||
- cmake --build . --target check
|
||||
|
||||
install:
|
||||
- BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
|
||||
- cd ..
|
||||
- git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
|
||||
- cd boost-root
|
||||
- git submodule update --init tools/boostdep
|
||||
- cp -r $TRAVIS_BUILD_DIR/* libs/function
|
||||
- python tools/boostdep/depinst/depinst.py function
|
||||
- ./bootstrap.sh
|
||||
- ./b2 headers
|
||||
|
||||
script:
|
||||
- |-
|
||||
echo "using $TOOLSET : : $TRAVIS_COMPILER ;" > ~/user-config.jam
|
||||
- ./b2 -j3 libs/function/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
|
||||
|
||||
notifications:
|
||||
email:
|
||||
on_success: always
|
||||
@ -1,34 +0,0 @@
|
||||
# Generated by `boostdep --cmake function`
|
||||
# Copyright 2020 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# https://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
cmake_minimum_required(VERSION 3.5...3.16)
|
||||
|
||||
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::integer
|
||||
Boost::preprocessor
|
||||
Boost::throw_exception
|
||||
Boost::type_index
|
||||
Boost::type_traits
|
||||
Boost::typeof
|
||||
)
|
||||
|
||||
if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
|
||||
|
||||
add_subdirectory(test)
|
||||
|
||||
endif()
|
||||
|
||||
18
README.md
18
README.md
@ -1,18 +0,0 @@
|
||||
# Boost.Function, a polymorphic function wrapper
|
||||
|
||||
[Boost.Function](http://boost.org/libs/function), part of the
|
||||
[Boost C++ Libraries](http://boost.org), is the original implementation of the
|
||||
polymorphic function wrapper `boost::function`, which was eventually accepted
|
||||
into the C++11 standard as [`std::function`](https://en.cppreference.com/w/cpp/utility/functional/function).
|
||||
|
||||
## Currently supported compilers
|
||||
|
||||
* g++ 4.8 or later
|
||||
* clang++ 3.9 or later
|
||||
* Visual Studio 2005-2022
|
||||
|
||||
Tested on [Github Actions](https://github.com/boostorg/function/actions) and [Appveyor](https://ci.appveyor.com/project/pdimov/function/).
|
||||
|
||||
## License
|
||||
|
||||
Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).
|
||||
66
appveyor.yml
66
appveyor.yml
@ -1,66 +0,0 @@
|
||||
# Copyright 2016-2019 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
|
||||
version: 1.0.{build}-{branch}
|
||||
|
||||
shallow_clone: true
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- develop
|
||||
- /feature\/.*/
|
||||
|
||||
environment:
|
||||
matrix:
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
|
||||
ADDRMD: 32
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
TOOLSET: msvc-12.0,msvc-14.0
|
||||
ADDRMD: 32,64
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
TOOLSET: msvc-14.1
|
||||
CXXSTD: 14,17
|
||||
ADDRMD: 32,64
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
|
||||
TOOLSET: clang-win
|
||||
CXXSTD: 14,17,latest
|
||||
ADDRMD: 64
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
ADDPATH: C:\cygwin\bin;
|
||||
TOOLSET: gcc
|
||||
CXXSTD: 03,11,14,1z
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
ADDPATH: C:\cygwin64\bin;
|
||||
TOOLSET: gcc
|
||||
CXXSTD: 03,11,14,1z
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
ADDPATH: C:\mingw\bin;
|
||||
TOOLSET: gcc
|
||||
CXXSTD: 03,11,14,1z
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
|
||||
TOOLSET: gcc
|
||||
CXXSTD: 03,11,14,1z
|
||||
|
||||
install:
|
||||
- set BOOST_BRANCH=develop
|
||||
- if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
|
||||
- cd ..
|
||||
- git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
- cd boost-root
|
||||
- git submodule update --init tools/boostdep
|
||||
- xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\function\
|
||||
- python tools/boostdep/depinst/depinst.py function
|
||||
- cmd /c bootstrap
|
||||
- b2 -d0 headers
|
||||
|
||||
build: off
|
||||
|
||||
test_script:
|
||||
- PATH=%ADDPATH%%PATH%
|
||||
- if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
|
||||
- if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
|
||||
- b2 -j3 libs/function/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
|
||||
@ -3,23 +3,8 @@
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt)
|
||||
project function/doc ;
|
||||
project boost/doc ;
|
||||
import boostbook : boostbook ;
|
||||
|
||||
boostbook function-doc
|
||||
:
|
||||
function.xml
|
||||
:
|
||||
<xsl:param>boost.root=../../../..
|
||||
<format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
|
||||
;
|
||||
boostbook function-doc : function.xml ;
|
||||
|
||||
###############################################################################
|
||||
alias boostdoc
|
||||
: function.xml
|
||||
:
|
||||
:
|
||||
: ;
|
||||
explicit boostdoc ;
|
||||
alias boostrelease ;
|
||||
explicit boostrelease ;
|
||||
|
||||
@ -13,35 +13,6 @@
|
||||
|
||||
<itemizedlist spacing="compact">
|
||||
|
||||
<listitem><para><bold>Version 1.52.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Move constructors and move assignment
|
||||
operators added (only for compilers with C++11 rvalue
|
||||
references support). Original patch
|
||||
contributed by Antony Polukhin.</para></listitem>
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.37.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Improved the performance of Boost.Function's
|
||||
swap() operation for large function objects. Original patch
|
||||
contributed by Niels Dekker.</para></listitem>
|
||||
|
||||
<listitem><para>Added a new header <boost/function/function_typeof.hpp> that provides support for using the Boost.Typeof library on Boost.Function objects.</para></listitem>
|
||||
|
||||
<listitem><para>Added a new header <boost/function/function_fwd.hpp> that provides support for using the Boost.Typeof library on Boost.Function objects.</para></listitem>
|
||||
|
||||
<listitem><para>The <methodname alt="boost::function::target">target</methodname>()
|
||||
function now respects the cv-qualifiers of function objects
|
||||
stored by reference
|
||||
(using <classname>boost::reference_wrapper</classname>), such
|
||||
that a reference to a <code>const</code> function object cannot
|
||||
be accessed as a reference to a non-<code>const</code> function
|
||||
object.</para></listitem>
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.36.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Boost.Function now implements allocator support
|
||||
|
||||
@ -58,7 +58,7 @@
|
||||
<para>A function object <code>f</code> of
|
||||
type <code>F</code> is
|
||||
<emphasis>stateless</emphasis> if it is a function pointer or if
|
||||
<code><classname>boost::is_stateless</classname><F></code>
|
||||
<code><classname>boost::is_stateless</classname><T></code>
|
||||
is true. The construction of or copy to a Boost.Function object
|
||||
from a stateless function object will not cause exceptions to be
|
||||
thrown and will not allocate any storage.
|
||||
@ -128,7 +128,7 @@
|
||||
|
||||
<method name="target_type" cv="const">
|
||||
<type>const std::type_info&</type>
|
||||
<returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-><methodname>empty</methodname>()</code>. Works even with RTTI off.</simpara></returns>
|
||||
<returns><simpara><code>typeid</code> of the target function object, or <code>typeid(void)</code> if <code>this-><methodname>empty</methodname>()</code>.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
@ -203,15 +203,6 @@
|
||||
<throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<parameter name="f">
|
||||
<paramtype><classname>functionN</classname>&&</paramtype>
|
||||
</parameter>
|
||||
<requires><simpara>C++11 compatible compiler.</simpara></requires>
|
||||
<postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
@ -245,15 +236,6 @@
|
||||
</parameter>
|
||||
<postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-><methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
</copy-assignment>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype><classname>functionN</classname>&&</paramtype>
|
||||
</parameter>
|
||||
<requires><simpara>C++11 compatible compiler.</simpara></requires>
|
||||
<postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<method-group name="modifiers">
|
||||
<method name="swap">
|
||||
@ -625,16 +607,7 @@
|
||||
<postconditions><simpara>Contains a copy of the <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<parameter name="f">
|
||||
<paramtype><classname>functionN</classname>&&</paramtype>
|
||||
</parameter>
|
||||
<requires><simpara>C++11 compatible compiler.</simpara></requires>
|
||||
<postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
|
||||
<constructor>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>function</classname>&</paramtype>
|
||||
@ -643,15 +616,6 @@
|
||||
<throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<parameter name="f">
|
||||
<paramtype><classname>function</classname>&&</paramtype>
|
||||
</parameter>
|
||||
<requires><simpara>C++11 compatible compiler.</simpara></requires>
|
||||
<postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
@ -681,19 +645,10 @@
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>functionN</classname>&</paramtype>
|
||||
<paramtype>const <classname>function</classname>&</paramtype>
|
||||
</parameter>
|
||||
<postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-><methodname>empty</methodname>()</code>.</simpara></postconditions>
|
||||
</copy-assignment>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype><classname>functionN</classname>&&</paramtype>
|
||||
</parameter>
|
||||
<requires><simpara>C++11 compatible compiler.</simpara></requires>
|
||||
<postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
@ -702,15 +657,6 @@
|
||||
<postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
|
||||
<throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-><methodname>empty</methodname>()</code>.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype><classname>function</classname>&&</paramtype>
|
||||
</parameter>
|
||||
<requires><simpara>C++11 compatible compiler.</simpara></requires>
|
||||
<postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
|
||||
<throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<method-group name="modifiers">
|
||||
<method name="swap">
|
||||
|
||||
@ -35,12 +35,12 @@ form to use for your compiler.
|
||||
<row>
|
||||
<entry>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><simpara>GNU C++ 2.95.x, 3.0.x and later versions</simpara></listitem>
|
||||
<listitem><simpara>GNU C++ 2.95.x, 3.0.x, 3.1.x</simpara></listitem>
|
||||
<listitem><simpara>Comeau C++ 4.2.45.2</simpara></listitem>
|
||||
<listitem><simpara>SGI MIPSpro 7.3.0</simpara></listitem>
|
||||
<listitem><simpara>Intel C++ 5.0, 6.0</simpara></listitem>
|
||||
<listitem><simpara>Compaq's cxx 6.2</simpara></listitem>
|
||||
<listitem><simpara>Microsoft Visual C++ 7.1 and later versions</simpara></listitem>
|
||||
<listitem><simpara>Microsoft Visual C++ 7.1</simpara></listitem>
|
||||
</itemizedlist>
|
||||
</entry>
|
||||
<entry>
|
||||
|
||||
@ -1,14 +0,0 @@
|
||||
# Boost.Function Library example Jamfile
|
||||
#
|
||||
# Copyright (c) 2008 James E. King III
|
||||
#
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# See accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
import ../../config/checks/config : requires ;
|
||||
import testing ;
|
||||
|
||||
run bind1st.cpp : : : [ requires cxx98_binders ] ;
|
||||
run int_div.cpp ;
|
||||
run sum_avg.cpp ;
|
||||
@ -10,27 +10,21 @@
|
||||
// William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
|
||||
// design of this library.
|
||||
|
||||
#ifndef BOOST_FUNCTION_MAX_ARGS
|
||||
# define BOOST_FUNCTION_MAX_ARGS 10
|
||||
#endif // BOOST_FUNCTION_MAX_ARGS
|
||||
|
||||
#if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) || (BOOST_FUNCTION_MAX_ARGS_DEFINED != BOOST_FUNCTION_MAX_ARGS)
|
||||
|
||||
#if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED)
|
||||
#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
|
||||
#endif
|
||||
|
||||
#include <functional> // unary_function, binary_function
|
||||
|
||||
#include <boost/preprocessor/iterate.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#ifndef BOOST_FUNCTION_MAX_ARGS
|
||||
# define BOOST_FUNCTION_MAX_ARGS 10
|
||||
#endif // BOOST_FUNCTION_MAX_ARGS
|
||||
|
||||
// Include the prologue here so that the use of file-level iteration
|
||||
// in anything that may be included by function_template.hpp doesn't break
|
||||
#include <boost/function/detail/prologue.hpp>
|
||||
|
||||
// Older Visual Age C++ version do not handle the file iteration well
|
||||
#if BOOST_WORKAROUND(__IBMCPP__, >= 500) && BOOST_WORKAROUND(__IBMCPP__, < 800)
|
||||
// Visual Age C++ doesn't handle the file iteration well
|
||||
#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 0
|
||||
# include <boost/function/function0.hpp>
|
||||
# endif
|
||||
@ -70,5 +64,3 @@
|
||||
# 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)
|
||||
|
||||
@ -27,8 +27,6 @@ for($on_arg = 0; $on_arg <= $max_args; ++$on_arg) {
|
||||
print OUT "#elif";
|
||||
}
|
||||
print OUT " BOOST_FUNCTION_NUM_ARGS == $on_arg\n";
|
||||
print OUT "# undef BOOST_FUNCTION_MAX_ARGS_DEFINED\n";
|
||||
print OUT "# define BOOST_FUNCTION_MAX_ARGS_DEFINED $on_arg\n";
|
||||
print OUT "# ifndef BOOST_FUNCTION_$on_arg\n";
|
||||
print OUT "# define BOOST_FUNCTION_$on_arg\n";
|
||||
print OUT "# include <boost/function/function_template.hpp>\n";
|
||||
|
||||
@ -8,358 +8,256 @@
|
||||
// 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>
|
||||
|
||||
@ -15,44 +15,98 @@
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include <new>
|
||||
#include <typeinfo>
|
||||
#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/mpl/if.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/type_traits/alignment_of.hpp>
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
#include <boost/type_traits/enable_if.hpp>
|
||||
# include "boost/utility/enable_if.hpp"
|
||||
#else
|
||||
#include <boost/type_traits/integral_constant.hpp>
|
||||
# include "boost/mpl/bool.hpp"
|
||||
#endif
|
||||
#include <boost/function_equal.hpp>
|
||||
#include <boost/function/function_fwd.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning( push )
|
||||
# pragma warning( disable : 4793 ) // complaint about native code generation
|
||||
# pragma warning( disable : 4127 ) // "conditional expression is constant"
|
||||
#endif
|
||||
|
||||
// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
|
||||
#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
|
||||
// Embedded VC++ does not have type_info in namespace std
|
||||
# define BOOST_FUNCTION_STD_NS
|
||||
#else
|
||||
# define BOOST_FUNCTION_STD_NS std
|
||||
#endif
|
||||
|
||||
#if defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
|
||||
// Borrowed from Boost.Python library: determines the cases where we
|
||||
// need to use std::type_info::name to compare instead of operator==.
|
||||
# if (defined(__GNUC__) && __GNUC__ >= 3) \
|
||||
|| defined(_AIX) \
|
||||
|| ( defined(__sgi) && defined(__host_mips))
|
||||
# include <cstring>
|
||||
# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
|
||||
(std::strcmp((X).name(),(Y).name()) == 0)
|
||||
# else
|
||||
# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
|
||||
# define BOOST_FUNCTION_TARGET_FIX(x) x
|
||||
#else
|
||||
# define BOOST_FUNCTION_TARGET_FIX(x)
|
||||
#endif // __ICL etc
|
||||
#endif // not MSVC
|
||||
|
||||
#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
|
||||
// Work around a compiler bug.
|
||||
// boost::python::objects::function has to be seen by the compiler before the
|
||||
// boost::function class template.
|
||||
namespace boost { namespace python { namespace objects {
|
||||
class function;
|
||||
}}}
|
||||
#endif
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|
||||
|| defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
|
||||
|| !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
|
||||
# define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
|
||||
#endif
|
||||
|
||||
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
|
||||
# define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
|
||||
typename ::boost::enable_if_< \
|
||||
!(::boost::is_integral<Functor>::value), \
|
||||
typename ::boost::enable_if_c<(::boost::type_traits::ice_not< \
|
||||
(::boost::is_integral<Functor>::value)>::value), \
|
||||
Type>::type
|
||||
#else
|
||||
// BCC doesn't recognize this depends on a template argument and complains
|
||||
// about the use of 'typename'
|
||||
# define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
|
||||
::boost::enable_if_c<(::boost::type_traits::ice_not< \
|
||||
(::boost::is_integral<Functor>::value)>::value), \
|
||||
Type>::type
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
namespace boost {
|
||||
|
||||
template<typename Signature>
|
||||
class function;
|
||||
|
||||
template<typename Signature>
|
||||
inline void swap(function<Signature>& f1,
|
||||
function<Signature>& f2)
|
||||
{
|
||||
f1.swap(f2);
|
||||
}
|
||||
|
||||
} // end namespace boost
|
||||
#endif // have partial specialization
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
@ -65,31 +119,17 @@ namespace boost {
|
||||
* object pointers, and a structure that resembles a bound
|
||||
* member function pointer.
|
||||
*/
|
||||
union function_buffer_members
|
||||
union function_buffer
|
||||
{
|
||||
// For pointers to function objects
|
||||
typedef void* obj_ptr_t;
|
||||
mutable obj_ptr_t obj_ptr;
|
||||
void* obj_ptr;
|
||||
|
||||
// For pointers to std::type_info objects
|
||||
struct type_t {
|
||||
// (get_functor_type_tag, check_functor_type_tag).
|
||||
const boost::typeindex::type_info* type;
|
||||
|
||||
// Whether the type is const-qualified.
|
||||
bool const_qualified;
|
||||
// Whether the type is volatile-qualified.
|
||||
bool volatile_qualified;
|
||||
} type;
|
||||
// (get_functor_type_tag, check_functor_type_tag).
|
||||
const void* const_obj_ptr;
|
||||
|
||||
// For function pointers of all kinds
|
||||
typedef void (*func_ptr_t)();
|
||||
mutable func_ptr_t func_ptr;
|
||||
|
||||
#if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 5243)
|
||||
#endif
|
||||
mutable void (*func_ptr)();
|
||||
|
||||
// For bound member pointers
|
||||
struct bound_memfunc_ptr_t {
|
||||
@ -97,26 +137,8 @@ namespace boost {
|
||||
void* obj_ptr;
|
||||
} bound_memfunc_ptr;
|
||||
|
||||
#if defined(BOOST_MSVC) && BOOST_MSVC >= 1929
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
// For references to function objects. We explicitly keep
|
||||
// track of the cv-qualifiers on the object referenced.
|
||||
struct obj_ref_t {
|
||||
mutable void* obj_ptr;
|
||||
bool is_const_qualified;
|
||||
bool is_volatile_qualified;
|
||||
} obj_ref;
|
||||
};
|
||||
|
||||
union BOOST_SYMBOL_VISIBLE function_buffer
|
||||
{
|
||||
// Type-specific union members
|
||||
mutable function_buffer_members members;
|
||||
|
||||
// To relax aliasing constraints
|
||||
mutable char data[sizeof(function_buffer_members)];
|
||||
mutable char data;
|
||||
};
|
||||
|
||||
/**
|
||||
@ -146,7 +168,6 @@ namespace boost {
|
||||
// The operation type to perform on the given functor/function pointer
|
||||
enum functor_manager_operation_type {
|
||||
clone_functor_tag,
|
||||
move_functor_tag,
|
||||
destroy_functor_tag,
|
||||
check_functor_type_tag,
|
||||
get_functor_type_tag
|
||||
@ -161,15 +182,15 @@ namespace boost {
|
||||
template<typename F>
|
||||
class get_function_tag
|
||||
{
|
||||
typedef typename conditional<(is_pointer<F>::value),
|
||||
typedef typename mpl::if_c<(is_pointer<F>::value),
|
||||
function_ptr_tag,
|
||||
function_obj_tag>::type ptr_or_obj_tag;
|
||||
|
||||
typedef typename conditional<(is_member_pointer<F>::value),
|
||||
typedef typename mpl::if_c<(is_member_pointer<F>::value),
|
||||
member_ptr_tag,
|
||||
ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
|
||||
|
||||
typedef typename conditional<(is_reference_wrapper<F>::value),
|
||||
typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
|
||||
function_obj_ref_tag,
|
||||
ptr_or_obj_or_mem_tag>::type or_ref_tag;
|
||||
|
||||
@ -183,42 +204,34 @@ namespace boost {
|
||||
struct reference_manager
|
||||
{
|
||||
static inline void
|
||||
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
get(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
switch (op) {
|
||||
case clone_functor_tag:
|
||||
out_buffer.members.obj_ref = in_buffer.members.obj_ref;
|
||||
return;
|
||||
|
||||
case move_functor_tag:
|
||||
out_buffer.members.obj_ref = in_buffer.members.obj_ref;
|
||||
in_buffer.members.obj_ref.obj_ptr = 0;
|
||||
case clone_functor_tag:
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
return;
|
||||
|
||||
case destroy_functor_tag:
|
||||
out_buffer.members.obj_ref.obj_ptr = 0;
|
||||
out_buffer.obj_ptr = 0;
|
||||
return;
|
||||
|
||||
case check_functor_type_tag:
|
||||
{
|
||||
// Check whether we have the same type. We can add
|
||||
// cv-qualifiers, but we can't take them away.
|
||||
if (*out_buffer.members.type.type == boost::typeindex::type_id<F>()
|
||||
&& (!in_buffer.members.obj_ref.is_const_qualified
|
||||
|| out_buffer.members.type.const_qualified)
|
||||
&& (!in_buffer.members.obj_ref.is_volatile_qualified
|
||||
|| out_buffer.members.type.volatile_qualified))
|
||||
out_buffer.members.obj_ptr = in_buffer.members.obj_ref.obj_ptr;
|
||||
// DPG TBD: Since we're only storing a pointer, it's
|
||||
// possible that the user could ask for a base class or
|
||||
// derived class. Is that okay?
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
else
|
||||
out_buffer.members.obj_ptr = 0;
|
||||
out_buffer.obj_ptr = 0;
|
||||
}
|
||||
return;
|
||||
|
||||
case get_functor_type_tag:
|
||||
out_buffer.members.type.type = &boost::typeindex::type_id<F>().type_info();
|
||||
out_buffer.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.const_obj_ptr = &typeid(F);
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -232,9 +245,9 @@ namespace boost {
|
||||
struct function_allows_small_object_optimization
|
||||
{
|
||||
BOOST_STATIC_CONSTANT
|
||||
(bool,
|
||||
(bool,
|
||||
value = ((sizeof(F) <= sizeof(function_buffer) &&
|
||||
(alignment_of<function_buffer>::value
|
||||
(alignment_of<function_buffer>::value
|
||||
% alignment_of<F>::value == 0))));
|
||||
};
|
||||
|
||||
@ -246,12 +259,6 @@ namespace boost {
|
||||
A(a)
|
||||
{
|
||||
}
|
||||
|
||||
functor_wrapper(const functor_wrapper& f) :
|
||||
F(static_cast<const F&>(f)),
|
||||
A(static_cast<const A&>(f))
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
@ -265,57 +272,42 @@ namespace boost {
|
||||
|
||||
// Function pointers
|
||||
static inline void
|
||||
manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
if (op == clone_functor_tag)
|
||||
out_buffer.members.func_ptr = in_buffer.members.func_ptr;
|
||||
else if (op == move_functor_tag) {
|
||||
out_buffer.members.func_ptr = in_buffer.members.func_ptr;
|
||||
in_buffer.members.func_ptr = 0;
|
||||
} else if (op == destroy_functor_tag)
|
||||
out_buffer.members.func_ptr = 0;
|
||||
else if (op == check_functor_type_tag) {
|
||||
if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
|
||||
out_buffer.members.obj_ptr = &in_buffer.members.func_ptr;
|
||||
out_buffer.func_ptr = in_buffer.func_ptr;
|
||||
else if (op == destroy_functor_tag)
|
||||
out_buffer.func_ptr = 0;
|
||||
else /* op == check_functor_type_tag */ {
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = &in_buffer.func_ptr;
|
||||
else
|
||||
out_buffer.members.obj_ptr = 0;
|
||||
} else /* op == get_functor_type_tag */ {
|
||||
out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
|
||||
out_buffer.members.type.const_qualified = false;
|
||||
out_buffer.members.type.volatile_qualified = false;
|
||||
out_buffer.obj_ptr = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Function objects that fit in the small-object buffer.
|
||||
static inline void
|
||||
manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
if (op == clone_functor_tag || op == move_functor_tag) {
|
||||
const functor_type* in_functor =
|
||||
reinterpret_cast<const functor_type*>(in_buffer.data);
|
||||
new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor);
|
||||
|
||||
if (op == move_functor_tag) {
|
||||
functor_type* f = reinterpret_cast<functor_type*>(in_buffer.data);
|
||||
(void)f; // suppress warning about the value of f not being used (MSVC)
|
||||
f->~Functor();
|
||||
}
|
||||
if (op == clone_functor_tag) {
|
||||
const functor_type* in_functor =
|
||||
reinterpret_cast<const functor_type*>(&in_buffer.data);
|
||||
new ((void*)&out_buffer.data) functor_type(*in_functor);
|
||||
} else if (op == destroy_functor_tag) {
|
||||
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
|
||||
functor_type* f = reinterpret_cast<functor_type*>(out_buffer.data);
|
||||
(void)f; // suppress warning about the value of f not being used (MSVC)
|
||||
f->~Functor();
|
||||
} else if (op == check_functor_type_tag) {
|
||||
if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
|
||||
out_buffer.members.obj_ptr = in_buffer.data;
|
||||
reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
|
||||
} else /* op == check_functor_type_tag */ {
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = &in_buffer.data;
|
||||
else
|
||||
out_buffer.members.obj_ptr = 0;
|
||||
} else /* op == get_functor_type_tag */ {
|
||||
out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
|
||||
out_buffer.members.type.const_qualified = false;
|
||||
out_buffer.members.type.volatile_qualified = false;
|
||||
out_buffer.obj_ptr = 0;
|
||||
}
|
||||
}
|
||||
};
|
||||
@ -328,7 +320,7 @@ namespace boost {
|
||||
|
||||
// Function pointers
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, function_ptr_tag)
|
||||
{
|
||||
functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
|
||||
@ -336,45 +328,38 @@ namespace boost {
|
||||
|
||||
// Function objects that fit in the small-object buffer.
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, true_type)
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, mpl::true_)
|
||||
{
|
||||
functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
|
||||
}
|
||||
|
||||
|
||||
// Function objects that require heap allocation
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, false_type)
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, mpl::false_)
|
||||
{
|
||||
if (op == clone_functor_tag) {
|
||||
// Clone the functor
|
||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||
// can't do the static_cast that we should do.
|
||||
// jewillco: Changing this to static_cast because GCC 2.95.3 is
|
||||
// obsolete.
|
||||
const functor_type* f =
|
||||
static_cast<const functor_type*>(in_buffer.members.obj_ptr);
|
||||
(const functor_type*)(in_buffer.obj_ptr);
|
||||
functor_type* new_f = new functor_type(*f);
|
||||
out_buffer.members.obj_ptr = new_f;
|
||||
} else if (op == move_functor_tag) {
|
||||
out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
|
||||
in_buffer.members.obj_ptr = 0;
|
||||
out_buffer.obj_ptr = new_f;
|
||||
} else if (op == destroy_functor_tag) {
|
||||
/* Cast from the void pointer to the functor pointer type */
|
||||
functor_type* f =
|
||||
static_cast<functor_type*>(out_buffer.members.obj_ptr);
|
||||
static_cast<functor_type*>(out_buffer.obj_ptr);
|
||||
delete f;
|
||||
out_buffer.members.obj_ptr = 0;
|
||||
} else if (op == check_functor_type_tag) {
|
||||
if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
|
||||
out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else /* op == check_functor_type_tag */ {
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
else
|
||||
out_buffer.members.obj_ptr = 0;
|
||||
} else /* op == get_functor_type_tag */ {
|
||||
out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
|
||||
out_buffer.members.type.const_qualified = false;
|
||||
out_buffer.members.type.volatile_qualified = false;
|
||||
out_buffer.obj_ptr = 0;
|
||||
}
|
||||
}
|
||||
|
||||
@ -382,35 +367,29 @@ namespace boost {
|
||||
// object can use the small-object optimization buffer or
|
||||
// whether we need to allocate it on the heap.
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, function_obj_tag)
|
||||
{
|
||||
manager(in_buffer, out_buffer, op,
|
||||
integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
|
||||
}
|
||||
|
||||
// For member pointers, we use the small-object optimization buffer.
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, member_ptr_tag)
|
||||
{
|
||||
manager(in_buffer, out_buffer, op, true_type());
|
||||
mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
|
||||
}
|
||||
|
||||
public:
|
||||
/* Dispatch to an appropriate manager based on whether we have a
|
||||
function pointer or a function object pointer. */
|
||||
static inline void
|
||||
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
typedef typename get_function_tag<functor_type>::type tag_type;
|
||||
if (op == get_functor_type_tag) {
|
||||
out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
|
||||
out_buffer.members.type.const_qualified = false;
|
||||
out_buffer.members.type.volatile_qualified = false;
|
||||
} else {
|
||||
switch (op) {
|
||||
case get_functor_type_tag:
|
||||
out_buffer.const_obj_ptr = &typeid(functor_type);
|
||||
return;
|
||||
|
||||
default:
|
||||
manager(in_buffer, out_buffer, op, tag_type());
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
@ -423,7 +402,7 @@ namespace boost {
|
||||
|
||||
// Function pointers
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, function_ptr_tag)
|
||||
{
|
||||
functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
|
||||
@ -431,68 +410,50 @@ namespace boost {
|
||||
|
||||
// Function objects that fit in the small-object buffer.
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, true_type)
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, mpl::true_)
|
||||
{
|
||||
functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
|
||||
}
|
||||
|
||||
|
||||
// Function objects that require heap allocation
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, false_type)
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, mpl::false_)
|
||||
{
|
||||
typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
|
||||
#if defined(BOOST_NO_CXX11_ALLOCATOR)
|
||||
typedef typename Allocator::template rebind<functor_wrapper_type>::other
|
||||
wrapper_allocator_type;
|
||||
typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
|
||||
#else
|
||||
using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
|
||||
using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
|
||||
#endif
|
||||
|
||||
if (op == clone_functor_tag) {
|
||||
// Clone the functor
|
||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||
// can't do the static_cast that we should do.
|
||||
const functor_wrapper_type* f =
|
||||
static_cast<const functor_wrapper_type*>(in_buffer.members.obj_ptr);
|
||||
(const functor_wrapper_type*)(in_buffer.obj_ptr);
|
||||
wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
|
||||
wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
|
||||
#if defined(BOOST_NO_CXX11_ALLOCATOR)
|
||||
wrapper_allocator.construct(copy, *f);
|
||||
#else
|
||||
std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, *f);
|
||||
#endif
|
||||
|
||||
// Get back to the original pointer type
|
||||
functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
|
||||
out_buffer.members.obj_ptr = new_f;
|
||||
} else if (op == move_functor_tag) {
|
||||
out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
|
||||
in_buffer.members.obj_ptr = 0;
|
||||
out_buffer.obj_ptr = new_f;
|
||||
} else if (op == destroy_functor_tag) {
|
||||
/* Cast from the void pointer to the functor_wrapper_type */
|
||||
functor_wrapper_type* victim =
|
||||
static_cast<functor_wrapper_type*>(in_buffer.members.obj_ptr);
|
||||
static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
|
||||
wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
|
||||
#if defined(BOOST_NO_CXX11_ALLOCATOR)
|
||||
wrapper_allocator.destroy(victim);
|
||||
#else
|
||||
std::allocator_traits<wrapper_allocator_type>::destroy(wrapper_allocator, victim);
|
||||
#endif
|
||||
wrapper_allocator.deallocate(victim,1);
|
||||
out_buffer.members.obj_ptr = 0;
|
||||
} else if (op == check_functor_type_tag) {
|
||||
if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
|
||||
out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
|
||||
out_buffer.obj_ptr = 0;
|
||||
} else /* op == check_functor_type_tag */ {
|
||||
const BOOST_FUNCTION_STD_NS::type_info& check_type =
|
||||
*static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
|
||||
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
|
||||
out_buffer.obj_ptr = in_buffer.obj_ptr;
|
||||
else
|
||||
out_buffer.members.obj_ptr = 0;
|
||||
} else /* op == get_functor_type_tag */ {
|
||||
out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
|
||||
out_buffer.members.type.const_qualified = false;
|
||||
out_buffer.members.type.volatile_qualified = false;
|
||||
out_buffer.obj_ptr = 0;
|
||||
}
|
||||
}
|
||||
|
||||
@ -500,27 +461,29 @@ namespace boost {
|
||||
// object can use the small-object optimization buffer or
|
||||
// whether we need to allocate it on the heap.
|
||||
static inline void
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
manager(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op, function_obj_tag)
|
||||
{
|
||||
manager(in_buffer, out_buffer, op,
|
||||
integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
|
||||
mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
|
||||
}
|
||||
|
||||
public:
|
||||
/* Dispatch to an appropriate manager based on whether we have a
|
||||
function pointer or a function object pointer. */
|
||||
static inline void
|
||||
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
manage(const function_buffer& in_buffer, function_buffer& out_buffer,
|
||||
functor_manager_operation_type op)
|
||||
{
|
||||
typedef typename get_function_tag<functor_type>::type tag_type;
|
||||
if (op == get_functor_type_tag) {
|
||||
out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
|
||||
out_buffer.members.type.const_qualified = false;
|
||||
out_buffer.members.type.volatile_qualified = false;
|
||||
} else {
|
||||
switch (op) {
|
||||
case get_functor_type_tag:
|
||||
out_buffer.const_obj_ptr = &typeid(functor_type);
|
||||
return;
|
||||
|
||||
default:
|
||||
manager(in_buffer, out_buffer, op, tag_type());
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
@ -531,24 +494,24 @@ namespace boost {
|
||||
#ifdef BOOST_NO_SFINAE
|
||||
// These routines perform comparisons between a Boost.Function
|
||||
// object and an arbitrary function object (when the last
|
||||
// parameter is false_type) or against zero (when the
|
||||
// last parameter is true_type). They are only necessary
|
||||
// parameter is mpl::bool_<false>) or against zero (when the
|
||||
// last parameter is mpl::bool_<true>). They are only necessary
|
||||
// for compilers that don't support SFINAE.
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_equal(const Function& f, const Functor&, int, true_type)
|
||||
compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
|
||||
{ return f.empty(); }
|
||||
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_not_equal(const Function& f, const Functor&, int,
|
||||
true_type)
|
||||
mpl::bool_<true>)
|
||||
{ return !f.empty(); }
|
||||
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_equal(const Function& f, const Functor& g, long,
|
||||
false_type)
|
||||
mpl::bool_<false>)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return function_equal(*fp, g);
|
||||
@ -558,7 +521,7 @@ namespace boost {
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_equal(const Function& f, const reference_wrapper<Functor>& g,
|
||||
int, false_type)
|
||||
int, mpl::bool_<false>)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return fp == g.get_pointer();
|
||||
@ -568,7 +531,7 @@ namespace boost {
|
||||
template<typename Function, typename Functor>
|
||||
bool
|
||||
compare_not_equal(const Function& f, const Functor& g, long,
|
||||
false_type)
|
||||
mpl::bool_<false>)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return !function_equal(*fp, g);
|
||||
@ -579,7 +542,7 @@ namespace boost {
|
||||
bool
|
||||
compare_not_equal(const Function& f,
|
||||
const reference_wrapper<Functor>& g, int,
|
||||
false_type)
|
||||
mpl::bool_<false>)
|
||||
{
|
||||
if (const Functor* fp = f.template target<Functor>())
|
||||
return fp != g.get_pointer();
|
||||
@ -593,8 +556,9 @@ namespace boost {
|
||||
*/
|
||||
struct vtable_base
|
||||
{
|
||||
void (*manager)(const function_buffer& in_buffer,
|
||||
function_buffer& out_buffer,
|
||||
vtable_base() : manager(0) { }
|
||||
void (*manager)(const function_buffer& in_buffer,
|
||||
function_buffer& out_buffer,
|
||||
functor_manager_operation_type op);
|
||||
};
|
||||
} // end namespace function
|
||||
@ -614,15 +578,15 @@ public:
|
||||
/** Determine if the function is empty (i.e., has no target). */
|
||||
bool empty() const { return !vtable; }
|
||||
|
||||
/** Retrieve the type of the stored function object, or type_id<void>()
|
||||
/** Retrieve the type of the stored function object, or typeid(void)
|
||||
if this is empty. */
|
||||
const boost::typeindex::type_info& target_type() const
|
||||
const BOOST_FUNCTION_STD_NS::type_info& target_type() const
|
||||
{
|
||||
if (!vtable) return boost::typeindex::type_id<void>().type_info();
|
||||
if (!vtable) return typeid(void);
|
||||
|
||||
detail::function::function_buffer type;
|
||||
get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
|
||||
return *type.members.type.type;
|
||||
vtable->manager(functor, type, detail::function::get_functor_type_tag);
|
||||
return *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(type.const_obj_ptr);
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
@ -631,34 +595,38 @@ public:
|
||||
if (!vtable) return 0;
|
||||
|
||||
detail::function::function_buffer type_result;
|
||||
type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
|
||||
type_result.members.type.const_qualified = is_const<Functor>::value;
|
||||
type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
|
||||
get_vtable()->manager(functor, type_result,
|
||||
type_result.const_obj_ptr = &typeid(Functor);
|
||||
vtable->manager(functor, type_result,
|
||||
detail::function::check_functor_type_tag);
|
||||
return static_cast<Functor*>(type_result.members.obj_ptr);
|
||||
return static_cast<Functor*>(type_result.obj_ptr);
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
const Functor* target( Functor * = 0 ) const
|
||||
#else
|
||||
const Functor* target() const
|
||||
#endif
|
||||
{
|
||||
if (!vtable) return 0;
|
||||
|
||||
detail::function::function_buffer type_result;
|
||||
type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
|
||||
type_result.members.type.const_qualified = true;
|
||||
type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
|
||||
get_vtable()->manager(functor, type_result,
|
||||
type_result.const_obj_ptr = &typeid(Functor);
|
||||
vtable->manager(functor, type_result,
|
||||
detail::function::check_functor_type_tag);
|
||||
// GCC 2.95.3 gets the CV qualifiers wrong here, so we
|
||||
// can't do the static_cast that we should do.
|
||||
return static_cast<const Functor*>(type_result.members.obj_ptr);
|
||||
return (const Functor*)(type_result.obj_ptr);
|
||||
}
|
||||
|
||||
template<typename F>
|
||||
bool contains(const F& f) const
|
||||
{
|
||||
#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
if (const F* fp = this->target( (F*)0 ))
|
||||
#else
|
||||
if (const F* fp = this->template target<F>())
|
||||
#endif
|
||||
{
|
||||
return function_equal(*fp, f);
|
||||
} else {
|
||||
@ -690,35 +658,19 @@ public:
|
||||
#endif
|
||||
|
||||
public: // should be protected, but GCC 2.95.3 will fail to allow access
|
||||
detail::function::vtable_base* get_vtable() const {
|
||||
return reinterpret_cast<detail::function::vtable_base*>(
|
||||
reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
|
||||
}
|
||||
|
||||
bool has_trivial_copy_and_destroy() const {
|
||||
return reinterpret_cast<std::size_t>(vtable) & 0x01;
|
||||
}
|
||||
|
||||
detail::function::vtable_base* vtable;
|
||||
mutable detail::function::function_buffer functor;
|
||||
};
|
||||
|
||||
#if defined(BOOST_CLANG)
|
||||
# pragma clang diagnostic push
|
||||
# pragma clang diagnostic ignored "-Wweak-vtables"
|
||||
#endif
|
||||
/**
|
||||
* The bad_function_call exception class is thrown when a boost::function
|
||||
* object is invoked
|
||||
*/
|
||||
class BOOST_SYMBOL_VISIBLE bad_function_call : public std::runtime_error
|
||||
class bad_function_call : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
bad_function_call() : std::runtime_error("call to empty boost::function") {}
|
||||
};
|
||||
#if defined(BOOST_CLANG)
|
||||
# pragma clang diagnostic pop
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_SFINAE
|
||||
inline bool operator==(const function_base& f,
|
||||
@ -751,28 +703,28 @@ inline bool operator!=(detail::function::useless_clear_type*,
|
||||
template<typename Functor>
|
||||
inline bool operator==(const function_base& f, Functor g)
|
||||
{
|
||||
typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
|
||||
typedef mpl::bool_<(is_integral<Functor>::value)> integral;
|
||||
return detail::function::compare_equal(f, g, 0, integral());
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
inline bool operator==(Functor g, const function_base& f)
|
||||
{
|
||||
typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
|
||||
typedef mpl::bool_<(is_integral<Functor>::value)> integral;
|
||||
return detail::function::compare_equal(f, g, 0, integral());
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
inline bool operator!=(const function_base& f, Functor g)
|
||||
{
|
||||
typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
|
||||
typedef mpl::bool_<(is_integral<Functor>::value)> integral;
|
||||
return detail::function::compare_not_equal(f, g, 0, integral());
|
||||
}
|
||||
|
||||
template<typename Functor>
|
||||
inline bool operator!=(Functor g, const function_base& f)
|
||||
{
|
||||
typedef integral_constant<bool, (is_integral<Functor>::value)> integral;
|
||||
typedef mpl::bool_<(is_integral<Functor>::value)> integral;
|
||||
return detail::function::compare_not_equal(f, g, 0, integral());
|
||||
}
|
||||
#else
|
||||
@ -879,9 +831,6 @@ namespace detail {
|
||||
} // end namespace boost
|
||||
|
||||
#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning( pop )
|
||||
#endif
|
||||
#undef BOOST_FUNCTION_COMPARE_TYPE_ID
|
||||
|
||||
#endif // BOOST_FUNCTION_BASE_HEADER
|
||||
|
||||
@ -1,69 +0,0 @@
|
||||
// Boost.Function library
|
||||
// Copyright (C) Douglas Gregor 2008
|
||||
//
|
||||
// Use, modification and distribution is subject to the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// For more information, see http://www.boost.org
|
||||
#ifndef BOOST_FUNCTION_FWD_HPP
|
||||
#define BOOST_FUNCTION_FWD_HPP
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
|
||||
// Work around a compiler bug.
|
||||
// boost::python::objects::function has to be seen by the compiler before the
|
||||
// boost::function class template.
|
||||
namespace boost { namespace python { namespace objects {
|
||||
class function;
|
||||
}}}
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
|
||||
|| !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
|
||||
# define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
class bad_function_call;
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
// Preferred syntax
|
||||
template<typename Signature> class function;
|
||||
|
||||
template<typename Signature>
|
||||
inline void swap(function<Signature>& f1, function<Signature>& f2)
|
||||
{
|
||||
f1.swap(f2);
|
||||
}
|
||||
#endif // have partial specialization
|
||||
|
||||
// Portable syntax
|
||||
template<typename R> class function0;
|
||||
template<typename R, typename T1> class function1;
|
||||
template<typename R, typename T1, typename T2> class function2;
|
||||
template<typename R, typename T1, typename T2, typename T3> class function3;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4>
|
||||
class function4;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4,
|
||||
typename T5>
|
||||
class function5;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4,
|
||||
typename T5, typename T6>
|
||||
class function6;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4,
|
||||
typename T5, typename T6, typename T7>
|
||||
class function7;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4,
|
||||
typename T5, typename T6, typename T7, typename T8>
|
||||
class function8;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4,
|
||||
typename T5, typename T6, typename T7, typename T8, typename T9>
|
||||
class function9;
|
||||
template<typename R, typename T1, typename T2, typename T3, typename T4,
|
||||
typename T5, typename T6, typename T7, typename T8, typename T9,
|
||||
typename T10>
|
||||
class function10;
|
||||
}
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,45 +0,0 @@
|
||||
// Boost.Function library - Typeof support
|
||||
// Copyright (C) Douglas Gregor 2008
|
||||
//
|
||||
// Use, modification and distribution is subject to the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// For more information, see http://www.boost.org
|
||||
#ifndef BOOST_FUNCTION_TYPEOF_HPP
|
||||
#define BOOST_FUNCTION_TYPEOF_HPP
|
||||
#include <boost/function/function_fwd.hpp>
|
||||
#include <boost/typeof/typeof.hpp>
|
||||
|
||||
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::bad_function_call)
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function, (typename))
|
||||
#endif
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function0, (typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function1, (typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function2, (typename)(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function3,
|
||||
(typename)(typename)(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function4,
|
||||
(typename)(typename)(typename)(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function5,
|
||||
(typename)(typename)(typename)(typename)(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function6,
|
||||
(typename)(typename)(typename)(typename)(typename)(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function7,
|
||||
(typename)(typename)(typename)(typename)(typename)(typename)(typename)
|
||||
(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function8,
|
||||
(typename)(typename)(typename)(typename)(typename)(typename)(typename)
|
||||
(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function9,
|
||||
(typename)(typename)(typename)(typename)(typename)(typename)(typename)
|
||||
(typename)(typename)(typename))
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function10,
|
||||
(typename)(typename)(typename)(typename)(typename)(typename)(typename)
|
||||
(typename)(typename)(typename)(typename))
|
||||
#endif
|
||||
@ -1,19 +0,0 @@
|
||||
{
|
||||
"key": "function",
|
||||
"name": "Function",
|
||||
"authors": [
|
||||
"Doug Gregor"
|
||||
],
|
||||
"description": "Function object wrappers for deferred calls or callbacks.",
|
||||
"std": [
|
||||
"tr1"
|
||||
],
|
||||
"category": [
|
||||
"Function-objects",
|
||||
"Programming"
|
||||
],
|
||||
"maintainers": [
|
||||
"Peter Dimov <pdimov -at- gmail.com>"
|
||||
],
|
||||
"cxxstd": "03"
|
||||
}
|
||||
@ -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)
|
||||
|
||||
endif()
|
||||
@ -7,78 +7,57 @@
|
||||
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
project
|
||||
: source-location $(BOOST_ROOT)
|
||||
;
|
||||
|
||||
# bring in rules for testing
|
||||
import testing ;
|
||||
|
||||
project
|
||||
: default-build
|
||||
<warnings>extra
|
||||
: requirements
|
||||
<toolset>msvc:<warnings-as-errors>on
|
||||
<toolset>gcc:<warnings-as-errors>on
|
||||
<toolset>clang:<warnings-as-errors>on
|
||||
;
|
||||
{
|
||||
|
||||
run function_test.cpp ;
|
||||
# /usr/include/c++/4.4/bits/shared_ptr.h:146: error: cannot use typeid with -fno-rtti
|
||||
run function_test.cpp : : : <rtti>off <toolset>gcc-4.4.7,<cxxstd>0x:<build>no : function_test_no_rtti ;
|
||||
run function_n_test.cpp ;
|
||||
run allocator_test.cpp ;
|
||||
run stateless_test.cpp ;
|
||||
run lambda_test.cpp ;
|
||||
compile-fail function_test_fail1.cpp ;
|
||||
compile-fail function_test_fail2.cpp ;
|
||||
compile function_30.cpp ;
|
||||
compile function_30_repeat.cpp ;
|
||||
run function_arith_cxx98.cpp ;
|
||||
run function_arith_portable.cpp ;
|
||||
run sum_avg_cxx98.cpp ;
|
||||
run sum_avg_portable.cpp ;
|
||||
run mem_fun_cxx98.cpp ;
|
||||
run mem_fun_portable.cpp ;
|
||||
run std_bind_cxx98.cpp ;
|
||||
run std_bind_portable.cpp ;
|
||||
run function_ref_cxx98.cpp ;
|
||||
run function_ref_portable.cpp ;
|
||||
run contains_test.cpp ;
|
||||
run contains2_test.cpp ;
|
||||
run nothrow_swap.cpp ;
|
||||
run rvalues_test.cpp ;
|
||||
compile function_typeof_test.cpp ;
|
||||
run result_arg_types_test.cpp ;
|
||||
test-suite function
|
||||
:
|
||||
[ run libs/function/test/function_test.cpp : : : : lib_function_test ]
|
||||
|
||||
lib throw_bad_function_call : throw_bad_function_call.cpp : <link>shared:<define>THROW_BAD_FUNCTION_CALL_DYN_LINK=1 ;
|
||||
[ run libs/function/test/function_n_test.cpp : : : : ]
|
||||
|
||||
run test_bad_function_call.cpp throw_bad_function_call : : : <link>shared : test_bad_function_call_shared ;
|
||||
run test_bad_function_call.cpp throw_bad_function_call : : : <link>static : test_bad_function_call_static ;
|
||||
[ run libs/function/test/allocator_test.cpp ../../../libs/test/build//boost_test_exec_monitor : : : : ]
|
||||
|
||||
lib mixed_cxxstd : mixed_cxxstd.cpp : <link>shared:<define>MIXED_CXXSTD_DYN_LINK=1 ;
|
||||
[ run libs/function/test/stateless_test.cpp ../../../libs/test/build//boost_test_exec_monitor : : : : ]
|
||||
|
||||
run test_mixed_cxxstd.cpp mixed_cxxstd : : : <link>shared : mixed_cxxstd_shared ;
|
||||
run test_mixed_cxxstd.cpp mixed_cxxstd : : : <link>static : mixed_cxxstd_static ;
|
||||
[ run libs/function/test/lambda_test.cpp ../../../libs/test/build//boost_test_exec_monitor : : : : ]
|
||||
|
||||
run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>98 : : : <link>shared : mixed_cxxstd_shared_98 ;
|
||||
run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>98 : : : <link>static : mixed_cxxstd_static_98 ;
|
||||
[ compile-fail libs/function/test/function_test_fail1.cpp : : : : ]
|
||||
|
||||
run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>0x : : : <link>shared : mixed_cxxstd_shared_0x ;
|
||||
run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>0x : : : <link>static : mixed_cxxstd_static_0x ;
|
||||
[ compile-fail libs/function/test/function_test_fail2.cpp : : : : ]
|
||||
|
||||
local check14 = [ check-target-builds mixed_cxxstd/<cxxstd>14 : : <build>no ] ;
|
||||
[ compile libs/function/test/function_30.cpp : : : : ]
|
||||
|
||||
run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>14 : : : <link>shared $(check14) : mixed_cxxstd_shared_14 ;
|
||||
run test_mixed_cxxstd.cpp mixed_cxxstd/<cxxstd>14 : : : <link>static $(check14) : mixed_cxxstd_static_14 ;
|
||||
[ run libs/function/test/function_arith_cxx98.cpp : : : : ]
|
||||
|
||||
lib return_function : return_function.cpp : <link>shared:<define>RETURN_FUNCTION_DYN_LINK=1 ;
|
||||
[ run libs/function/test/function_arith_portable.cpp : : : : ]
|
||||
|
||||
run test_return_function.cpp return_function : : : <link>shared : return_function_shared ;
|
||||
run test_return_function.cpp return_function : : : <link>static : return_function_static ;
|
||||
[ run libs/function/test/sum_avg_cxx98.cpp : : : : ]
|
||||
|
||||
run test_return_function.cpp return_function/<cxxstd>98 : : : <link>shared : return_function_shared_98 ;
|
||||
run test_return_function.cpp return_function/<cxxstd>98 : : : <link>static : return_function_static_98 ;
|
||||
[ run libs/function/test/sum_avg_portable.cpp : : : : ]
|
||||
|
||||
run test_return_function.cpp return_function/<cxxstd>0x : : : <link>shared : return_function_shared_0x ;
|
||||
run test_return_function.cpp return_function/<cxxstd>0x : : : <link>static : return_function_static_0x ;
|
||||
[ run libs/function/test/mem_fun_cxx98.cpp : : : : ]
|
||||
|
||||
run test_return_function.cpp return_function/<cxxstd>14 : : : <link>shared $(check14) : return_function_shared_14 ;
|
||||
run test_return_function.cpp return_function/<cxxstd>14 : : : <link>static $(check14) : return_function_static_14 ;
|
||||
[ run libs/function/test/mem_fun_portable.cpp : : : : ]
|
||||
|
||||
run quick.cpp ;
|
||||
[ run libs/function/test/std_bind_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/std_bind_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_ref_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_ref_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/contains_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/contains2_test.cpp : : : : ]
|
||||
|
||||
;
|
||||
}
|
||||
|
||||
|
||||
@ -7,10 +7,10 @@
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <cassert>
|
||||
#include <functional>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
@ -74,19 +74,20 @@ struct DoNothing: base
|
||||
|
||||
static void do_nothing() {}
|
||||
|
||||
int main()
|
||||
int
|
||||
test_main(int, char*[])
|
||||
{
|
||||
function2<int, int, int> f;
|
||||
f.assign( plus_int<disable_small_object_optimization>(), counting_allocator<int>() );
|
||||
f.clear();
|
||||
BOOST_TEST_EQ( alloc_count, 1 );
|
||||
BOOST_TEST_EQ( dealloc_count, 1 );
|
||||
BOOST_CHECK(alloc_count == 1);
|
||||
BOOST_CHECK(dealloc_count == 1);
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
|
||||
f.clear();
|
||||
BOOST_TEST_EQ( alloc_count, 0 );
|
||||
BOOST_TEST_EQ( dealloc_count, 0 );
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
f.assign( plus_int<disable_small_object_optimization>(), std::allocator<int>() );
|
||||
f.clear();
|
||||
f.assign( plus_int<enable_small_object_optimization>(), std::allocator<int>() );
|
||||
@ -96,8 +97,8 @@ int main()
|
||||
dealloc_count = 0;
|
||||
f.assign( &do_minus, counting_allocator<int>() );
|
||||
f.clear();
|
||||
BOOST_TEST_EQ( alloc_count, 0 );
|
||||
BOOST_TEST_EQ( dealloc_count, 0 );
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
f.assign( &do_minus, std::allocator<int>() );
|
||||
f.clear();
|
||||
|
||||
@ -106,14 +107,14 @@ int main()
|
||||
dealloc_count = 0;
|
||||
fv.assign( DoNothing<disable_small_object_optimization>(), counting_allocator<int>() );
|
||||
fv.clear();
|
||||
BOOST_TEST_EQ( alloc_count, 1 );
|
||||
BOOST_TEST_EQ( dealloc_count, 1 );
|
||||
BOOST_CHECK(alloc_count == 1);
|
||||
BOOST_CHECK(dealloc_count == 1);
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv.assign( DoNothing<enable_small_object_optimization>(), counting_allocator<int>() );
|
||||
fv.clear();
|
||||
BOOST_TEST_EQ( alloc_count, 0 );
|
||||
BOOST_TEST_EQ( dealloc_count, 0 );
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
fv.assign( DoNothing<disable_small_object_optimization>(), std::allocator<int>() );
|
||||
fv.clear();
|
||||
fv.assign( DoNothing<enable_small_object_optimization>(), std::allocator<int>() );
|
||||
@ -123,14 +124,10 @@ int main()
|
||||
dealloc_count = 0;
|
||||
fv.assign( &do_nothing, counting_allocator<int>() );
|
||||
fv.clear();
|
||||
BOOST_TEST_EQ( alloc_count, 0 );
|
||||
BOOST_TEST_EQ( dealloc_count, 0 );
|
||||
BOOST_CHECK(alloc_count == 0);
|
||||
BOOST_CHECK(dealloc_count == 0);
|
||||
fv.assign( &do_nothing, std::allocator<int>() );
|
||||
fv.clear();
|
||||
|
||||
function0<void> fv2;
|
||||
fv.assign(&do_nothing, std::allocator<int>() );
|
||||
fv2.assign(fv, std::allocator<int>() );
|
||||
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -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 COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
|
||||
@ -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 );
|
||||
}
|
||||
@ -1,49 +0,0 @@
|
||||
# Copyright 2018, 2019 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
project(cmake_subdir_test LANGUAGES CXX)
|
||||
|
||||
add_subdirectory(../.. boostorg/function)
|
||||
|
||||
# boost_add_subdir
|
||||
|
||||
function(boost_add_subdir name)
|
||||
|
||||
add_subdirectory(../../../${name} boostorg/${name})
|
||||
|
||||
endfunction()
|
||||
|
||||
# primary dependencies
|
||||
|
||||
boost_add_subdir(assert)
|
||||
boost_add_subdir(bind)
|
||||
boost_add_subdir(config)
|
||||
boost_add_subdir(core)
|
||||
boost_add_subdir(integer)
|
||||
boost_add_subdir(preprocessor)
|
||||
boost_add_subdir(throw_exception)
|
||||
boost_add_subdir(type_index)
|
||||
boost_add_subdir(type_traits)
|
||||
boost_add_subdir(typeof)
|
||||
|
||||
# secondary dependencies
|
||||
|
||||
boost_add_subdir(static_assert)
|
||||
boost_add_subdir(container_hash)
|
||||
boost_add_subdir(smart_ptr)
|
||||
boost_add_subdir(detail)
|
||||
boost_add_subdir(move)
|
||||
boost_add_subdir(predef)
|
||||
|
||||
# --target check
|
||||
|
||||
add_executable(quick ../quick.cpp)
|
||||
target_link_libraries(quick Boost::function Boost::core)
|
||||
|
||||
enable_testing()
|
||||
add_test(quick quick)
|
||||
|
||||
add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
|
||||
@ -9,7 +9,7 @@
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
static int forty_two()
|
||||
{
|
||||
|
||||
@ -5,12 +5,10 @@
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
#define BOOST_CHECK BOOST_TEST
|
||||
|
||||
static int forty_two() { return 42; }
|
||||
|
||||
struct Seventeen
|
||||
@ -90,15 +88,6 @@ static void target_test()
|
||||
BOOST_CHECK(!f.target<int (*)()>());
|
||||
BOOST_CHECK(f.target<Seventeen>());
|
||||
BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);
|
||||
|
||||
const Seventeen const_seventeen = this_seventeen;
|
||||
f = boost::ref(const_seventeen);
|
||||
BOOST_CHECK(!f.target<int (*)()>());
|
||||
BOOST_CHECK(f.target<const Seventeen>());
|
||||
BOOST_CHECK(f.target<const Seventeen>() == &const_seventeen);
|
||||
BOOST_CHECK(f.target<const volatile Seventeen>());
|
||||
BOOST_CHECK(!f.target<Seventeen>());
|
||||
BOOST_CHECK(!f.target<volatile Seventeen>());
|
||||
}
|
||||
|
||||
static void equal_test()
|
||||
@ -227,11 +216,11 @@ static void ref_equal_test()
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
target_test();
|
||||
equal_test();
|
||||
ref_equal_test();
|
||||
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,35 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
// Make sure we don't try to redefine function2
|
||||
#include <boost/function/function2.hpp>
|
||||
|
||||
// Define all Boost.Function class templates up to 30 arguments
|
||||
#define BOOST_FUNCTION_MAX_ARGS 20
|
||||
#include <boost/function.hpp>
|
||||
#undef BOOST_FUNCTION_MAX_ARGS
|
||||
#define BOOST_FUNCTION_MAX_ARGS 40
|
||||
#include <boost/function.hpp>
|
||||
#undef BOOST_FUNCTION_MAX_ARGS
|
||||
#define BOOST_FUNCTION_MAX_ARGS 25
|
||||
#include <boost/function.hpp>
|
||||
#undef BOOST_FUNCTION_MAX_ARGS
|
||||
#define BOOST_FUNCTION_MAX_ARGS 30
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function0<float> f0;
|
||||
|
||||
boost::function30<float, int, int, int, int, int, int, int, int, int, int,
|
||||
int, int, int, int, int, int, int, int, int, int,
|
||||
int, int, int, int, int, int, int, int, int, int> f30;
|
||||
return 0;
|
||||
}
|
||||
@ -7,20 +7,12 @@
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#if defined(__clang__) && defined(__has_warning)
|
||||
# if __has_warning( "-Wself-assign-overloaded" )
|
||||
# pragma clang diagnostic ignored "-Wself-assign-overloaded"
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <functional>
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
|
||||
#define BOOST_CHECK BOOST_TEST
|
||||
|
||||
using namespace boost;
|
||||
using std::string;
|
||||
using std::negate;
|
||||
@ -639,60 +631,12 @@ test_ref()
|
||||
boost::function2<int, int, int> f(ref(atc));
|
||||
BOOST_CHECK(f(1, 3) == 4);
|
||||
}
|
||||
catch(std::runtime_error const&) {
|
||||
catch(std::runtime_error e) {
|
||||
BOOST_ERROR("Nonthrowing constructor threw an exception");
|
||||
}
|
||||
}
|
||||
|
||||
static unsigned construction_count = 0;
|
||||
static unsigned destruction_count = 0;
|
||||
|
||||
struct MySmallFunctor {
|
||||
MySmallFunctor() { ++construction_count; }
|
||||
MySmallFunctor(const MySmallFunctor &) { ++construction_count; }
|
||||
~MySmallFunctor() { ++destruction_count; }
|
||||
int operator()() { return 0; }
|
||||
};
|
||||
|
||||
struct MyLargeFunctor {
|
||||
MyLargeFunctor() { ++construction_count; }
|
||||
MyLargeFunctor(const MyLargeFunctor &) { ++construction_count; }
|
||||
~MyLargeFunctor() { ++destruction_count; }
|
||||
int operator()() { return 0; }
|
||||
|
||||
float data[128];
|
||||
};
|
||||
|
||||
void test_construct_destroy_count()
|
||||
{
|
||||
{
|
||||
boost::function0<int> f;
|
||||
boost::function0<int> g;
|
||||
f = MySmallFunctor();
|
||||
g = MySmallFunctor();
|
||||
f.swap(g);
|
||||
}
|
||||
|
||||
// MySmallFunctor objects should be constructed as many times as
|
||||
// they are destroyed.
|
||||
BOOST_CHECK(construction_count == destruction_count);
|
||||
|
||||
construction_count = 0;
|
||||
destruction_count = 0;
|
||||
{
|
||||
boost::function0<int> f;
|
||||
boost::function0<int> g;
|
||||
f = MyLargeFunctor();
|
||||
g = MyLargeFunctor();
|
||||
f.swap(g);
|
||||
}
|
||||
|
||||
// MyLargeFunctor objects should be constructed as many times as
|
||||
// they are destroyed.
|
||||
BOOST_CHECK(construction_count == destruction_count);
|
||||
}
|
||||
|
||||
int main()
|
||||
int test_main(int, char* [])
|
||||
{
|
||||
test_zero_args();
|
||||
test_one_arg();
|
||||
@ -700,6 +644,5 @@ int main()
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
test_construct_destroy_count();
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -7,22 +7,14 @@
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#if defined(__clang__) && defined(__has_warning)
|
||||
# if __has_warning( "-Wself-assign-overloaded" )
|
||||
# pragma clang diagnostic ignored "-Wself-assign-overloaded"
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <functional>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
|
||||
#define BOOST_CHECK BOOST_TEST
|
||||
|
||||
using boost::function;
|
||||
using std::string;
|
||||
using namespace boost;
|
||||
using namespace std;
|
||||
|
||||
int global_int;
|
||||
|
||||
@ -533,7 +525,7 @@ test_zero_args()
|
||||
static void
|
||||
test_one_arg()
|
||||
{
|
||||
std::negate<int> neg;
|
||||
negate<int> neg;
|
||||
|
||||
function<int (int)> f1(neg);
|
||||
BOOST_CHECK(f1(5) == -5);
|
||||
@ -615,12 +607,12 @@ struct add_with_throw_on_copy {
|
||||
|
||||
add_with_throw_on_copy(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw std::runtime_error("But this CAN'T throw");
|
||||
throw runtime_error("But this CAN'T throw");
|
||||
}
|
||||
|
||||
add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
|
||||
{
|
||||
throw std::runtime_error("But this CAN'T throw");
|
||||
throw runtime_error("But this CAN'T throw");
|
||||
}
|
||||
};
|
||||
|
||||
@ -629,51 +621,14 @@ test_ref()
|
||||
{
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function<int (int, int)> f(boost::ref(atc));
|
||||
boost::function<int (int, int)> f(ref(atc));
|
||||
BOOST_CHECK(f(1, 3) == 4);
|
||||
}
|
||||
catch(std::runtime_error const&) {
|
||||
catch(runtime_error e) {
|
||||
BOOST_ERROR("Nonthrowing constructor threw an exception");
|
||||
}
|
||||
}
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_GCC, >= 70000 && BOOST_GCC < 80000) && __cplusplus >= 201700
|
||||
|
||||
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81311
|
||||
#pragma message("Skipping test_empty_ref on g++ 7 -std=c++17")
|
||||
|
||||
static void test_empty_ref()
|
||||
{
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static void dummy() {}
|
||||
|
||||
static void test_empty_ref()
|
||||
{
|
||||
boost::function<void()> f1;
|
||||
boost::function<void()> f2(boost::ref(f1));
|
||||
|
||||
try {
|
||||
f2();
|
||||
BOOST_ERROR("Exception didn't throw for reference to empty function.");
|
||||
}
|
||||
catch(std::runtime_error const&) {}
|
||||
|
||||
f1 = dummy;
|
||||
|
||||
try {
|
||||
f2();
|
||||
}
|
||||
catch(std::runtime_error const&) {
|
||||
BOOST_ERROR("Error calling referenced function.");
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
static void test_exception()
|
||||
{
|
||||
boost::function<int (int, int)> f;
|
||||
@ -681,7 +636,7 @@ static void test_exception()
|
||||
f(5, 4);
|
||||
BOOST_CHECK(false);
|
||||
}
|
||||
catch(boost::bad_function_call const&) {
|
||||
catch(boost::bad_function_call) {
|
||||
// okay
|
||||
}
|
||||
}
|
||||
@ -711,96 +666,7 @@ static void test_call()
|
||||
test_call_cref(std::plus<int>());
|
||||
}
|
||||
|
||||
struct big_aggregating_structure {
|
||||
int disable_small_objects_optimizations[32];
|
||||
|
||||
big_aggregating_structure()
|
||||
{
|
||||
++ global_int;
|
||||
}
|
||||
|
||||
big_aggregating_structure(const big_aggregating_structure&)
|
||||
{
|
||||
++ global_int;
|
||||
}
|
||||
|
||||
~big_aggregating_structure()
|
||||
{
|
||||
-- global_int;
|
||||
}
|
||||
|
||||
void operator()()
|
||||
{
|
||||
++ global_int;
|
||||
}
|
||||
|
||||
void operator()(int)
|
||||
{
|
||||
++ global_int;
|
||||
}
|
||||
};
|
||||
|
||||
template <class FunctionT>
|
||||
static void test_move_semantics()
|
||||
{
|
||||
typedef FunctionT f1_type;
|
||||
|
||||
big_aggregating_structure obj;
|
||||
|
||||
f1_type f1 = obj;
|
||||
global_int = 0;
|
||||
f1();
|
||||
|
||||
BOOST_CHECK(!f1.empty());
|
||||
BOOST_CHECK(global_int == 1);
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
// Testing rvalue constructors
|
||||
f1_type f2(static_cast<f1_type&&>(f1));
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_CHECK(!f2.empty());
|
||||
BOOST_CHECK(global_int == 1);
|
||||
f2();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
|
||||
f1_type f3(static_cast<f1_type&&>(f2));
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_CHECK(f2.empty());
|
||||
BOOST_CHECK(!f3.empty());
|
||||
BOOST_CHECK(global_int == 2);
|
||||
f3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Testing move assignment
|
||||
f1_type f4;
|
||||
BOOST_CHECK(f4.empty());
|
||||
f4 = static_cast<f1_type&&>(f3);
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_CHECK(f2.empty());
|
||||
BOOST_CHECK(f3.empty());
|
||||
BOOST_CHECK(!f4.empty());
|
||||
BOOST_CHECK(global_int == 3);
|
||||
f4();
|
||||
BOOST_CHECK(global_int == 4);
|
||||
|
||||
// Testing self move assignment
|
||||
f4 = static_cast<f1_type&&>(f4);
|
||||
BOOST_CHECK(!f4.empty());
|
||||
BOOST_CHECK(global_int == 4);
|
||||
|
||||
// Testing, that no memory leaked when assigning to nonempty function
|
||||
f4 = obj;
|
||||
BOOST_CHECK(!f4.empty());
|
||||
BOOST_CHECK(global_int == 4);
|
||||
f1_type f5 = obj;
|
||||
BOOST_CHECK(global_int == 5);
|
||||
f4 = static_cast<f1_type&&>(f5);
|
||||
BOOST_CHECK(global_int == 4);
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
int main()
|
||||
int test_main(int, char* [])
|
||||
{
|
||||
test_zero_args();
|
||||
test_one_arg();
|
||||
@ -808,12 +674,9 @@ int main()
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
test_empty_ref();
|
||||
test_exception();
|
||||
test_implicit();
|
||||
test_call();
|
||||
test_move_semantics<function<void()> >();
|
||||
test_move_semantics<boost::function0<void> >();
|
||||
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -7,12 +7,22 @@
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
void test()
|
||||
{
|
||||
boost::function0<int> f1;
|
||||
boost::function0<int> f2;
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
@ -7,12 +7,21 @@
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
static int bad_fn(float f) { return static_cast<int>(f); }
|
||||
|
||||
void test()
|
||||
int
|
||||
test_main(int, char*[])
|
||||
{
|
||||
boost::function0<int> f1;
|
||||
f1 = bad_fn;
|
||||
function0<int> f1;
|
||||
f1 = bad_fn;
|
||||
|
||||
BOOST_ERROR("This should not have compiled.");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,18 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2008. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
#include <boost/function/function_typeof.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/typeof/typeof.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
void f(boost::function0<void> f, boost::function0<void> g)
|
||||
{
|
||||
BOOST_STATIC_ASSERT((boost::is_same<boost::function0<void>, BOOST_TYPEOF(f = g)>::value));
|
||||
}
|
||||
@ -7,34 +7,32 @@
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/lambda/lambda.hpp>
|
||||
#include <boost/lambda/bind.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/lambda/lambda.hpp>
|
||||
#include <boost/lambda/bind.hpp>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
using namespace boost::lambda;
|
||||
|
||||
static unsigned
|
||||
func_impl(int arg1, bool arg2, double arg3)
|
||||
{
|
||||
using namespace std;
|
||||
return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
|
||||
}
|
||||
|
||||
int main()
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
using boost::function;
|
||||
using namespace boost::lambda;
|
||||
|
||||
function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
|
||||
BOOST_TEST_EQ( f1(true, 2.0), 30 );
|
||||
function <unsigned(double)> f2 = bind(f1, false, _1);
|
||||
function <unsigned()> f3 = bind(f2, 4.0);
|
||||
|
||||
function <unsigned(double)> f2 = boost::lambda::bind(f1, false, _1);
|
||||
BOOST_TEST_EQ( f2(2.0), 60 );
|
||||
f3();
|
||||
|
||||
function <unsigned()> f3 = boost::lambda::bind(f2, 4.0);
|
||||
BOOST_TEST_EQ( f3(), 120 );
|
||||
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -10,36 +10,22 @@
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
|
||||
struct Y {
|
||||
Y(int y = 0) : y_(y) {}
|
||||
bool operator==(const Y& rhs) const { return y_ == rhs.y_; }
|
||||
private:
|
||||
int y_;
|
||||
};
|
||||
|
||||
struct X {
|
||||
int foo(int);
|
||||
Y& foo2(Y&) const;
|
||||
};
|
||||
int X::foo(int x) { return -x; }
|
||||
Y& X::foo2(Y& x) const { return x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function<int (X*, int)> f;
|
||||
boost::function<Y& (X*, Y&)> f2;
|
||||
Y y1;
|
||||
|
||||
f = &X::foo;
|
||||
f2 = &X::foo2;
|
||||
|
||||
X x;
|
||||
BOOST_TEST(f(&x, 5) == -5);
|
||||
BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
|
||||
f = &X::foo;
|
||||
|
||||
X x;
|
||||
f(&x, 5);
|
||||
|
||||
return ::boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -10,36 +10,22 @@
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
|
||||
struct Y {
|
||||
Y(int y = 0) : y_(y) {}
|
||||
bool operator==(const Y& rhs) const { return y_ == rhs.y_; }
|
||||
private:
|
||||
int y_;
|
||||
};
|
||||
|
||||
struct X {
|
||||
int foo(int);
|
||||
Y& foo2(Y&) const;
|
||||
};
|
||||
int X::foo(int x) { return -x; }
|
||||
Y& X::foo2(Y& x) const { return x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function2<int, X*, int> f;
|
||||
boost::function2<Y&, X*, Y&> f2;
|
||||
Y y1;
|
||||
|
||||
f = &X::foo;
|
||||
f2 = &X::foo2;
|
||||
|
||||
X x;
|
||||
BOOST_TEST(f(&x, 5) == -5);
|
||||
BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
|
||||
f = &X::foo;
|
||||
|
||||
X x;
|
||||
f(&x, 5);
|
||||
|
||||
return ::boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -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 );
|
||||
}
|
||||
@ -1,62 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2008. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#define BOOST_CHECK BOOST_TEST
|
||||
|
||||
struct tried_to_copy { };
|
||||
|
||||
struct MaybeThrowOnCopy {
|
||||
MaybeThrowOnCopy(int value = 0) : value(value) { }
|
||||
|
||||
MaybeThrowOnCopy(const MaybeThrowOnCopy& other) : value(other.value) {
|
||||
if (throwOnCopy)
|
||||
throw tried_to_copy();
|
||||
}
|
||||
|
||||
MaybeThrowOnCopy& operator=(const MaybeThrowOnCopy& other) {
|
||||
if (throwOnCopy)
|
||||
throw tried_to_copy();
|
||||
value = other.value;
|
||||
return *this;
|
||||
}
|
||||
|
||||
int operator()() { return value; }
|
||||
|
||||
int value;
|
||||
|
||||
// Make sure that this function object doesn't trigger the
|
||||
// small-object optimization in Function.
|
||||
float padding[100];
|
||||
|
||||
static bool throwOnCopy;
|
||||
};
|
||||
|
||||
bool MaybeThrowOnCopy::throwOnCopy = false;
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function0<int> f;
|
||||
boost::function0<int> g;
|
||||
|
||||
MaybeThrowOnCopy::throwOnCopy = false;
|
||||
f = MaybeThrowOnCopy(1);
|
||||
g = MaybeThrowOnCopy(2);
|
||||
BOOST_CHECK(f() == 1);
|
||||
BOOST_CHECK(g() == 2);
|
||||
|
||||
MaybeThrowOnCopy::throwOnCopy = true;
|
||||
f.swap(g);
|
||||
BOOST_CHECK(f() == 2);
|
||||
BOOST_CHECK(g() == 1);
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -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();
|
||||
}
|
||||
@ -1,40 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright 2016 Peter Dimov
|
||||
|
||||
// Use, modification and distribution is subject to
|
||||
// the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/core/is_same.hpp>
|
||||
#include <boost/core/lightweight_test_trait.hpp>
|
||||
|
||||
struct X
|
||||
{
|
||||
};
|
||||
|
||||
struct Y
|
||||
{
|
||||
};
|
||||
|
||||
struct Z
|
||||
{
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
typedef boost::function<X(Y)> F1;
|
||||
|
||||
BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F1::result_type, X> ));
|
||||
BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F1::argument_type, Y> ));
|
||||
|
||||
typedef boost::function<X(Y, Z)> F2;
|
||||
|
||||
BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F2::result_type, X> ));
|
||||
BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F2::first_argument_type, Y> ));
|
||||
BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<F2::second_argument_type, Z> ));
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
@ -1,107 +0,0 @@
|
||||
// Copyright 2014 Antony Polukhin.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/move/move.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
|
||||
#define BOOST_CHECK BOOST_TEST
|
||||
|
||||
class only_movable {
|
||||
private:
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(only_movable)
|
||||
int value_;
|
||||
bool moved_;
|
||||
|
||||
public:
|
||||
only_movable(BOOST_RV_REF(only_movable) x)
|
||||
: value_(x.value_)
|
||||
, moved_(false)
|
||||
{
|
||||
x.moved_ = true;
|
||||
}
|
||||
|
||||
only_movable& operator=(BOOST_RV_REF(only_movable) x) {
|
||||
value_ = x.value_;
|
||||
x.moved_ = true;
|
||||
moved_ = false;
|
||||
return *this;
|
||||
}
|
||||
|
||||
explicit only_movable(int value = 0) : value_(value), moved_(false) {}
|
||||
int get_value() const { return value_; }
|
||||
bool is_moved() const { return moved_; }
|
||||
};
|
||||
|
||||
|
||||
int one(BOOST_RV_REF(only_movable) v) { return v.get_value(); }
|
||||
only_movable two(BOOST_RV_REF(only_movable) t) {
|
||||
only_movable t1 = boost::move(t);
|
||||
return BOOST_MOVE_RET(only_movable, t1);
|
||||
}
|
||||
|
||||
only_movable two_sum(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) {
|
||||
only_movable ret(t1.get_value() + t2.get_value());
|
||||
return BOOST_MOVE_RET(only_movable, ret);
|
||||
}
|
||||
|
||||
struct sum_struct {
|
||||
only_movable operator()(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) const {
|
||||
only_movable ret(t1.get_value() + t2.get_value());
|
||||
return BOOST_MOVE_RET(only_movable, ret);
|
||||
}
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
int three(std::string&&) { return 1; }
|
||||
std::string&& four(std::string&& s) { return boost::move(s); }
|
||||
#endif
|
||||
|
||||
int main()
|
||||
{
|
||||
using boost::function;
|
||||
|
||||
function <int(BOOST_RV_REF(only_movable))> f1 = one;
|
||||
|
||||
only_movable om1(1);
|
||||
BOOST_CHECK(f1(boost::move(om1)) == 1);
|
||||
|
||||
function <only_movable(BOOST_RV_REF(only_movable))> f2 = two;
|
||||
|
||||
only_movable om2(2);
|
||||
only_movable om2_2 = f2(boost::move(om2));
|
||||
BOOST_CHECK(om2_2.get_value() == 2);
|
||||
BOOST_CHECK(om2.is_moved());
|
||||
|
||||
{
|
||||
function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))> f2_sum = two_sum;
|
||||
only_movable om1_sum(1), om2_sum(2);
|
||||
only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
|
||||
BOOST_CHECK(om2_sum_2.get_value() == 3);
|
||||
}
|
||||
|
||||
{
|
||||
sum_struct s;
|
||||
function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))> f2_sum = s;
|
||||
only_movable om1_sum(1), om2_sum(2);
|
||||
only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
|
||||
BOOST_CHECK(om2_sum_2.get_value() == 3);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
function <int(std::string&&)> f3 = three;
|
||||
function <std::string&& (std::string&& s)> f4 = four;
|
||||
|
||||
f3(std::string("Hello"));
|
||||
BOOST_CHECK(f4(std::string("world")) == "world");
|
||||
#endif
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -7,18 +7,16 @@
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <stdexcept>
|
||||
#include <new>
|
||||
|
||||
struct stateless_integer_add {
|
||||
int operator()(int x, int y) const { return x+y; }
|
||||
|
||||
void* operator new(std::size_t n)
|
||||
void* operator new(std::size_t)
|
||||
{
|
||||
BOOST_ERROR( "stateless_integer_add incorrectly allocated" );
|
||||
return ::operator new( n );
|
||||
throw std::runtime_error("Cannot allocate a stateless_integer_add");
|
||||
}
|
||||
|
||||
void* operator new(std::size_t, void* p)
|
||||
@ -26,17 +24,15 @@ struct stateless_integer_add {
|
||||
return p;
|
||||
}
|
||||
|
||||
void operator delete(void* p) throw()
|
||||
void operator delete(void*) throw()
|
||||
{
|
||||
BOOST_ERROR( "stateless_integer_add incorrectly deallocated" );
|
||||
return ::operator delete( p );
|
||||
}
|
||||
};
|
||||
|
||||
int main()
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
boost::function2<int, int, int> f;
|
||||
f = stateless_integer_add();
|
||||
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -8,12 +8,7 @@
|
||||
|
||||
// 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
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
@ -25,12 +20,11 @@ int X::foo(int x) { return -x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
#ifndef BOOST_NO_CXX98_BINDERS
|
||||
boost::function<int (int)> f;
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -8,12 +8,7 @@
|
||||
|
||||
// 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
|
||||
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
@ -25,12 +20,11 @@ int X::foo(int x) { return -x; }
|
||||
|
||||
int main()
|
||||
{
|
||||
#ifndef BOOST_NO_CXX98_BINDERS
|
||||
boost::function1<int, int> f;
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -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();
|
||||
}
|
||||
@ -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();
|
||||
}
|
||||
@ -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();
|
||||
}
|
||||
@ -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();
|
||||
}
|
||||
Reference in New Issue
Block a user