diff --git a/.travis.yml b/.travis.yml index 11961b1b1..05e44aaa5 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,171 +1,193 @@ -# Copyright 2016, 2017, 2018 Peter Dimov +# Copyright 2016 - 2018 Peter Dimov # Copyright 2018 T. Zachary Laine +# Copyright 2017 - 2019 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 Travis CI build script for boostorg repositories +# See: https://github.com/boostorg/boost-ci +# +# Instructions for customizing this script for your library: +# +# 1. Customize the compilers and language levels you want in the 'jobs'. +# 2. If you have more than include/, src/, test/, example/, examples/, or +# tools/ directories, modify your Travis CI project and add the environment +# variable DEPINST. For example if your build uses code in "bench/" and +# "fog/" directories, then set DEPINST to the following: +# --include bench --include fog +# 3. If you want to enable Coverity Scan, you need to provide the environment +# variables COVERITY_SCAN_TOKEN and COVERITY_SCAN_NOTIFICATION_EMAIL in +# your github settings. +# 4. Enable pull request builds in your boostorg/ account. +# +# That's it - the scripts will do everything else for you. + +dist: xenial language: cpp -sudo: false +env: + 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.. + # - B2_ADDRESS_MODEL=address-model=64,32 + # - B2_LINK=link=shared,static + # - B2_THREADING=threading=multi,single + - B2_VARIANT=variant=release,debug + +install: + - git clone https://github.com/boostorg/boost-ci.git boost-ci + - cp -pr boost-ci/ci boost-ci/.codecov.yml . + - source ci/travis/install.sh + +addons: + apt: + packages: + - binutils-gold + - gdb + - libc6-dbg branches: only: - master - develop - - /feature\/.*/ - -env: - matrix: - - BOGUS_JOB=true - -matrix: + - bugfix/* + - feature/* + - fix/* + - pr/* - exclude: - - env: BOGUS_JOB=true +script: + - cd $BOOST_ROOT/libs/$SELF + - ci/travis/build.sh + +# +# Default toolsets in Ubuntu +# +# trusty xenial bionic +# 14.04 16.04 18.04 +# ------ ------ ------ +# clang 3.4 3.8 6.0 +# gcc 4.8.2 5.3.1 7.3.0 +# + +anchors: + clang-38: &clang-38 { apt: { packages: [ "clang-3.8", + "libstdc++-6-dev" ], sources: [ "llvm-toolchain-xenial-3.8", + "ubuntu-toolchain-r-test" ] } } + clang-4: &clang-4 { apt: { packages: [ "clang-4.0", + "libstdc++-6-dev" ], sources: [ "llvm-toolchain-xenial-4.0", + "ubuntu-toolchain-r-test" ] } } + clang-5: &clang-5 { apt: { packages: [ "clang-5.0", + "libstdc++-7-dev" ], sources: [ "llvm-toolchain-xenial-5.0", + "ubuntu-toolchain-r-test" ] } } + clang-6: &clang-6 { apt: { packages: [ "clang-6.0", + "libc6-dbg", + "libc++-dev", + "libstdc++-8-dev" ], sources: [ "llvm-toolchain-xenial-6.0", + "ubuntu-toolchain-r-test" ] } } + clang-7: &clang-7 { apt: { packages: [ "clang-7", + "libc6-dbg", + "libc++-dev", + "libstdc++-8-dev" ], sources: [ "llvm-toolchain-xenial-7", + "ubuntu-toolchain-r-test" ] } } + clang-8: &clang-8 { apt: { packages: [ "clang-8", + "libc6-dbg", + "libc++-dev", + "libstdc++-8-dev" ], sources: [ "llvm-toolchain-xenial-8", + "ubuntu-toolchain-r-test" ] } } + gcc-48: &gcc-48 { apt: { packages: [ "g++-4.8" ] } } + gcc-49: &gcc-49 { apt: { packages: [ "g++-4.9" ] } } + gcc-5: &gcc-5 { apt: { packages: [ "g++-5" ] } } + gcc-6: &gcc-6 { apt: { packages: [ "g++-6" ], sources: [ "ubuntu-toolchain-r-test" ] } } + gcc-7: &gcc-7 { apt: { packages: [ "g++-7" ], sources: [ "ubuntu-toolchain-r-test" ] } } + gcc-8: &gcc-8 { apt: { packages: [ "g++-8" ], sources: [ "ubuntu-toolchain-r-test" ] } } + +jobs: + allow_failures: + - env: + - COPY="all the environment settings from your job" include: - - os: linux - env: TOOLSET=gcc COMPILER=g++ CXXSTD=11 - - - os: linux - env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=11 - addons: - apt: - packages: - - g++-4.7 - sources: - - ubuntu-toolchain-r-test + # libstdc++ + - { os: "linux", env: [ "B2_TOOLSET=gcc-4.8", "B2_CXXSTD=03,11" ], addons: *gcc-48 } + - { os: "linux", env: [ "B2_TOOLSET=gcc-4.9", "B2_CXXSTD=03,11" ], addons: *gcc-49 } + - { os: "linux", env: [ "B2_TOOLSET=gcc-5", "B2_CXXSTD=11" ], addons: *gcc-5 } + - { os: "linux", env: [ "B2_TOOLSET=gcc-6", "B2_CXXSTD=11,14" ], addons: *gcc-6 } + - { os: "linux", env: [ "B2_TOOLSET=gcc-7", "B2_CXXSTD=11,14,17" ], addons: *gcc-7 } + - { os: "linux", env: [ "B2_TOOLSET=gcc-8", "B2_CXXSTD=14,17,2a" ], addons: *gcc-8 } + - { os: "linux", env: [ "B2_TOOLSET=clang-3.8", "B2_CXXSTD=03,11,14" ], addons: *clang-38 } + - { os: "linux", env: [ "B2_TOOLSET=clang-4.0", "B2_CXXSTD=11,14" ], addons: *clang-4 } + - { os: "linux", env: [ "B2_TOOLSET=clang-5.0", "B2_CXXSTD=11,14,17" ], addons: *clang-5 } + - { os: "linux", env: [ "B2_TOOLSET=clang-6.0", "B2_CXXSTD=14,17,2a" ], addons: *clang-6 } + - { os: "linux", env: [ "B2_TOOLSET=clang-7", "B2_CXXSTD=14,17,2a" ], addons: *clang-7 } + - { os: "linux", env: [ "B2_TOOLSET=clang-8", "B2_CXXSTD=14,17,2a" ], addons: *clang-8 } + + # libc++ + - { os: "linux", env: [ "B2_TOOLSET=clang-6.0", "B2_CXXSTD=03,11,14,17,2a", + "B2_CXXFLAGS=-stdlib=libc++" ], addons: *clang-6 } + - { os: "osx" , env: [ "B2_TOOLSET=clang", "B2_CXXSTD=03,11,17" ] } + + # to enable Intel ICC define INTEL_ICC_SERIAL_NUMBER and the following: + # - { os: "linux", env: [ "B2_TOOLSET=intel-linux", "B2_CXXSTD=11,14,17" ], addons: *gcc-7, + # script: cd $BOOST_ROOT/libs/$SELF && ci/travis/intelicc.sh } - os: linux - env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=11 - addons: - apt: - packages: - - g++-4.8 - sources: - - ubuntu-toolchain-r-test + env: + - COMMENT=codecov.io + - B2_TOOLSET=03,11,14 + - B2_TOOLSET=gcc-8 + - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1" + addons: *gcc-8 + script: + - pushd /tmp && git clone https://github.com/linux-test-project/lcov.git && export PATH=/tmp/lcov/bin:$PATH && which lcov && lcov --version && popd + - cd $BOOST_ROOT/libs/$SELF + - ci/travis/codecov.sh - os: linux - env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=11 - addons: - apt: - packages: - - g++-4.9 - sources: - - ubuntu-toolchain-r-test + env: + - COMMENT=cppcheck + script: + - cd $BOOST_ROOT/libs/$SELF + - ci/travis/cppcheck.sh - os: linux - env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=11,14,1z - addons: - apt: - packages: - - g++-5 - sources: - - ubuntu-toolchain-r-test + env: + - COMMENT=ubsan + - B2_VARIANT=variant=debug + - B2_TOOLSET=gcc-8 + - B2_CXXSTD=03,11,14,17,2a + - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1" + - B2_CXXFLAGS="cxxflags=-fno-omit-frame-pointer cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=all" + - B2_LINKFLAGS="linkflags=-fsanitize=undefined linkflags=-fno-sanitize-recover=all linkflags=-fuse-ld=gold" + - UBSAN_OPTIONS=print_stacktrace=1 + addons: *gcc-8 - os: linux - env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=11,14,1z - addons: - apt: - packages: - - g++-6 - sources: - - ubuntu-toolchain-r-test - - - os: linux - env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=11,14,1z CXXSTD_DIALECT=cxxstd-dialect=gnu - addons: - apt: - packages: - - g++-6 - sources: - - ubuntu-toolchain-r-test - + env: + - COMMENT=valgrind + - B2_TOOLSET=clang-6.0 + - B2_CXXSTD=03,11,14,17,2a + - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1" + - B2_VARIANT=variant=debug + - B2_TESTFLAGS=testing.launcher=valgrind + - VALGRIND_OPTS=--error-exitcode=1 + addons: *clang-6 + script: + - cd $BOOST_ROOT/libs/$SELF + - ci/travis/valgrind.sh + + #################### Jobs to run on pushes to master, develop ################### + + # Coverity Scan - os: linux - env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=11,14,17 - addons: - apt: - packages: - - g++-7 - sources: - - ubuntu-toolchain-r-test - - - os: linux - env: TOOLSET=clang COMPILER=clang++ CXXSTD=11 - - - os: linux - compiler: clang++-libc++ - env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=11,14,1z - addons: - apt: - packages: - - libc++-dev - - - os: osx - env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z - osx_image: xcode9.1 - - - os: osx - env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z - osx_image: xcode9 - - - os: osx - env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z - osx_image: xcode8.3 - - - os: osx - env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z - osx_image: xcode8 - - - os: osx - env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z - osx_image: xcode7.3 - - - os: osx - env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z - osx_image: xcode6.4 - -install: - - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true - - cd .. - - git clone -b $BOOST_BRANCH --depth 1 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 libs/predef - - git submodule update --init libs/core - - git submodule update --init libs/detail - - git submodule update --init libs/range - - git submodule update --init libs/assert - - git submodule update --init libs/array - - git submodule update --init libs/type_traits - - git submodule update --init libs/static_assert - - git submodule update --init libs/iterator - - git submodule update --init libs/preprocessor - - git submodule update --init libs/mpl - - git submodule update --init libs/smart_ptr - - git submodule update --init libs/callable_traits - - git submodule update --init libs/type_index - - git submodule update --init libs/exception - - git submodule update --init libs/throw_exception - - git submodule update --init libs/utility - - git submodule update --init libs/bind - - git submodule update --init libs/ratio - - git submodule update --init libs/function - - git submodule update --init libs/integer - - git submodule update --init libs/numeric - - git submodule update --init libs/move - - git submodule update --init libs/container_hash - - git submodule update --init libs/io - - git submodule update --init libs/concept_check - - git submodule update --init libs/test - - git submodule update --init libs/timer - - git submodule update --init libs/chrono - - git submodule update --init libs/system - - cp -r $TRAVIS_BUILD_DIR/* libs/algorithm - - ./bootstrap.sh - - ./b2 headers - -script: - - |- - echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam - - ./b2 -j3 libs/algorithm/test toolset=$TOOLSET cxxstd=$CXXSTD $CXXSTD_DIALECT + if: (env(COVERITY_SCAN_NOTIFICATION_EMAIL) IS present) AND (branch IN (develop, master)) AND (type IN (cron, push)) + env: + - COMMENT="Coverity Scan" + - B2_TOOLSET=clang + script: + - cd $BOOST_ROOT/libs/$SELF + - ci/travis/coverity.sh + +notifications: + email: + false diff --git a/CMakeLists.txt b/CMakeLists.txt index 806b689ee..d51d4bef7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -26,7 +26,6 @@ target_link_libraries(boost_algorithm Boost::mpl Boost::range Boost::regex - Boost::static_assert Boost::throw_exception Boost::tuple Boost::type_traits diff --git a/LICENSE b/LICENSE new file mode 100644 index 000000000..36b7cd93c --- /dev/null +++ b/LICENSE @@ -0,0 +1,23 @@ +Boost Software License - Version 1.0 - August 17th, 2003 + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 000000000..80fb526c6 --- /dev/null +++ b/README.md @@ -0,0 +1,35 @@ +Algorithm, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), is a collection of general purpose algorithms. + +### 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/algorithm/tree/master) | [![Build Status](https://travis-ci.org/boostorg/algorithm.svg?branch=master)](https://travis-ci.org/boostorg/algorithm) | [![Build status](https://ci.appveyor.com/api/projects/status/FIXME/branch/master?svg=true)](https://ci.appveyor.com/project/USER/PROJECT/branch/master) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/99999/badge.svg)](https://scan.coverity.com/projects/boostorg-algorithm) | [![codecov](https://codecov.io/gh/boostorg/algorithm/branch/master/graph/badge.svg)](https://codecov.io/gh/boostorg/algorithm/branch/master)| [![Deps](https://img.shields.io/badge/deps-master-brightgreen.svg)](https://pdimov.github.io/boostdep-report/master/algorithm.html) | [![Documentation](https://img.shields.io/badge/docs-master-brightgreen.svg)](http://www.boost.org/doc/libs/master/doc/html/algorithm.html) | [![Enter the Matrix](https://img.shields.io/badge/matrix-master-brightgreen.svg)](https://regression.boost.io/master/developer/algorithm.html) +[`develop`](https://github.com/boostorg/algorithm/tree/develop) | [![Build Status](https://travis-ci.org/boostorg/algorithm.svg?branch=develop)](https://travis-ci.org/boostorg/algorithm) | [![Build status](https://ci.appveyor.com/api/projects/status/FIXME/branch/develop?svg=true)](https://ci.appveyor.com/project/USER/PROJECT/branch/develop) | [![Coverity Scan Build Status](https://scan.coverity.com/projects/99999/badge.svg)](https://scan.coverity.com/projects/boostorg-algorithm) | [![codecov](https://codecov.io/gh/boostorg/algorithm/branch/develop/graph/badge.svg)](https://codecov.io/gh/boostorg/algorithm/branch/develop) | [![Deps](https://img.shields.io/badge/deps-develop-brightgreen.svg)](https://pdimov.github.io/boostdep-report/develop/algorithm.html) | [![Documentation](https://img.shields.io/badge/docs-develop-brightgreen.svg)](http://www.boost.org/doc/libs/develop/doc/html/algorithm.html) | [![Enter the Matrix](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](https://regression.boost.io/develop/developer/algorithm.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-algorithm) +* [Report bugs](https://github.com/boostorg/algorithm/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 `[algorithm]` tag at the beginning of the subject line. + + diff --git a/appveyor.yml b/appveyor.yml index 6cdae8870..fa8e256a0 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -1,7 +1,24 @@ -# Copyright 2016 Peter Dimov +# Copyright 2016, 2017 Peter Dimov +# Copyright (C) 2017 - 2019 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/boostorg/boost-ci/ +# +# Instructions for customizing this script for your library: +# +# 1. Customize the compilers and language levels you want. +# 2. If you have more 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/ account. +# +# That's it - the script will do everything else for you. +# + version: 1.0.{build}-{branch} shallow_clone: true @@ -10,84 +27,104 @@ branches: only: - master - develop + - bugfix/* + - feature/* + - fix/* + - pr/* -platform: - - x64 +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: - - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 - ARGS: --toolset=msvc-14.1 address-model=64 - - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 - ARGS: --toolset=msvc-14.1 address-model=32 - - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 - ARGS: --toolset=msvc-14.1 address-model=64 cxxflags=-std:c++latest cxxflags=-permissive- - - ARGS: --toolset=msvc-9.0 address-model=32 - - ARGS: --toolset=msvc-10.0 address-model=32 - - ARGS: --toolset=msvc-11.0 address-model=32 - - ARGS: --toolset=msvc-12.0 address-model=32 - - ARGS: --toolset=msvc-14.0 address-model=32 - - ARGS: --toolset=msvc-12.0 address-model=64 - - ARGS: --toolset=msvc-14.0 address-model=64 - - ARGS: --toolset=msvc-14.0 address-model=64 cxxflags=-std:c++latest - - ARGS: --toolset=gcc address-model=64 - CXXSTD: 03,11,14,1z - PATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH% - - ARGS: --toolset=gcc address-model=64 - CXXSTD: 03,11,14,1z - PATH: C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH% - - ARGS: --toolset=gcc address-model=32 linkflags=-Wl,-allow-multiple-definition - CXXSTD: 03,11,14,1z - PATH: C:\MinGW\bin;%PATH% - - ARGS: --toolset=gcc address-model=64 - CXXSTD: 03,11,14,1z - PATH: C:\cygwin64\bin;%PATH% - - ARGS: --toolset=gcc address-model=32 - CXXSTD: 03,11,14,1z - PATH: C:\cygwin\bin;%PATH% + - FLAVOR: Visual Studio 2017 C++2a Strict + APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 + B2_ADDRESS_MODEL: address-model=64 + B2_CXXFLAGS: cxxflags=-permissive- + B2_CXXSTD: latest # 2a + B2_TOOLSET: msvc-14.1 + + - FLAVOR: Visual Studio 2017 C++17 + APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 + B2_ADDRESS_MODEL: address-model=64 + B2_CXXSTD: 17 + B2_TOOLSET: msvc-14.1 + + - FLAVOR: Visual Studio 2017 C++14 (Default) + APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 + B2_ADDRESS_MODEL: address-model=64,32 + B2_TOOLSET: msvc-14.1 + + - FLAVOR: Visual Studio 2015 C++14 (Default) + APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 + B2_ADDRESS_MODEL: address-model=64,32 + B2_TOOLSET: msvc-14.0 + + - FLAVOR: Visual Studio 2010, 2012, 2013 + APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 + B2_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 + B2_CXXSTD: 03,11 + # https://github.com/boostorg/test/issues/144 + B2_DEFINES: define=_POSIX_C_SOURCE=200112L + B2_THREADING: threadapi=pthread + B2_TOOLSET: gcc + + - FLAVOR: cygwin (64-bit) + APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 + ADDPATH: C:\cygwin64\bin; + B2_ADDRESS_MODEL: address-model=64 + B2_CXXSTD: 11,17 + # https://github.com/boostorg/test/issues/144 + B2_DEFINES: define=_POSIX_C_SOURCE=200112L define=__USE_ISOC99 + B2_THREADING: threadapi=pthread + B2_TOOLSET: gcc + + - FLAVOR: mingw32 + APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 + ARCH: i686 + B2_ADDRESS_MODEL: address-model=32 + B2_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 + B2_CXXSTD: 11,17 + B2_DEFINES: define=__USE_ISOC99 + SCRIPT: ci\appveyor\mingw.bat install: - - cd .. - - git clone -b %APPVEYOR_REPO_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root - - cd boost-root - - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\algorithm - - git submodule update --init tools/build - - git submodule update --init libs/config - - git submodule update --init libs/predef - - git submodule update --init libs/core - - git submodule update --init libs/detail - - git submodule update --init libs/range - - git submodule update --init libs/assert - - git submodule update --init libs/array - - git submodule update --init libs/type_traits - - git submodule update --init libs/static_assert - - git submodule update --init libs/iterator - - git submodule update --init libs/preprocessor - - git submodule update --init libs/mpl - - git submodule update --init libs/smart_ptr - - git submodule update --init libs/callable_traits - - git submodule update --init libs/type_index - - git submodule update --init libs/exception - - git submodule update --init libs/throw_exception - - git submodule update --init libs/utility - - git submodule update --init libs/bind - - git submodule update --init libs/ratio - - git submodule update --init libs/function - - git submodule update --init libs/integer - - git submodule update --init libs/numeric - - git submodule update --init libs/move - - git submodule update --init libs/container_hash - - git submodule update --init libs/io - - git submodule update --init libs/concept_check - - git submodule update --init libs/test - - git submodule update --init libs/timer - - git submodule update --init libs/chrono - - git submodule update --init libs/system - - bootstrap - - b2 headers - + - set SELF=%APPVEYOR_PROJECT_NAME:-=_% + - git clone https://github.com/boostorg/boost-ci.git C:\boost-ci + - xcopy /s /e /q /i C:\boost-ci\ci .\ci + - ci\appveyor\install.bat + build: off test_script: - - cd libs\config\test - - ..\..\..\b2 -j3 %ARGS% cxxstd=%CXXSTD% + - set SELF=%APPVEYOR_PROJECT_NAME:-=_% + - PATH=%ADDPATH%%PATH% + # The definition of B2_TOOLCXX omits B2_CXXSTD= if it was not defined above + - IF NOT DEFINED B2_CXXSTD (SET B2_TOOLCXX=toolset=%B2_TOOLSET%) ELSE (SET B2_TOOLCXX=toolset=%B2_TOOLSET% cxxstd=%B2_CXXSTD%) + # Echo the complete build command to the build log + - IF NOT DEFINED SCRIPT (ECHO b2 libs/%SELF:\=/% %B2_TOOLCXX% %B2_CXXFLAGS% %B2_DEFINES% %B2_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:\=/% %B2_TOOLCXX% %B2_CXXFLAGS% %B2_DEFINES% %B2_THREADING% %B2_ADDRESS_MODEL% %B2_LINK% %B2_THREADING% %B2_VARIANT% -j3) diff --git a/build.jam b/build.jam new file mode 100644 index 000000000..33b732316 --- /dev/null +++ b/build.jam @@ -0,0 +1,41 @@ +# Copyright René Ferdinand Rivera Morell 2023-2024 +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) + +require-b2 5.2 ; + +constant boost_dependencies : + /boost/array//boost_array + /boost/assert//boost_assert + /boost/bind//boost_bind + /boost/concept_check//boost_concept_check + /boost/config//boost_config + /boost/core//boost_core + /boost/exception//boost_exception + /boost/function//boost_function + /boost/iterator//boost_iterator + /boost/mpl//boost_mpl + /boost/range//boost_range + /boost/regex//boost_regex + /boost/throw_exception//boost_throw_exception + /boost/tuple//boost_tuple + /boost/type_traits//boost_type_traits + /boost/unordered//boost_unordered ; + +project /boost/algorithm + : common-requirements + include + ; + +explicit + [ alias boost_algorithm : : : : $(boost_dependencies) ] + [ alias all : boost_algorithm test + example + minmax/example minmax/test + string/example string/test + ] + ; + +call-if : boost-library algorithm + ; diff --git a/doc/Jamfile.v2 b/doc/Jamfile.v2 index bc67f7def..4d3319af0 100644 --- a/doc/Jamfile.v2 +++ b/doc/Jamfile.v2 @@ -16,18 +16,18 @@ using quickbook ; using doxygen ; using boostbook ; -doxygen autodoc - : - [ glob ../../../boost/algorithm/*.hpp - ../../../boost/algorithm/searching/*.hpp - ../../../boost/algorithm/cxx11/*.hpp - ../../../boost/algorithm/cxx14/*.hpp - ../../../boost/algorithm/cxx17/*.hpp +doxygen autodoc + : + [ glob ../include/boost/algorithm/*.hpp + ../include/boost/algorithm/searching/*.hpp + ../include/boost/algorithm/cxx11/*.hpp + ../include/boost/algorithm/cxx14/*.hpp + ../include/boost/algorithm/cxx17/*.hpp ] - : + : "PREDEFINED=\"BOOST_ALGORITHM_DOXYGEN=1\"" WARNINGS=YES # Default NO, but useful to see warnings, especially in a logfile. - ; + ; xml algorithm : algorithm.qbk ; @@ -36,7 +36,7 @@ boostbook standalone : algorithm : - autodoc + autodoc boost.root=../../../.. "boost.doxygen.reftitle=Boost.Algorithms C++ Reference" chapter.autolabel=0 diff --git a/doc/algorithm.qbk b/doc/algorithm.qbk index 64e8dfb70..02a156236 100644 --- a/doc/algorithm.qbk +++ b/doc/algorithm.qbk @@ -106,11 +106,50 @@ Generate an increasing series Apply a functor to the elements of a sequence [endsect:for_each_n] +[section:transform_inclusive_scan transform_inclusive_scan] +[*[^[link boost.algorithm.transform_inclusive_scan transform_inclusive_scan] ] ] +Transform each element in a range then combine adjacent elements to create an output range. Inclusive scaning means that the nth input is present in the nth output. +[endsect:transform_inclusive_scan] + +[section:transform_exclusive_scan transform_exclusive_scan] +[*[^[link boost.algorithm.transform_exclusive_scan transform_exclusive_scan] ] ] +Transform each element in a range then combine adjacent elements to create an output range. Exclusive scanning means that the nth input is not present in the nth output. +[endsect:transform_exclusive_scan] + [endsect:CXX17_inner_algorithms] [endsect:CXX17] +[section:Copy Variations on Copy] +[section:variations_on_copy] + +[section:copy_until copy_until ] +[*[^[link header.boost.algorithm.cxx11.copy_if_hpp copy_until] ] ] +Copy all the elements from the start of the input range to the output range until the predicate is satisfied +[endsect:copy_until] + +[section:copy_while copy_while ] +[*[^[link header.boost.algorithm.cxx11.copy_if_hpp copy_while] ] ] +Copy all the elements from the start of the input range to the output range while the predicate is satisfied +[endsect:copy_while] + +[section:copy_if_until copy_if_until ] +[*[^[link header.boost.algorithm.cxx11.copy_if_hpp copy_if_until ] ] +Copy all elements that satisfy the element predicate from the start of the input range to the output range until the termination predicate is satisfied + +[endsect:copy_if_until] + +[section:copy_if_while copy_if_while ] +[*[^[link header.boost.algorithm.cxx11.copy_if_hpp copy_if_while ] ] +Copy all elements that satisfy the element predicate from the start of the input range to the output range while the termination predicate is satisfied + +[endsect:copy_if_while] + +[endsect:variations_on_copy] +[endsect:Copy] + + [section:Misc Other Algorithms] [section:misc_inner_algorithms] @@ -204,16 +243,6 @@ See below [include apply_permutation.qbk] -[section:copy_until copy_until ] -[*[^[link header.boost.algorithm.cxx11.copy_if_hpp copy_until] ] ] -Copy all the elements at the start of the input range that do not satisfy the predicate to the output range -[endsect:copy_until] - -[section:copy_while copy_while ] -[*[^[link header.boost.algorithm.cxx11.copy_if_hpp copy_while] ] ] -Copy all the elements at the start of the input range that satisfy the predicate to the output range -[endsect:copy_while] - [section:iota_n iota_n ] [*[^[link boost.algorithm.iota_n iota_n] ] ] Write a sequence of n increasing values to an output iterator @@ -234,8 +263,6 @@ Raise a value to an integral power ([^constexpr] since C++14) * [*[^[link header.boost.algorithm.cxx17.exclusive_scan_hpp exclusive_scan] ] ] * [*[^[link header.boost.algorithm.cxx17.inclusive_scan_hpp inclusive_scan] ] ] * [*[^[link header.boost.algorithm.cxx17.reduce_hpp reduce] ] ] -* [*[^[link header.boost.algorithm.cxx17.transform_exclusive_scan_hpp transform_exclusive_scan] ] ] -* [*[^[link header.boost.algorithm.cxx17.transform_inclusive_scan_hpp transform_inclusive_scan] ] ] * [*[^[link header.boost.algorithm.cxx17.transform_reduce_hpp transform_reduce] ] ] [endsect:not_yet_documented_cxx17_algos] diff --git a/doc/apply_permutation.qbk b/doc/apply_permutation.qbk index 86bebf1e9..a71354808 100644 --- a/doc/apply_permutation.qbk +++ b/doc/apply_permutation.qbk @@ -16,12 +16,12 @@ The routine `apply_permutation` takes a item sequence and a order sequence. It r The routine `apply_reverse_permutation` takes a item sequence and a order sequence. It will reshuffle item sequence according to order sequence. Every value in order sequence means where the item goes to. Order sequence needs to be exactly a permutation of the sequence [0, 1, ... , N], where N is the biggest index in the item sequence (zero-indexed). Implementations are based on these articles: -https://blogs.msdn.microsoft.com/oldnewthing/20170102-00/?p=95095 -https://blogs.msdn.microsoft.com/oldnewthing/20170103-00/?p=95105 -https://blogs.msdn.microsoft.com/oldnewthing/20170104-00/?p=95115 -https://blogs.msdn.microsoft.com/oldnewthing/20170109-00/?p=95145 -https://blogs.msdn.microsoft.com/oldnewthing/20170110-00/?p=95155 -https://blogs.msdn.microsoft.com/oldnewthing/20170111-00/?p=95165 +https://devblogs.microsoft.com/oldnewthing/20170102-00/?p=95095 +https://devblogs.microsoft.com/oldnewthing/20170103-00/?p=95105 +https://devblogs.microsoft.com/oldnewthing/20170104-00/?p=95115 +https://devblogs.microsoft.com/oldnewthing/20170109-00/?p=95145 +https://devblogs.microsoft.com/oldnewthing/20170110-00/?p=95155 +https://devblogs.microsoft.com/oldnewthing/20170111-00/?p=95165 The routines come in 2 forms; the first one takes two iterators to define the item range and one iterator to define the beginning of index range. The second form takes range to define the item sequence and range to define index sequence. diff --git a/example/Jamfile.v2 b/example/Jamfile.v2 index 64a405559..ce3eca301 100644 --- a/example/Jamfile.v2 +++ b/example/Jamfile.v2 @@ -8,9 +8,9 @@ # See http://www.boost.org for updates, documentation, and revision history. -project /boost/algorithm/example +project : requirements - ../../../ + /boost/algorithm//boost_algorithm speed msvc:_SCL_SECURE_NO_WARNINGS msvc:NOMINMAX diff --git a/include/boost/algorithm/algorithm.hpp b/include/boost/algorithm/algorithm.hpp index 76753cd67..85b43c0ed 100644 --- a/include/boost/algorithm/algorithm.hpp +++ b/include/boost/algorithm/algorithm.hpp @@ -20,7 +20,7 @@ #include // for plus and multiplies #include -#include // for boost::disable_if +#include // for boost::disable_if #include namespace boost { namespace algorithm { diff --git a/include/boost/algorithm/clamp.hpp b/include/boost/algorithm/clamp.hpp index 82a99bde0..2f160a016 100644 --- a/include/boost/algorithm/clamp.hpp +++ b/include/boost/algorithm/clamp.hpp @@ -26,14 +26,14 @@ #include #include #include -#include // for identity -#include // for boost::disable_if +#include // for boost::type_identity +#include // for boost::disable_if namespace boost { namespace algorithm { /// \fn clamp ( T const& val, -/// typename boost::mpl::identity::type const & lo, -/// typename boost::mpl::identity::type const & hi, Pred p ) +/// typename boost::type_identity::type const & lo, +/// typename boost::type_identity::type const & hi, Pred p ) /// \return the value "val" brought into the range [ lo, hi ] /// using the comparison predicate p. /// If p ( val, lo ) return lo. @@ -48,8 +48,8 @@ namespace boost { namespace algorithm { /// template BOOST_CXX14_CONSTEXPR T const & clamp ( T const& val, - typename boost::mpl::identity::type const & lo, - typename boost::mpl::identity::type const & hi, Pred p ) + typename boost::type_identity::type const & lo, + typename boost::type_identity::type const & hi, Pred p ) { // assert ( !p ( hi, lo )); // Can't assert p ( lo, hi ) b/c they might be equal return p ( val, lo ) ? lo : p ( hi, val ) ? hi : val; @@ -57,8 +57,8 @@ namespace boost { namespace algorithm { /// \fn clamp ( T const& val, -/// typename boost::mpl::identity::type const & lo, -/// typename boost::mpl::identity::type const & hi ) +/// typename boost::identity::type const & lo, +/// typename boost::identity::type const & hi ) /// \return the value "val" brought into the range [ lo, hi ]. /// If the value is less than lo, return lo. /// If the value is greater than "hi", return hi. @@ -70,8 +70,8 @@ namespace boost { namespace algorithm { /// template BOOST_CXX14_CONSTEXPR T const& clamp ( const T& val, - typename boost::mpl::identity::type const & lo, - typename boost::mpl::identity::type const & hi ) + typename boost::type_identity::type const & lo, + typename boost::type_identity::type const & hi ) { return boost::algorithm::clamp ( val, lo, hi, std::less()); } diff --git a/include/boost/algorithm/cxx11/copy_if.hpp b/include/boost/algorithm/cxx11/copy_if.hpp index d3914bf20..307c21310 100644 --- a/include/boost/algorithm/cxx11/copy_if.hpp +++ b/include/boost/algorithm/cxx11/copy_if.hpp @@ -126,6 +126,86 @@ copy_until ( const Range &r, OutputIterator result, Predicate p ) return boost::algorithm::copy_until (boost::begin (r), boost::end(r), result, p); } +/// \fn copy_if_while ( InputIterator first, InputIterator last, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred ) +/// \brief Copies all the elements from the input range that satisfy the +/// copy predicate to the output range while the termination predicate is +/// satisfied. +/// \return The updated output iterator +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param result An output iterator to write the results into +/// \param copy_pred A predicate for testing whether to the current element +/// \param term_pred A predicate for testing whether to end the copy operation +template +BOOST_CXX14_CONSTEXPR std::pair +copy_if_while ( InputIterator first, InputIterator last, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred) +{ + for ( ; first != last && term_pred(*first); ++first ) { + if (copy_pred(*first)) { + *result++ = *first; + } + } + return std::make_pair(first, result); +} + +/// \fn copy_if_while ( const Range& r, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred ) +/// \brief Copies all the elements from the input range that satisfy the +/// copy predicate to the output range while the termination predicate is +/// satisfied. +/// \return The updated output iterator +/// +/// \param r The input range +/// \param result An output iterator to write the results into +/// \param copy_pred A predicate for testing whether to the current element +/// \param term_pred A predicate for testing whether to end the copy operation +template +BOOST_CXX14_CONSTEXPR std::pair::type, OutputIterator> +copy_if_while ( const Range& r, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred) +{ + return boost::algorithm::copy_if_while(boost::begin(r), boost::end(r), result, copy_pred, term_pred); +} + +/// \fn copy_if_until ( InputIterator first, InputIterator last, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred ) +/// \brief Copies all the elements from the input range that satisfy the +/// copy predicate to the output range until the termination predicate is +/// satisfied. +/// \return The updated output iterator +/// +/// \param first The start of the input sequence +/// \param last One past the end of the input sequence +/// \param result An output iterator to write the results into +/// \param copy_pred A predicate for testing whether to the current element +/// \param term_pred A predicate for testing whether to end the copy operation +template +BOOST_CXX14_CONSTEXPR std::pair +copy_if_until ( InputIterator first, InputIterator last, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred) +{ + for ( ; first != last && !term_pred(*first); ++first ) { + if (copy_pred(*first)) { + *result++ = *first; + } + } + return std::make_pair(first, result); +} + +/// \fn copy_if_until ( const Range& r, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred ) +/// \brief Copies all the elements from the input range that satisfy the +/// copy predicate to the output range until the termination predicate is +/// satisfied. +/// \return The updated output iterator +/// +/// \param r The input range +/// \param result An output iterator to write the results into +/// \param copy_pred A predicate for testing whether to the current element +/// \param term_pred A predicate for testing whether to end the copy operation +template +BOOST_CXX14_CONSTEXPR std::pair::type, OutputIterator> +copy_if_until ( const Range& r, OutputIterator result, CopyPredicate copy_pred, TerminatePred term_pred) +{ + return boost::algorithm::copy_if_until(boost::begin(r), boost::end(r), result, copy_pred, term_pred); +} + }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_COPY_IF_HPP diff --git a/include/boost/algorithm/cxx11/is_permutation.hpp b/include/boost/algorithm/cxx11/is_permutation.hpp index 31eac939d..fb4083a15 100644 --- a/include/boost/algorithm/cxx11/is_permutation.hpp +++ b/include/boost/algorithm/cxx11/is_permutation.hpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include namespace boost { namespace algorithm { @@ -100,7 +100,7 @@ namespace detail { } /// \endcond -/// \fn is_permutation ( ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 first2, BinaryPredicate p ) +/// \fn is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, BinaryPredicate p ) /// \brief Tests to see if the sequence [first,last) is a permutation of the sequence starting at first2 /// /// \param first1 The start of the input sequence @@ -127,11 +127,11 @@ bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, return true; } -/// \fn is_permutation ( ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 first2 ) +/// \fn is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2 ) /// \brief Tests to see if the sequence [first,last) is a permutation of the sequence starting at first2 /// /// \param first1 The start of the input sequence -/// \param last2 One past the end of the input sequence +/// \param last1 One past the end of the input sequence /// \param first2 The start of the second sequence /// \note This function is part of the C++2011 standard library. template< class ForwardIterator1, class ForwardIterator2 > diff --git a/include/boost/algorithm/cxx11/is_sorted.hpp b/include/boost/algorithm/cxx11/is_sorted.hpp index 0aa812236..2526a8728 100644 --- a/include/boost/algorithm/cxx11/is_sorted.hpp +++ b/include/boost/algorithm/cxx11/is_sorted.hpp @@ -20,9 +20,9 @@ #include #include -#include +#include #include -#include +#include // for boost::type_identity namespace boost { namespace algorithm { @@ -127,7 +127,7 @@ namespace boost { namespace algorithm { /// \param p A binary predicate that returns true if two elements are ordered. /// template - BOOST_CXX14_CONSTEXPR typename boost::lazy_disable_if_c< boost::is_same::value, boost::mpl::identity >::type + BOOST_CXX14_CONSTEXPR typename boost::lazy_disable_if_c< boost::is_same::value, boost::type_identity >::type is_sorted ( const R &range, Pred p ) { return boost::algorithm::is_sorted ( boost::begin ( range ), boost::end ( range ), p ); diff --git a/include/boost/algorithm/cxx17/transform_exclusive_scan.hpp b/include/boost/algorithm/cxx17/transform_exclusive_scan.hpp index 68318a59a..86446b803 100644 --- a/include/boost/algorithm/cxx17/transform_exclusive_scan.hpp +++ b/include/boost/algorithm/cxx17/transform_exclusive_scan.hpp @@ -22,6 +22,21 @@ namespace boost { namespace algorithm { +/// \fn transform_exclusive_scan ( InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp, UnaryOperation uOp, T init ) +/// \brief Transforms elements from the input range with uOp and then combines +/// those transformed elements with bOp such that the n-1th element and the nth +/// element are combined. Exclusivity means that the nth element is not +/// included in the nth combination. +/// \return The updated output iterator +/// +/// \param first The start of the input sequence +/// \param last The end of the input sequence +/// \param result The output iterator to write the results into +/// \param bOp The operation for combining transformed input elements +/// \param uOp The operation for transforming input elements +/// \param init The initial value +/// +/// \note This function is part of the C++17 standard library template OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last, diff --git a/include/boost/algorithm/cxx17/transform_inclusive_scan.hpp b/include/boost/algorithm/cxx17/transform_inclusive_scan.hpp index 31607703e..9d877c02d 100644 --- a/include/boost/algorithm/cxx17/transform_inclusive_scan.hpp +++ b/include/boost/algorithm/cxx17/transform_inclusive_scan.hpp @@ -22,6 +22,21 @@ namespace boost { namespace algorithm { +/// \fn transform_inclusive_scan ( InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp, UnaryOperation uOp, T init ) +/// \brief Transforms elements from the input range with uOp and then combines +/// those transformed elements with bOp such that the n-1th element and the nth +/// element are combined. Inclusivity means that the nth element is included in +/// the nth combination. +/// \return The updated output iterator +/// +/// \param first The start of the input sequence +/// \param last The end of the input sequence +/// \param result The output iterator to write the results into +/// \param bOp The operation for combining transformed input elements +/// \param uOp The operation for transforming input elements +/// \param init The initial value +/// +/// \note This function is part of the C++17 standard library template OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last, @@ -37,6 +52,20 @@ OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last, return result; } +/// \fn transform_inclusive_scan ( InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp, UnaryOperation uOp, T init ) +/// \brief Transforms elements from the input range with uOp and then combines +/// those transformed elements with bOp such that the n-1th element and the nth +/// element are combined. Inclusivity means that the nth element is included in +/// the nth combination. The first value will be used as the init. +/// \return The updated output iterator +/// +/// \param first The start of the input sequence +/// \param last The end of the input sequence +/// \param result The output iterator to write the results into +/// \param bOp The operation for combining transformed input elements +/// \param uOp The operation for transforming input elements +/// +/// \note This function is part of the C++17 standard library template OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last, diff --git a/include/boost/algorithm/gather.hpp b/include/boost/algorithm/gather.hpp index e777f8bd1..00f173397 100644 --- a/include/boost/algorithm/gather.hpp +++ b/include/boost/algorithm/gather.hpp @@ -1,4 +1,4 @@ -/* +/* Copyright 2008 Adobe Systems Incorporated Distributed under the Boost Software License, Version 1.0. (See accompanying @@ -84,7 +84,7 @@ namespace boost { namespace algorithm { template < typename BidirectionalIterator, // models BidirectionalIterator typename Pred> // models UnaryPredicate -std::pair gather +std::pair gather ( BidirectionalIterator first, BidirectionalIterator last, BidirectionalIterator pivot, Pred pred ) { // The first call partitions everything up to (but not including) the pivot element, @@ -106,11 +106,11 @@ template < typename BidirectionalRange, // typename Pred> // Pred models UnaryPredicate std::pair< - typename boost::range_iterator::type, - typename boost::range_iterator::type> + typename boost::range_iterator::type, + typename boost::range_iterator::type> gather ( - const BidirectionalRange &range, - typename boost::range_iterator::type pivot, + BidirectionalRange &range, + typename boost::range_iterator::type pivot, Pred pred ) { return boost::algorithm::gather ( boost::begin ( range ), boost::end ( range ), pivot, pred ); diff --git a/include/boost/algorithm/hex.hpp b/include/boost/algorithm/hex.hpp index 446a5b12a..f94580468 100644 --- a/include/boost/algorithm/hex.hpp +++ b/include/boost/algorithm/hex.hpp @@ -30,7 +30,7 @@ #include #include -#include +#include #include @@ -48,9 +48,9 @@ namespace boost { namespace algorithm { \brief Thrown when the input sequence unexpectedly ends */ -struct hex_decode_error : virtual boost::exception, virtual std::exception {}; -struct not_enough_input : virtual hex_decode_error {}; -struct non_hex_input : virtual hex_decode_error {}; +struct BOOST_SYMBOL_VISIBLE hex_decode_error : virtual boost::exception, virtual std::exception {}; +struct BOOST_SYMBOL_VISIBLE not_enough_input : virtual hex_decode_error {}; +struct BOOST_SYMBOL_VISIBLE non_hex_input : virtual hex_decode_error {}; typedef boost::error_info bad_char; namespace detail { diff --git a/include/boost/algorithm/is_clamped.hpp b/include/boost/algorithm/is_clamped.hpp new file mode 100644 index 000000000..72287d302 --- /dev/null +++ b/include/boost/algorithm/is_clamped.hpp @@ -0,0 +1,72 @@ +/* + Copyright (c) Ivan Matek, Marshall Clow 2021. + + 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) + +*/ + +/// \file is_clamped.hpp +/// \brief IsClamped algorithm +/// \authors Ivan Matek, Marshall Clow +/// + +#ifndef BOOST_ALGORITHM_IS_CLAMPED_HPP +#define BOOST_ALGORITHM_IS_CLAMPED_HPP + +#include // for std::less +#include + +#include // for boost::type_identity + +namespace boost { namespace algorithm { + +/// \fn is_clamped ( T const& val, +/// typename boost::type_identity::type const & lo, +/// typename boost::type_identity::type const & hi, Pred p ) +/// \returns true if value "val" is in the range [ lo, hi ] +/// using the comparison predicate p. +/// If p ( val, lo ) return false. +/// If p ( hi, val ) return false. +/// Otherwise, returns true. +/// +/// \param val The value to be checked +/// \param lo The lower bound of the range +/// \param hi The upper bound of the range +/// \param p A predicate to use to compare the values. +/// p ( a, b ) returns a boolean. +/// + template + BOOST_CXX14_CONSTEXPR bool is_clamped( + T const& val, typename boost::type_identity::type const& lo, + typename boost::type_identity::type const& hi, Pred p) { + // assert ( !p ( hi, lo )); // Can't assert p ( lo, hi ) b/c they + // might be equal + return p(val, lo) ? false : p(hi, val) ? false : true; + } + +/// \fn is_clamped ( T const& val, +/// typename boost::type_identity::type const & lo, +/// typename boost::type_identity::type const & hi) +/// \returns true if value "val" is in the range [ lo, hi ] +/// using operator < for comparison. +/// If the value is less than lo, return false. +/// If the value is greater than hi, return false. +/// Otherwise, returns true. +/// +/// \param val The value to be checked +/// \param lo The lower bound of the range +/// \param hi The upper bound of the range +/// + + template + BOOST_CXX14_CONSTEXPR bool is_clamped ( const T& val, + typename boost::type_identity::type const & lo, + typename boost::type_identity::type const & hi ) + { + return boost::algorithm::is_clamped ( val, lo, hi, std::less()); + } + +}} + +#endif // BOOST_ALGORITHM_CLAMP_HPP diff --git a/include/boost/algorithm/is_palindrome.hpp b/include/boost/algorithm/is_palindrome.hpp index 8e1df1811..531f82ecf 100644 --- a/include/boost/algorithm/is_palindrome.hpp +++ b/include/boost/algorithm/is_palindrome.hpp @@ -113,7 +113,7 @@ bool is_palindrome(const R& range, Predicate p) /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). -bool is_palindrome(const char* str) +inline bool is_palindrome(const char* str) { if(!str) return true; diff --git a/include/boost/algorithm/searching/boyer_moore.hpp b/include/boost/algorithm/searching/boyer_moore.hpp index 4bf76575e..87a413d52 100644 --- a/include/boost/algorithm/searching/boyer_moore.hpp +++ b/include/boost/algorithm/searching/boyer_moore.hpp @@ -10,6 +10,7 @@ #ifndef BOOST_ALGORITHM_BOYER_MOORE_SEARCH_HPP #define BOOST_ALGORITHM_BOYER_MOORE_SEARCH_HPP +#include // for std::reverse_copy #include // for std::iterator_traits #include @@ -19,7 +20,7 @@ #include #include -#include +#include #include #include @@ -107,12 +108,11 @@ mismatch on a character that _is_ in the pattern. typename traits::skip_table_t skip_; std::vector suffix_; - /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last, Pred p ) + /// \fn do_search ( corpusIter corpus_first, corpusIter corpus_last ) /// \brief Searches the corpus for the pattern that was passed into the constructor - /// + /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search - /// \param p A predicate used for the search comparisons. /// template std::pair diff --git a/include/boost/algorithm/searching/boyer_moore_horspool.hpp b/include/boost/algorithm/searching/boyer_moore_horspool.hpp index dd354cc54..2c0afc320 100644 --- a/include/boost/algorithm/searching/boyer_moore_horspool.hpp +++ b/include/boost/algorithm/searching/boyer_moore_horspool.hpp @@ -19,7 +19,7 @@ #include #include -#include +#include #include #include @@ -107,7 +107,6 @@ namespace boost { namespace algorithm { /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search - /// \param k_corpus_length The length of the corpus to search /// template std::pair diff --git a/include/boost/algorithm/searching/knuth_morris_pratt.hpp b/include/boost/algorithm/searching/knuth_morris_pratt.hpp index 7c1541cc4..f25f13a70 100644 --- a/include/boost/algorithm/searching/knuth_morris_pratt.hpp +++ b/include/boost/algorithm/searching/knuth_morris_pratt.hpp @@ -20,7 +20,7 @@ #include #include -#include +#include #include #include @@ -62,12 +62,11 @@ namespace boost { namespace algorithm { ~knuth_morris_pratt () {} - /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last, Pred p ) + /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last ) /// \brief Searches the corpus for the pattern that was passed into the constructor - /// + /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search - /// \param p A predicate used for the search comparisons. /// template std::pair @@ -99,16 +98,16 @@ namespace boost { namespace algorithm { const difference_type k_pattern_length; std::vector skip_; - /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last, Pred p ) + /// \fn do_search ( corpusIter corpus_first, corpusIter corpus_last, difference_type k_corpus_length ) /// \brief Searches the corpus for the pattern that was passed into the constructor - /// + /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search - /// \param p A predicate used for the search comparisons. + /// \param k_corpus_length The length of the corpus to search /// template std::pair - do_search ( corpusIter corpus_first, corpusIter corpus_last, + do_search ( corpusIter corpus_first, corpusIter corpus_last, difference_type k_corpus_length ) const { difference_type match_start = 0; // position in the corpus that we're matching diff --git a/include/boost/algorithm/string/classification.hpp b/include/boost/algorithm/string/classification.hpp index ca43602d4..83cdca529 100644 --- a/include/boost/algorithm/string/classification.hpp +++ b/include/boost/algorithm/string/classification.hpp @@ -85,6 +85,22 @@ namespace boost { return detail::is_classifiedF(std::ctype_base::alpha, Loc); } +#ifndef BOOST_NO_CXX11 + //! is_blank predicate + /*! + Construct the \c is_classified predicate for the \c ctype_base::blank category. + + \param Loc A locale used for classification + \return An instance of the \c is_classified predicate + \since c++11 + */ + inline detail::is_classifiedF + is_blank(const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(std::ctype_base::blank, Loc); + } +#endif + //! is_cntrl predicate /*! Construct the \c is_classified predicate for the \c ctype_base::cntrl category. @@ -294,6 +310,9 @@ namespace boost { // pull names to the boost namespace using algorithm::is_classified; using algorithm::is_space; +#ifndef BOOST_NO_CXX11 + using algorithm::is_blank; +#endif using algorithm::is_alnum; using algorithm::is_alpha; using algorithm::is_cntrl; diff --git a/include/boost/algorithm/string/detail/find_iterator.hpp b/include/boost/algorithm/string/detail/find_iterator.hpp index 4f90a98fc..c99078525 100644 --- a/include/boost/algorithm/string/detail/find_iterator.hpp +++ b/include/boost/algorithm/string/detail/find_iterator.hpp @@ -40,10 +40,18 @@ namespace boost { // Protected construction/destruction // Default constructor - find_iterator_base() {} + BOOST_DEFAULTED_FUNCTION(find_iterator_base(), {}) + // Copy construction - find_iterator_base( const find_iterator_base& Other ) : + BOOST_DEFAULTED_FUNCTION(find_iterator_base( const find_iterator_base& Other ), : m_Finder(Other.m_Finder) {} + ) + + // Assignment + BOOST_DEFAULTED_FUNCTION(find_iterator_base& operator=( const find_iterator_base& Other ), { + m_Finder = Other.m_Finder; + return *this; + }) // Constructor template @@ -51,7 +59,7 @@ namespace boost { m_Finder(Finder) {} // Destructor - ~find_iterator_base() {} + BOOST_DEFAULTED_FUNCTION(~find_iterator_base(), {}) // Find operation match_type do_find( diff --git a/include/boost/algorithm/string/find_iterator.hpp b/include/boost/algorithm/string/find_iterator.hpp index 5a52d92e4..47c20e673 100644 --- a/include/boost/algorithm/string/find_iterator.hpp +++ b/include/boost/algorithm/string/find_iterator.hpp @@ -74,7 +74,7 @@ namespace boost { \post eof()==true */ - find_iterator() {} + BOOST_DEFAULTED_FUNCTION(find_iterator(), {}) //! Copy constructor /*! @@ -85,6 +85,18 @@ namespace boost { m_Match(Other.m_Match), m_End(Other.m_End) {} + //! Copy assignment + /*! + Assigns a copy of the find_iterator + */ + BOOST_DEFAULTED_FUNCTION(find_iterator& operator=( const find_iterator& Other ), { + if (this == &Other) return *this; + this->base_type::operator=(Other); + m_Match = Other.m_Match; + m_End = Other.m_End; + return *this; + }) + //! Constructor /*! Construct new find_iterator for a given finder @@ -248,6 +260,20 @@ namespace boost { m_bEof(Other.m_bEof) {} + //! Assignment operator + /*! + Assigns a copy of the split_iterator + */ + BOOST_DEFAULTED_FUNCTION(split_iterator& operator=( const split_iterator& Other ), { + if (this == &Other) return *this; + this->base_type::operator=(Other); + m_Match = Other.m_Match; + m_Next = Other.m_Next; + m_End = Other.m_End; + m_bEof = Other.m_bEof; + return *this; + }) + //! Constructor /*! Construct new split_iterator for a given finder diff --git a/include/boost/algorithm/string/formatter.hpp b/include/boost/algorithm/string/formatter.hpp index 0e08ae7b3..ce590c778 100644 --- a/include/boost/algorithm/string/formatter.hpp +++ b/include/boost/algorithm/string/formatter.hpp @@ -75,7 +75,7 @@ namespace boost { Constructs an \c empty_formatter. Empty formatter always returns an empty sequence. - \param Input container used to select a correct value_type for the + \param - container used to select a correct value_type for the resulting empty_container<>. \return An instance of the \c empty_formatter object. */ diff --git a/include/boost/algorithm/string/trim_all.hpp b/include/boost/algorithm/string/trim_all.hpp index a616f7f33..94f2522bc 100644 --- a/include/boost/algorithm/string/trim_all.hpp +++ b/include/boost/algorithm/string/trim_all.hpp @@ -108,7 +108,6 @@ namespace boost { \param Input An input sequence \param Loc A locale used for 'space' classification - \return A trimmed copy of the input */ template inline void trim_all(SequenceT& Input, const std::locale& Loc =std::locale()) @@ -191,7 +190,6 @@ namespace boost { \param Input An input sequence \param Fill A string used to fill the inner spaces \param Loc A locale used for 'space' classification - \return A trimmed copy of the input */ template inline void trim_fill(SequenceT& Input, const RangeT& Fill, const std::locale& Loc =std::locale()) diff --git a/minmax/example/Jamfile b/minmax/example/Jamfile index d8650e042..9aa7e6982 100644 --- a/minmax/example/Jamfile +++ b/minmax/example/Jamfile @@ -7,6 +7,11 @@ # http://www.boost.org/LICENSE_1_0.txt) # +project + : requirements + /boost/algorithm//boost_algorithm + /boost/timer//boost_timer ; + exe minmax_ex : minmax_ex.cpp ; exe minmax_timer : minmax_timer.cpp ; diff --git a/minmax/example/minmax_timer.cpp b/minmax/example/minmax_timer.cpp index 0ab51a8a4..41aecfcce 100644 --- a/minmax/example/minmax_timer.cpp +++ b/minmax/example/minmax_timer.cpp @@ -15,8 +15,10 @@ // What's the proper BOOST_ flag for vs #include -#include #include +#include +#include +#include template void tie(std::pair p, T1& min, T2& max) @@ -56,17 +58,19 @@ inline int opt_boost_minmax_count(int n) { int repeats = 10; #define TIMER( n, cmd , cmdname ) \ - t.restart(); \ - for (int i=0; i void test_minmax_element(CIterator first, CIterator last, int n, char* name) { typedef typename std::iterator_traits::value_type vtype; - boost::timer t; + boost::timer::cpu_timer t; std::cout << " ON " << name << " WITH OPERATOR<()\n"; TIMER( n, std::min_element(first, last), @@ -99,15 +103,11 @@ void test_minmax_element(CIterator first, CIterator last, int n, char* name) "boost::last_min_last_max_element" << name << " "); #define pred std::bind2nd( std::greater(), vtype(10) ) - TIMER( n, boost::min_element_if(first, last, pred), - "boost::min_element_if" << name << ""); - TIMER( n, boost::max_element_if(first, last, pred), - "boost::max_element_if" << name << ""); - TIMER( n, std::min_element(boost::make_filter_iterator(first, last, pred), - boost::make_filter_iterator(last, last, pred)), + TIMER( n, std::min_element(boost::make_filter_iterator(pred, first, last), + boost::make_filter_iterator(pred, last, last)), "std::min_element_with_filter_iterator" << name << ""); - TIMER( n, std::max_element(boost::make_filter_iterator(first, last, pred), - boost::make_filter_iterator(last, last, pred)), + TIMER( n, std::max_element(boost::make_filter_iterator(pred, first, last), + boost::make_filter_iterator(pred, last, last)), "std::max_element_if_with_filter_iterator" << name << ""); #undef pred @@ -199,10 +199,9 @@ void test(int n) test_range(first, last, n); } -int -main(char argc, char** argv) +int main(int argc, char** argv) { - int n = 100; + int n = 1000; if (argc > 1) n = atoi(argv[1]); if (argc > 2) repeats = atoi(argv[2]); diff --git a/minmax/test/Jamfile.v2 b/minmax/test/Jamfile.v2 index 384b35929..de74e2c64 100644 --- a/minmax/test/Jamfile.v2 +++ b/minmax/test/Jamfile.v2 @@ -9,17 +9,19 @@ import testing ; +project : requirements /boost/algorithm//boost_algorithm ; + alias unit_test_framework : # sources - /boost//unit_test_framework - ; + /boost/test//boost_unit_test_framework + ; { test-suite algorithm/minmax : [ run minmax_element_test.cpp unit_test_framework : : : : minmax_element ] [ run minmax_test.cpp unit_test_framework - : : : : minmax ] + : : : : minmax ] ; } diff --git a/string/doc/Jamfile.v2 b/string/doc/Jamfile.v2 index 9ddebb8b6..58fc21430 100644 --- a/string/doc/Jamfile.v2 +++ b/string/doc/Jamfile.v2 @@ -10,40 +10,40 @@ import toolset ; toolset.using doxygen ; -boostbook string_algo : string_algo.xml autodoc +boostbook string_algo : string_algo.xml autodoc : boost.root=../../../../.. pdf:boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html ; doxygen autodoc - : - [ glob ../../../../boost/algorithm/string.hpp ] - [ glob ../../../../boost/algorithm/string_regex.hpp ] - - [ glob ../../../../boost/algorithm/string/classification.hpp ] - [ glob ../../../../boost/algorithm/string/iterator_range.hpp ] - [ glob ../../../../boost/algorithm/string/sequence_traits.hpp ] - [ glob ../../../../boost/algorithm/string/std_containers_traits.hpp ] - [ glob ../../../../boost/algorithm/string/concept.hpp ] - [ glob ../../../../boost/algorithm/string/compare.hpp ] - [ glob ../../../../boost/algorithm/string/constants.hpp ] - [ glob ../../../../boost/algorithm/string/case_conv.hpp ] - [ glob ../../../../boost/algorithm/string/find.hpp ] - [ glob ../../../../boost/algorithm/string/finder.hpp ] - [ glob ../../../../boost/algorithm/string/find_iterator.hpp ] - [ glob ../../../../boost/algorithm/string/trim.hpp ] - [ glob ../../../../boost/algorithm/string/predicate.hpp ] - [ glob ../../../../boost/algorithm/string/split.hpp ] - [ glob ../../../../boost/algorithm/string/iter_find.hpp ] - [ glob ../../../../boost/algorithm/string/erase.hpp ] - [ glob ../../../../boost/algorithm/string/join.hpp ] - [ glob ../../../../boost/algorithm/string/replace.hpp ] - [ glob ../../../../boost/algorithm/string/find_format.hpp ] - [ glob ../../../../boost/algorithm/string/formatter.hpp ] - [ glob ../../../../boost/algorithm/string/regex.hpp ] - [ glob ../../../../boost/algorithm/string/regex_find_format.hpp ] - [ glob ../../../../boost/algorithm/string/trim_all.hpp ] + : + [ glob ../../include/boost/algorithm/string.hpp ] + [ glob ../../include/boost/algorithm/string_regex.hpp ] + + [ glob ../../include/boost/algorithm/string/classification.hpp ] + [ glob ../../include/boost/algorithm/string/iterator_range.hpp ] + [ glob ../../include/boost/algorithm/string/sequence_traits.hpp ] + [ glob ../../include/boost/algorithm/string/std_containers_traits.hpp ] + [ glob ../../include/boost/algorithm/string/concept.hpp ] + [ glob ../../include/boost/algorithm/string/compare.hpp ] + [ glob ../../include/boost/algorithm/string/constants.hpp ] + [ glob ../../include/boost/algorithm/string/case_conv.hpp ] + [ glob ../../include/boost/algorithm/string/find.hpp ] + [ glob ../../include/boost/algorithm/string/finder.hpp ] + [ glob ../../include/boost/algorithm/string/find_iterator.hpp ] + [ glob ../../include/boost/algorithm/string/trim.hpp ] + [ glob ../../include/boost/algorithm/string/predicate.hpp ] + [ glob ../../include/boost/algorithm/string/split.hpp ] + [ glob ../../include/boost/algorithm/string/iter_find.hpp ] + [ glob ../../include/boost/algorithm/string/erase.hpp ] + [ glob ../../include/boost/algorithm/string/join.hpp ] + [ glob ../../include/boost/algorithm/string/replace.hpp ] + [ glob ../../include/boost/algorithm/string/find_format.hpp ] + [ glob ../../include/boost/algorithm/string/formatter.hpp ] + [ glob ../../include/boost/algorithm/string/regex.hpp ] + [ glob ../../include/boost/algorithm/string/regex_find_format.hpp ] + [ glob ../../include/boost/algorithm/string/trim_all.hpp ] : HIDE_UNDOC_MEMBERS=YES EXTRACT_PRIVATE=NO @@ -53,7 +53,7 @@ doxygen autodoc SEARCH_INCLUDES=YES PREDEFINED="BOOST_STRING_TYPENAME=typename \"BOOST_STATIC_CONSTANT(type,var)=static const type var;\"" ; - + diff --git a/string/doc/quickref.xml b/string/doc/quickref.xml index fe267e718..39a224b70 100644 --- a/string/doc/quickref.xml +++ b/string/doc/quickref.xml @@ -667,6 +667,13 @@ is_space() + + is_blank + Recognize blanks + + is_blank() + + is_alnum Recognize alphanumeric characters diff --git a/string/example/Jamfile b/string/example/Jamfile index 74c923f8b..4cbe09d3d 100644 --- a/string/example/Jamfile +++ b/string/example/Jamfile @@ -7,6 +7,7 @@ # # See http://www.boost.org for updates, documentation, and revision history. +project : requirements /boost/algorithm//boost_algorithm ; exe conv_example : conv_example.cpp ; exe predicate_example : predicate_example.cpp ; diff --git a/string/test/Jamfile.v2 b/string/test/Jamfile.v2 index 7f60df703..8c9508504 100644 --- a/string/test/Jamfile.v2 +++ b/string/test/Jamfile.v2 @@ -9,31 +9,33 @@ import testing ; +project : requirements /boost/algorithm//boost_algorithm ; + alias unit_test_framework : # sources - /boost//unit_test_framework - ; + /boost/test//boost_unit_test_framework + ; test-suite algorithm/string - : [ run + : [ run trim_test.cpp unit_test_framework : : : : trim ] - [ run + [ run conv_test.cpp unit_test_framework : : : : conv ] - [ run + [ run predicate_test.cpp unit_test_framework : : : : predicate ] - [ run + [ run find_test.cpp unit_test_framework : : : @@ -51,23 +53,23 @@ test-suite algorithm/string : : join ] - [ run + [ run replace_test.cpp unit_test_framework : : : : replace ] - [ run + [ run regex_test.cpp unit_test_framework ../../../regex/build//boost_regex : : - : + : : regex ] - [ run + [ run find_format_test.cpp unit_test_framework : : - : + : : find_format ] ; diff --git a/string/test/predicate_test.cpp b/string/test/predicate_test.cpp index ba1564e53..2e1ebd7a6 100644 --- a/string/test/predicate_test.cpp +++ b/string/test/predicate_test.cpp @@ -138,7 +138,12 @@ void classification_test() TEST_CLASS( is_any_of( string("abc") ), "aaabbcc", "aaxb" ); TEST_CLASS( is_any_of( "abc" ), "aaabbcc", "aaxb" ); TEST_CLASS( is_from_range( 'a', 'c' ), "aaabbcc", "aaxb" ); - + +#ifndef BOOST_NO_CXX11 + TEST_CLASS( is_blank(), " \t", "\t \n\r" ); + TEST_CLASS( !is_blank(), "abc\n\v\f\r", "a x\t" ); +#endif + TEST_CLASS( !is_classified(std::ctype_base::space), "...", "..\n\r\t " ); TEST_CLASS( ( !is_any_of("abc") && is_from_range('a','e') ) || is_space(), "d e", "abcde" ); diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index e7091e05e..0c0f93360 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -9,9 +9,11 @@ import testing ; +project : requirements /boost/algorithm//boost_algorithm ; + alias unit_test_framework : # sources - /boost//unit_test_framework + /boost/test//boost_unit_test_framework ; @@ -29,6 +31,7 @@ alias unit_test_framework # Misc tests [ run clamp_test.cpp unit_test_framework : : : : clamp_test ] + [ run is_clamped_test.cpp unit_test_framework : : : : is_clamped_test ] [ run power_test.cpp unit_test_framework : : : : power_test ] [ compile-fail power_fail1.cpp : : : : ] @@ -68,6 +71,7 @@ alias unit_test_framework [ run hex_test2.cpp unit_test_framework : : : : hex_test2 ] [ run hex_test3.cpp unit_test_framework : : : : hex_test3 ] [ run hex_test4.cpp unit_test_framework : : : : hex_test4 ] + [ run mclow.cpp unit_test_framework : : : : mclow ] [ compile-fail hex_fail1.cpp ] # Gather tests @@ -83,7 +87,7 @@ alias unit_test_framework # Is_partitioned_until tests [ run is_partitioned_until_test.cpp unit_test_framework : : : : is_partitioned_until_test ] - + # Apply_permutation tests [ run apply_permutation_test.cpp unit_test_framework : : : : apply_permutation_test ] # Find tests diff --git a/test/copy_if_test1.cpp b/test/copy_if_test1.cpp index b275f5f5d..750b7057e 100644 --- a/test/copy_if_test1.cpp +++ b/test/copy_if_test1.cpp @@ -28,19 +28,21 @@ namespace ba = boost::algorithm; // namespace ba = boost; -BOOST_CXX14_CONSTEXPR bool is_true ( int v ) { return true; } -BOOST_CXX14_CONSTEXPR bool is_false ( int v ) { return false; } +BOOST_CXX14_CONSTEXPR bool is_true ( int ) { return true; } +BOOST_CXX14_CONSTEXPR bool is_false ( int ) { return false; } BOOST_CXX14_CONSTEXPR bool is_even ( int v ) { return v % 2 == 0; } BOOST_CXX14_CONSTEXPR bool is_odd ( int v ) { return v % 2 == 1; } BOOST_CXX14_CONSTEXPR bool is_zero ( int v ) { return v == 0; } +BOOST_CXX14_CONSTEXPR bool less_than_ten ( int v ) { return v < 10; } +BOOST_CXX14_CONSTEXPR bool greater_than_ten ( int v ) { return v > 10; } template void test_copy_if ( Container const &c ) { typedef typename Container::value_type value_type; std::vector v; - + // None of the elements v.clear (); ba::copy_if ( c.begin (), c.end (), back_inserter ( v ), is_false); @@ -118,6 +120,160 @@ void test_copy_while ( Container const &c ) { BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ())); } +template +void test_copy_if_while ( Container const &c ) { + + typedef typename Container::value_type value_type; + typename Container::const_iterator it; + +// Terminate immediately + { + std::vector v; + ba::copy_if_while ( c.begin (), c.end (), back_inserter ( v ), is_true, is_false); + BOOST_CHECK ( v.size () == 0 ); + } + { + std::vector v; + ba::copy_if_while ( c, back_inserter ( v ), is_true, is_false); + BOOST_CHECK ( v.size () == 0 ); + } + +// Copy nothing - never terminate + { + std::vector v; + ba::copy_if_while ( c.begin (), c.end (), back_inserter ( v ), is_false, is_true); + BOOST_CHECK ( v.size () == 0 ); + } + { + std::vector v; + ba::copy_if_while ( c, back_inserter ( v ), is_false, is_true); + BOOST_CHECK ( v.size () == 0 ); + } + +// Copy everything + { + std::vector v; + ba::copy_if_while ( c.begin (), c.end (), back_inserter ( v ), is_true, is_true); + BOOST_CHECK ( v.size () == c.size() ); + BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ())); + } + { + std::vector v; + ba::copy_if_while ( c, back_inserter ( v ), is_true, is_true); + BOOST_CHECK ( v.size () == c.size() ); + BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ())); + } + +// Copy all evens + { + std::vector v; + ba::copy_if_while ( c.begin (), c.end (), back_inserter ( v ), is_even, is_true); + BOOST_CHECK ( v.size () == (size_t) std::count_if ( c.begin (), c.end (), is_even )); + BOOST_CHECK ( ba::all_of ( v.begin (), v.end (), is_even )); + } + { + std::vector v; + ba::copy_if_while ( c, back_inserter ( v ), is_even, is_true); + BOOST_CHECK ( v.size () == (size_t) std::count_if ( c.begin (), c.end (), is_even )); + BOOST_CHECK ( ba::all_of ( v.begin (), v.end (), is_even )); + } + +// Copy some until termination + { + std::vector v; + typename Container::const_iterator it = ba::copy_if_while ( + c.begin (), c.end (), back_inserter ( v ), is_even, less_than_ten).first; + BOOST_CHECK ( it == std::find_if ( c.begin(), c.end(), greater_than_ten )); + BOOST_CHECK ( v.size () == std::count_if ( c.begin(), it, is_even )); + BOOST_CHECK ( ba::all_of ( v.begin (), v.end (), is_even )); + } + { + std::vector v; + typename Container::const_iterator it = ba::copy_if_while ( + c, back_inserter ( v ), is_even, less_than_ten).first; + BOOST_CHECK ( it == std::find_if ( c.begin(), c.end(), greater_than_ten )); + BOOST_CHECK ( v.size () == std::count_if ( c.begin(), it, is_even )); + BOOST_CHECK ( ba::all_of ( v.begin (), v.end (), is_even )); + } + } + +template +void test_copy_if_until ( Container const &c ) { + + typedef typename Container::value_type value_type; + typename Container::const_iterator it; + +// Terminate immediately + { + std::vector v; + ba::copy_if_until ( c.begin (), c.end (), back_inserter ( v ), is_true, is_true); + BOOST_CHECK ( v.size () == 0 ); + } + { + std::vector v; + ba::copy_if_until ( c, back_inserter ( v ), is_true, is_true); + BOOST_CHECK ( v.size () == 0 ); + } + +// Copy nothing - never terminate + { + std::vector v; + ba::copy_if_until ( c.begin (), c.end (), back_inserter ( v ), is_false, is_false); + BOOST_CHECK ( v.size () == 0 ); + } + { + std::vector v; + ba::copy_if_until ( c, back_inserter ( v ), is_false, is_false); + BOOST_CHECK ( v.size () == 0 ); + } + +// Copy everything + { + std::vector v; + ba::copy_if_until ( c.begin (), c.end (), back_inserter ( v ), is_true, is_false); + BOOST_CHECK ( v.size () == c.size() ); + BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ())); + } + { + std::vector v; + ba::copy_if_until ( c, back_inserter ( v ), is_true, is_false); + BOOST_CHECK ( v.size () == c.size() ); + BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ())); + } + +// Copy all evens + { + std::vector v; + ba::copy_if_until ( c.begin (), c.end (), back_inserter ( v ), is_even, is_false); + BOOST_CHECK ( v.size () == (size_t) std::count_if ( c.begin (), c.end (), is_even )); + BOOST_CHECK ( ba::all_of ( v.begin (), v.end (), is_even )); + } + { + std::vector v; + ba::copy_if_until ( c, back_inserter ( v ), is_even, is_false); + BOOST_CHECK ( v.size () == (size_t) std::count_if ( c.begin (), c.end (), is_even )); + BOOST_CHECK ( ba::all_of ( v.begin (), v.end (), is_even )); + } + +// Copy some until termination + { + std::vector v; + typename Container::const_iterator it = ba::copy_if_until ( + c.begin (), c.end (), back_inserter ( v ), is_even, greater_than_ten).first; + BOOST_CHECK ( it == std::find_if ( c.begin(), c.end(), greater_than_ten )); + BOOST_CHECK ( v.size () == std::count_if ( c.begin(), it, is_even )); + BOOST_CHECK ( ba::all_of ( v.begin (), v.end (), is_even )); + } + { + std::vector v; + typename Container::const_iterator it = ba::copy_if_until ( + c, back_inserter ( v ), is_even, greater_than_ten).first; + BOOST_CHECK ( it == std::find_if ( c.begin(), c.end(), greater_than_ten )); + BOOST_CHECK ( v.size () == std::count_if ( c.begin(), it, is_even )); + BOOST_CHECK ( ba::all_of ( v.begin (), v.end (), is_even )); + } + } + template void test_copy_until ( Container const &c ) { @@ -224,8 +380,77 @@ BOOST_CXX14_CONSTEXPR inline bool constexpr_test_copy_until() { return res; } - - + +BOOST_CXX14_CONSTEXPR inline bool constexpr_test_copy_if_while() { + const int sz = 64; + int in_data[sz] = {0}; + bool res = true; + + const int* from = in_data; + const int* to = in_data + sz; + +// Terminate immediately + { + int out_data[sz] = {0}; + int* out = out_data; + out = ba::copy_if_while ( from, to, out, is_true, is_false ).second; + res = (res && out == out_data && ba::all_of(out, out + sz, is_zero)); + } +// Copy nothing + { + int out_data[sz] = {0}; + int* out = out_data; + out = ba::copy_if_while ( from, to, out, is_false, is_true ).second; + res = (res && out == out_data && ba::all_of(out, out + sz, is_zero)); + } +// Copy everything + { + int out_data[sz] = {0}; + int* out = out_data; + out = ba::copy_if_while ( from, to, out, is_true, is_true ).second; + res = (res && out == out_data + sz + && ba::equal( input_iterator(out_data), input_iterator(out_data + sz), + input_iterator(from), input_iterator(to))); + } + + return res; + } + +BOOST_CXX14_CONSTEXPR inline bool constexpr_test_copy_if_until() { + const int sz = 64; + int in_data[sz] = {0}; + bool res = true; + + const int* from = in_data; + const int* to = in_data + sz; + +// Terminate immediately + { + int out_data[sz] = {0}; + int* out = out_data; + out = ba::copy_if_until ( from, to, out, is_true, is_true ).second; + res = (res && out == out_data && ba::all_of(out, out + sz, is_zero)); + } +// Copy nothing + { + int out_data[sz] = {0}; + int* out = out_data; + out = ba::copy_if_until ( from, to, out, is_false, is_false ).second; + res = (res && out == out_data && ba::all_of(out, out + sz, is_zero)); + } +// Copy everything + { + int out_data[sz] = {0}; + int* out = out_data; + out = ba::copy_if_until ( from, to, out, is_true, is_false ).second; + res = (res && out == out_data + sz + && ba::equal( input_iterator(out_data), input_iterator(out_data + sz), + input_iterator(from), input_iterator(to))); + } + + return res; + } + void test_sequence1 () { std::vector v; for ( int i = 5; i < 15; ++i ) @@ -233,20 +458,26 @@ void test_sequence1 () { test_copy_if ( v ); test_copy_while ( v ); test_copy_until ( v ); - + BOOST_CXX14_CONSTEXPR bool constexpr_res_if = constexpr_test_copy_if(); BOOST_CHECK ( constexpr_res_if ); BOOST_CXX14_CONSTEXPR bool constexpr_res_while = constexpr_test_copy_while(); BOOST_CHECK ( constexpr_res_while ); BOOST_CXX14_CONSTEXPR bool constexpr_res_until = constexpr_test_copy_until(); BOOST_CHECK ( constexpr_res_until ); - + BOOST_CXX14_CONSTEXPR bool constexpr_res_if_while = constexpr_test_copy_if_while(); + BOOST_CHECK ( constexpr_res_if_while ); + BOOST_CXX14_CONSTEXPR bool constexpr_res_if_until = constexpr_test_copy_if_until(); + BOOST_CHECK ( constexpr_res_if_until ); + std::list l; for ( int i = 25; i > 15; --i ) l.push_back ( i ); test_copy_if ( l ); test_copy_while ( l ); test_copy_until ( l ); + test_copy_if_while ( l ); + test_copy_if_until ( l ); } diff --git a/test/hex_test4.cpp b/test/hex_test4.cpp index ba1ee341c..19abb4e36 100644 --- a/test/hex_test4.cpp +++ b/test/hex_test4.cpp @@ -25,7 +25,7 @@ void test_short_input1 () { std::string s; try { ba::unhex ( std::string ( "A" ), std::back_inserter(s)); } - catch ( const std::exception &ex ) { return; } + catch ( const std::exception & ) { return; } BOOST_TEST_MESSAGE ( "Failed to catch std::exception in test_short_input1" ); BOOST_CHECK ( false ); } @@ -34,7 +34,7 @@ void test_short_input2 () { std::string s; try { ba::unhex ( std::string ( "A" ), std::back_inserter(s)); } - catch ( const ba::hex_decode_error &ex ) { return; } + catch ( const ba::hex_decode_error & ) { return; } BOOST_TEST_MESSAGE ( "Failed to catch ba::hex_decode_error in test_short_input2" ); BOOST_CHECK ( false ); } @@ -43,7 +43,7 @@ void test_short_input3 () { std::string s; try { ba::unhex ( std::string ( "A" ), std::back_inserter(s)); } - catch ( const ba::not_enough_input &ex ) { return; } + catch ( const ba::not_enough_input & ) { return; } BOOST_TEST_MESSAGE ( "Failed to catch ba::not_enough_input in test_short_input3" ); BOOST_CHECK ( false ); } @@ -53,8 +53,8 @@ void test_short_input4 () { std::string s; try { ba::unhex ( std::string ( "A" ), std::back_inserter(s)); } - catch ( const ba::non_hex_input &ex ) { BOOST_CHECK ( false ); } - catch ( const ba::not_enough_input &ex ) { return; } + catch ( const ba::non_hex_input & ) { BOOST_CHECK ( false ); } + catch ( const ba::not_enough_input & ) { return; } catch ( ... ) { BOOST_CHECK ( false ); } BOOST_CHECK ( false ); } @@ -64,8 +64,8 @@ void test_short_input5 () { std::string s; try { ba::unhex ( "A", std::back_inserter(s)); } - catch ( const ba::non_hex_input &ex ) { BOOST_CHECK ( false ); } - catch ( const ba::not_enough_input &ex ) { return; } + catch ( const ba::non_hex_input & ) { BOOST_CHECK ( false ); } + catch ( const ba::not_enough_input & ) { return; } catch ( ... ) { BOOST_CHECK ( false ); } BOOST_CHECK ( false ); } @@ -125,8 +125,8 @@ void test_nonhex_input4 () { std::string s; try { ba::unhex ( "P1234FA1234", std::back_inserter(s)); } - catch ( const ba::not_enough_input &ex ) { BOOST_CHECK ( false ); } - catch ( const ba::non_hex_input &ex ) { return; } + catch ( const ba::not_enough_input & ) { BOOST_CHECK ( false ); } + catch ( const ba::non_hex_input & ) { return; } catch ( ... ) { BOOST_CHECK ( false ); } BOOST_CHECK ( false ); } diff --git a/test/is_clamped_test.cpp b/test/is_clamped_test.cpp new file mode 100644 index 000000000..575e34305 --- /dev/null +++ b/test/is_clamped_test.cpp @@ -0,0 +1,246 @@ +// (C) Copyright Ivan Matek, Marshall Clow 2021. +// 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) + +#include +#include +#include +#include +#ifdef __cpp_impl_three_way_comparison +#if __has_include() +#define BOOST_IS_CLAMPED_TEST_SPACESHIP +#endif +#ifdef BOOST_IS_CLAMPED_TEST_SPACESHIP +#include +#endif +#endif +#include +#include +#include + +#define BOOST_TEST_MAIN +#include + +namespace ba = boost::algorithm; + +BOOST_CONSTEXPR bool intGreater(int lhs, int rhs) { return lhs > rhs; } + +class custom { + public: + custom(int x) : v(x) {} + custom(const custom &rhs) : v(rhs.v) {} + + bool operator<(const custom &rhs) const { return v < rhs.v; } + bool operator==(const custom &rhs) const { + return v == rhs.v; + } // need this for the test + int v; +}; + +static bool customLess(const custom &lhs, const custom &rhs) { return lhs.v < rhs.v; } + +void test_ints() { + // Inside the range, equal to the endpoints, and outside the endpoints. + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 3, 1, 6 )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 1, 1, 6 )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 6, 1, 6 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 0, 1, 6 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 7, 1, 6 )); + + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 3, 6, 1, intGreater )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 1, 6, 1, intGreater )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 6, 6, 1, intGreater )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 0, 6, 1, intGreater )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 7, 6, 1, intGreater )); + + // Negative numbers + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( -3, -6, -1 )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( -1, -6, -1 )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( -6, -6, -1 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 0, -6, -1 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( -7, -6, -1 )); + + // Mixed positive and negative numbers + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 1, -5, 5 )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( -5, -5, 5 )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 5, -5, 5 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( -6, -5, 5 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 6, -5, 5 )); + + // Unsigned + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 5U, 1U, 6U )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 1U, 1U, 6U )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 6U, 1U, 6U )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 0U, 1U, 6U )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 8U, 1U, 6U )); + + // Mixed (1) + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 5U, 1, 6 )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 1U, 1, 6 )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 6U, 1, 6 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 0U, 1, 6 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 8U, 1, 6 )); + + // Mixed (2) + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 5U, 1, 6. )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 1U, 1, 6. )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 6U, 1, 6. )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 0U, 1, 6. )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 8U, 1, 6. )); + + // float->short conversion does not round + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( 50, 50.999, 100 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( 50, 51.001, 100 )); +} + +void test_floats() { + // If floats are IEEE754 certain floats have exact representations. + if (std::numeric_limits::is_iec559) { + const float lo = 0.125; + const float hi = 0.625; + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( lo, lo, hi )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( hi, lo, hi )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( lo + 0.01, lo, hi )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( lo - 0.01, lo, hi )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( hi + 0.01, lo, hi )); + // If we have nextafterf we can be more precise. + #if __cplusplus >= 201103L + assert(lo < hi); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( hi, lo, hi )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( std::nextafterf( lo, hi ), lo, hi )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( std::nextafterf( hi, lo ), lo, hi )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( (lo + hi) / 2, lo, hi )); + // 1.0 is just for direction of nextafterf, value of 1.0 is not significant. + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( std::nextafterf( lo, lo - 1.0f ), lo, hi )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( std::nextafterf( hi, hi + 1.0f ), lo, hi )); + #endif + } +} + +void test_std_string() { + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( std::string("a3"), std::string("a1"), std::string("a6") )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( std::string("a1"), std::string("a1"), std::string("a6") )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( std::string("a6"), std::string("a1"), std::string("a6") )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( std::string("a7"), std::string("a1"), std::string("a6") )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( std::string("a0"), std::string("a1"), std::string("a6") )); +} + +void test_custom() { + // Inside the range, equal to the endpoints, and outside the endpoints. + const custom c0(0); + const custom c1(1); + const custom c3(3); + const custom c6(6); + const custom c7(7); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( c3, c1, c6 )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( c1, c1, c6 )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( c6, c1, c6 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( c0, c1, c6 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( c7, c1, c6 )); + + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( c3, c1, c6, customLess )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( c1, c1, c6, customLess )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped ( c6, c1, c6, customLess )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( c0, c1, c6, customLess )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped ( c7, c1, c6, customLess )); +} + +void test_point_interval() { + BOOST_CHECK_EQUAL(true, ba::is_clamped(1, 1, 1)); + BOOST_CHECK_EQUAL(false, ba::is_clamped(0, 1, 1)); + BOOST_CHECK_EQUAL(false, ba::is_clamped(2, 1, 1)); +} + +void test_first_argument_determines_types() { + // all arguments are int + BOOST_CHECK_EQUAL(true, ba::is_clamped(5, 5.9, 6.1)); + BOOST_CHECK_EQUAL(true, ba::is_clamped(6, 5.9, 6.1)); + // all arguments are double + BOOST_CHECK_EQUAL(false, ba::is_clamped(5.0, 5.9, 6.1)); + BOOST_CHECK_EQUAL(false, ba::is_clamped(6.2, 5.9, 6.1)); +} + +void test_constexpr() { + #if __cplusplus >= 201402L + { + constexpr bool is_clamped = (ba::is_clamped ( 3, 1, 6 )); + BOOST_CHECK_EQUAL (true, is_clamped ); + } + { + constexpr bool is_clamped = (ba::is_clamped ( 1, 1, 6 )); + BOOST_CHECK_EQUAL (true, is_clamped ); + } + { + constexpr bool is_clamped = (ba::is_clamped ( 6, 1, 6 )); + BOOST_CHECK_EQUAL (true, is_clamped ); + } + { + constexpr bool is_clamped = (ba::is_clamped ( 0, 1, 6 )); + BOOST_CHECK_EQUAL(false, is_clamped ); + } + { + constexpr bool is_clamped = (ba::is_clamped ( 7, 1, 6 )); + BOOST_CHECK_EQUAL(false, is_clamped ); + } + #endif +} + + +#ifdef BOOST_IS_CLAMPED_TEST_SPACESHIP +struct custom_with_spaceship { + int v; + auto operator<=>(const custom_with_spaceship&) const = default; +}; +#endif + +void test_spaceship() { + #ifdef BOOST_IS_CLAMPED_TEST_SPACESHIP + // Inside the range, equal to the endpoints, and outside the endpoints. + const custom_with_spaceship c0(0); + const custom_with_spaceship c1(1); + const custom_with_spaceship c3(3); + const custom_with_spaceship c6(6); + const custom_with_spaceship c7(7); + BOOST_CHECK_EQUAL ( true, ba::is_clamped (c3, c1, c6 )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped (c1, c1, c6 )); + BOOST_CHECK_EQUAL ( true, ba::is_clamped (c6, c1, c6 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped (c0, c1, c6 )); + BOOST_CHECK_EQUAL ( false, ba::is_clamped (c7, c1, c6 )); + { + constexpr custom_with_spaceship c1(1); + constexpr custom_with_spaceship c3(3); + constexpr custom_with_spaceship c6(6); + constexpr bool clamped = ba::is_clamped (c3, c1, c6 ); + BOOST_CHECK_EQUAL ( true, clamped ); + } + #endif +} + +BOOST_AUTO_TEST_CASE(test_main) { + test_ints(); + test_floats(); + test_std_string(); + test_custom(); + test_point_interval(); + test_first_argument_determines_types(); + test_constexpr(); + test_spaceship(); +} + +#if __cplusplus >= 201103L +typedef std::tuple test_types_tuple; + +BOOST_AUTO_TEST_CASE_TEMPLATE(test_extremes, T, test_types_tuple) { + const T max = std::numeric_limits::max(); + BOOST_CHECK_EQUAL(true, ba::is_clamped( max, max, max )); + BOOST_CHECK_EQUAL(true, ba::is_clamped( max, max - 1, max )); + BOOST_CHECK_EQUAL(false, ba::is_clamped( max - 1, max, max )); + + const T min = std::numeric_limits::min(); + BOOST_CHECK_EQUAL(true, ba::is_clamped( min, min, min )); + BOOST_CHECK_EQUAL(true, ba::is_clamped( min, min, min + 1 )); + BOOST_CHECK_EQUAL(false, ba::is_clamped( min, min + 1, min + 1 )); +} +#endif diff --git a/test/is_permutation_test1.cpp b/test/is_permutation_test1.cpp index 2e1a12f35..85cf806ee 100644 --- a/test/is_permutation_test1.cpp +++ b/test/is_permutation_test1.cpp @@ -112,7 +112,7 @@ void test_sequence1 () { std::vector v, v1; v.clear (); - for ( std::size_t i = 5; i < 15; ++i ) + for ( int i = 5; i < 15; ++i ) v.push_back ( i ); v1 = v; BOOST_CHECK ( ba::is_permutation ( v.begin (), v.end (), v.begin ())); // better be a permutation of itself! diff --git a/test/mclow.cpp b/test/mclow.cpp new file mode 100644 index 000000000..79e06cc2b --- /dev/null +++ b/test/mclow.cpp @@ -0,0 +1,15 @@ +#include + +#include +#include + +struct hex_decode_error : virtual boost::exception, virtual std::exception {}; +struct not_enough_input : virtual hex_decode_error {}; +struct non_hex_input : virtual hex_decode_error {}; + +void toss() { BOOST_THROW_EXCEPTION(not_enough_input()); } + +int main () { + try { toss(); } + catch ( const hex_decode_error & /*ex*/ ) {} + } diff --git a/test/search_test1.cpp b/test/search_test1.cpp index 3fe3b91cd..8bcc5a7ef 100644 --- a/test/search_test1.cpp +++ b/test/search_test1.cpp @@ -32,7 +32,7 @@ namespace { // Check using iterators template - void check_one_iter ( const Container &haystack, const std::string &needle, int expected ) { + void check_one_iter ( const Container &haystack, const std::string &needle, std::ptrdiff_t expected ) { typedef typename Container::const_iterator iter_type; typedef typename std::pair ret_type; typedef std::string::const_iterator pattern_type; @@ -53,7 +53,7 @@ namespace { // iter_type it1r = ret1r.first; // iter_type it2 = ret2.first; // iter_type it3 = ret3.first; - const int dist = ret1.first == hEnd ? -1 : std::distance ( hBeg, ret1.first ); + const std::ptrdiff_t dist = ret1.first == hEnd ? -1 : std::distance ( hBeg, ret1.first ); std::cout << "(Iterators) Pattern is " << needle.length () << ", haysstack is " << haystack.length () << " chars long; " << std::endl; try { @@ -97,7 +97,7 @@ namespace { // Check using pointers // We're assuming that the container implements contiguous storage here. template - void check_one_pointer ( const Container &haystack, const std::string &needle, int expected ) { + void check_one_pointer ( const Container &haystack, const std::string &needle, std::ptrdiff_t expected ) { typedef const typename Container::value_type *ptr_type; typedef typename std::pair ret_type; @@ -110,7 +110,7 @@ namespace { ret_type ret1 = ba::boyer_moore_search (hBeg, hEnd, nBeg, nEnd); ret_type ret2 = ba::boyer_moore_horspool_search (hBeg, hEnd, nBeg, nEnd); ret_type ret3 = ba::knuth_morris_pratt_search (hBeg, hEnd, nBeg, nEnd); - const int dist = ret1.first == hEnd ? -1 : std::distance ( hBeg, ret1.first ); + const std::ptrdiff_t dist = ret1.first == hEnd ? -1 : std::distance ( hBeg, ret1.first ); std::cout << "(Pointers) Pattern is " << needle.length () << ", haysstack is " << haystack.length () << " chars long; " << std::endl; try { @@ -147,7 +147,7 @@ namespace { // Check using objects template - void check_one_object ( const Container &haystack, const std::string &needle, int expected ) { + void check_one_object ( const Container &haystack, const std::string &needle, std::ptrdiff_t expected ) { typedef typename Container::const_iterator iter_type; typedef typename std::pair ret_type; typedef std::string::const_iterator pattern_type; @@ -169,7 +169,7 @@ namespace { ret_type retr1r = bm_r (haystack); ret_type ret2 = bmh (hBeg, hEnd); ret_type ret3 = kmp (hBeg, hEnd); - const int dist = ret1.first == hEnd ? -1 : std::distance ( hBeg, ret1.first ); + const std::ptrdiff_t dist = ret1.first == hEnd ? -1 : std::distance ( hBeg, ret1.first ); std::cout << "(Objects) Pattern is " << needle.length () << ", haysstack is " << haystack.length () << " chars long; " << std::endl; try { @@ -224,7 +224,7 @@ namespace { template - void check_one ( const Container &haystack, const std::string &needle, int expected ) { + void check_one ( const Container &haystack, const std::string &needle, std::ptrdiff_t expected ) { check_one_iter ( haystack, needle, expected ); check_one_pointer ( haystack, needle, expected ); check_one_object ( haystack, needle, expected ); diff --git a/test/search_test2.cpp b/test/search_test2.cpp index eba105e9b..ae517cde4 100644 --- a/test/search_test2.cpp +++ b/test/search_test2.cpp @@ -85,7 +85,7 @@ namespace { std::cout << std::endl; } - void check_one ( const vec &haystack, const vec &needle, int expected ) { + void check_one ( const vec &haystack, const vec &needle, std::ptrdiff_t expected ) { std::size_t i; std::clock_t sTime; unsigned long stdDiff; @@ -147,7 +147,7 @@ BOOST_AUTO_TEST_CASE( test_main ) std::cout << "---- Middle -----" << std::endl; check_one ( c1, p1f, -2 ); // Don't know answer std::cout << "------ End ------" << std::endl; - check_one ( c1, p1e, c1.size() - p1e.size ()); + check_one ( c1, p1e, static_cast(c1.size() - p1e.size ())); std::cout << "--- Not found ---" << std::endl; check_one ( c1, p1n, -1 ); // Not found } diff --git a/test/search_test3.cpp b/test/search_test3.cpp index e4c766185..cac7499d4 100644 --- a/test/search_test3.cpp +++ b/test/search_test3.cpp @@ -85,7 +85,7 @@ namespace { std::cout << std::endl; } - void check_one ( const vec &haystack, const vec &needle, int expected ) { + void check_one ( const vec &haystack, const vec &needle, std::ptrdiff_t expected ) { std::size_t i; std::clock_t sTime; unsigned long stdDiff; @@ -147,7 +147,7 @@ BOOST_AUTO_TEST_CASE( test_main ) std::cout << "---- Middle -----" << std::endl; check_one ( c1, p1f, -2 ); // Don't know answer std::cout << "------ End ------" << std::endl; - check_one ( c1, p1e, c1.size() - p1e.size ()); + check_one ( c1, p1e, static_cast(c1.size() - p1e.size ())); std::cout << "--- Not found ---" << std::endl; check_one ( c1, p1n, -1 ); // Not found } diff --git a/test/search_test4.cpp b/test/search_test4.cpp index 997e35907..0916508b0 100644 --- a/test/search_test4.cpp +++ b/test/search_test4.cpp @@ -62,7 +62,7 @@ namespace { return retVal; } - void check_one ( const vec &haystack, const vec &needle, int expected ) { + void check_one ( const vec &haystack, const vec &needle, std::ptrdiff_t expected ) { std::pair res; std::pair exp; // the expected result @@ -117,7 +117,7 @@ BOOST_AUTO_TEST_CASE( test_main ) std::cout << "---- Middle -----" << std::endl; check_one ( c1, p1f, -2 ); // Don't know answer std::cout << "------ End ------" << std::endl; - check_one ( c1, p1e, c1.size() - p1e.size ()); + check_one ( c1, p1e, static_cast(c1.size() - p1e.size ())); std::cout << "--- Not found ---" << std::endl; check_one ( c1, p1n, -1 ); // Not found }