Merge doc fixes to master

Implement copy_if_while and copy_if_until

.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/<library> 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\/.*/
+    - bugfix/*
-
+    - feature/*
-env:
+    - fix/*
-  matrix:
+    - pr/*
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  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
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=11
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=11
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - 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
-
-    - 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:
-  - |-
+  - cd $BOOST_ROOT/libs/$SELF
-    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ci/travis/build.sh
-  - ./b2 -j3 libs/algorithm/test toolset=$TOOLSET cxxstd=$CXXSTD $CXXSTD_DIALECT
+
+#
+# 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:
+    # 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:
+        - 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:
+        - COMMENT=cppcheck
+      script:
+        - cd $BOOST_ROOT/libs/$SELF
+        - ci/travis/cppcheck.sh
+
+    - os: linux
+      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:
+        - 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
+      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

CMakeLists.txt

@@ -0,0 +1,41 @@
+# Generated by `boostdep --cmake algorithm`
+# Copyright 2020 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(boost_algorithm VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_algorithm INTERFACE)
+add_library(Boost::algorithm ALIAS boost_algorithm)
+
+target_include_directories(boost_algorithm INTERFACE include)
+
+target_link_libraries(boost_algorithm
+  INTERFACE
+    Boost::array
+    Boost::assert
+    Boost::bind
+    Boost::concept_check
+    Boost::config
+    Boost::core
+    Boost::exception
+    Boost::function
+    Boost::iterator
+    Boost::mpl
+    Boost::range
+    Boost::regex
+    Boost::static_assert
+    Boost::throw_exception
+    Boost::tuple
+    Boost::type_traits
+    Boost::unordered
+)
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()
+

Jamfile

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

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.

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)](http://www.boost.org/development/tests/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)](http://www.boost.org/development/tests/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.
+
+

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/<library> 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:
+matrix:
-  - x64
+  # 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
+    - FLAVOR: Visual Studio 2017 C++2a Strict
-      ARGS: --toolset=msvc-14.1 address-model=64
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      B2_ADDRESS_MODEL: address-model=64
-      ARGS: --toolset=msvc-14.1 address-model=32
+      B2_CXXFLAGS: cxxflags=-permissive-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      B2_CXXSTD: latest # 2a
-      ARGS: --toolset=msvc-14.1 address-model=64 cxxflags=-std:c++latest cxxflags=-permissive-
+      B2_TOOLSET: msvc-14.1
-    - ARGS: --toolset=msvc-9.0  address-model=32
+
-    - ARGS: --toolset=msvc-10.0 address-model=32
+    - FLAVOR: Visual Studio 2017 C++17
-    - ARGS: --toolset=msvc-11.0 address-model=32
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-    - ARGS: --toolset=msvc-12.0 address-model=32
+      B2_ADDRESS_MODEL: address-model=64
-    - ARGS: --toolset=msvc-14.0 address-model=32
+      B2_CXXSTD: 17
-    - ARGS: --toolset=msvc-12.0 address-model=64
+      B2_TOOLSET: msvc-14.1
-    - ARGS: --toolset=msvc-14.0 address-model=64
+
-    - ARGS: --toolset=msvc-14.0 address-model=64 cxxflags=-std:c++latest
+    - FLAVOR: Visual Studio 2017 C++14 (Default)
-    - ARGS: --toolset=gcc address-model=64 
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      CXXSTD: 03,11,14,1z
+      B2_ADDRESS_MODEL: address-model=64,32
-      PATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
+      B2_TOOLSET: msvc-14.1
-    - ARGS: --toolset=gcc address-model=64
+
-      CXXSTD: 03,11,14,1z
+    - FLAVOR: Visual Studio 2015 C++14 (Default)
-      PATH: C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-    - ARGS: --toolset=gcc address-model=32 linkflags=-Wl,-allow-multiple-definition
+      B2_ADDRESS_MODEL: address-model=64,32
-      CXXSTD: 03,11,14,1z
+      B2_TOOLSET: msvc-14.0
-      PATH: C:\MinGW\bin;%PATH%
+
-    - ARGS: --toolset=gcc address-model=64
+    - FLAVOR: Visual Studio 2010, 2012, 2013
-      CXXSTD: 03,11,14,1z
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      PATH: C:\cygwin64\bin;%PATH%
+      B2_TOOLSET: msvc-10.0,msvc-11.0,msvc-12.0
-    - ARGS: --toolset=gcc address-model=32
+
-      CXXSTD: 03,11,14,1z
+    - FLAVOR: cygwin (32-bit)
-      PATH: C:\cygwin\bin;%PATH%
+      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 ..
+  - set SELF=%APPVEYOR_PROJECT_NAME:-=_%
-  - git clone -b %APPVEYOR_REPO_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+  - git clone https://github.com/boostorg/boost-ci.git C:\boost-ci
-  - cd boost-root
+  - xcopy /s /e /q /i C:\boost-ci\ci .\ci
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\algorithm
+  - ci\appveyor\install.bat
-  - 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
 
 build: off
 
 test_script:
-  - cd libs\config\test
+  - set SELF=%APPVEYOR_PROJECT_NAME:-=_%
-  - ..\..\..\b2 -j3 %ARGS% cxxstd=%CXXSTD%
+  - 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)

doc/Jamfile.v2

@@ -22,6 +22,7 @@ doxygen autodoc
                ../../../boost/algorithm/searching/*.hpp
                ../../../boost/algorithm/cxx11/*.hpp
                ../../../boost/algorithm/cxx14/*.hpp
+               ../../../boost/algorithm/cxx17/*.hpp
         ]
     :
        <doxygen:param>"PREDEFINED=\"BOOST_ALGORITHM_DOXYGEN=1\""
@@ -40,8 +41,8 @@ boostbook standalone
     <xsl:param>"boost.doxygen.reftitle=Boost.Algorithms C++ Reference"
     <xsl:param>chapter.autolabel=0
     <xsl:param>chunk.section.depth=8
-    <xsl:param>toc.section.depth=2
+    <xsl:param>toc.section.depth=3
-    <xsl:param>toc.max.depth=2
+    <xsl:param>toc.max.depth=3
     <xsl:param>generate.section.toc.level=1
   ;
 

doc/algorithm.qbk

@@ -46,7 +46,11 @@ Thanks to all the people who have reviewed this library and made suggestions for
 [include knuth_morris_pratt.qbk]
 [endsect]
 
+
 [section:CXX11 C++11 Algorithms]
+
+[section:CXX11_inner_algorithms]
+
 [include all_of.qbk]
 [include any_of.qbk]
 [include none_of.qbk]
@@ -55,24 +59,231 @@ Thanks to all the people who have reviewed this library and made suggestions for
 [include is_partitioned.qbk]
 [include is_permutation.qbk]
 [include partition_point.qbk]
-[endsect]
+
+[section:partition_copy partition_copy ]
+[*[^[link header.boost.algorithm.cxx11.partition_copy_hpp            partition_copy]              ] ]
+Copy a subset of a sequence to a new sequence
+[endsect:partition_copy]
+
+[section:copy_if        copy_if        ]
+[*[^[link header.boost.algorithm.cxx11.copy_if_hpp                   copy_if]                     ] ]
+Copy a subset of a sequence to a new sequence
+[endsect:copy_if]
+
+[section:copy_n         copy_n         ]
+[*[^[link header.boost.algorithm.cxx11.copy_n_hpp                    copy_n]                      ] ]
+Copy n items from one sequence to another
+[endsect:copy_n]
+
+[section:iota           iota           ]
+[*[^[link header.boost.algorithm.cxx11.iota_hpp                      iota]                        ] ]
+Generate an increasing series
+[endsect:iota]
+
+[endsect:CXX11_inner_algorithms]
+
+[endsect:CXX11]
+
 
 [section:CXX14 C++14 Algorithms]
+
+[section:CXX14_inner_algorithms]
+
 [include equal.qbk]
 [include mismatch.qbk]
-[endsect]
+
+[endsect:CXX14_inner_algorithms]
+
+[endsect:CXX14]
+
+
+[section:CXX17 C++17 Algorithms]
+
+[section:CXX17_inner_algorithms]
+
+[section:for_each_n for_each_n]
+[*[^[link boost.algorithm.for_each_n                                 for_each_n]                  ] ]
+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]
-[include clamp-hpp.qbk]
-[include find_not.qbk]
-[include find_backward.qbk]
-[include gather.qbk]
-[include hex.qbk]
-[include is_palindrome.qbk]
-[include is_partitioned_until.qbk]
-[include apply_permutation.qbk]
-[endsect]
 
+[section:misc_inner_algorithms]
+
+[section:none_of_equal             none_of_equal             ]
+[*[^[link header.boost.algorithm.cxx11.none_of_hpp                   none_of_equal]               ] ]
+Whether none of a range's elements matches a value
+[endsect:none_of_equal]
+
+[section:one_of_equal              one_of_equal              ]
+[*[^[link header.boost.algorithm.cxx11.one_of_hpp                    one_of_equal]                ] ]
+Whether only one of a range's elements matches a value
+[endsect:one_of_equal]
+
+[section:is_decreasing             is_decreasing             ]
+[*[^[link header.boost.algorithm.cxx11.is_sorted_hpp                 is_decreasing]               ] ]
+Whether an entire sequence is decreasing; i.e, each item is less than or equal to the previous one
+[endsect:is_decreasing]
+
+[section:is_increasing             is_increasing             ]
+[*[^[link header.boost.algorithm.cxx11.is_sorted_hpp                 is_increasing]               ] ]
+Whether an entire sequence is increasing; i.e, each item is greater than or equal to the previous one
+[endsect:is_increasing]
+
+[section:is_strictly_decreasing    is_strictly_decreasing    ]
+[*[^[link header.boost.algorithm.cxx11.is_sorted_hpp                 is_strictly_decreasing]      ] ]
+Whether an entire sequence is strictly decreasing; i.e, each item is less than the previous one
+[endsect:is_strictly_decreasing]
+
+[section:is_strictly_increasing    is_strictly_increasing    ]
+[*[^[link header.boost.algorithm.cxx11.is_sorted_hpp                 is_strictly_increasing]      ] ]
+Whether an entire sequence is strictly increasing; i.e, each item is greater than the previous one
+[endsect:is_strictly_increasing]
+
+[include clamp-hpp.qbk]
+
+[section:clamp_range               clamp_range               ]
+[*[^[link header.boost.algorithm.clamp_hpp                           clamp_range]                 ] ]
+Perform [^clamp] on the elements of a range and write the results into an output iterator
+[endsect:clamp_range]
+
+[include find_not.qbk]
+
+[include find_backward.qbk]
+
+[section:find_not_backward         find_not_backward         ]
+[*[^[link header.boost.algorithm.find_backward_hpp                   find_not_backward]           ] ]
+Find the last element in a sequence that does not equal a value.
+See [link the_boost_algorithm_library.Misc.misc_inner_algorithms.find_backward find_backward].
+[endsect:find_not_backward]
+
+[section:find_if_backward          find_if_backward          ]
+[*[^[link header.boost.algorithm.find_backward_hpp                   find_if_backward]            ] ]
+Find the last element in a sequence that satisfies a predicate.
+See [link the_boost_algorithm_library.Misc.misc_inner_algorithms.find_backward find_backward].
+[endsect:find_if_backward]
+
+[section:find_if_not               find_if_not               ]
+[*[^[link header.boost.algorithm.cxx11.find_if_not_hpp               find_if_not]                 ] ]
+Find the first element in a sequence that does not satisfy a predicate.
+See [link the_boost_algorithm_library.Misc.misc_inner_algorithms.find_not find_not].
+[endsect:find_if_not]
+
+[section:find_if_not_backward      find_if_not_backward      ]
+[*[^[link header.boost.algorithm.find_backward_hpp                   find_if_not_backward]        ] ]
+Find the last element in a sequence that does not satisfy a predicate.
+See [link the_boost_algorithm_library.Misc.misc_inner_algorithms.find_backward find_backward].
+[endsect:find_if_not_backward]
+
+[include gather.qbk]
+
+[include hex.qbk]
+
+[section:unhex                     unhex                     ]
+[*[^[link header.boost.algorithm.hex_hpp                             unhex]                       ] ]
+Convert a sequence of hexadecimal characters into a sequence of integers or characters
+[endsect:unhex]
+
+[section:hex_lower                 hex_lower                 ]
+[*[^[link header.boost.algorithm.hex_hpp                             hex_lower]                   ] ]
+Convert a sequence of integral types into a lower case hexadecimal sequence of characters
+[endsect:hex_lower]
+
+[include is_palindrome.qbk]
+
+[include is_partitioned_until.qbk]
+
+[section:apply_reverse_permutation apply_reverse_permutation ]
+See below
+[endsect:apply_reverse_permutation]
+
+[include apply_permutation.qbk]
+
+[section:iota_n                    iota_n                    ]
+[*[^[link boost.algorithm.iota_n                                     iota_n]                      ] ]
+Write a sequence of n increasing values to an output iterator
+[endsect:iota_n]
+
+[section:power                     power                     ]
+[*[^[link header.boost.algorithm.algorithm_hpp                       power]                       ] ]
+Raise a value to an integral power ([^constexpr] since C++14)
+[endsect:power]
+
+[endsect:misc_inner_algorithms]
+
+[endsect:Misc]
+
+
+[section:not_yet_documented_cxx17_algos Not-yet-documented C++17 Algorithms]
+
+* [*[^[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_reduce_hpp          transform_reduce]            ] ]
+
+[endsect:not_yet_documented_cxx17_algos]
+
+
+[section:not_yet_documented_other_algos Not-yet-documented Other Algorithms]
+
+* [*[^[link header.boost.algorithm.minmax_hpp                          minmax]                      ] ]
+* [*[^[link header.boost.algorithm.minmax_element_hpp                  first_max_element]           ] ]
+* [*[^[link header.boost.algorithm.minmax_element_hpp                  first_min_element]           ] ]
+* [*[^[link header.boost.algorithm.minmax_element_hpp                  first_min_first_max_element] ] ]
+* [*[^[link header.boost.algorithm.minmax_element_hpp                  first_min_last_max_element]  ] ]
+* [*[^[link header.boost.algorithm.minmax_element_hpp                  last_max_element]            ] ]
+* [*[^[link header.boost.algorithm.minmax_element_hpp                  last_min_element]            ] ]
+* [*[^[link header.boost.algorithm.minmax_element_hpp                  last_min_first_max_element]  ] ]
+* [*[^[link header.boost.algorithm.minmax_element_hpp                  last_min_last_max_element]   ] ]
+* [*[^[link header.boost.algorithm.minmax_element_hpp                  minmax_element]              ] ]
+* [*[^[link header.boost.algorithm.sort_subrange_hpp                   partition_subrange]          ] ]
+* [*[^[link header.boost.algorithm.sort_subrange_hpp                   sort_subrange]               ] ]
+
+[endsect:not_yet_documented_other_algos]
 
 
 [xinclude autodoc.xml]

doc/apply_permutation.qbk

@@ -9,7 +9,7 @@ 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)
 ]
 
-The header file 'apply_permutation.hpp' contains two algorithms, apply_permutation and apply_reverse_permutation. Also there are range-based versions. 
+The header file [^[link header.boost.algorithm.apply_permutation_hpp apply_permutation.hpp]] contains two algorithms, `apply_permutation` and `apply_reverse_permutation`. There are also range-based versions.
 The algorithms transform the item sequence according to index sequence order.
 
 The routine `apply_permutation` takes a item sequence and a order sequence. It reshuffles item sequence according to order sequence. Every value in order sequence means where the item comes from. 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).

example/Jamfile.v2

@@ -18,8 +18,8 @@ project /boost/algorithm/example
     :
     ;
 
-exe clamp_example   : clamp_example.cpp ;
+exe clamp_example   : clamp_example.cpp : ;
 exe search_example  : search_example.cpp ;
-exe is_palindrome_example  : is_palindrome_example.cpp;
+exe is_palindrome_example  : is_palindrome_example.cpp : <cxxstd>11 ;
-exe is_partitioned_until_example  : is_partitioned_until_example.cpp;
+exe is_partitioned_until_example  : is_partitioned_until_example.cpp : <cxxstd>11 ;
-exe apply_permutation_example  : apply_permutation_example.cpp;
+exe apply_permutation_example  : apply_permutation_example.cpp : <cxxstd>11 ;

example/is_partitioned_until_example.cpp

@@ -32,8 +32,8 @@ struct isOddComp
 
 int main ( int /*argc*/, char * /*argv*/ [] )
 {
-    std::vector<int> good({1, 2, 4});
+    std::vector<int> good{1, 2, 4};
-    std::vector<int> bad({1, 2, 3});
+    std::vector<int> bad{1, 2, 3};
 
     //Use custom function
     auto it1 = ba::is_partitioned_until(good.begin(), good.end(), isOdd);

example/search_example.cpp

@@ -27,7 +27,7 @@ int main ( int /*argc*/, char * /*argv*/ [] ) {
 //  algorithms. They all have the same (dual) interface.
 
 //  There is a procedural interface, based on std::search:
-    if ( ba::boyer_moore_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != haystack.end ())
+    if ( ba::boyer_moore_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != std::make_pair(haystack.end(), haystack.end()))
         std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (boyer-moore 1)" << std::endl;
     else
         std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (boyer-moore 1)" << std::endl;
@@ -36,19 +36,19 @@ int main ( int /*argc*/, char * /*argv*/ [] ) {
 //  you can create a search object and use that over and over again - amortizing the setup
 //  costs across several searches
     ba::boyer_moore<std::string::const_iterator> search1 ( needle1.begin (), needle1.end ());
-    if ( search1 ( haystack.begin (), haystack.end ()) != haystack.end ())
+    if ( search1 ( haystack.begin (), haystack.end ()) != std::make_pair(haystack.end(), haystack.end()))
         std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (boyer-moore 2)" << std::endl;
     else
         std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (boyer-moore 2)" << std::endl;
 
 //  There is also an implementation of boyer-moore-horspool searching
-    if ( ba::boyer_moore_horspool_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != haystack.end ())
+    if ( ba::boyer_moore_horspool_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != std::make_pair(haystack.end(), haystack.end()))
         std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (boyer-moore-horspool)" << std::endl;
     else
         std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (boyer-moore-horspool)" << std::endl;
 
 //  And also the knuth-pratt-morris search algorithm
-    if ( ba::knuth_morris_pratt_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != haystack.end ())
+    if ( ba::knuth_morris_pratt_search ( haystack.begin (), haystack.end (), needle1.begin (), needle1.end ()) != std::make_pair(haystack.end(), haystack.end()))
         std::cout << "Found '" << needle1 << "'  in '" << haystack << "' (knuth_morris_pratt)" << std::endl;
     else
         std::cout << "Did NOT find '" << needle1 << "'  in '" << haystack << "' (knuth_morris_pratt)" << std::endl;

include/boost/algorithm/algorithm.hpp

@@ -19,6 +19,7 @@
 
 #include <functional> // for plus and multiplies
 
+#include <boost/config.hpp>
 #include <boost/utility/enable_if.hpp> // for boost::disable_if
 #include <boost/type_traits/is_integral.hpp>
 

include/boost/algorithm/apply_permutation.hpp

@@ -19,8 +19,8 @@
 #define BOOST_ALGORITHM_APPLY_PERMUTATION_HPP
 
 #include <algorithm>
-#include <type_traits>
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 

include/boost/algorithm/clamp.hpp

@@ -23,16 +23,17 @@
 #include <iterator>         //  For std::iterator_traits
 #include <cassert>
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
-#include <boost/mpl/identity.hpp>      // for identity
+#include <boost/type_traits/type_identity.hpp> // for boost::type_identity
 #include <boost/utility/enable_if.hpp>         // for boost::disable_if
 
 namespace boost { namespace algorithm {
 
 /// \fn clamp ( T const& val, 
-///               typename boost::mpl::identity<T>::type const & lo, 
+///               typename boost::type_identity<T>::type const & lo, 
-///               typename boost::mpl::identity<T>::type const & hi, Pred p )
+///               typename boost::type_identity<T>::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.
@@ -47,8 +48,8 @@ namespace boost { namespace algorithm {
 ///
   template<typename T, typename Pred> 
   BOOST_CXX14_CONSTEXPR T const & clamp ( T const& val, 
-    typename boost::mpl::identity<T>::type const & lo, 
+    typename boost::type_identity<T>::type const & lo, 
-    typename boost::mpl::identity<T>::type const & hi, Pred p )
+    typename boost::type_identity<T>::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;
@@ -56,8 +57,8 @@ namespace boost { namespace algorithm {
 
 
 /// \fn clamp ( T const& val, 
-///               typename boost::mpl::identity<T>::type const & lo, 
+///               typename boost::identity<T>::type const & lo, 
-///               typename boost::mpl::identity<T>::type const & hi )
+///               typename boost::identity<T>::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.
@@ -69,8 +70,8 @@ namespace boost { namespace algorithm {
 ///
   template<typename T> 
   BOOST_CXX14_CONSTEXPR T const& clamp ( const T& val, 
-    typename boost::mpl::identity<T>::type const & lo, 
+    typename boost::type_identity<T>::type const & lo, 
-    typename boost::mpl::identity<T>::type const & hi )
+    typename boost::type_identity<T>::type const & hi )
   {
     return boost::algorithm::clamp ( val, lo, hi, std::less<T>());
   } 

include/boost/algorithm/cxx11/all_of.hpp

@@ -12,6 +12,7 @@
 #ifndef BOOST_ALGORITHM_ALL_OF_HPP
 #define BOOST_ALGORITHM_ALL_OF_HPP
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 

include/boost/algorithm/cxx11/any_of.hpp

@@ -14,6 +14,7 @@
 #ifndef BOOST_ALGORITHM_ANY_OF_HPP
 #define BOOST_ALGORITHM_ANY_OF_HPP
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 

include/boost/algorithm/cxx11/copy_if.hpp

@@ -13,6 +13,8 @@
 #define BOOST_ALGORITHM_COPY_IF_HPP
 
 #include <utility>    // for std::pair, std::make_pair
+
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
@@ -124,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<typename InputIterator, typename OutputIterator, typename CopyPredicate, typename TerminatePred>
+BOOST_CXX14_CONSTEXPR std::pair<InputIterator, OutputIterator>
+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<typename Range, typename OutputIterator, typename CopyPredicate, typename TerminatePred>
+BOOST_CXX14_CONSTEXPR std::pair<typename boost::range_iterator<const Range>::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<typename InputIterator, typename OutputIterator, typename CopyPredicate, typename TerminatePred>
+BOOST_CXX14_CONSTEXPR std::pair<InputIterator, OutputIterator>
+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<typename Range, typename OutputIterator, typename CopyPredicate, typename TerminatePred>
+BOOST_CXX14_CONSTEXPR std::pair<typename boost::range_iterator<const Range>::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

include/boost/algorithm/cxx11/copy_n.hpp

@@ -12,6 +12,8 @@
 #ifndef BOOST_ALGORITHM_COPY_N_HPP
 #define BOOST_ALGORITHM_COPY_N_HPP
 
+#include <boost/config.hpp>
+
 namespace boost { namespace algorithm {
 
 /// \fn copy_n ( InputIterator first, Size n, OutputIterator result )

include/boost/algorithm/cxx11/find_if_not.hpp

@@ -12,6 +12,7 @@
 #ifndef BOOST_ALGORITHM_FIND_IF_NOT_HPP
 #define BOOST_ALGORITHM_FIND_IF_NOT_HPP
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 

include/boost/algorithm/cxx11/iota.hpp

@@ -12,6 +12,7 @@
 #ifndef BOOST_ALGORITHM_IOTA_HPP
 #define BOOST_ALGORITHM_IOTA_HPP
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 

include/boost/algorithm/cxx11/is_partitioned.hpp

@@ -12,6 +12,7 @@
 #ifndef BOOST_ALGORITHM_IS_PARTITIONED_HPP
 #define BOOST_ALGORITHM_IS_PARTITIONED_HPP
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 

include/boost/algorithm/cxx11/is_permutation.hpp

@@ -17,6 +17,7 @@
 #include <functional>   // for std::equal_to
 #include <iterator>
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/utility/enable_if.hpp>

include/boost/algorithm/cxx11/is_sorted.hpp

@@ -16,12 +16,13 @@
 #include <functional>
 #include <iterator>
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/type_identity.hpp> // for boost::type_identity
 
 namespace boost { namespace algorithm {
 
@@ -126,7 +127,7 @@ namespace boost { namespace algorithm {
 /// \param p     A binary predicate that returns true if two elements are ordered.
 ///
     template <typename R, typename Pred>
-    BOOST_CXX14_CONSTEXPR typename boost::lazy_disable_if_c< boost::is_same<R, Pred>::value, boost::mpl::identity<bool> >::type
+    BOOST_CXX14_CONSTEXPR typename boost::lazy_disable_if_c< boost::is_same<R, Pred>::value, boost::type_identity<bool> >::type
     is_sorted ( const R &range, Pred p )
     {
         return boost::algorithm::is_sorted ( boost::begin ( range ), boost::end ( range ), p );

include/boost/algorithm/cxx11/none_of.hpp

@@ -12,6 +12,7 @@
 #ifndef BOOST_ALGORITHM_NONE_OF_HPP
 #define BOOST_ALGORITHM_NONE_OF_HPP
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 

include/boost/algorithm/cxx11/one_of.hpp

@@ -12,11 +12,13 @@
 #ifndef BOOST_ALGORITHM_ONE_OF_HPP
 #define BOOST_ALGORITHM_ONE_OF_HPP
 
-#include <boost/algorithm/cxx11/none_of.hpp>
+#include <boost/config.hpp>
-
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
+#include <boost/algorithm/cxx11/none_of.hpp>
+
+
 namespace boost { namespace algorithm {
 
 /// \fn one_of ( InputIterator first, InputIterator last, Predicate p )

include/boost/algorithm/cxx11/partition_point.hpp

@@ -14,6 +14,7 @@
 
 #include <iterator>    // for std::distance, advance
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 

include/boost/algorithm/cxx14/equal.hpp

@@ -14,6 +14,8 @@
 
 #include <iterator>
 
+#include <boost/config.hpp>
+
 namespace boost { namespace algorithm {
 
 namespace detail {

include/boost/algorithm/cxx14/is_permutation.hpp

@@ -16,6 +16,7 @@
 #include <functional>   // for std::equal_to
 #include <iterator>
 
+#include <boost/config.hpp>
 #include <boost/algorithm/cxx11/is_permutation.hpp>
 #include <boost/algorithm/cxx14/mismatch.hpp>
 

include/boost/algorithm/cxx14/mismatch.hpp

@@ -13,6 +13,7 @@
 #define BOOST_ALGORITHM_MISMATCH_HPP
 
 #include <utility>      // for std::pair
+
 #include <boost/config.hpp>
 
 namespace boost { namespace algorithm {

include/boost/algorithm/cxx17/exclusive_scan.hpp

@@ -15,6 +15,7 @@
 #include <functional>     // for std::plus
 #include <iterator>       // for std::iterator_traits
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>

include/boost/algorithm/cxx17/for_each_n.hpp

@@ -14,6 +14,8 @@
 
 #include <utility>      // for std::pair
 
+#include <boost/config.hpp>
+
 namespace boost { namespace algorithm {
 
 /// \fn for_each_n(InputIterator first, Size n, Function f);

include/boost/algorithm/cxx17/inclusive_scan.hpp

@@ -9,12 +9,13 @@
 /// \brief Combine the (transformed) elements of a sequence (or two) into a single value.
 /// \author Marshall Clow
 
-#ifndef BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+#ifndef BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP
-#define BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+#define BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP
 
 #include <functional>     // for std::plus
 #include <iterator>       // for std::iterator_traits
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>
@@ -57,4 +58,4 @@ OutputIterator inclusive_scan(InputIterator first, InputIterator last,
 
 }} // namespace boost and algorithm
 
-#endif // BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+#endif // BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP

include/boost/algorithm/cxx17/reduce.hpp

@@ -15,6 +15,7 @@
 #include <functional>     // for std::plus
 #include <iterator>       // for std::iterator_traits
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>

include/boost/algorithm/cxx17/transform_exclusive_scan.hpp

@@ -15,12 +15,28 @@
 #include <functional>     // for std::plus
 #include <iterator>       // for std::iterator_traits
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>
 
 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<class InputIterator, class OutputIterator, class T,
          class BinaryOperation, class UnaryOperation>
 OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,

include/boost/algorithm/cxx17/transform_inclusive_scan.hpp

@@ -15,12 +15,28 @@
 #include <functional>     // for std::plus
 #include <iterator>       // for std::iterator_traits
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>
 
 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<class InputIterator, class OutputIterator,
          class BinaryOperation, class UnaryOperation, class T>
 OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
@@ -36,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<class InputIterator, class OutputIterator,
          class BinaryOperation, class UnaryOperation>
 OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,

include/boost/algorithm/cxx17/transform_reduce.hpp

@@ -15,6 +15,7 @@
 #include <functional>     // for std::plus
 #include <iterator>       // for std::iterator_traits
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>

include/boost/algorithm/find_backward.hpp

@@ -2,18 +2,17 @@
    Copyright (c) T. Zachary Laine 2018.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALGORITHM_FIND_BACKWARD_HPP
 #define BOOST_ALGORITHM_FIND_BACKWARD_HPP
 
+#include <utility>
+
 #include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
-#include <utility>
-
-
 namespace boost { namespace algorithm {
 
 template<typename BidiIter, typename T>

include/boost/algorithm/find_not.hpp

@@ -2,18 +2,17 @@
    Copyright (c) T. Zachary Laine 2018.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALGORITHM_FIND_NOT_HPP
 #define BOOST_ALGORITHM_FIND_NOT_HPP
 
+#include <utility>
+
 #include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
-#include <utility>
-
-
 namespace boost { namespace algorithm {
 
 template<typename InputIter, typename Sentinel, typename T>        

include/boost/algorithm/gather.hpp

@@ -22,8 +22,10 @@
 
 #include <algorithm>                // for std::stable_partition
 #include <functional>
+#include <utility>                  // for std::make_pair
 
-#include <boost/bind.hpp>           // for boost::bind
+#include <boost/config.hpp>
+#include <boost/bind/bind.hpp>      // for boost::bind
 #include <boost/range/begin.hpp>    // for boost::begin(range)
 #include <boost/range/end.hpp>      // for boost::end(range)
 
@@ -80,13 +82,14 @@ namespace boost { namespace algorithm {
 */
 
 template <
-    typename BidirectionalIterator,  // Iter models BidirectionalIterator
+    typename BidirectionalIterator,  // models BidirectionalIterator
-    typename Pred>                   // Pred models UnaryPredicate
+    typename Pred>                   // models UnaryPredicate
 std::pair<BidirectionalIterator, BidirectionalIterator> gather 
         ( BidirectionalIterator first, BidirectionalIterator last, BidirectionalIterator pivot, Pred pred )
 {
 //  The first call partitions everything up to (but not including) the pivot element,
 //  while the second call partitions the rest of the sequence.
+    using namespace boost::placeholders;
     return std::make_pair (
         std::stable_partition ( first, pivot, !boost::bind<bool> ( pred, _1 )),
         std::stable_partition ( pivot, last,   boost::bind<bool> ( pred, _1 )));

include/boost/algorithm/hex.hpp

@@ -23,6 +23,7 @@
 #include <iterator>     // for std::iterator_traits
 #include <stdexcept>
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/exception/exception.hpp>
@@ -47,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 BOOST_SYMBOL_VISIBLE hex_decode_error : virtual boost::exception, virtual std::exception {};
-struct not_enough_input : virtual hex_decode_error {};
+struct BOOST_SYMBOL_VISIBLE not_enough_input : virtual hex_decode_error {};
-struct non_hex_input    : virtual hex_decode_error {};
+struct BOOST_SYMBOL_VISIBLE non_hex_input    : virtual hex_decode_error {};
 typedef boost::error_info<struct bad_char_,char> bad_char;
 
 namespace detail {

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 <functional>       //  for std::less
+#include <cassert>
+
+#include <boost/type_traits/type_identity.hpp> // for boost::type_identity
+
+namespace boost { namespace algorithm {
+
+/// \fn is_clamped ( T const& val,
+///               typename boost::type_identity<T>::type const & lo,
+///               typename boost::type_identity<T>::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 <typename T, typename Pred>
+  BOOST_CXX14_CONSTEXPR bool is_clamped(
+      T const& val, typename boost::type_identity<T>::type const& lo,
+      typename boost::type_identity<T>::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<T>::type const & lo,
+///               typename boost::type_identity<T>::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<typename T> 
+  BOOST_CXX14_CONSTEXPR bool is_clamped ( const T& val,
+    typename boost::type_identity<T>::type const & lo,
+    typename boost::type_identity<T>::type const & hi )
+  {
+    return boost::algorithm::is_clamped ( val, lo, hi, std::less<T>());
+  } 
+
+}}
+
+#endif // BOOST_ALGORITHM_CLAMP_HPP

include/boost/algorithm/is_palindrome.hpp

@@ -19,6 +19,7 @@
 #include <functional>
 #include <cstring>
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 

include/boost/algorithm/is_partitioned_until.hpp

@@ -12,6 +12,7 @@
 #ifndef BOOST_ALGORITHM_IS_PARTITIONED_UNTIL_HPP
 #define BOOST_ALGORITHM_IS_PARTITIONED_UNTIL_HPP
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 

include/boost/algorithm/minmax.hpp

@@ -25,6 +25,7 @@
  *
  */
 
+#include <boost/config.hpp>
 #include <boost/tuple/tuple.hpp> // for using pairs with boost::cref
 #include <boost/ref.hpp>
 

include/boost/algorithm/minmax_element.hpp

@@ -28,6 +28,8 @@
 
 #include <utility> // for std::pair and std::make_pair
 
+#include <boost/config.hpp>
+
 namespace boost {
 
   namespace detail {  // for obtaining a uniform version of minmax_element

include/boost/algorithm/searching/boyer_moore.hpp

@@ -12,6 +12,7 @@
 
 #include <iterator>     // for std::iterator_traits
 
+#include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 

include/boost/algorithm/searching/boyer_moore_horspool.hpp

@@ -12,6 +12,7 @@
 
 #include <iterator>     // for std::iterator_traits
 
+#include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 

include/boost/algorithm/searching/knuth_morris_pratt.hpp

@@ -13,6 +13,7 @@
 #include <vector>
 #include <iterator>     // for std::iterator_traits
 
+#include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 

include/boost/algorithm/sort_subrange.hpp

@@ -22,6 +22,7 @@
 #include <iterator>         // For std::iterator_traits
 #include <algorithm>        // For nth_element and partial_sort
 
+#include <boost/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 

include/boost/algorithm/string/compare.hpp

@@ -65,7 +65,7 @@ namespace boost {
             template< typename T1, typename T2 >
                 bool operator()( const T1& Arg1, const T2& Arg2 ) const
             {
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
                     return std::toupper(Arg1)==std::toupper(Arg2);
                 #else
                     return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
@@ -118,7 +118,7 @@ namespace boost {
             template< typename T1, typename T2 >
                 bool operator()( const T1& Arg1, const T2& Arg2 ) const
             {
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
                     return std::toupper(Arg1)<std::toupper(Arg2);
                 #else
                     return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
@@ -171,7 +171,7 @@ namespace boost {
             template< typename T1, typename T2 >
                 bool operator()( const T1& Arg1, const T2& Arg2 ) const
             {
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
                     return std::toupper(Arg1)<=std::toupper(Arg2);
                 #else
                     return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);

include/boost/algorithm/string/detail/case_conv.hpp

@@ -15,6 +15,9 @@
 #include <locale>
 #include <functional>
 
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
 
 namespace boost {
@@ -40,7 +43,7 @@ namespace boost {
                 // Operation
                 CharT operator ()( CharT Ch ) const
                 {
-                    #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                    #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
                         return std::tolower( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
                     #else
                         return std::tolower<CharT>( Ch, *m_Loc );
@@ -62,7 +65,7 @@ namespace boost {
                 // Operation
                 CharT operator ()( CharT Ch ) const
                 {
-                    #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
+                    #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL)
                         return std::toupper( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
                     #else
                         return std::toupper<CharT>( Ch, *m_Loc );

include/boost/algorithm/string/detail/classification.hpp

@@ -13,10 +13,12 @@
 
 #include <boost/algorithm/string/config.hpp>
 #include <algorithm>
+#include <cstring>
 #include <functional>
 #include <locale>
 
 #include <boost/range/begin.hpp>
+#include <boost/range/distance.hpp>
 #include <boost/range/end.hpp>
 
 #include <boost/algorithm/string/predicate_facade.hpp>
@@ -45,7 +47,7 @@ namespace boost {
                     return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch );
                 }
 
-                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x582) && !defined(_USE_OLD_RW_STL)
+                #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x582) && !defined(_USE_OLD_RW_STL)
                     template<>
                     bool operator()( char const Ch ) const
                     {

include/boost/algorithm/string/detail/find_format_all.hpp

@@ -18,6 +18,8 @@
 #include <boost/algorithm/string/detail/find_format_store.hpp>
 #include <boost/algorithm/string/detail/replace_storage.hpp>
 
+#include <deque>
+
 namespace boost {
     namespace algorithm {
         namespace detail {

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<typename FinderT>
@@ -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( 

include/boost/algorithm/string/detail/finder.hpp

@@ -13,7 +13,7 @@
 
 #include <boost/algorithm/string/config.hpp>
 #include <boost/algorithm/string/constants.hpp>
-#include <boost/detail/iterator.hpp>
+#include <iterator>
 
 #include <boost/range/iterator_range_core.hpp>
 #include <boost/range/begin.hpp>
@@ -127,8 +127,8 @@ namespace boost {
                     if( boost::empty(m_Search) )
                         return result_type( End, End );
 
-                    typedef BOOST_STRING_TYPENAME boost::detail::
+                    typedef BOOST_STRING_TYPENAME
-                        iterator_traits<ForwardIteratorT>::iterator_category category;
+                        std::iterator_traits<ForwardIteratorT>::iterator_category category;
 
                     return findit( Begin, End, category() );
                 }
@@ -344,9 +344,8 @@ namespace boost {
                 typedef iterator_range<ForwardIteratorT> result_type;
 
                 input_iterator_type It=Begin;
-                for(
+                for( unsigned int Index=0; Index<N && It!=End; ++Index,++It )
-                    unsigned int Index=0;
+                    ;
-                    Index<N && It!=End; ++Index,++It ) {};
 
                 return result_type( Begin, It );
             }
@@ -375,8 +374,8 @@ namespace boost {
                 ForwardIteratorT End,
                 unsigned int N )
             {
-                typedef BOOST_STRING_TYPENAME boost::detail::
+                typedef BOOST_STRING_TYPENAME
-                    iterator_traits<ForwardIteratorT>::iterator_category category;
+                    std::iterator_traits<ForwardIteratorT>::iterator_category category;
 
                 return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
             }
@@ -397,10 +396,12 @@ namespace boost {
                 input_iterator_type It2=Begin;
 
                 // Advance It2 by N increments
-                for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {};
+                for( Index=0; Index<N && It2!=End; ++Index,++It2 )
+                    ;
 
                 // Advance It, It2 to the end
-                for(; It2!=End; ++It,++It2 ) {};
+                for(; It2!=End; ++It,++It2 )
+                	;
 
                 return result_type( It, It2 );
             }
@@ -417,9 +418,8 @@ namespace boost {
                 typedef iterator_range<ForwardIteratorT> result_type;
 
                 input_iterator_type It=End;
-                for(
+                for( unsigned int Index=0; Index<N && It!=Begin; ++Index,--It )
-                    unsigned int Index=0;
+                    ;
-                    Index<N && It!=Begin; ++Index,--It ) {};
 
                 return result_type( It, End );
             }
@@ -448,8 +448,8 @@ namespace boost {
                 ForwardIteratorT End,
                 unsigned int N )
             {
-                typedef BOOST_STRING_TYPENAME boost::detail::
+                typedef BOOST_STRING_TYPENAME
-                    iterator_traits<ForwardIteratorT>::iterator_category category;
+                    std::iterator_traits<ForwardIteratorT>::iterator_category category;
 
                 return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
             }

include/boost/algorithm/string/detail/formatter.hpp

@@ -42,7 +42,7 @@ namespace boost {
                     m_Format(::boost::begin(Format), ::boost::end(Format)) {}
 
                 // Operation
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
                 template<typename Range2T>
                 result_type& operator()(const Range2T&)
                 {

include/boost/algorithm/string/detail/trim.hpp

@@ -12,7 +12,7 @@
 #define BOOST_STRING_TRIM_DETAIL_HPP
 
 #include <boost/algorithm/string/config.hpp>
-#include <boost/detail/iterator.hpp>
+#include <iterator>
 
 namespace boost {
     namespace algorithm {
@@ -80,8 +80,8 @@ namespace boost {
                 ForwardIteratorT InEnd, 
                 PredicateT IsSpace )
             {
-                typedef BOOST_STRING_TYPENAME boost::detail::
+                typedef BOOST_STRING_TYPENAME
-                    iterator_traits<ForwardIteratorT>::iterator_category category;
+                    std::iterator_traits<ForwardIteratorT>::iterator_category category;
 
                 return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
             }

include/boost/algorithm/string/find_format.hpp

@@ -12,7 +12,6 @@
 #define BOOST_STRING_FIND_FORMAT_HPP
 
 #include <deque>
-#include <boost/detail/iterator.hpp>
 #include <boost/range/iterator_range_core.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

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

include/boost/algorithm/string/formatter.hpp

@@ -11,7 +11,6 @@
 #ifndef BOOST_STRING_FORMATTER_HPP
 #define BOOST_STRING_FORMATTER_HPP
 
-#include <boost/detail/iterator.hpp>
 #include <boost/range/value_type.hpp>
 #include <boost/range/iterator_range_core.hpp>
 #include <boost/range/as_literal.hpp>

include/boost/algorithm/string/iter_find.hpp

@@ -71,7 +71,11 @@ namespace boost {
         inline SequenceSequenceT&
         iter_find(
             SequenceSequenceT& Result,
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+            RangeT&& Input,
+#else
             RangeT& Input,
+#endif
             FinderT Finder )
         {
             BOOST_CONCEPT_ASSERT((
@@ -142,7 +146,11 @@ namespace boost {
         inline SequenceSequenceT&
         iter_split(
             SequenceSequenceT& Result,
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+            RangeT&& Input,
+#else
             RangeT& Input,
+#endif
             FinderT Finder )
         {
             BOOST_CONCEPT_ASSERT((

include/boost/algorithm/string/predicate.hpp

@@ -11,6 +11,7 @@
 #ifndef BOOST_STRING_PREDICATE_HPP
 #define BOOST_STRING_PREDICATE_HPP
 
+#include <iterator>
 #include <boost/algorithm/string/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
@@ -146,8 +147,8 @@ namespace boost {
 
             typedef BOOST_STRING_TYPENAME
                 range_const_iterator<Range1T>::type Iterator1T;
-            typedef BOOST_STRING_TYPENAME boost::detail::
+            typedef BOOST_STRING_TYPENAME
-                iterator_traits<Iterator1T>::iterator_category category;
+                std::iterator_traits<Iterator1T>::iterator_category category;
 
             return detail::
                 ends_with_iter_select( 

include/boost/algorithm/string/split.hpp

@@ -61,7 +61,11 @@ namespace boost {
         template< typename SequenceSequenceT, typename Range1T, typename Range2T >
         inline SequenceSequenceT& find_all(
             SequenceSequenceT& Result,
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+            Range1T&& Input,
+#else
             Range1T& Input,
+#endif
             const Range2T& Search)
         {
             return ::boost::algorithm::iter_find(
@@ -96,7 +100,11 @@ namespace boost {
         template< typename SequenceSequenceT, typename Range1T, typename Range2T >
         inline SequenceSequenceT& ifind_all(
             SequenceSequenceT& Result,
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+            Range1T&& Input,
+#else
             Range1T& Input,
+#endif
             const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
@@ -139,7 +147,11 @@ namespace boost {
         template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
         inline SequenceSequenceT& split(
             SequenceSequenceT& Result,
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+            RangeT&& Input,
+#else
             RangeT& Input,
+#endif
             PredicateT Pred,
             token_compress_mode_type eCompress=token_compress_off )
         {

meta/libraries.json

@@ -11,7 +11,8 @@
         ],
         "maintainers": [
             "Marshall Clow <marshall -at- idio.com>"
-        ]
+        ],
+        "cxxstd": "03"
     },
     {
         "key": "algorithm/minmax",
@@ -26,7 +27,8 @@
         ],
         "maintainers": [
             "Marshall Clow <marshall -at- idio.com>"
-        ]
+        ],
+        "cxxstd": "03"
     },
     {
         "key": "algorithm/string",
@@ -42,6 +44,7 @@
         ],
         "maintainers": [
             "Marshall Clow <marshall -at- idio.com>"
-        ]
+        ],
+        "cxxstd": "03"
     }
 ]

minmax/doc/minmax_synopsis.html

@@ -24,7 +24,7 @@ namespace boost {
   tuple<T const&, T const&> >
   minmax(const T& a, const T& b);
 
-  template &lt;class T, class <a href="http://www.sgi.com/tech/stl/  BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class T, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
   tuple&lt;T const&amp;, T const&amp;> >
   minmax(const T&amp; a, const T&amp; b, BinaryPredicate comp);
 
@@ -38,77 +38,77 @@ Synopsis of <tt>&lt;boost/algorithm/minmax_element.hpp></tt></h3>
 
 namespace boost {
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   minmax_element(ForwardIterator first, ForwardIterator last);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   minmax_element(ForwardIterator first, ForwardIterator last,
                  BinaryPredicate comp);
 
   // Variants
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   ForwardIterator first_min_element(ForwardIterator first, ForwardIterator last);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
   ForwardIterator first_min_element(ForwardIterator first, ForwardIterator last,
                                     BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   ForwardIterator last_min_element(ForwardIterator first, ForwardIterator last);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
   ForwardIterator last_min_element(ForwardIterator first, ForwardIterator last,
                                    BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   ForwardIterator first_max_element(ForwardIterator first, ForwardIterator last);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
   ForwardIterator first_max_element(ForwardIterator first, ForwardIterator last,
                                     BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   ForwardIterator last_max_element(ForwardIterator first, ForwardIterator last);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
   ForwardIterator last_max_element(ForwardIterator first, ForwardIterator last,
                                    BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   first_min_first_max_element(ForwardIterator first, ForwardIterator last);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   first_min_first_max_element(ForwardIterator first, ForwardIterator last,
                              BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   first_min_last_max_element(ForwardIterator first, ForwardIterator last);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   first_min_last_max_element(ForwardIterator first, ForwardIterator last,
                              BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   last_min_first_max_element(ForwardIterator first, ForwardIterator last);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   last_min_first_max_element(ForwardIterator first, ForwardIterator last,
                              BinaryPredicate comp);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   last_min_last_max_element(ForwardIterator first, ForwardIterator last);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   last_min_last_max_element(ForwardIterator first, ForwardIterator last,
                             BinaryPredicate comp);

minmax/index.html

@@ -95,7 +95,7 @@ namespace boost {
   tuple<T const&, T const&>
   minmax(const T& a, const T& b);
 
-  template &lt;class T, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class T, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
   tuple&lt;T const&amp;, T const&amp;>
   minmax(const T&amp; a, const T&amp; b, BinaryPredicate comp);
 
@@ -109,11 +109,11 @@ Synopsis of <tt>&lt;boost/algorithm/minmax_element.hpp></tt></h3>
 
 namespace boost {
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   minmax_element(ForwardIterator first, ForwardIterator last);
 
-  template &lt;class <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
+  template &lt;class <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">ForwardIterator</a>, class <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>>
   std::pair&lt;ForwardIterator,ForwardIterator>
   minmax_element(ForwardIterator first, ForwardIterator last,
                  BinaryPredicate comp);
@@ -190,26 +190,26 @@ in <a href="../../../boost/algorithm/minmax_element.hpp">minmax_element.hpp</a>.
 <a name="reqs">
 <h3>
 Requirements on types</h3>
-For minmax, <tt>T</tt> must be a model of <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThan
+For minmax, <tt>T</tt> must be a model of <a href="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThan
 Comparable</a>.
 <p>For all the other function templates, versions with two template parameters:
 <ul>
 <li>
-<tt>ForwardIterator</tt> is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
+<tt>ForwardIterator</tt> is a model of <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">Forward
 Iterator</a>.</li>
 
 <li>
-<tt>ForwardIterator</tt>'s value type is <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThan
+<tt>ForwardIterator</tt>'s value type is <a href="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThan
 Comparable</a>.</li>
 </ul>
 For the versions with three template parameters:
 <ul>
 <li>
-<tt>ForwardIterator</tt> is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
+<tt>ForwardIterator</tt> is a model of <a href="https://www.boost.org/sgi/stl/ForwardIterator.html">Forward
 Iterator</a>.</li>
 
 <li>
-<tt>BinaryPredicate</tt> is a model of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary
+<tt>BinaryPredicate</tt> is a model of <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html">Binary
 Predicate</a>.</li>
 
 <li>
@@ -285,8 +285,8 @@ the library under
   assert( result1.get<0>() == 0 );
   assert( result1.get<1>() == 1 );
 
-  <a href="http://www.sgi.com/tech/stl/List.html">list</a>&lt;int> L;
+  <a href="https://www.boost.org/sgi/stl/List.html">list</a>&lt;int> L;
-  <a href="http://www.sgi.com/tech/stl/generate_n.html">generate_n</a>(<a href="http://www.sgi.com/tech/stl/front_insert_iterator.html">front_inserter</a>(L), 1000, rand);
+  <a href="https://www.boost.org/sgi/stl/generate_n.html">generate_n</a>(<a href="https://www.boost.org/sgi/stl/front_insert_iterator.html">front_inserter</a>(L), 1000, rand);
 
   typedef list&lt;int>::const_iterator iterator;
   pair&lt; iterator, iterator > result2 = boost::minmax_element(L.begin(), L.end());
@@ -512,13 +512,13 @@ release, Eric Niebler noted the bad behavior of <tt>std::pair</tt> for
 All my thanks for the excellent advice and reviews from all.
 <h3>
 See also</h3>
-<tt><a href="http://www.sgi.com/tech/stl/min.html">min</a></tt>, <tt><a href="http://www.sgi.com/tech/stl/max.html">max</a></tt>,
+<tt><a href="https://www.boost.org/sgi/stl/min.html">min</a></tt>, <tt><a href="https://www.boost.org/sgi/stl/max.html">max</a></tt>,
-<tt><a href="http://www.sgi.com/tech/stl/min_element.html">min_element</a></tt>,
+<tt><a href="https://www.boost.org/sgi/stl/min_element.html">min_element</a></tt>,
-<tt><a href="http://www.sgi.com/tech/stl/max_element.html">max_element</a></tt>,
+<tt><a href="https://www.boost.org/sgi/stl/max_element.html">max_element</a></tt>,
-<tt><a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThan
+<tt><a href="https://www.boost.org/sgi/stl/LessThanComparable.html">LessThan
 Comparable</a></tt>,
-<tt><a href="http://www.sgi.com/tech/stl/sort.html">sort</a></tt>,
+<tt><a href="https://www.boost.org/sgi/stl/sort.html">sort</a></tt>,
-<tt><a href="http://www.sgi.com/tech/stl/nth_element.html">nth_element</a></tt>
+<tt><a href="https://www.boost.org/sgi/stl/nth_element.html">nth_element</a></tt>
 .
 <hr SIZE="6">
 <br>Last modified 2012-12-10

string/doc/external_concepts.html

@@ -31,7 +31,7 @@
                typedef <i>implementation defined </i> foo_type;</code><p  >The corresponding external concept is the ExternalFooConcept.</p><p  >A type <code>T</code> fullfills the ExternalFooConcept if these
             free-standing functions and type-generators exists:</p><code>void foo( const T&, int ); <br>
                 int bar( T& ); <br>
-             foo_type_of< T >::type;</code> <br> <br><hr size="1" ><h3  >Literature</h3><ul  ><li  > <a href="http://www.boost.org/more/generic_programming.html#type_generator" target="_self" >Type Generators</a> </li><li  > <a href="http://www.boost.org/more/generic_programming.html#concept" target="_self" >Concepts</a> </li><li  > <a href="http://www.sgi.com/tech/stl/stl_introduction.html" target="_self" >Concepts and SGI STL</a> </li></ul><hr size="1" ><p  >&copy; Thorsten Ottosen 2003-2004 (nesotto_AT_cs.auc.dk).
+             foo_type_of< T >::type;</code> <br> <br><hr size="1" ><h3  >Literature</h3><ul  ><li  > <a href="http://www.boost.org/more/generic_programming.html#type_generator" target="_self" >Type Generators</a> </li><li  > <a href="http://www.boost.org/more/generic_programming.html#concept" target="_self" >Concepts</a> </li><li  > <a href="https://www.boost.org/sgi/stl/stl_introduction.html" target="_self" >Concepts and SGI STL</a> </li></ul><hr size="1" ><p  >&copy; Thorsten Ottosen 2003-2004 (nesotto_AT_cs.auc.dk).
 <br>Use, modification and distribution is subject to the Boost
  Software License, Version 1.0. (See accompanying file
  <code class="filename">LICENSE_1_0.txt</code> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)

string/doc/usage.xml

@@ -265,7 +265,7 @@
         <title>Find Iterator</title>
 
         <para>
-            An extension to find algorithms it the Find Iterator. Instead of searching for just a one part of a string, 
+            An extension to find algorithms is the Find Iterator. Instead of searching for just a one part of a string, 
             the find iterator allows us to iterate over the substrings matching the specified criteria.
             This facility is using the <link linkend="string_algo.finder_concept">Finder</link> to incrementally
             search the string. 

string/example/predicate_example.cpp

@@ -12,8 +12,6 @@
 #include <functional>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/classification.hpp>
-#include <boost/bind.hpp>
-
 
 using namespace std;
 using namespace boost;

string/example/rle_example.cpp

@@ -16,7 +16,7 @@
 #include <string>
 #include <iostream>
 #include <limits>
-#include <boost/detail/iterator.hpp>
+#include <iterator>
 #include <boost/algorithm/string/find_format.hpp>
 #include <boost/algorithm/string/finder.hpp>
 
@@ -46,7 +46,7 @@ struct find_compressF
         ForwardIteratorT End ) const
     {
         typedef ForwardIteratorT input_iterator_type;
-        typedef typename boost::detail::iterator_traits<input_iterator_type>::value_type value_type;
+        typedef typename std::iterator_traits<input_iterator_type>::value_type value_type;
         typedef iterator_range<input_iterator_type> result_type;
 
         // begin of the matching segment
@@ -144,7 +144,7 @@ struct find_decompressF
         ForwardIteratorT End ) const
     {
         typedef ForwardIteratorT input_iterator_type;
-        typedef typename boost::detail::iterator_traits<input_iterator_type>::value_type value_type;
+        typedef typename std::iterator_traits<input_iterator_type>::value_type value_type;
         typedef iterator_range<input_iterator_type> result_type;
 
         for(input_iterator_type It=Begin; It!=End; It++)

string/test/split_test.cpp

@@ -7,6 +7,8 @@
 
 //  See http://www.boost.org for updates, documentation, and revision history.
 
+#include <boost/algorithm/string/config.hpp>
+
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/classification.hpp>
 // equals predicate is used for result comparison
@@ -82,6 +84,28 @@ void iterator_test()
         string("xx") );
     deep_compare( tokens, vtokens );
 
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    // If using a compiler that supports forwarding references, we should be able to use rvalues, too
+    find_all(
+        tokens,
+        string("xx-abc--xx-abb"),
+        "xx" );
+
+    BOOST_REQUIRE( tokens.size()==2 );
+    BOOST_CHECK( tokens[0]==string("xx") );
+    BOOST_CHECK( tokens[1]==string("xx") );
+
+    ifind_all(
+        tokens,
+        string("Xx-abc--xX-abb-xx"),
+        "xx" );
+
+    BOOST_REQUIRE( tokens.size()==3 );
+    BOOST_CHECK( tokens[0]==string("Xx") );
+    BOOST_CHECK( tokens[1]==string("xX") );
+    BOOST_CHECK( tokens[2]==string("xx") );
+#endif
+
     // split tests
     split(
         tokens,
@@ -144,6 +168,21 @@ void iterator_test()
     BOOST_REQUIRE( tokens.size()==1 );
     BOOST_CHECK( tokens[0]==string("") );
 
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    // If using a compiler that supports forwarding references, we should be able to use rvalues, too
+    split(
+        tokens,
+        string("Xx-abc--xX-abb-xx"),
+        is_any_of("xX"),
+        token_compress_on );
+
+    BOOST_REQUIRE( tokens.size()==4 );
+    BOOST_CHECK( tokens[0]==string("") );
+    BOOST_CHECK( tokens[1]==string("-abc--") );
+    BOOST_CHECK( tokens[2]==string("-abb-") );
+    BOOST_CHECK( tokens[3]==string("") );
+#endif
+
 
     find_iterator<string::iterator> fiter=make_find_iterator(str1, first_finder("xx"));
     find_iterator<string::iterator> fiter2;

test/Jamfile.v2

@@ -29,6 +29,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 +69,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

test/apply_permutation_test.cpp

@@ -14,19 +14,19 @@
 
 #define BOOST_TEST_MAIN
 
-#include <boost/test/unit_test.hpp>
+#include <boost/test/included/unit_test.hpp>
 
 namespace ba = boost::algorithm;
 
 
-void test_apply_permutation()
+BOOST_AUTO_TEST_CASE(test_apply_permutation)
 {
     //Empty
     {
         std::vector<int> vec, order, result;
         
         ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
     //1 element
     {
@@ -36,7 +36,7 @@ void test_apply_permutation()
         result = vec;
         
         ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
     //2 elements, no changes
     {
@@ -46,7 +46,7 @@ void test_apply_permutation()
         result = vec;
         
         ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
     //2 elements, changed
     {
@@ -56,7 +56,7 @@ void test_apply_permutation()
         result.push_back(2); result.push_back(1);
         
         ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
     //Multiple elements, no changes
     {
@@ -66,7 +66,7 @@ void test_apply_permutation()
         result = vec;
         
         ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
     //Multiple elements, changed
     {
@@ -76,7 +76,7 @@ void test_apply_permutation()
         result.push_back(5); result.push_back(4); result.push_back(3); result.push_back(2); result.push_back(1);
         
         ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
     //Just test range interface
     {
@@ -86,18 +86,18 @@ void test_apply_permutation()
         result = vec;
         
         ba::apply_permutation(vec, order);
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
 }
 
-void test_apply_reverse_permutation()
+BOOST_AUTO_TEST_CASE(test_apply_reverse_permutation)
 {
     //Empty
     {
         std::vector<int> vec, order, result;
         
         ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
     //1 element
     {
@@ -107,7 +107,7 @@ void test_apply_reverse_permutation()
         result = vec;
         
         ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
     //2 elements, no changes
     {
@@ -117,7 +117,7 @@ void test_apply_reverse_permutation()
         result = vec;
         
         ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
     //2 elements, changed
     {
@@ -127,7 +127,7 @@ void test_apply_reverse_permutation()
         result.push_back(2); result.push_back(1);
         
         ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
     //Multiple elements, no changes
     {
@@ -137,7 +137,7 @@ void test_apply_reverse_permutation()
         result = vec;
         
         ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
     //Multiple elements, changed
     {
@@ -147,7 +147,7 @@ void test_apply_reverse_permutation()
         result.push_back(5); result.push_back(4); result.push_back(3); result.push_back(2); result.push_back(1);
         
         ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
     //Just test range interface
     {
@@ -157,12 +157,6 @@ void test_apply_reverse_permutation()
         result = vec;
         
         ba::apply_reverse_permutation(vec, order);
-        BOOST_CHECK(vec == result);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
     }
 }
-
-BOOST_AUTO_TEST_CASE(test_main)
-{
-    test_apply_permutation();
-    test_apply_reverse_permutation();
-}

test/copy_if_test1.cpp

@@ -34,6 +34,8 @@ 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 <typename Container>
 void test_copy_if ( Container const &c ) {
@@ -118,6 +120,160 @@ void test_copy_while ( Container const &c ) {
     BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
     }
 
+template <typename Container>
+void test_copy_if_while ( Container const &c ) {
+
+    typedef typename Container::value_type value_type;
+    typename Container::const_iterator it;
+
+//  Terminate immediately
+    {
+        std::vector<value_type> v;
+        ba::copy_if_while ( c.begin (), c.end (), back_inserter ( v ), is_true, is_false);
+        BOOST_CHECK ( v.size () == 0 );
+    }
+    {
+        std::vector<value_type> v;
+        ba::copy_if_while ( c, back_inserter ( v ), is_true, is_false);
+        BOOST_CHECK ( v.size () == 0 );
+    }
+
+// Copy nothing - never terminate
+    {
+        std::vector<value_type> v;
+        ba::copy_if_while ( c.begin (), c.end (), back_inserter ( v ), is_false, is_true);
+        BOOST_CHECK ( v.size () == 0 );
+    }
+    {
+        std::vector<value_type> v;
+        ba::copy_if_while ( c, back_inserter ( v ), is_false, is_true);
+        BOOST_CHECK ( v.size () == 0 );
+    }
+
+// Copy everything
+    {
+        std::vector<value_type> 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<value_type> 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<value_type> 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<value_type> 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<value_type> 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<value_type> 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 <typename Container>
+void test_copy_if_until ( Container const &c ) {
+
+    typedef typename Container::value_type value_type;
+    typename Container::const_iterator it;
+
+//  Terminate immediately
+    {
+        std::vector<value_type> v;
+        ba::copy_if_until ( c.begin (), c.end (), back_inserter ( v ), is_true, is_true);
+        BOOST_CHECK ( v.size () == 0 );
+    }
+    {
+        std::vector<value_type> v;
+        ba::copy_if_until ( c, back_inserter ( v ), is_true, is_true);
+        BOOST_CHECK ( v.size () == 0 );
+    }
+
+// Copy nothing - never terminate
+    {
+        std::vector<value_type> v;
+        ba::copy_if_until ( c.begin (), c.end (), back_inserter ( v ), is_false, is_false);
+        BOOST_CHECK ( v.size () == 0 );
+    }
+    {
+        std::vector<value_type> v;
+        ba::copy_if_until ( c, back_inserter ( v ), is_false, is_false);
+        BOOST_CHECK ( v.size () == 0 );
+    }
+
+// Copy everything
+    {
+        std::vector<value_type> 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<value_type> 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<value_type> 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<value_type> 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<value_type> 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<value_type> 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 <typename Container>
 void test_copy_until ( Container const &c ) {
 
@@ -225,6 +381,75 @@ 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<const int *>(out_data),  input_iterator<const int *>(out_data + sz),
+                             input_iterator<const int *>(from), input_iterator<const int *>(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<const int *>(out_data),  input_iterator<const int *>(out_data + sz),
+                             input_iterator<const int *>(from), input_iterator<const int *>(to)));
+    }
+
+    return res;
+    }
 
 void test_sequence1 () {
     std::vector<int> v;
@@ -240,6 +465,10 @@ void test_sequence1 () {
     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<int> l;
     for ( int i = 25; i > 15; --i )
@@ -247,6 +476,8 @@ void test_sequence1 () {
     test_copy_if ( l );
     test_copy_while ( l );
     test_copy_until ( l );
+    test_copy_if_while ( l );
+    test_copy_if_until ( l );
     }
 
 

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 <boost/algorithm/is_clamped.hpp>
+#include <boost/algorithm/clamp.hpp>
+#include <cmath>
+#include <cstdint>
+#ifdef __cpp_impl_three_way_comparison
+#if __has_include(<compare>)
+#define BOOST_IS_CLAMPED_TEST_SPACESHIP
+#endif
+#ifdef BOOST_IS_CLAMPED_TEST_SPACESHIP
+#include <compare>
+#endif
+#endif
+#include <limits>
+#include <string>
+#include <tuple>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+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<float>::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<std::uint8_t, std::int8_t, std::uint16_t, std::int16_t,
+                   std::int32_t, std::uint32_t, std::int64_t, std::uint64_t> test_types_tuple;
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_extremes, T, test_types_tuple) {
+  const T max = std::numeric_limits<T>::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<T>::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

test/mclow.cpp

@@ -0,0 +1,15 @@
+#include <stdexcept>
+
+#include <boost/exception/exception.hpp>
+#include <boost/throw_exception.hpp>
+
+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*/ ) {}
+	}