mirror of
https://github.com/boostorg/function.git
synced 2025-06-26 04:21:38 +02:00
Compare commits
2 Commits
feature/fu
...
boost-1.31
| Author | SHA1 | Date | |
|---|---|---|---|
| 6b6fbcb5c6 | |||
| 8623578cc7 |
301
.travis.yml
301
.travis.yml
@ -1,301 +0,0 @@
|
||||
# Copyright 2016, 2017, 2018 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
|
||||
language: cpp
|
||||
|
||||
sudo: false
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- develop
|
||||
- /feature\/.*/
|
||||
|
||||
env:
|
||||
matrix:
|
||||
- BOGUS_JOB=true
|
||||
|
||||
matrix:
|
||||
|
||||
exclude:
|
||||
- env: BOGUS_JOB=true
|
||||
|
||||
include:
|
||||
- os: linux
|
||||
compiler: g++
|
||||
env: TOOLSET=gcc CXXSTD=03,11 VARIANT=debug,release
|
||||
|
||||
- os: linux
|
||||
compiler: g++-4.4
|
||||
env: TOOLSET=gcc CXXSTD=98,0x
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.4
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-4.6
|
||||
env: TOOLSET=gcc CXXSTD=03,0x
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-4.7
|
||||
env: TOOLSET=gcc CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-4.8
|
||||
env: TOOLSET=gcc CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- os: linux
|
||||
compiler: g++-4.9
|
||||
env: TOOLSET=gcc CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-5
|
||||
env: TOOLSET=gcc CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-5
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-6
|
||||
env: TOOLSET=gcc CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-7
|
||||
env: TOOLSET=gcc CXXSTD=03,11,14,17 VARIANT=release
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-8
|
||||
env: TOOLSET=gcc CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-7
|
||||
env: UBSAN=1 TOOLSET=gcc CXXSTD=03,11,14,17 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: clang++
|
||||
env: TOOLSET=clang CXXSTD=03,11 VARIANT=debug,release
|
||||
|
||||
- os: linux
|
||||
compiler: /usr/bin/clang++
|
||||
env: TOOLSET=clang CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.3
|
||||
|
||||
- os: linux
|
||||
compiler: /usr/bin/clang++
|
||||
env: TOOLSET=clang CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.4
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.5
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.5
|
||||
- libstdc++-4.9-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.5
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.6
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.6
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.7
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.7
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.8
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.8
|
||||
- libstdc++-4.9-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.8
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.9
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.9
|
||||
- libstdc++-4.9-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.9
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-4.0
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-4.0
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-trusty-4.0
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-5.0
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z VARIANT=release
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-5.0
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-trusty-5.0
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-6.0
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-6.0
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-trusty-6.0
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-7
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-trusty-7
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-5.0
|
||||
env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-5.0
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-trusty-5.0
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-libc++
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z VARIANT=release
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- libc++-dev
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-libc++
|
||||
env: UBSAN=1 TOOLSET=clang CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- libc++-dev
|
||||
|
||||
- os: osx
|
||||
compiler: clang++
|
||||
env: TOOLSET=clang CXXSTD=03,11,14,1z
|
||||
|
||||
install:
|
||||
- BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
|
||||
- cd ..
|
||||
- git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
|
||||
- cd boost-root
|
||||
- git submodule update --init tools/build
|
||||
- git submodule update --init libs/config
|
||||
- git submodule update --init tools/boostdep
|
||||
- cp -r $TRAVIS_BUILD_DIR/* libs/function
|
||||
- python tools/boostdep/depinst/depinst.py function
|
||||
- ./bootstrap.sh
|
||||
- ./b2 headers
|
||||
|
||||
script:
|
||||
- |-
|
||||
echo "using $TOOLSET : : $TRAVIS_COMPILER ;" > ~/user-config.jam
|
||||
- ./b2 -j3 libs/function/test toolset=$TOOLSET cxxstd=$CXXSTD ${VARIANT:+variant=$VARIANT} ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
|
||||
|
||||
notifications:
|
||||
email:
|
||||
on_success: always
|
||||
11
Jamfile
11
Jamfile
@ -1,11 +0,0 @@
|
||||
# Boost.Function Library Jamfile
|
||||
#
|
||||
# Copyright (c) 2018 James E. King III
|
||||
#
|
||||
# Use, modification, and distribution are subject to the
|
||||
# Boost Software License, Version 1.0. (See accompanying file
|
||||
# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
# please order by name to ease maintenance
|
||||
build-project example ;
|
||||
build-project test ;
|
||||
23
LICENSE
23
LICENSE
@ -1,23 +0,0 @@
|
||||
Boost Software License - Version 1.0 - August 17th, 2003
|
||||
|
||||
Permission is hereby granted, free of charge, to any person or organization
|
||||
obtaining a copy of the software and accompanying documentation covered by
|
||||
this license (the "Software") to use, reproduce, display, distribute,
|
||||
execute, and transmit the Software, and to prepare derivative works of the
|
||||
Software, and to permit third-parties to whom the Software is furnished to
|
||||
do so, all subject to the following:
|
||||
|
||||
The copyright notices in the Software and this entire statement, including
|
||||
the above license grant, this restriction and the following disclaimer,
|
||||
must be included in all copies of the Software, in whole or in part, and
|
||||
all derivative works of the Software, unless such copies or derivative
|
||||
works are solely in the form of machine-executable object code generated by
|
||||
a source language processor.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
|
||||
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
|
||||
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
|
||||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
DEALINGS IN THE SOFTWARE.
|
||||
34
README.md
34
README.md
@ -1,34 +0,0 @@
|
||||
Function, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), contains a family of class templates that are function object wrappers.
|
||||
|
||||
### License
|
||||
|
||||
Distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
|
||||
|
||||
### Properties
|
||||
|
||||
* C++03
|
||||
* Header-Only
|
||||
|
||||
### Build Status
|
||||
|
||||
Branch | Travis | Appveyor | Coverity Scan | codecov.io | Deps | Docs | Tests |
|
||||
:-------------: | ------ | -------- | ------------- | ---------- | ---- | ---- | ----- |
|
||||
[`master`](https://github.com/boostorg/function/tree/master) | [](https://travis-ci.org/boostorg/function) | [](https://ci.appveyor.com/project/jeking3/function-d036y/branch/master) | [](https://scan.coverity.com/projects/boostorg-function) | [](https://codecov.io/gh/boostorg/function/branch/master)| [](https://pdimov.github.io/boostdep-report/master/function.html) | [](http://www.boost.org/doc/libs/master/doc/html/function.html) | [](http://www.boost.org/development/tests/master/developer/function.html)
|
||||
[`develop`](https://github.com/boostorg/function/tree/develop) | [](https://travis-ci.org/boostorg/function) | [](https://ci.appveyor.com/project/jeking3/function-d036y/branch/develop) | [](https://scan.coverity.com/projects/boostorg-function) | [](https://codecov.io/gh/boostorg/function/branch/develop) | [](https://pdimov.github.io/boostdep-report/develop/function.html) | [](http://www.boost.org/doc/libs/develop/doc/html/function.html) | [](http://www.boost.org/development/tests/develop/developer/function.html)
|
||||
|
||||
### Directories
|
||||
|
||||
| Name | Purpose |
|
||||
| ----------- | ------------------------------ |
|
||||
| `doc` | documentation |
|
||||
| `example` | examples |
|
||||
| `include` | headers |
|
||||
| `test` | unit tests |
|
||||
|
||||
### More information
|
||||
|
||||
* [Ask questions](http://stackoverflow.com/questions/ask?tags=c%2B%2B,boost,boost-function)
|
||||
* [Report bugs](https://github.com/boostorg/function/issues): Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
|
||||
* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
|
||||
* Discussions about the library are held on the [Boost developers mailing list](http://www.boost.org/community/groups.html#main). Be sure to read the [discussion policy](http://www.boost.org/community/policy.html) before posting and add the `[function]` tag at the beginning of the subject line.
|
||||
|
||||
126
appveyor.yml
126
appveyor.yml
@ -1,126 +0,0 @@
|
||||
# Copyright 2016, 2017 Peter Dimov
|
||||
# Copyright (C) 2017, 2018 James E. King III
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#
|
||||
# Generic Appveyor build script for boostorg repositories
|
||||
# See: https://github.com/jeking3/boost-ci/
|
||||
#
|
||||
# Instructions for customizing this script for your library:
|
||||
#
|
||||
# 1. Customize the compilers and language levels you want.
|
||||
# 2. If you have move than include/, src/, test/, example/, examples/,
|
||||
# benchmark/ or tools/ directories, set the environment variable DEPINST.
|
||||
# For example if your build uses code in "bench/" and "fog/" directories:
|
||||
# - DEPINST: --include bench --include fog
|
||||
# 3. Enable pull request builds in your boostorg/<library> account.
|
||||
#
|
||||
# That's it - the script will do everything else for you.
|
||||
#
|
||||
|
||||
version: 1.0.{build}-{branch}
|
||||
|
||||
shallow_clone: true
|
||||
|
||||
branches:
|
||||
only:
|
||||
- develop
|
||||
- master
|
||||
|
||||
matrix:
|
||||
# Adding MAYFAIL to any matrix job allows it to fail but the build stays green:
|
||||
allow_failures:
|
||||
- MAYFAIL: true
|
||||
|
||||
environment:
|
||||
global:
|
||||
# see: http://www.boost.org/build/doc/html/bbv2/overview/invocation.html#bbv2.overview.invocation.properties
|
||||
# to use the default for a given environment, comment it out; recommend you build debug and release however:
|
||||
# on Windows it is important to exercise all the possibilities, especially shared vs static, however most
|
||||
# libraries that care about this exercise it in their Jamfiles...
|
||||
# B2_ADDRESS_MODEL: address-model=64,32
|
||||
# B2_LINK: link=shared,static
|
||||
# B2_THREADING: threading=multi,single
|
||||
B2_VARIANT: variant=release,debug
|
||||
|
||||
matrix:
|
||||
- FLAVOR: Visual Studio 2017 C++2a Strict
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
TOOLSET: msvc-14.1
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
CXXFLAGS: cxxflags=-permissive-
|
||||
CXXSTD: latest # 2a
|
||||
|
||||
- FLAVOR: Visual Studio 2017 C++17
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
TOOLSET: msvc-14.1
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
CXXSTD: 17
|
||||
|
||||
- FLAVOR: Visual Studio 2017 C++14 (Default)
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
TOOLSET: msvc-14.1
|
||||
B2_ADDRESS_MODEL: address-model=64,32
|
||||
|
||||
- FLAVOR: Visual Studio 2015 C++14 (Default)
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
TOOLSET: msvc-14.0
|
||||
B2_ADDRESS_MODEL: address-model=64,32
|
||||
|
||||
- FLAVOR: Visual Studio 2010, 2012, 2013
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
|
||||
TOOLSET: msvc-10.0,msvc-11.0,msvc-12.0
|
||||
|
||||
- FLAVOR: cygwin (32-bit)
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
ADDPATH: C:\cygwin\bin;
|
||||
B2_ADDRESS_MODEL: address-model=32
|
||||
CXXSTD: 03,11
|
||||
# https://github.com/boostorg/test/issues/144
|
||||
DEFINES: define=_POSIX_C_SOURCE=200112L
|
||||
THREADING: threadapi=pthread
|
||||
TOOLSET: gcc
|
||||
|
||||
- FLAVOR: cygwin (64-bit)
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
ADDPATH: C:\cygwin64\bin;
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
CXXSTD: 11,17
|
||||
# https://github.com/boostorg/test/issues/144
|
||||
DEFINES: define=_POSIX_C_SOURCE=200112L define=__USE_ISOC99
|
||||
THREADING: threadapi=pthread
|
||||
TOOLSET: gcc
|
||||
|
||||
- FLAVOR: mingw32
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
ARCH: i686
|
||||
B2_ADDRESS_MODEL: address-model=32
|
||||
CXXSTD: 03,11
|
||||
SCRIPT: ci\appveyor\mingw.bat
|
||||
|
||||
- FLAVOR: mingw64
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
ARCH: x86_64
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
CXXSTD: 11,17
|
||||
DEFINES: define=__USE_ISOC99
|
||||
SCRIPT: ci\appveyor\mingw.bat
|
||||
|
||||
install:
|
||||
- set SELF=%APPVEYOR_PROJECT_NAME:-=_%
|
||||
- git clone https://github.com/jeking3/boost-ci.git C:\boost-ci
|
||||
- xcopy /s /e /q /i C:\boost-ci\ci .\ci
|
||||
- ci\appveyor\install.bat
|
||||
|
||||
build: off
|
||||
|
||||
test_script:
|
||||
- set SELF=%APPVEYOR_PROJECT_NAME:-=_%
|
||||
- PATH=%ADDPATH%%PATH%
|
||||
# The definition of TOOLCXX omits CXXSTD= if it was not defined above
|
||||
- IF NOT DEFINED CXXSTD (SET TOOLCXX=toolset=%TOOLSET%) ELSE (SET TOOLCXX=toolset=%TOOLSET% cxxstd=%CXXSTD%)
|
||||
# Echo the complete build command to the build log
|
||||
- IF NOT DEFINED SCRIPT (ECHO b2 libs/%SELF:\=/% %TOOLCXX% %CXXFLAGS% %DEFINES% %THREADING% %B2_ADDRESS_MODEL% %B2_LINK% %B2_THREADING% %B2_VARIANT% -j3)
|
||||
# Now go build...
|
||||
- IF DEFINED SCRIPT (call libs\%SELF%\%SCRIPT%) ELSE (b2 libs/%SELF:\=/% %TOOLCXX% %CXXFLAGS% %DEFINES% %THREADING% %B2_ADDRESS_MODEL% %B2_LINK% %B2_THREADING% %B2_VARIANT% -j3)
|
||||
@ -1,25 +1,5 @@
|
||||
# Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt)
|
||||
project function/doc ;
|
||||
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 ;
|
||||
|
||||
26
doc/faq.xml
26
doc/faq.xml
@ -1,11 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<section id="function.faq" last-revision="$Date$">
|
||||
@ -139,25 +132,6 @@ function objects with parameters that don't exactly match.</para>
|
||||
application a reference-counting allocator could be used.</para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
|
||||
<qandaentry>
|
||||
<question><para>How much overhead does a call through <code><classname>boost::function</classname></code> incur?</para></question>
|
||||
<answer>
|
||||
<para>The cost of <code>boost::function</code> can be reasonably
|
||||
consistently measured at around 20ns +/- 10 ns on a modern >2GHz
|
||||
platform versus directly inlining the code.</para>
|
||||
|
||||
<para>However, the performance of your application may benefit
|
||||
from or be disadvantaged by <code>boost::function</code>
|
||||
depending on how your C++ optimiser optimises. Similar to a
|
||||
standard function pointer, differences of order of 10% have been
|
||||
noted to the benefit or disadvantage of using
|
||||
<code>boost::function</code> to call a function that contains a
|
||||
tight loop depending on your compilation circumstances.</para>
|
||||
|
||||
<para>[Answer provided by Matt Hurd. See <ulink url="http://article.gmane.org/gmane.comp.lib.boost.devel/33278"/>]</para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
</qandaset>
|
||||
|
||||
</section>
|
||||
|
||||
@ -8,14 +8,13 @@
|
||||
<author>
|
||||
<firstname>Douglas</firstname>
|
||||
<surname>Gregor</surname>
|
||||
<email>dgregor -at- cs.indiana.edu</email>
|
||||
<email>gregod@cs.rpi.edu</email>
|
||||
</author>
|
||||
|
||||
<copyright>
|
||||
<year>2001</year>
|
||||
<year>2002</year>
|
||||
<year>2003</year>
|
||||
<year>2004</year>
|
||||
<holder>Douglas Gregor</holder>
|
||||
</copyright>
|
||||
|
||||
|
||||
@ -1,70 +1,11 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<section id="function.history" last-revision="$Date$">
|
||||
<title>History & Compatibility Notes</title>
|
||||
|
||||
<itemizedlist spacing="compact">
|
||||
|
||||
<listitem><para><bold>Version 1.52.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Move constructors and move assignment
|
||||
operators added (only for compilers with C++11 rvalue
|
||||
references support). Original patch
|
||||
contributed by Antony Polukhin.</para></listitem>
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.37.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Improved the performance of Boost.Function's
|
||||
swap() operation for large function objects. Original patch
|
||||
contributed by Niels Dekker.</para></listitem>
|
||||
|
||||
<listitem><para>Added a new header <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
|
||||
in the same way that is is provided in C++0x, based on C++
|
||||
committee
|
||||
proposal <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2308.html">N2308</ulink>. This
|
||||
change removes the <computeroutput>Allocator</computeroutput>
|
||||
template parameter of <classname>boost::function</classname> in
|
||||
favor of a constructor that takes an argument. While this is a
|
||||
backward-incompatible change, it is likely to affect only a few
|
||||
users. This change to Function was contributed by Emil
|
||||
Dotchevski, which also authored the corresponding C++ committee
|
||||
proposal.</para></listitem>
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.34.0</bold>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>Boost.Function now implements a small buffer optimization, which can drastically improve the performance when copying or construction Boost.Function objects storing small function objects. For instance, <code>bind(&X:foo, &x, _1, _2)</code> requires no heap allocation when placed into a Boost.Function object. Note that some exception-safety guarantees have changed: assignment provides the basic exception guarantee and <code>swap()</code> may throw.</para></listitem>
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.30.0</bold>: </para>
|
||||
<listitem><para><emphasis role="bold">Version 1.30.0</emphasis>: </para>
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para>All features deprecated in version 1.29.0 have
|
||||
been removed from Boost.Function.</para></listitem>
|
||||
@ -91,7 +32,7 @@
|
||||
</itemizedlist>
|
||||
</listitem>
|
||||
|
||||
<listitem><para><bold>Version 1.29.0</bold>:
|
||||
<listitem><para><emphasis role="bold">Version 1.29.0</emphasis>:
|
||||
Boost.Function has been partially redesigned to minimize the
|
||||
interface and make it cleaner. Several seldom- or never-used
|
||||
features of the older Boost.Function have been deprecated and will
|
||||
|
||||
13
doc/misc.xml
13
doc/misc.xml
@ -1,11 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<section id="function.misc" last-revision="$Date$">
|
||||
@ -24,7 +17,7 @@
|
||||
<para> And, of course, function pointers have several advantages over Boost.Function:
|
||||
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><para> Function pointers are smaller (the size of one pointer instead of four or more) </para></listitem>
|
||||
<listitem><para> Function pointers are smaller (the size of one pointer instead of three) </para></listitem>
|
||||
<listitem><para> Function pointers are faster (Boost.Function may require two calls through function pointers) </para></listitem>
|
||||
<listitem><para> Function pointers are backward-compatible with C libraries.</para></listitem>
|
||||
<listitem><para> More readable error messages. </para></listitem>
|
||||
@ -37,12 +30,12 @@
|
||||
|
||||
<section>
|
||||
<title>Function object wrapper size</title>
|
||||
<para> Function object wrappers will be the size of a struct containing a member function pointer and two data pointers. The actual size can vary significantly depending on the underlying platform; on 32-bit Mac OS X with GCC, this amounts to 16 bytes, while it is 32 bytes Windows with Visual C++. Additionally, the function object target may be allocated on the heap, if it cannot be placed into the small-object buffer in the <code>boost::function</code> object.</para>
|
||||
<para> Function object wrappers will be the size of two function pointers plus one function pointer or data pointer (whichever is larger). On common 32-bit platforms, this amounts to 12 bytes per wrapper. Additionally, the function object target will be allocated on the heap.</para>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>Copying efficiency</title>
|
||||
<para> Copying function object wrappers may require allocating memory for a copy of the function object target. The default allocator may be replaced with a faster custom allocator or one may choose to allow the function object wrappers to only store function object targets by reference (using <computeroutput>ref</computeroutput>) if the cost of this cloning becomes prohibitive. Small function objects can be stored within the <code>boost::function</code> object itself, improving copying efficiency.</para>
|
||||
<para> Copying function object wrappers may require allocating memory for a copy of the function object target. The default allocator may be replaced with a faster custom allocator or one may choose to allow the function object wrappers to only store function object targets by reference (using <computeroutput>ref</computeroutput>) if the cost of this cloning becomes prohibitive.</para>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
|
||||
@ -1,11 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
|
||||
@ -58,7 +51,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.
|
||||
@ -86,49 +79,7 @@
|
||||
<method-group name="capacity">
|
||||
<method name="empty" cv="const">
|
||||
<type>bool</type>
|
||||
<returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="target access">
|
||||
<overloaded-method name="target">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>Functor*</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>const Functor*</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>If <code>this</code> stores a target of type
|
||||
<code>Functor</code>, returns the address of the
|
||||
target. Otherwise, returns the NULL
|
||||
pointer.</simpara></returns>
|
||||
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<method name="contains" cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f">
|
||||
<paramtype>const Functor&</paramtype>
|
||||
</parameter>
|
||||
<returns><simpara><code>true</code> if <code>this-><methodname>target</methodname><Functor>()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this->target<Functor>()), f)</code></simpara></returns>
|
||||
|
||||
</method>
|
||||
|
||||
<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>true</code> if <code>this</code> has a target, and <code>false</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
@ -141,6 +92,9 @@
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator">
|
||||
<default><classname>std::allocator</classname><void></default>
|
||||
</template-type-parameter>
|
||||
</template>
|
||||
|
||||
<inherit access="public"><classname>function_base</classname></inherit>
|
||||
@ -157,6 +111,7 @@
|
||||
</description>
|
||||
|
||||
<typedef name="result_type"><type>R</type></typedef>
|
||||
<typedef name="allocator_type"><type>Allocator</type></typedef>
|
||||
<typedef name="argument_type">
|
||||
<type>T1</type><purpose>If N == 1</purpose>
|
||||
</typedef>
|
||||
@ -191,7 +146,7 @@
|
||||
</struct>
|
||||
|
||||
<constructor>
|
||||
<postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
@ -203,15 +158,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"/>
|
||||
@ -219,23 +165,11 @@
|
||||
<parameter name="f"><paramtype>F</paramtype></parameter>
|
||||
<requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-><methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
</template>
|
||||
<parameter name="f"><paramtype>F</paramtype></parameter>
|
||||
<parameter name="alloc"><paramtype>Allocator</paramtype></parameter>
|
||||
<requires><simpara>F is a function object Callable from <code>this</code>, Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw.</simpara></requires>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-><methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
|
||||
|
||||
<effects><simpara>If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory.</simpara></effects>
|
||||
<throws><simpara>Will not throw when <code>f</code> is a stateless function object.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<destructor>
|
||||
<effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
|
||||
<effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of this.</simpara></effects>
|
||||
|
||||
</destructor>
|
||||
|
||||
@ -243,16 +177,8 @@
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>functionN</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>
|
||||
<postconditions><simpara><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.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<method-group name="modifiers">
|
||||
@ -260,18 +186,20 @@
|
||||
<type>void</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname>&</paramtype></parameter>
|
||||
<effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="clear">
|
||||
<type>void</type>
|
||||
<postconditions><simpara>this-><methodname>empty</methodname>()</simpara></postconditions>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="capacity">
|
||||
<method name="empty" cv="const">
|
||||
<type>bool</type>
|
||||
<returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
|
||||
<returns><simpara><code>true</code> if <code>this</code> has a target, and <code>false</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
@ -288,49 +216,6 @@
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="target access">
|
||||
<overloaded-method name="target">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>Functor*</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>const Functor*</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>If <code>this</code> stores a target of type
|
||||
<code>Functor</code>, returns the address of the
|
||||
target. Otherwise, returns the NULL
|
||||
pointer.</simpara></returns>
|
||||
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<method name="contains" cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f">
|
||||
<paramtype>const Functor&</paramtype>
|
||||
</parameter>
|
||||
<returns><simpara><code>true</code> if <code>this-><methodname>target</methodname><Functor>()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this->target<Functor>()), f)</code></simpara></returns>
|
||||
|
||||
</method>
|
||||
|
||||
<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>.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
</method-group>
|
||||
|
||||
<method-group name="invocation">
|
||||
<method name="operator()" cv="const">
|
||||
<type>result_type</type>
|
||||
@ -340,7 +225,7 @@
|
||||
<parameter name="aN"><paramtype>argN_type</paramtype></parameter>
|
||||
<effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
|
||||
<returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>!this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
@ -351,204 +236,56 @@
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype><classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype><classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="f1"><paramtype><classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype><classname>functionN</classname><T1, T2, ..., TN, Allocator>&</paramtype></parameter>
|
||||
<effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</function>
|
||||
</free-function-group>
|
||||
|
||||
<free-function-group name="comparison operators">
|
||||
<overloaded-function name="operator==">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="U1"/>
|
||||
<template-type-parameter name="U2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="UN"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN>&</paramtype></parameter>
|
||||
</signature>
|
||||
<free-function-group name="undefined operators">
|
||||
<function name="operator==">
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator1"/>
|
||||
<template-type-parameter name="U1"/>
|
||||
<template-type-parameter name="U2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="UN"/>
|
||||
<template-type-parameter name="Allocator2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN, Allocator2>&</paramtype></parameter>
|
||||
<notes><simpara>This function must be left undefined.</simpara></notes>
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>==</code>. This undefined <code>void operator ==</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
|
||||
</function>
|
||||
|
||||
<returns><simpara>True when <code>f</code> stores an object of
|
||||
type <code>Functor</code> and one of the following conditions applies:
|
||||
<itemizedlist>
|
||||
|
||||
<listitem><simpara><code>g</code> is of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>f.target<Functor>() == g.<methodname
|
||||
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
|
||||
|
||||
<listitem><simpara><code>g</code> is not of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and
|
||||
<code><functionname>function_equal</functionname>(*(f.target<Functor>()),
|
||||
g)</code>.</simpara></listitem>
|
||||
|
||||
</itemizedlist>
|
||||
</simpara></returns>
|
||||
|
||||
<notes><simpara><code><classname>functionN</classname></code>
|
||||
objects are not
|
||||
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
|
||||
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion
|
||||
opens a loophole whereby two <code>functionN</code>
|
||||
instances can be compared via <code>==</code>, although this
|
||||
is not feasible to implement. The undefined <code>void
|
||||
operator==</code> closes the loophole and ensures a
|
||||
compile-time or link-time error.</simpara></rationale>
|
||||
</overloaded-function>
|
||||
|
||||
<overloaded-function name="operator!=">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="U1"/>
|
||||
<template-type-parameter name="U2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="UN"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN>&</paramtype></parameter>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>True when <code>f</code> does not store an
|
||||
object of type <code>Functor</code> or it stores an object of
|
||||
type <code>Functor</code> and one of the following conditions
|
||||
applies:
|
||||
<itemizedlist>
|
||||
|
||||
<listitem><simpara><code>g</code> is of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>f.target<Functor>() != g.<methodname
|
||||
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
|
||||
|
||||
<listitem><simpara><code>g</code> is not of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>!<functionname>function_equal</functionname>(*(f.target<Functor>()), g)</code>.</simpara></listitem>
|
||||
|
||||
</itemizedlist>
|
||||
</simpara></returns>
|
||||
|
||||
<notes><simpara><code><classname>functionN</classname></code>
|
||||
objects are not
|
||||
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
|
||||
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion
|
||||
opens a loophole whereby two <code>functionN</code>
|
||||
instances can be compared via <code>!=</code>, although this
|
||||
is not feasible to implement. The undefined <code>void
|
||||
operator!=</code> closes the loophole and ensures a
|
||||
compile-time or link-time error.</simpara></rationale>
|
||||
</overloaded-function>
|
||||
<function name="operator!=">
|
||||
<template>
|
||||
<template-type-parameter name="T1"/>
|
||||
<template-type-parameter name="T2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="TN"/>
|
||||
<template-type-parameter name="Allocator1"/>
|
||||
<template-type-parameter name="U1"/>
|
||||
<template-type-parameter name="U2"/>
|
||||
<template-varargs/>
|
||||
<template-type-parameter name="UN"/>
|
||||
<template-type-parameter name="Allocator2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>functionN</classname><T1, T2, ..., TN, Allocator1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>functionN</classname><U1, U2, ..., UN, Allocator2>&</paramtype></parameter>
|
||||
<notes><simpara>This function must be left undefined.</simpara></notes>
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>!=</code>. This undefined <code>void operator !=</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
|
||||
</function>
|
||||
</free-function-group>
|
||||
</class>
|
||||
|
||||
@ -557,8 +294,11 @@
|
||||
<template-type-parameter name="Signature">
|
||||
<purpose>Function type R (T1, T2, ..., TN)</purpose>
|
||||
</template-type-parameter>
|
||||
<template-type-parameter name="Allocator">
|
||||
<default><classname>std::allocator</classname><void></default>
|
||||
</template-type-parameter>
|
||||
</template>
|
||||
<inherit access="public"><classname>functionN</classname><R, T1, T2, ..., TN></inherit>
|
||||
<inherit access="public"><classname>functionN</classname><R, T1, T2, ..., TN, Allocator></inherit>
|
||||
|
||||
<purpose>A generalized function pointer that can be used for
|
||||
callbacks or wrapping function objects.</purpose>
|
||||
@ -580,6 +320,7 @@
|
||||
</description>
|
||||
|
||||
<typedef name="result_type"><type>R</type></typedef>
|
||||
<typedef name="allocator_type"><type>Allocator</type></typedef>
|
||||
<typedef name="argument_type">
|
||||
<type>T1</type><purpose>If N == 1</purpose>
|
||||
</typedef>
|
||||
@ -614,7 +355,7 @@
|
||||
</struct>
|
||||
|
||||
<constructor>
|
||||
<postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<postconditions><simpara><code>this-><methodname>empty</methodname>()</code></simpara></postconditions>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
@ -625,16 +366,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 +375,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"/>
|
||||
@ -659,23 +382,11 @@
|
||||
<parameter name="f"><paramtype>F</paramtype></parameter>
|
||||
<requires><simpara>F is a function object Callable from <code>this</code>.</simpara></requires>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-><methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
|
||||
</constructor>
|
||||
|
||||
<constructor>
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
</template>
|
||||
<parameter name="f"><paramtype>F</paramtype></parameter>
|
||||
<parameter name="alloc"><paramtype>Allocator</paramtype></parameter>
|
||||
<requires><simpara>F is a function object Callable from <code>this</code>, Allocator is an allocator. The copy constructor and destructor of Allocator shall not throw.</simpara></requires>
|
||||
<postconditions><simpara><code>*this</code> targets a copy of <code>f</code> if <code>f</code> is nonempty, or <code>this-><methodname>empty</methodname>()</code> if <code>f</code> is empty.</simpara></postconditions>
|
||||
|
||||
<effects><simpara>If memory allocation is required, the given allocator (or a copy of it) will be used to allocate that memory.</simpara></effects>
|
||||
<throws><simpara>Will not throw when <code>f</code> is a stateless function object.</simpara></throws>
|
||||
</constructor>
|
||||
|
||||
<destructor>
|
||||
<effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
|
||||
<effects><simpara>If <code>!this-><methodname>empty</methodname>()</code>, destroys the target of <code>this</code>.</simpara></effects>
|
||||
|
||||
</destructor>
|
||||
|
||||
@ -683,33 +394,16 @@
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>functionN</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>
|
||||
<postconditions><simpara><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.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<copy-assignment>
|
||||
<parameter name="f">
|
||||
<paramtype>const <classname>function</classname>&</paramtype>
|
||||
</parameter>
|
||||
<postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
|
||||
<throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-><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>
|
||||
<postconditions><simpara><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.</simpara></throws>
|
||||
</copy-assignment>
|
||||
|
||||
<method-group name="modifiers">
|
||||
@ -717,6 +411,7 @@
|
||||
<type>void</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname>&</paramtype></parameter>
|
||||
<effects><simpara>Interchanges the targets of <code>*this</code> and <code>f</code>.</simpara></effects>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="clear">
|
||||
@ -729,7 +424,7 @@
|
||||
<method-group name="capacity">
|
||||
<method name="empty" cv="const">
|
||||
<type>bool</type>
|
||||
<returns><simpara><code>false</code> if <code>this</code> has a target, and <code>true</code> otherwise.</simpara></returns>
|
||||
<returns><simpara><code>true</code> if <code>this</code> has a target, and <code>false</code> otherwise.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
|
||||
@ -746,47 +441,6 @@
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="target access">
|
||||
<overloaded-method name="target">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>Functor*</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>const Functor*</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>If <code>this</code> stores a target of type
|
||||
<code>Functor</code>, returns the address of the
|
||||
target. Otherwise, returns the NULL
|
||||
pointer.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<method name="contains" cv="const">
|
||||
<template>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f">
|
||||
<paramtype>const Functor&</paramtype>
|
||||
</parameter>
|
||||
<returns><simpara><code>true</code> if <code>this-><methodname>target</methodname><Functor>()</code> is non-NULL and <code><functionname>function_equal</functionname>(*(this->target<Functor>()), f)</code></simpara></returns>
|
||||
|
||||
</method>
|
||||
|
||||
<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>.</simpara></returns>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="invocation">
|
||||
<method name="operator()" cv="const">
|
||||
<type>result_type</type>
|
||||
@ -796,7 +450,7 @@
|
||||
<parameter name="aN"><paramtype>argN_type</paramtype></parameter>
|
||||
<effects><simpara><code>f(a1, a2, ..., aN)</code>, where <code>f</code> is the target of <code>*this</code>.</simpara></effects>
|
||||
<returns><simpara>if <code>R</code> is <code>void</code>, nothing is returned; otherwise, the return value of the call to <code>f</code> is returned.</simpara></returns>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
<throws><simpara><code><classname>bad_function_call</classname></code> if <code>!this-><methodname>empty</methodname>()</code>. Otherwise, may through any exception thrown by the target function <code>f</code>.</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
@ -804,189 +458,46 @@
|
||||
<function name="swap">
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Allocator"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype><classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype><classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<parameter name="f1"><paramtype><classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype><classname>function</classname><Signature, Allocator>&</paramtype></parameter>
|
||||
<effects><simpara><code>f1.<methodname>swap</methodname>(f2)</code></simpara></effects>
|
||||
<throws><simpara>Will not throw.</simpara></throws>
|
||||
</function>
|
||||
</free-function-group>
|
||||
|
||||
<free-function-group name="comparison operators">
|
||||
<overloaded-function name="operator==">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature1"/>
|
||||
<template-type-parameter name="Signature2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2>&</paramtype></parameter>
|
||||
</signature>
|
||||
<free-function-group name="undefined operators">
|
||||
<function name="operator==">
|
||||
<template>
|
||||
<template-type-parameter name="Signature1"/>
|
||||
<template-type-parameter name="Allocator1"/>
|
||||
<template-type-parameter name="Signature2"/>
|
||||
<template-type-parameter name="Allocator2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1, Allocator1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2, Allocator2>&</paramtype></parameter>
|
||||
<notes><simpara>This function must be left undefined.</simpara></notes>
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>==</code>. This undefined <code>void operator ==</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
|
||||
</function>
|
||||
|
||||
<returns><simpara>True when <code>f</code> stores an object of
|
||||
type <code>Functor</code> and one of the following conditions applies:
|
||||
<itemizedlist>
|
||||
|
||||
<listitem><simpara><code>g</code> is of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>f.target<Functor>() == g.<methodname
|
||||
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
|
||||
|
||||
<listitem><simpara><code>g</code> is not of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code><functionname>function_equals</functionname>(*(f.target<Functor>()), g)</code>.</simpara></listitem>
|
||||
|
||||
</itemizedlist>
|
||||
</simpara></returns>
|
||||
|
||||
<notes><simpara><code><classname>function</classname></code>
|
||||
objects are not
|
||||
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
|
||||
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion
|
||||
opens a loophole whereby two <code>function</code>
|
||||
instances can be compared via <code>==</code>, although this
|
||||
is not feasible to implement. The undefined <code>void
|
||||
operator==</code> closes the loophole and ensures a
|
||||
compile-time or link-time error.</simpara></rationale>
|
||||
</overloaded-function>
|
||||
|
||||
<overloaded-function name="operator!=">
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype>Functor</paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature"/>
|
||||
<template-type-parameter name="Functor"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="g"><paramtype><classname>reference_wrapper</classname><Functor></paramtype></parameter>
|
||||
<parameter name="f"><paramtype>const <classname>function</classname><Signature>&</paramtype></parameter>
|
||||
</signature>
|
||||
<signature>
|
||||
<template>
|
||||
<template-type-parameter name="Signature1"/>
|
||||
<template-type-parameter name="Signature2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2>&</paramtype></parameter>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>True when <code>f</code> does not store an
|
||||
object of type <code>Functor</code> or it stores an object of
|
||||
type <code>Functor</code> and one of the following conditions
|
||||
applies:
|
||||
<itemizedlist>
|
||||
|
||||
<listitem><simpara><code>g</code> is of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>f.target<Functor>() != g.<methodname
|
||||
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
|
||||
|
||||
<listitem><simpara><code>g</code> is not of type
|
||||
<code><classname>reference_wrapper</classname><Functor></code>
|
||||
and <code>!<functionname>function_equals</functionname>(*(f.target<Functor>()), g)</code>.</simpara></listitem>
|
||||
|
||||
</itemizedlist>
|
||||
</simpara></returns>
|
||||
|
||||
<notes><simpara><code><classname>function</classname></code>
|
||||
objects are not
|
||||
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
|
||||
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion
|
||||
opens a loophole whereby two <code>function</code>
|
||||
instances can be compared via <code>!=</code>, although this
|
||||
is not feasible to implement. The undefined <code>void
|
||||
operator!=</code> closes the loophole and ensures a
|
||||
compile-time or link-time error.</simpara></rationale>
|
||||
</overloaded-function>
|
||||
<function name="operator!=">
|
||||
<template>
|
||||
<template-type-parameter name="Signature1"/>
|
||||
<template-type-parameter name="Allocator1"/>
|
||||
<template-type-parameter name="Signature2"/>
|
||||
<template-type-parameter name="Allocator2"/>
|
||||
</template>
|
||||
<type>void</type>
|
||||
<parameter name="f1"><paramtype>const <classname>function</classname><Signature1, Allocator1>&</paramtype></parameter>
|
||||
<parameter name="f2"><paramtype>const <classname>function</classname><Signature2, Allocator2>&</paramtype></parameter>
|
||||
<notes><simpara>This function must be left undefined.</simpara></notes>
|
||||
<rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>!=</code>. This undefined <code>void operator !=</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
|
||||
</function>
|
||||
</free-function-group>
|
||||
</class>
|
||||
</namespace>
|
||||
</header>
|
||||
|
||||
<header name="boost/function_equal.hpp">
|
||||
<namespace name="boost">
|
||||
<function name="function_equal">
|
||||
<template>
|
||||
<template-type-parameter name="F"/>
|
||||
<template-type-parameter name="G"/>
|
||||
</template>
|
||||
<type>bool</type>
|
||||
<parameter name="f">
|
||||
<paramtype>const F&</paramtype>
|
||||
</parameter>
|
||||
<parameter name="g">
|
||||
<paramtype>const G&</paramtype>
|
||||
</parameter>
|
||||
<purpose><simpara>Compare two function objects for equality.</simpara></purpose>
|
||||
<returns><simpara><code>f == g</code>.</simpara></returns>
|
||||
<throws><simpara>Only if <code>f == g</code> throws.</simpara></throws>
|
||||
</function>
|
||||
</namespace>
|
||||
</header>
|
||||
</library-reference>
|
||||
|
||||
@ -1,11 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<testsuite id="function.testsuite" last-revision="$Date$">
|
||||
@ -33,12 +26,6 @@
|
||||
<if-fails><para>Either Boost.Lambda does not work on the platform, or Boost.Function cannot safely be applied without the use of <functionname>boost::unlambda</functionname>.</para></if-fails>
|
||||
</run-test>
|
||||
|
||||
<run-test filename="contains_test.cpp">
|
||||
<purpose><para>Test the operation of the
|
||||
<code><methodname>target</methodname></code> member function and the
|
||||
equality operators.</para></purpose>
|
||||
</run-test>
|
||||
|
||||
<compile-fail-test filename="function_test_fail1.cpp">
|
||||
<purpose><para>Test the (incorrect!) use of comparisons between Boost.Function function objects.</para></purpose>
|
||||
<if-fails><para>Intuitive (but incorrect!) code may compile and will give meaningless results.</para></if-fails>
|
||||
|
||||
@ -1,11 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<section xmlns:xi="http://www.w3.org/2001/XInclude" id="function.tutorial"
|
||||
@ -35,12 +28,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>
|
||||
@ -255,17 +248,17 @@ f(&x, 5);</programlisting>
|
||||
<row>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.std_bind.cxx98"> <classname>boost::function</classname><int (int)> f;
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)</programlisting>
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)</programlisting>
|
||||
</entry>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.std_bind.portable"> <classname alt="functionN">boost::function1</classname><int, int> f;
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)</programlisting>
|
||||
X x;
|
||||
f = std::bind1st(
|
||||
std::mem_fun(&X::foo), &x);
|
||||
f(5); // Call x.foo(5)</programlisting>
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
@ -281,7 +274,7 @@ f(5); // Call x.foo(5)</programlisting>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>References to Function Objects</title> <para> In some cases it is
|
||||
<title>References to Functions</title> <para> In some cases it is
|
||||
expensive (or semantically incorrect) to have Boost.Function clone a
|
||||
function object. In such cases, it is possible to request that
|
||||
Boost.Function keep only a reference to the actual function
|
||||
@ -300,18 +293,18 @@ f(5); // Call x.foo(5)</programlisting>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.ref.cxx98">stateful_type a_function_object;
|
||||
<classname>boost::function</classname><int (int)> f;
|
||||
f = <functionname>boost::ref</functionname>(a_function_object);
|
||||
<programlisting name="function.tutorial.ref.cxx98"> stateful_type a_function_object;
|
||||
<classname>boost::function</classname><int (int)> f;
|
||||
f = <functionname>boost::ref</functionname>(a_function_object);
|
||||
|
||||
<classname>boost::function</classname><int (int)> f2(f);</programlisting>
|
||||
<classname>boost::function</classname><int (int)> f2(f);</programlisting>
|
||||
</entry>
|
||||
<entry>
|
||||
<programlisting name="function.tutorial.ref.portable">stateful_type a_function_object;
|
||||
<classname alt="functionN">boost::function1</classname><int, int> f;
|
||||
f = <functionname>boost::ref</functionname>(a_function_object);
|
||||
<programlisting name="function.tutorial.ref.portable"> stateful_type a_function_object;
|
||||
<classname alt="functionN">boost::function1</classname><int, int> f;
|
||||
f = <functionname>boost::ref</functionname>(a_function_object);
|
||||
|
||||
<classname alt="functionN">boost::function1</classname><int, int> f2(f);</programlisting>
|
||||
<classname alt="functionN">boost::function1</classname><int, int> f2(f);</programlisting>
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
@ -328,37 +321,5 @@ using references to function objects, Boost.Function will not throw
|
||||
exceptions during assignment or construction.
|
||||
</para>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<title>Comparing Boost.Function function objects</title>
|
||||
|
||||
<para>Function object wrappers can be compared via <code>==</code>
|
||||
or <code>!=</code> against any function object that can be stored
|
||||
within the wrapper. If the function object wrapper contains a
|
||||
function object of that type, it will be compared against the given
|
||||
function object (which must be either be
|
||||
<conceptname>EqualityComparable</conceptname> or have an overloaded <functionname>boost::function_equal</functionname>). For instance:</para>
|
||||
|
||||
<programlisting name="function.tutorial.compare">int compute_with_X(X*, int);
|
||||
|
||||
f = &X::foo;
|
||||
assert(f == &X::foo);
|
||||
assert(&compute_with_X != f);</programlisting>
|
||||
|
||||
<para>When comparing against an instance of
|
||||
<code><classname>reference_wrapper</classname></code>, the address
|
||||
of the object in the
|
||||
<code><classname>reference_wrapper</classname></code> is compared
|
||||
against the address of the object stored by the function object
|
||||
wrapper:</para>
|
||||
|
||||
<programlisting name="function.tutorial.compare-ref">a_stateful_object so1, so2;
|
||||
f = <functionname>boost::ref</functionname>(so1);
|
||||
assert(f == <functionname>boost::ref</functionname>(so1));
|
||||
assert(f == so1); <emphasis>// Only if a_stateful_object is <conceptname>EqualityComparable</conceptname></emphasis>
|
||||
assert(f != <functionname>boost::ref</functionname>(so2));</programlisting>
|
||||
|
||||
</section>
|
||||
|
||||
</section>
|
||||
|
||||
|
||||
@ -1,21 +0,0 @@
|
||||
# Boost.Function Library example Jamfile
|
||||
#
|
||||
# Copyright (c) 2008 James E. King III
|
||||
#
|
||||
# Distributed under the Boost Software License, Version 1.0. (See accompany-
|
||||
# ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
import ../../config/checks/config : requires ;
|
||||
import os ;
|
||||
import testing ;
|
||||
|
||||
project
|
||||
: requirements
|
||||
;
|
||||
|
||||
test-suite "function-examples"
|
||||
: [ run bind1st.cpp : : : [ requires cxx98_binders ] ]
|
||||
[ run int_div.cpp ]
|
||||
[ run sum_avg.cpp ]
|
||||
;
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library examples
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library examples
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library examples
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
@ -10,27 +10,19 @@
|
||||
// William Kempf, Jesse Jones and Karl Nelson were all very helpful in the
|
||||
// design of this library.
|
||||
|
||||
#include <boost/preprocessor/iterate.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#ifndef BOOST_FUNCTION_MAX_ARGS
|
||||
# define BOOST_FUNCTION_MAX_ARGS 10
|
||||
#endif // BOOST_FUNCTION_MAX_ARGS
|
||||
|
||||
#if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED) || (BOOST_FUNCTION_MAX_ARGS_DEFINED != BOOST_FUNCTION_MAX_ARGS)
|
||||
|
||||
#if !defined(BOOST_FUNCTION_MAX_ARGS_DEFINED)
|
||||
#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
|
||||
#endif
|
||||
|
||||
#include <functional> // unary_function, binary_function
|
||||
|
||||
#include <boost/preprocessor/iterate.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
|
||||
// Include the prologue here so that the use of file-level iteration
|
||||
// in anything that may be included by function_template.hpp doesn't break
|
||||
#include <boost/function/detail/prologue.hpp>
|
||||
|
||||
// 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__, <= 600)
|
||||
# if BOOST_FUNCTION_MAX_ARGS >= 0
|
||||
# include <boost/function/function0.hpp>
|
||||
# endif
|
||||
@ -70,5 +62,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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2003. Use, modification and
|
||||
// Copyright Doug Gregor 2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
#
|
||||
# Boost.Function library
|
||||
#
|
||||
# Copyright (C) 2001-2003 Douglas Gregor (gregod@cs.rpi.edu)
|
||||
# Copyright (C) 2001-2003 Doug Gregor (gregod@cs.rpi.edu)
|
||||
#
|
||||
# Permission to copy, use, sell and distribute this software is granted
|
||||
# provided this copyright notice appears in all copies.
|
||||
@ -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";
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2003. Use, modification and
|
||||
// Copyright Doug Gregor 2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
@ -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>
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
@ -11,7 +11,6 @@
|
||||
#define BOOST_FUNCTION_PROLOGUE_HPP
|
||||
# include <cassert>
|
||||
# include <algorithm>
|
||||
# include <boost/config/no_tr1/functional.hpp> // unary_function, binary_function
|
||||
# include <boost/throw_exception.hpp>
|
||||
# include <boost/config.hpp>
|
||||
# include <boost/function/function_base.hpp>
|
||||
@ -22,5 +21,4 @@
|
||||
# include <boost/preprocessor/cat.hpp>
|
||||
# include <boost/preprocessor/repeat.hpp>
|
||||
# include <boost/preprocessor/inc.hpp>
|
||||
# include <boost/type_traits/is_void.hpp>
|
||||
#endif // BOOST_FUNCTION_PROLOGUE_HPP
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -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
|
||||
@ -2,7 +2,7 @@
|
||||
#
|
||||
# Boost.Function library
|
||||
#
|
||||
# Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
# Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
# distribution is subject to the Boost Software License, Version
|
||||
# 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
@ -1,28 +0,0 @@
|
||||
// Copyright Douglas Gregor 2004.
|
||||
// Copyright 2005 Peter Dimov
|
||||
|
||||
// Use, modification and distribution is subject to
|
||||
// the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
#ifndef BOOST_FUNCTION_EQUAL_HPP
|
||||
#define BOOST_FUNCTION_EQUAL_HPP
|
||||
|
||||
namespace boost {
|
||||
|
||||
template<typename F, typename G>
|
||||
bool function_equal_impl(const F& f, const G& g, long)
|
||||
{ return f == g; }
|
||||
|
||||
// function_equal_impl needs to be unqualified to pick
|
||||
// user overloads on two-phase compilers
|
||||
|
||||
template<typename F, typename G>
|
||||
bool function_equal(const F& f, const G& g)
|
||||
{ return function_equal_impl(f, g, 0); }
|
||||
|
||||
} // end namespace boost
|
||||
|
||||
#endif // BOOST_FUNCTION_EQUAL_HPP
|
||||
15
index.html
15
index.html
@ -1,20 +1,9 @@
|
||||
<html>
|
||||
<!--
|
||||
Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
-->
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=../../doc/html/function.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="../../doc/html/function.html">../../doc/html/function.html</a> <hr>
|
||||
<p><EFBFBD> Copyright Beman Dawes, 2001</p>
|
||||
<p>Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy
|
||||
at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
|
||||
<a href="../../doc/html/function.html">../../doc/html/function.html</a>
|
||||
</body>
|
||||
</html>
|
||||
</html>
|
||||
|
||||
@ -1,18 +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": [
|
||||
"Douglas Gregor <dgregor -at- cs.indiana.edu>"
|
||||
]
|
||||
}
|
||||
65
test/Jamfile
Normal file
65
test/Jamfile
Normal file
@ -0,0 +1,65 @@
|
||||
# Function library
|
||||
|
||||
# Copyright (C) 2001-2003 Douglas Gregor
|
||||
|
||||
# Use, modification and distribution is subject to the Boost Software License,
|
||||
# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
# Testing Jamfile autogenerated from XML source
|
||||
subproject libs/function/test ;
|
||||
|
||||
# bring in rules for testing
|
||||
SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
|
||||
include testing.jam ;
|
||||
|
||||
# Make tests run by default.
|
||||
DEPENDS all : test ;
|
||||
|
||||
{
|
||||
# look in BOOST_ROOT for sources first, just in this Jamfile
|
||||
local SEARCH_SOURCE = $(BOOST_ROOT) $(SEARCH_SOURCE) ;
|
||||
|
||||
test-suite function
|
||||
:
|
||||
[ run libs/function/test/function_test.cpp : : : : lib_function_test ]
|
||||
|
||||
[ run libs/function/test/function_n_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/allocator_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/stateless_test.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/lambda_test.cpp : : : : ]
|
||||
|
||||
[ compile-fail libs/function/test/function_test_fail1.cpp : : : : ]
|
||||
|
||||
[ compile-fail libs/function/test/function_test_fail2.cpp : : : : ]
|
||||
|
||||
[ compile libs/function/test/function_30.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_arith_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_arith_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/sum_avg_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/sum_avg_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/mem_fun_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/mem_fun_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/std_bind_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/std_bind_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_ref_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_ref_portable.cpp : : : : ]
|
||||
;
|
||||
}
|
||||
|
||||
@ -1,59 +1,58 @@
|
||||
# Function library
|
||||
|
||||
# Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
# Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
# distribution is subject to the Boost Software License, Version
|
||||
# 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
project
|
||||
: source-location $(BOOST_ROOT)
|
||||
;
|
||||
|
||||
# bring in rules for testing
|
||||
import testing ;
|
||||
|
||||
run function_test.cpp ;
|
||||
# /usr/include/c++/4.4/bits/shared_ptr.h:146: error: cannot use typeid with -fno-rtti
|
||||
run function_test.cpp : : : <rtti>off <toolset>gcc-4.4.7,<cxxstd>0x:<build>no : function_test_no_rtti ;
|
||||
run function_n_test.cpp ;
|
||||
run allocator_test.cpp ;
|
||||
run stateless_test.cpp ;
|
||||
run lambda_test.cpp ;
|
||||
compile-fail function_test_fail1.cpp ;
|
||||
compile-fail function_test_fail2.cpp ;
|
||||
compile function_30.cpp ;
|
||||
compile function_30_repeat.cpp ;
|
||||
run function_arith_cxx98.cpp ;
|
||||
run function_arith_portable.cpp ;
|
||||
run sum_avg_cxx98.cpp ;
|
||||
run sum_avg_portable.cpp ;
|
||||
run mem_fun_cxx98.cpp ;
|
||||
run mem_fun_portable.cpp ;
|
||||
run std_bind_cxx98.cpp ;
|
||||
run std_bind_portable.cpp ;
|
||||
run function_ref_cxx98.cpp ;
|
||||
run function_ref_portable.cpp ;
|
||||
run contains_test.cpp ;
|
||||
run contains2_test.cpp ;
|
||||
run nothrow_swap.cpp ;
|
||||
run rvalues_test.cpp ;
|
||||
compile function_typeof_test.cpp ;
|
||||
run result_arg_types_test.cpp ;
|
||||
{
|
||||
|
||||
lib throw_bad_function_call : throw_bad_function_call.cpp : <link>shared:<define>THROW_BAD_FUNCTION_CALL_DYN_LINK=1 ;
|
||||
test-suite function
|
||||
:
|
||||
[ run libs/function/test/function_test.cpp : : : : lib_function_test ]
|
||||
|
||||
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/function_n_test.cpp : : : : ]
|
||||
|
||||
lib mixed_cxxstd : mixed_cxxstd.cpp : <link>shared:<define>MIXED_CXXSTD_DYN_LINK=1 ;
|
||||
[ run libs/function/test/allocator_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/stateless_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 ;
|
||||
[ run libs/function/test/lambda_test.cpp ../../../libs/test/build//boost_test_exec_monitor : : : : ]
|
||||
|
||||
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_fail1.cpp : : : : ]
|
||||
|
||||
local check14 = [ check-target-builds mixed_cxxstd/<cxxstd>14 : : <build>no ] ;
|
||||
[ compile-fail libs/function/test/function_test_fail2.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 ;
|
||||
[ compile libs/function/test/function_30.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_arith_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_arith_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/sum_avg_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/sum_avg_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/mem_fun_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/mem_fun_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/std_bind_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/std_bind_portable.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_ref_cxx98.cpp : : : : ]
|
||||
|
||||
[ run libs/function/test/function_ref_portable.cpp : : : : ]
|
||||
;
|
||||
}
|
||||
|
||||
@ -1,16 +1,16 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <cassert>
|
||||
#include <functional>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
@ -27,14 +27,6 @@ struct counting_allocator : public std::allocator<T>
|
||||
typedef counting_allocator<U> other;
|
||||
};
|
||||
|
||||
counting_allocator()
|
||||
{
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
counting_allocator( counting_allocator<U> )
|
||||
{
|
||||
}
|
||||
|
||||
T* allocate(std::size_t n)
|
||||
{
|
||||
@ -49,88 +41,41 @@ struct counting_allocator : public std::allocator<T>
|
||||
}
|
||||
};
|
||||
|
||||
struct enable_small_object_optimization
|
||||
{
|
||||
};
|
||||
|
||||
struct disable_small_object_optimization
|
||||
{
|
||||
int unused_state_data[32];
|
||||
};
|
||||
|
||||
template <typename base>
|
||||
struct plus_int: base
|
||||
{
|
||||
int operator()(int x, int y) const { return x + y; }
|
||||
};
|
||||
|
||||
static int do_minus(int x, int y) { return x-y; }
|
||||
|
||||
template <typename base>
|
||||
struct DoNothing: base
|
||||
struct DoNothing
|
||||
{
|
||||
void operator()() const {}
|
||||
};
|
||||
|
||||
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 );
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
f.assign( plus_int<enable_small_object_optimization>(), counting_allocator<int>() );
|
||||
f.clear();
|
||||
BOOST_TEST_EQ( alloc_count, 0 );
|
||||
BOOST_TEST_EQ( dealloc_count, 0 );
|
||||
f.assign( plus_int<disable_small_object_optimization>(), std::allocator<int>() );
|
||||
f.clear();
|
||||
f.assign( plus_int<enable_small_object_optimization>(), std::allocator<int>() );
|
||||
function2<int, int, int, counting_allocator<int> > f;
|
||||
f = plus<int>();
|
||||
f.clear();
|
||||
BOOST_TEST(alloc_count == 1);
|
||||
BOOST_TEST(dealloc_count == 1);
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
f.assign( &do_minus, counting_allocator<int>() );
|
||||
f.clear();
|
||||
BOOST_TEST_EQ( alloc_count, 0 );
|
||||
BOOST_TEST_EQ( dealloc_count, 0 );
|
||||
f.assign( &do_minus, std::allocator<int>() );
|
||||
f = &do_minus;
|
||||
f.clear();
|
||||
|
||||
function0<void> fv;
|
||||
function0<void, counting_allocator<int> > fv;
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv.assign( DoNothing<disable_small_object_optimization>(), counting_allocator<int>() );
|
||||
fv.clear();
|
||||
BOOST_TEST_EQ( alloc_count, 1 );
|
||||
BOOST_TEST_EQ( dealloc_count, 1 );
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv.assign( DoNothing<enable_small_object_optimization>(), counting_allocator<int>() );
|
||||
fv.clear();
|
||||
BOOST_TEST_EQ( alloc_count, 0 );
|
||||
BOOST_TEST_EQ( dealloc_count, 0 );
|
||||
fv.assign( DoNothing<disable_small_object_optimization>(), std::allocator<int>() );
|
||||
fv.clear();
|
||||
fv.assign( DoNothing<enable_small_object_optimization>(), std::allocator<int>() );
|
||||
fv = DoNothing();
|
||||
fv.clear();
|
||||
BOOST_TEST(alloc_count == 1);
|
||||
BOOST_TEST(dealloc_count == 1);
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv.assign( &do_nothing, counting_allocator<int>() );
|
||||
fv = &do_nothing;
|
||||
fv.clear();
|
||||
BOOST_TEST_EQ( alloc_count, 0 );
|
||||
BOOST_TEST_EQ( dealloc_count, 0 );
|
||||
fv.assign( &do_nothing, std::allocator<int>() );
|
||||
fv.clear();
|
||||
|
||||
function0<void> fv2;
|
||||
fv.assign(&do_nothing, std::allocator<int>() );
|
||||
fv2.assign(fv, std::allocator<int>() );
|
||||
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,88 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2004.
|
||||
// Copyright 2005 Peter Dimov
|
||||
|
||||
// Use, modification and distribution is subject to
|
||||
// the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
static int forty_two()
|
||||
{
|
||||
return 42;
|
||||
}
|
||||
|
||||
struct Seventeen
|
||||
{
|
||||
int operator()() const
|
||||
{
|
||||
return 17;
|
||||
}
|
||||
};
|
||||
|
||||
bool operator==(const Seventeen&, const Seventeen&)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
struct ReturnInt
|
||||
{
|
||||
explicit ReturnInt(int value) : value(value)
|
||||
{
|
||||
}
|
||||
|
||||
int operator()() const
|
||||
{
|
||||
return value;
|
||||
}
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
bool operator==(const ReturnInt& x, const ReturnInt& y)
|
||||
{
|
||||
return x.value == y.value;
|
||||
}
|
||||
|
||||
bool operator!=(const ReturnInt& x, const ReturnInt& y)
|
||||
{
|
||||
return x.value != y.value;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::function0<int> fn;
|
||||
|
||||
fn = &forty_two;
|
||||
|
||||
BOOST_TEST( fn() == 42 );
|
||||
|
||||
BOOST_TEST( fn.contains(&forty_two) );
|
||||
BOOST_TEST( !fn.contains( Seventeen() ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(0) ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(12) ) );
|
||||
|
||||
fn = Seventeen();
|
||||
|
||||
BOOST_TEST( fn() == 17 );
|
||||
|
||||
BOOST_TEST( !fn.contains( &forty_two ) );
|
||||
BOOST_TEST( fn.contains( Seventeen() ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(0) ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(12) ) );
|
||||
|
||||
fn = ReturnInt(12);
|
||||
|
||||
BOOST_TEST( fn() == 12 );
|
||||
|
||||
BOOST_TEST( !fn.contains( &forty_two ) );
|
||||
BOOST_TEST( !fn.contains( Seventeen() ) );
|
||||
BOOST_TEST( !fn.contains( ReturnInt(0) ) );
|
||||
BOOST_TEST( fn.contains( ReturnInt(12) ) );
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,235 +0,0 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2004. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
static int forty_two() { return 42; }
|
||||
|
||||
struct Seventeen
|
||||
{
|
||||
int operator()() const { return 17; }
|
||||
};
|
||||
|
||||
struct ReturnInt
|
||||
{
|
||||
explicit ReturnInt(int value) : value(value) {}
|
||||
|
||||
int operator()() const { return value; }
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
bool operator==(const ReturnInt& x, const ReturnInt& y)
|
||||
{ return x.value == y.value; }
|
||||
|
||||
bool operator!=(const ReturnInt& x, const ReturnInt& y)
|
||||
{ return x.value != y.value; }
|
||||
|
||||
namespace contain_test {
|
||||
|
||||
struct ReturnIntFE
|
||||
{
|
||||
explicit ReturnIntFE(int value) : value(value) {}
|
||||
|
||||
int operator()() const { return value; }
|
||||
|
||||
int value;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
|
||||
namespace contain_test {
|
||||
# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
bool function_equal(const ReturnIntFE& x, const ReturnIntFE& y)
|
||||
{ return x.value == y.value; }
|
||||
# else
|
||||
bool function_equal_impl(const ReturnIntFE& x, const ReturnIntFE& y, int)
|
||||
{ return x.value == y.value; }
|
||||
# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
}
|
||||
#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
|
||||
namespace boost {
|
||||
# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
bool
|
||||
function_equal(const contain_test::ReturnIntFE& x,
|
||||
const contain_test::ReturnIntFE& y)
|
||||
{ return x.value == y.value; }
|
||||
# else
|
||||
bool
|
||||
function_equal_impl(const contain_test::ReturnIntFE& x,
|
||||
const contain_test::ReturnIntFE& y, int)
|
||||
{ return x.value == y.value; }
|
||||
# endif
|
||||
}
|
||||
#endif
|
||||
|
||||
static void target_test()
|
||||
{
|
||||
boost::function0<int> f;
|
||||
|
||||
f = &forty_two;
|
||||
BOOST_CHECK(*f.target<int (*)()>() == &forty_two);
|
||||
BOOST_CHECK(!f.target<Seventeen>());
|
||||
|
||||
f = Seventeen();
|
||||
BOOST_CHECK(!f.target<int (*)()>());
|
||||
BOOST_CHECK(f.target<Seventeen>());
|
||||
|
||||
Seventeen this_seventeen;
|
||||
f = boost::ref(this_seventeen);
|
||||
BOOST_CHECK(!f.target<int (*)()>());
|
||||
BOOST_CHECK(f.target<Seventeen>());
|
||||
BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);
|
||||
|
||||
const Seventeen const_seventeen = this_seventeen;
|
||||
f = boost::ref(const_seventeen);
|
||||
BOOST_CHECK(!f.target<int (*)()>());
|
||||
BOOST_CHECK(f.target<const Seventeen>());
|
||||
BOOST_CHECK(f.target<const Seventeen>() == &const_seventeen);
|
||||
BOOST_CHECK(f.target<const volatile Seventeen>());
|
||||
BOOST_CHECK(!f.target<Seventeen>());
|
||||
BOOST_CHECK(!f.target<volatile Seventeen>());
|
||||
}
|
||||
|
||||
static void equal_test()
|
||||
{
|
||||
boost::function0<int> f;
|
||||
|
||||
f = &forty_two;
|
||||
BOOST_CHECK(f == &forty_two);
|
||||
BOOST_CHECK(f != ReturnInt(17));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two == f);
|
||||
BOOST_CHECK(ReturnInt(17) != f);
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(f.contains(&forty_two));
|
||||
|
||||
f = ReturnInt(17);
|
||||
BOOST_CHECK(f != &forty_two);
|
||||
BOOST_CHECK(f == ReturnInt(17));
|
||||
BOOST_CHECK(f != ReturnInt(16));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two != f);
|
||||
BOOST_CHECK(ReturnInt(17) == f);
|
||||
BOOST_CHECK(ReturnInt(16) != f);
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(f.contains(ReturnInt(17)));
|
||||
|
||||
f = contain_test::ReturnIntFE(17);
|
||||
BOOST_CHECK(f != &forty_two);
|
||||
BOOST_CHECK(f == contain_test::ReturnIntFE(17));
|
||||
BOOST_CHECK(f != contain_test::ReturnIntFE(16));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two != f);
|
||||
BOOST_CHECK(contain_test::ReturnIntFE(17) == f);
|
||||
BOOST_CHECK(contain_test::ReturnIntFE(16) != f);
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(f.contains(contain_test::ReturnIntFE(17)));
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
boost::function<int(void)> g;
|
||||
|
||||
g = &forty_two;
|
||||
BOOST_CHECK(g == &forty_two);
|
||||
BOOST_CHECK(g != ReturnInt(17));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two == g);
|
||||
BOOST_CHECK(ReturnInt(17) != g);
|
||||
# endif
|
||||
|
||||
g = ReturnInt(17);
|
||||
BOOST_CHECK(g != &forty_two);
|
||||
BOOST_CHECK(g == ReturnInt(17));
|
||||
BOOST_CHECK(g != ReturnInt(16));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(&forty_two != g);
|
||||
BOOST_CHECK(ReturnInt(17) == g);
|
||||
BOOST_CHECK(ReturnInt(16) != g);
|
||||
# endif
|
||||
#endif
|
||||
}
|
||||
|
||||
static void ref_equal_test()
|
||||
{
|
||||
{
|
||||
ReturnInt ri(17);
|
||||
boost::function0<int> f = boost::ref(ri);
|
||||
|
||||
// References and values are equal
|
||||
BOOST_CHECK(f == boost::ref(ri));
|
||||
BOOST_CHECK(f == ri);
|
||||
BOOST_CHECK(boost::ref(ri) == f);
|
||||
BOOST_CHECK(!(f != boost::ref(ri)));
|
||||
BOOST_CHECK(!(f != ri));
|
||||
BOOST_CHECK(!(boost::ref(ri) != f));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri == f);
|
||||
BOOST_CHECK(!(ri != f));
|
||||
#endif
|
||||
|
||||
// Values equal, references inequal
|
||||
ReturnInt ri2(17);
|
||||
BOOST_CHECK(f == ri2);
|
||||
BOOST_CHECK(f != boost::ref(ri2));
|
||||
BOOST_CHECK(boost::ref(ri2) != f);
|
||||
BOOST_CHECK(!(f != ri2));
|
||||
BOOST_CHECK(!(f == boost::ref(ri2)));
|
||||
BOOST_CHECK(!(boost::ref(ri2) == f));
|
||||
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri2 == f);
|
||||
BOOST_CHECK(!(ri2 != f));
|
||||
#endif
|
||||
}
|
||||
|
||||
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
|
||||
{
|
||||
ReturnInt ri(17);
|
||||
boost::function<int(void)> f = boost::ref(ri);
|
||||
|
||||
// References and values are equal
|
||||
BOOST_CHECK(f == boost::ref(ri));
|
||||
BOOST_CHECK(f == ri);
|
||||
BOOST_CHECK(boost::ref(ri) == f);
|
||||
BOOST_CHECK(!(f != boost::ref(ri)));
|
||||
BOOST_CHECK(!(f != ri));
|
||||
BOOST_CHECK(!(boost::ref(ri) != f));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri == f);
|
||||
BOOST_CHECK(!(ri != f));
|
||||
# endif
|
||||
|
||||
// Values equal, references inequal
|
||||
ReturnInt ri2(17);
|
||||
BOOST_CHECK(f == ri2);
|
||||
BOOST_CHECK(f != boost::ref(ri2));
|
||||
BOOST_CHECK(boost::ref(ri2) != f);
|
||||
BOOST_CHECK(!(f != ri2));
|
||||
BOOST_CHECK(!(f == boost::ref(ri2)));
|
||||
BOOST_CHECK(!(boost::ref(ri2) == f));
|
||||
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
|
||||
BOOST_CHECK(ri2 == f);
|
||||
BOOST_CHECK(!(ri2 != f));
|
||||
# endif
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
target_test();
|
||||
equal_test();
|
||||
ref_equal_test();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug 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)
|
||||
|
||||
@ -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;
|
||||
}
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
@ -56,30 +56,30 @@ test_zero_args()
|
||||
|
||||
// Default construction
|
||||
func_void_type v1;
|
||||
BOOST_CHECK(v1.empty());
|
||||
BOOST_TEST(v1.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v1.clear();
|
||||
BOOST_CHECK(!v1);
|
||||
BOOST_TEST(!v1);
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation and self-assignment
|
||||
global_int = 0;
|
||||
v1 = v1;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v1 = five;
|
||||
@ -88,61 +88,61 @@ test_zero_args()
|
||||
global_int = 0;
|
||||
v1 = (v1);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear
|
||||
v1 = 0;
|
||||
BOOST_CHECK(v1.empty());
|
||||
BOOST_TEST(v1.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v1 = &write_five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = &write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v1 = five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Construction from another function (that is empty)
|
||||
v1.clear();
|
||||
func_void_type v2(v1);
|
||||
BOOST_CHECK(!v2? true : false);
|
||||
BOOST_TEST(!v2? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v2 = three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v2 = (five);
|
||||
@ -150,86 +150,86 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
v2.clear();
|
||||
BOOST_CHECK(v2.empty());
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v2 = (&write_five);
|
||||
BOOST_CHECK(v2? true : false);
|
||||
BOOST_TEST(v2? true : false);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = &write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Swapping
|
||||
v1 = five;
|
||||
swap(v1, v2);
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
swap(v1, v2);
|
||||
v1.clear();
|
||||
|
||||
// Assignment
|
||||
v2 = five;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = &write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a function from an empty function
|
||||
v2 = v1;
|
||||
BOOST_CHECK(v2.empty());
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to a function from a function with a functor
|
||||
v1 = three;
|
||||
v2 = v1;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assign to a function from a function with a function
|
||||
v2 = &write_five;
|
||||
v1 = v2;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construct a function given another function containing a function
|
||||
func_void_type v3(v1);
|
||||
@ -237,20 +237,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v3.clear();
|
||||
BOOST_CHECK(!v3? true : false);
|
||||
BOOST_TEST(!v3? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v3 = three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v3 = five;
|
||||
@ -258,38 +258,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v3.clear();
|
||||
BOOST_CHECK(v3.empty());
|
||||
BOOST_TEST(v3.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v3 = &write_five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v3 = &write_three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v3 = five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a function containing a functor
|
||||
func_void_type v4(v3);
|
||||
@ -297,20 +297,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
BOOST_TEST(v4.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v4 = three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v4 = five;
|
||||
@ -318,38 +318,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
BOOST_TEST(v4.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v4 = &write_five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v4 = &write_three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v4 = five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a functor
|
||||
func_void_type v5(five);
|
||||
@ -357,20 +357,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
BOOST_TEST(v5.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v5 = three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v5 = five;
|
||||
@ -378,38 +378,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
BOOST_TEST(v5.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v5 = &write_five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v5 = &write_three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v5 = five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a function
|
||||
func_void_type v6(&write_five);
|
||||
@ -417,20 +417,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
BOOST_TEST(v6.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v6 = three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v6 = five;
|
||||
@ -438,38 +438,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
BOOST_TEST(v6.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v6 = &write_five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v6 = &write_three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v6 = five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Const vs. non-const
|
||||
// Initialization for Borland C++ 5.5
|
||||
@ -479,19 +479,19 @@ test_zero_args()
|
||||
|
||||
global_int = 0;
|
||||
v7();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
BOOST_TEST(global_int == 2);
|
||||
|
||||
global_int = 0;
|
||||
v8();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
BOOST_TEST(global_int == 2);
|
||||
|
||||
// Test construction from 0 and comparison to 0
|
||||
func_void_type v9(0);
|
||||
BOOST_CHECK(v9 == 0);
|
||||
BOOST_TEST(v9 == 0);
|
||||
# if !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540 || defined(BOOST_STRICT_CONFIG)
|
||||
BOOST_CHECK(0 == v9);
|
||||
BOOST_TEST(0 == v9);
|
||||
#else
|
||||
BOOST_CHECK(v9.empty());
|
||||
BOOST_TEST(v9.empty());
|
||||
#endif
|
||||
|
||||
// Test return values
|
||||
@ -501,31 +501,31 @@ test_zero_args()
|
||||
generate_three_obj gen_three = generate_three_obj();
|
||||
func_int_type i0(gen_five);
|
||||
|
||||
BOOST_CHECK(i0() == 5);
|
||||
BOOST_TEST(i0() == 5);
|
||||
i0 = gen_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_TEST(i0() == 3);
|
||||
i0 = &generate_five;
|
||||
BOOST_CHECK(i0() == 5);
|
||||
BOOST_TEST(i0() == 5);
|
||||
i0 = &generate_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_CHECK(i0? true : false);
|
||||
BOOST_TEST(i0() == 3);
|
||||
BOOST_TEST(i0? true : false);
|
||||
i0.clear();
|
||||
BOOST_CHECK(!i0? true : false);
|
||||
BOOST_TEST(!i0? true : false);
|
||||
|
||||
// Test return values with compatible types
|
||||
typedef function0<long> func_long_type;
|
||||
func_long_type i1(gen_five);
|
||||
|
||||
BOOST_CHECK(i1() == 5);
|
||||
BOOST_TEST(i1() == 5);
|
||||
i1 = gen_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_TEST(i1() == 3);
|
||||
i1 = &generate_five;
|
||||
BOOST_CHECK(i1() == 5);
|
||||
BOOST_TEST(i1() == 5);
|
||||
i1 = &generate_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_CHECK(i1? true : false);
|
||||
BOOST_TEST(i1() == 3);
|
||||
BOOST_TEST(i1? true : false);
|
||||
i1.clear();
|
||||
BOOST_CHECK(!i1? true : false);
|
||||
BOOST_TEST(!i1? true : false);
|
||||
}
|
||||
|
||||
static void
|
||||
@ -534,45 +534,45 @@ test_one_arg()
|
||||
negate<int> neg = negate<int>(); // Initialization for Borland C++ 5.5
|
||||
|
||||
function1<int, int> f1(neg);
|
||||
BOOST_CHECK(f1(5) == -5);
|
||||
BOOST_TEST(f1(5) == -5);
|
||||
|
||||
function1<string, string> id(&identity_str);
|
||||
BOOST_CHECK(id("str") == "str");
|
||||
BOOST_TEST(id("str") == "str");
|
||||
|
||||
function1<std::string, const char*> id2(&identity_str);
|
||||
BOOST_CHECK(id2("foo") == "foo");
|
||||
BOOST_TEST(id2("foo") == "foo");
|
||||
|
||||
add_to_obj add_to(5);
|
||||
function1<int, int> f2(add_to);
|
||||
BOOST_CHECK(f2(3) == 8);
|
||||
BOOST_TEST(f2(3) == 8);
|
||||
|
||||
const function1<int, int> cf2(add_to);
|
||||
BOOST_CHECK(cf2(3) == 8);
|
||||
BOOST_TEST(cf2(3) == 8);
|
||||
}
|
||||
|
||||
static void
|
||||
test_two_args()
|
||||
{
|
||||
function2<string, const string&, const string&> cat(&string_cat);
|
||||
BOOST_CHECK(cat("str", "ing") == "string");
|
||||
BOOST_TEST(cat("str", "ing") == "string");
|
||||
|
||||
function2<int, short, short> sum(&sum_ints);
|
||||
BOOST_CHECK(sum(2, 3) == 5);
|
||||
BOOST_TEST(sum(2, 3) == 5);
|
||||
}
|
||||
|
||||
static void
|
||||
test_emptiness()
|
||||
{
|
||||
function0<float> f1;
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_TEST(f1.empty());
|
||||
|
||||
function0<float> f2;
|
||||
f2 = f1;
|
||||
BOOST_CHECK(f2.empty());
|
||||
BOOST_TEST(f2.empty());
|
||||
|
||||
function0<double> f3;
|
||||
f3 = f2;
|
||||
BOOST_CHECK(f3.empty());
|
||||
BOOST_TEST(f3.empty());
|
||||
}
|
||||
|
||||
struct X {
|
||||
@ -593,18 +593,18 @@ test_member_functions()
|
||||
X one(1);
|
||||
X five(5);
|
||||
|
||||
BOOST_CHECK(f1(&one) == 2);
|
||||
BOOST_CHECK(f1(&five) == 10);
|
||||
BOOST_TEST(f1(&one) == 2);
|
||||
BOOST_TEST(f1(&five) == 10);
|
||||
|
||||
boost::function1<int, X*> f1_2;
|
||||
f1_2 = &X::twice;
|
||||
|
||||
BOOST_CHECK(f1_2(&one) == 2);
|
||||
BOOST_CHECK(f1_2(&five) == 10);
|
||||
BOOST_TEST(f1_2(&one) == 2);
|
||||
BOOST_TEST(f1_2(&five) == 10);
|
||||
|
||||
boost::function2<int, X&, int> f2(&X::plus);
|
||||
BOOST_CHECK(f2(one, 3) == 4);
|
||||
BOOST_CHECK(f2(five, 4) == 9);
|
||||
BOOST_TEST(f2(one, 3) == 4);
|
||||
BOOST_TEST(f2(five, 4) == 9);
|
||||
}
|
||||
|
||||
struct add_with_throw_on_copy {
|
||||
@ -629,61 +629,13 @@ test_ref()
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function2<int, int, int> f(ref(atc));
|
||||
BOOST_CHECK(f(1, 3) == 4);
|
||||
BOOST_TEST(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 test_main(int, char* [])
|
||||
{
|
||||
test_zero_args();
|
||||
@ -692,6 +644,5 @@ int test_main(int, char* [])
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
test_construct_destroy_count();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
@ -10,11 +10,12 @@
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <functional>
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
|
||||
using boost::function;
|
||||
using std::string;
|
||||
using namespace boost;
|
||||
using namespace std;
|
||||
|
||||
int global_int;
|
||||
|
||||
@ -55,30 +56,30 @@ test_zero_args()
|
||||
|
||||
// Default construction
|
||||
func_void_type v1;
|
||||
BOOST_CHECK(v1.empty());
|
||||
BOOST_TEST(v1.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = five;
|
||||
BOOST_CHECK(v1 != 0);
|
||||
BOOST_TEST(v1 != 0);
|
||||
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v1.clear();
|
||||
BOOST_CHECK(v1 == 0);
|
||||
BOOST_TEST(v1 == 0);
|
||||
|
||||
// Assignment to an empty function
|
||||
v1 = three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation and self-assignment
|
||||
global_int = 0;
|
||||
v1 = v1;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v1 = five;
|
||||
@ -87,61 +88,61 @@ test_zero_args()
|
||||
global_int = 0;
|
||||
v1 = (v1);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear
|
||||
v1 = 0;
|
||||
BOOST_CHECK(0 == v1);
|
||||
BOOST_TEST(0 == v1);
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
|
||||
BOOST_CHECK(0 != v1);
|
||||
BOOST_TEST(0 != v1);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v1 = five;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v1 = &write_three;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Construction from another function (that is empty)
|
||||
v1.clear();
|
||||
func_void_type v2(v1);
|
||||
BOOST_CHECK(!v2? true : false);
|
||||
BOOST_TEST(!v2? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v2 = three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v2 = (five);
|
||||
@ -149,86 +150,86 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
v2.clear();
|
||||
BOOST_CHECK(v2.empty());
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
|
||||
BOOST_CHECK(v2? true : false);
|
||||
BOOST_TEST(v2? true : false);
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Swapping
|
||||
v1 = five;
|
||||
swap(v1, v2);
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
swap(v1, v2);
|
||||
v1.clear();
|
||||
|
||||
// Assignment
|
||||
v2 = five;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v2 = &write_three;
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a function from an empty function
|
||||
v2 = v1;
|
||||
BOOST_CHECK(v2.empty());
|
||||
BOOST_TEST(v2.empty());
|
||||
|
||||
// Assignment to a function from a function with a functor
|
||||
v1 = three;
|
||||
v2 = v1;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assign to a function from a function with a function
|
||||
v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
|
||||
v1 = v2;
|
||||
BOOST_CHECK(!v1.empty());
|
||||
BOOST_CHECK(!v2.empty());
|
||||
BOOST_TEST(!v1.empty());
|
||||
BOOST_TEST(!v2.empty());
|
||||
global_int = 0;
|
||||
v1();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
global_int = 0;
|
||||
v2();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construct a function given another function containing a function
|
||||
func_void_type v3(v1);
|
||||
@ -236,20 +237,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v3.clear();
|
||||
BOOST_CHECK(!v3? true : false);
|
||||
BOOST_TEST(!v3? true : false);
|
||||
|
||||
// Assignment to an empty function
|
||||
v3 = three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v3 = five;
|
||||
@ -257,38 +258,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v3.clear();
|
||||
BOOST_CHECK(v3.empty());
|
||||
BOOST_TEST(v3.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v3 = &write_five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v3 = &write_three;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v3 = five;
|
||||
BOOST_CHECK(!v3.empty());
|
||||
BOOST_TEST(!v3.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v3();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a function containing a functor
|
||||
func_void_type v4(v3);
|
||||
@ -296,20 +297,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
BOOST_TEST(v4.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v4 = three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v4 = five;
|
||||
@ -317,38 +318,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v4.clear();
|
||||
BOOST_CHECK(v4.empty());
|
||||
BOOST_TEST(v4.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v4 = &write_five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v4 = &write_three;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v4 = five;
|
||||
BOOST_CHECK(!v4.empty());
|
||||
BOOST_TEST(!v4.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v4();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a functor
|
||||
func_void_type v5(five);
|
||||
@ -356,20 +357,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
BOOST_TEST(v5.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v5 = three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v5 = five;
|
||||
@ -377,38 +378,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v5.clear();
|
||||
BOOST_CHECK(v5.empty());
|
||||
BOOST_TEST(v5.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v5 = &write_five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v5 = &write_three;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v5 = five;
|
||||
BOOST_CHECK(!v5.empty());
|
||||
BOOST_TEST(!v5.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v5();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Construction of a function from a function
|
||||
func_void_type v6(&write_five);
|
||||
@ -416,20 +417,20 @@ test_zero_args()
|
||||
// Invocation of a function
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear() method
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
BOOST_TEST(v6.empty());
|
||||
|
||||
// Assignment to an empty function
|
||||
v6 = three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment to a non-empty function
|
||||
v6 = five;
|
||||
@ -437,38 +438,38 @@ test_zero_args()
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// clear()
|
||||
v6.clear();
|
||||
BOOST_CHECK(v6.empty());
|
||||
BOOST_TEST(v6.empty());
|
||||
|
||||
// Assignment to an empty function from a free function
|
||||
v6 = &write_five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Assignment to a non-empty function from a free function
|
||||
v6 = &write_three;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
BOOST_TEST(global_int == 3);
|
||||
|
||||
// Assignment
|
||||
v6 = five;
|
||||
BOOST_CHECK(!v6.empty());
|
||||
BOOST_TEST(!v6.empty());
|
||||
|
||||
// Invocation
|
||||
global_int = 0;
|
||||
v6();
|
||||
BOOST_CHECK(global_int == 5);
|
||||
BOOST_TEST(global_int == 5);
|
||||
|
||||
// Const vs. non-const
|
||||
write_const_1_nonconst_2 one_or_two;
|
||||
@ -477,16 +478,16 @@ test_zero_args()
|
||||
|
||||
global_int = 0;
|
||||
v7();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
BOOST_TEST(global_int == 2);
|
||||
|
||||
global_int = 0;
|
||||
v8();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
BOOST_TEST(global_int == 2);
|
||||
|
||||
// Test construction from 0 and comparison to 0
|
||||
func_void_type v9(0);
|
||||
BOOST_CHECK(v9 == 0);
|
||||
BOOST_CHECK(0 == v9);
|
||||
BOOST_TEST(v9 == 0);
|
||||
BOOST_TEST(0 == v9);
|
||||
|
||||
// Test return values
|
||||
typedef function<int ()> func_int_type;
|
||||
@ -495,78 +496,78 @@ test_zero_args()
|
||||
|
||||
func_int_type i0(gen_five);
|
||||
|
||||
BOOST_CHECK(i0() == 5);
|
||||
BOOST_TEST(i0() == 5);
|
||||
i0 = gen_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_TEST(i0() == 3);
|
||||
i0 = &generate_five;
|
||||
BOOST_CHECK(i0() == 5);
|
||||
BOOST_TEST(i0() == 5);
|
||||
i0 = &generate_three;
|
||||
BOOST_CHECK(i0() == 3);
|
||||
BOOST_CHECK(i0? true : false);
|
||||
BOOST_TEST(i0() == 3);
|
||||
BOOST_TEST(i0? true : false);
|
||||
i0.clear();
|
||||
BOOST_CHECK(!i0? true : false);
|
||||
BOOST_TEST(!i0? true : false);
|
||||
|
||||
// Test return values with compatible types
|
||||
typedef function<long ()> func_long_type;
|
||||
func_long_type i1(gen_five);
|
||||
|
||||
BOOST_CHECK(i1() == 5);
|
||||
BOOST_TEST(i1() == 5);
|
||||
i1 = gen_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_TEST(i1() == 3);
|
||||
i1 = &generate_five;
|
||||
BOOST_CHECK(i1() == 5);
|
||||
BOOST_TEST(i1() == 5);
|
||||
i1 = &generate_three;
|
||||
BOOST_CHECK(i1() == 3);
|
||||
BOOST_CHECK(i1? true : false);
|
||||
BOOST_TEST(i1() == 3);
|
||||
BOOST_TEST(i1? true : false);
|
||||
i1.clear();
|
||||
BOOST_CHECK(!i1? true : false);
|
||||
BOOST_TEST(!i1? true : false);
|
||||
}
|
||||
|
||||
static void
|
||||
test_one_arg()
|
||||
{
|
||||
std::negate<int> neg;
|
||||
negate<int> neg;
|
||||
|
||||
function<int (int)> f1(neg);
|
||||
BOOST_CHECK(f1(5) == -5);
|
||||
BOOST_TEST(f1(5) == -5);
|
||||
|
||||
function<string (string)> id(&identity_str);
|
||||
BOOST_CHECK(id("str") == "str");
|
||||
BOOST_TEST(id("str") == "str");
|
||||
|
||||
function<string (const char*)> id2(&identity_str);
|
||||
BOOST_CHECK(id2("foo") == "foo");
|
||||
BOOST_TEST(id2("foo") == "foo");
|
||||
|
||||
add_to_obj add_to(5);
|
||||
function<int (int)> f2(add_to);
|
||||
BOOST_CHECK(f2(3) == 8);
|
||||
BOOST_TEST(f2(3) == 8);
|
||||
|
||||
const function<int (int)> cf2(add_to);
|
||||
BOOST_CHECK(cf2(3) == 8);
|
||||
BOOST_TEST(cf2(3) == 8);
|
||||
}
|
||||
|
||||
static void
|
||||
test_two_args()
|
||||
{
|
||||
function<string (const string&, const string&)> cat(&string_cat);
|
||||
BOOST_CHECK(cat("str", "ing") == "string");
|
||||
BOOST_TEST(cat("str", "ing") == "string");
|
||||
|
||||
function<int (short, short)> sum(&sum_ints);
|
||||
BOOST_CHECK(sum(2, 3) == 5);
|
||||
BOOST_TEST(sum(2, 3) == 5);
|
||||
}
|
||||
|
||||
static void
|
||||
test_emptiness()
|
||||
{
|
||||
function<float ()> f1;
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_TEST(f1.empty());
|
||||
|
||||
function<float ()> f2;
|
||||
f2 = f1;
|
||||
BOOST_CHECK(f2.empty());
|
||||
BOOST_TEST(f2.empty());
|
||||
|
||||
function<double ()> f3;
|
||||
f3 = f2;
|
||||
BOOST_CHECK(f3.empty());
|
||||
BOOST_TEST(f3.empty());
|
||||
}
|
||||
|
||||
struct X {
|
||||
@ -586,18 +587,18 @@ test_member_functions()
|
||||
X one(1);
|
||||
X five(5);
|
||||
|
||||
BOOST_CHECK(f1(&one) == 2);
|
||||
BOOST_CHECK(f1(&five) == 10);
|
||||
BOOST_TEST(f1(&one) == 2);
|
||||
BOOST_TEST(f1(&five) == 10);
|
||||
|
||||
boost::function<int (X*)> f1_2;
|
||||
f1_2 = &X::twice;
|
||||
|
||||
BOOST_CHECK(f1_2(&one) == 2);
|
||||
BOOST_CHECK(f1_2(&five) == 10);
|
||||
BOOST_TEST(f1_2(&one) == 2);
|
||||
BOOST_TEST(f1_2(&five) == 10);
|
||||
|
||||
boost::function<int (X&, int)> f2(&X::plus);
|
||||
BOOST_CHECK(f2(one, 3) == 4);
|
||||
BOOST_CHECK(f2(five, 4) == 9);
|
||||
BOOST_TEST(f2(one, 3) == 4);
|
||||
BOOST_TEST(f2(five, 4) == 9);
|
||||
}
|
||||
|
||||
struct add_with_throw_on_copy {
|
||||
@ -607,12 +608,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");
|
||||
}
|
||||
};
|
||||
|
||||
@ -621,59 +622,86 @@ test_ref()
|
||||
{
|
||||
add_with_throw_on_copy atc;
|
||||
try {
|
||||
boost::function<int (int, int)> f(boost::ref(atc));
|
||||
BOOST_CHECK(f(1, 3) == 4);
|
||||
boost::function<int (int, int)> f(ref(atc));
|
||||
BOOST_TEST(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
|
||||
static int alloc_count = 0;
|
||||
static int dealloc_count = 0;
|
||||
|
||||
// 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()
|
||||
template<typename T>
|
||||
struct counting_allocator : public allocator<T>
|
||||
{
|
||||
}
|
||||
template<typename U>
|
||||
struct rebind
|
||||
{
|
||||
typedef counting_allocator<U> other;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
static void dummy() {}
|
||||
T* allocate(size_t n)
|
||||
{
|
||||
alloc_count++;
|
||||
return allocator<T>::allocate(n);
|
||||
}
|
||||
|
||||
static void test_empty_ref()
|
||||
void deallocate(T* p, size_t n)
|
||||
{
|
||||
dealloc_count++;
|
||||
allocator<T>::deallocate(p, n);
|
||||
}
|
||||
};
|
||||
|
||||
static int do_minus(int x, int y) { return x-y; }
|
||||
|
||||
struct DoNothing
|
||||
{
|
||||
boost::function<void()> f1;
|
||||
boost::function<void()> f2(boost::ref(f1));
|
||||
void operator()() const {}
|
||||
};
|
||||
|
||||
try {
|
||||
f2();
|
||||
BOOST_ERROR("Exception didn't throw for reference to empty function.");
|
||||
}
|
||||
catch(std::runtime_error const&) {}
|
||||
static void do_nothing() {}
|
||||
|
||||
f1 = dummy;
|
||||
static void test_allocator()
|
||||
{
|
||||
#ifndef BOOST_NO_STD_ALLOCATOR
|
||||
boost::function<int (int, int), counting_allocator<int> > f;
|
||||
f = plus<int>();
|
||||
f.clear();
|
||||
BOOST_TEST(alloc_count == 1);
|
||||
BOOST_TEST(dealloc_count == 1);
|
||||
|
||||
try {
|
||||
f2();
|
||||
}
|
||||
catch(std::runtime_error const&) {
|
||||
BOOST_ERROR("Error calling referenced function.");
|
||||
}
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
f = &do_minus;
|
||||
f.clear();
|
||||
|
||||
boost::function<void (), counting_allocator<int> > fv;
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv = DoNothing();
|
||||
fv.clear();
|
||||
BOOST_TEST(alloc_count == 1);
|
||||
BOOST_TEST(dealloc_count == 1);
|
||||
|
||||
alloc_count = 0;
|
||||
dealloc_count = 0;
|
||||
fv = &do_nothing;
|
||||
fv.clear();
|
||||
#endif // ndef BOOST_NO_STD_ALLOCATOR
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
static void test_exception()
|
||||
{
|
||||
boost::function<int (int, int)> f;
|
||||
try {
|
||||
f(5, 4);
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
catch(boost::bad_function_call const&) {
|
||||
catch(boost::bad_function_call) {
|
||||
// okay
|
||||
}
|
||||
}
|
||||
@ -689,12 +717,12 @@ static void test_implicit()
|
||||
|
||||
static void test_call_obj(boost::function<int (int, int)> f)
|
||||
{
|
||||
BOOST_CHECK(!f.empty());
|
||||
assert(!f.empty());
|
||||
}
|
||||
|
||||
static void test_call_cref(const boost::function<int (int, int)>& f)
|
||||
{
|
||||
BOOST_CHECK(!f.empty());
|
||||
assert(!f.empty());
|
||||
}
|
||||
|
||||
static void test_call()
|
||||
@ -703,95 +731,6 @@ static void test_call()
|
||||
test_call_cref(std::plus<int>());
|
||||
}
|
||||
|
||||
struct big_aggregating_structure {
|
||||
int disable_small_objects_optimizations[32];
|
||||
|
||||
big_aggregating_structure()
|
||||
{
|
||||
++ global_int;
|
||||
}
|
||||
|
||||
big_aggregating_structure(const big_aggregating_structure&)
|
||||
{
|
||||
++ global_int;
|
||||
}
|
||||
|
||||
~big_aggregating_structure()
|
||||
{
|
||||
-- global_int;
|
||||
}
|
||||
|
||||
void operator()()
|
||||
{
|
||||
++ global_int;
|
||||
}
|
||||
|
||||
void operator()(int)
|
||||
{
|
||||
++ global_int;
|
||||
}
|
||||
};
|
||||
|
||||
template <class FunctionT>
|
||||
static void test_move_semantics()
|
||||
{
|
||||
typedef FunctionT f1_type;
|
||||
|
||||
big_aggregating_structure obj;
|
||||
|
||||
f1_type f1 = obj;
|
||||
global_int = 0;
|
||||
f1();
|
||||
|
||||
BOOST_CHECK(!f1.empty());
|
||||
BOOST_CHECK(global_int == 1);
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
// Testing rvalue constructors
|
||||
f1_type f2(static_cast<f1_type&&>(f1));
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_CHECK(!f2.empty());
|
||||
BOOST_CHECK(global_int == 1);
|
||||
f2();
|
||||
BOOST_CHECK(global_int == 2);
|
||||
|
||||
f1_type f3(static_cast<f1_type&&>(f2));
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_CHECK(f2.empty());
|
||||
BOOST_CHECK(!f3.empty());
|
||||
BOOST_CHECK(global_int == 2);
|
||||
f3();
|
||||
BOOST_CHECK(global_int == 3);
|
||||
|
||||
// Testing move assignment
|
||||
f1_type f4;
|
||||
BOOST_CHECK(f4.empty());
|
||||
f4 = static_cast<f1_type&&>(f3);
|
||||
BOOST_CHECK(f1.empty());
|
||||
BOOST_CHECK(f2.empty());
|
||||
BOOST_CHECK(f3.empty());
|
||||
BOOST_CHECK(!f4.empty());
|
||||
BOOST_CHECK(global_int == 3);
|
||||
f4();
|
||||
BOOST_CHECK(global_int == 4);
|
||||
|
||||
// Testing self move assignment
|
||||
f4 = static_cast<f1_type&&>(f4);
|
||||
BOOST_CHECK(!f4.empty());
|
||||
BOOST_CHECK(global_int == 4);
|
||||
|
||||
// Testing, that no memory leaked when assigning to nonempty function
|
||||
f4 = obj;
|
||||
BOOST_CHECK(!f4.empty());
|
||||
BOOST_CHECK(global_int == 4);
|
||||
f1_type f5 = obj;
|
||||
BOOST_CHECK(global_int == 5);
|
||||
f4 = static_cast<f1_type&&>(f5);
|
||||
BOOST_CHECK(global_int == 4);
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
int test_main(int, char* [])
|
||||
{
|
||||
test_zero_args();
|
||||
@ -800,12 +739,10 @@ int test_main(int, char* [])
|
||||
test_emptiness();
|
||||
test_member_functions();
|
||||
test_ref();
|
||||
test_empty_ref();
|
||||
test_allocator();
|
||||
test_exception();
|
||||
test_implicit();
|
||||
test_call();
|
||||
test_move_semantics<function<void()> >();
|
||||
test_move_semantics<boost::function0<void> >();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright (C) Douglas Gregor 2001-2005. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
@ -22,7 +22,7 @@ test_main(int, char*[])
|
||||
if (f1 == f2) {
|
||||
}
|
||||
|
||||
BOOST_ERROR("This should not have compiled.");
|
||||
BOOST_CRITICAL_ERROR("This should not have compiled.");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright (C) Douglas Gregor 2001-2005. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
@ -21,7 +21,7 @@ test_main(int, char*[])
|
||||
function0<int> f1;
|
||||
f1 = bad_fn;
|
||||
|
||||
BOOST_ERROR("This should not have compiled.");
|
||||
BOOST_CRITICAL_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));
|
||||
}
|
||||
@ -1,40 +1,38 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2002-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/lambda/lambda.hpp>
|
||||
#include <boost/lambda/bind.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
|
||||
#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) { 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) { 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,60 +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/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
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 test_main(int, char* [])
|
||||
{
|
||||
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 0;
|
||||
}
|
||||
@ -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,106 +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 <iostream>
|
||||
#include <cstdlib>
|
||||
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/move/move.hpp>
|
||||
|
||||
class only_movable {
|
||||
private:
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(only_movable)
|
||||
int value_;
|
||||
bool moved_;
|
||||
|
||||
public:
|
||||
only_movable(BOOST_RV_REF(only_movable) x)
|
||||
: value_(x.value_)
|
||||
, moved_(false)
|
||||
{
|
||||
x.moved_ = true;
|
||||
}
|
||||
|
||||
only_movable& operator=(BOOST_RV_REF(only_movable) x) {
|
||||
value_ = x.value_;
|
||||
x.moved_ = true;
|
||||
moved_ = false;
|
||||
return *this;
|
||||
}
|
||||
|
||||
explicit only_movable(int value = 0) : value_(value), moved_(false) {}
|
||||
int get_value() const { return value_; }
|
||||
bool is_moved() const { return moved_; }
|
||||
};
|
||||
|
||||
|
||||
int one(BOOST_RV_REF(only_movable) v) { return v.get_value(); }
|
||||
only_movable two(BOOST_RV_REF(only_movable) t) {
|
||||
only_movable t1 = boost::move(t);
|
||||
return BOOST_MOVE_RET(only_movable, t1);
|
||||
}
|
||||
|
||||
only_movable two_sum(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) {
|
||||
only_movable ret(t1.get_value() + t2.get_value());
|
||||
return BOOST_MOVE_RET(only_movable, ret);
|
||||
}
|
||||
|
||||
struct sum_struct {
|
||||
only_movable operator()(BOOST_RV_REF(only_movable) t1, BOOST_RV_REF(only_movable) t2) const {
|
||||
only_movable ret(t1.get_value() + t2.get_value());
|
||||
return BOOST_MOVE_RET(only_movable, ret);
|
||||
}
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
int three(std::string&&) { return 1; }
|
||||
std::string&& four(std::string&& s) { return boost::move(s); }
|
||||
#endif
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
using boost::function;
|
||||
|
||||
function <int(BOOST_RV_REF(only_movable))> f1 = one;
|
||||
|
||||
only_movable om1(1);
|
||||
BOOST_CHECK(f1(boost::move(om1)) == 1);
|
||||
|
||||
function <only_movable(BOOST_RV_REF(only_movable))> f2 = two;
|
||||
|
||||
only_movable om2(2);
|
||||
only_movable om2_2 = f2(boost::move(om2));
|
||||
BOOST_CHECK(om2_2.get_value() == 2);
|
||||
BOOST_CHECK(om2.is_moved());
|
||||
|
||||
{
|
||||
function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))> f2_sum = two_sum;
|
||||
only_movable om1_sum(1), om2_sum(2);
|
||||
only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
|
||||
BOOST_CHECK(om2_sum_2.get_value() == 3);
|
||||
}
|
||||
|
||||
{
|
||||
sum_struct s;
|
||||
function <only_movable(BOOST_RV_REF(only_movable), BOOST_RV_REF(only_movable))> f2_sum = s;
|
||||
only_movable om1_sum(1), om2_sum(2);
|
||||
only_movable om2_sum_2 = f2_sum(boost::move(om1_sum), boost::move(om2_sum));
|
||||
BOOST_CHECK(om2_sum_2.get_value() == 3);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
function <int(std::string&&)> f3 = three;
|
||||
function <std::string&& (std::string&& s)> f4 = four;
|
||||
|
||||
f3(std::string("Hello"));
|
||||
BOOST_CHECK(f4(std::string("world")) == "world");
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,42 +1,40 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2001-2003. Use, modification and
|
||||
// Copyright Doug Gregor 2001-2003. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
#include <boost/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, stateless_integer_add*)
|
||||
{
|
||||
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)
|
||||
void operator delete(void*, stateless_integer_add*) throw()
|
||||
{
|
||||
return p;
|
||||
}
|
||||
|
||||
void operator delete(void* p) throw()
|
||||
{
|
||||
BOOST_ERROR( "stateless_integer_add incorrectly deallocated" );
|
||||
return ::operator delete( p );
|
||||
}
|
||||
};
|
||||
|
||||
int main()
|
||||
namespace boost {
|
||||
template<>
|
||||
struct is_stateless<stateless_integer_add> {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
boost::function2<int, int, int> f;
|
||||
f = stateless_integer_add();
|
||||
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -20,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;
|
||||
}
|
||||
|
||||
@ -20,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,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