Use Azure mirrors of Ubuntu .deb repositories in containers.

This reduces the likelihood of spurious CI failures caused by DDoS filters
being triggered by massive numbers of concurrent CI jobs.

.github/workflows/ci.yml

@@ -0,0 +1,620 @@
+# Copyright 2021-2025 Andrey Semashev
+#
+# 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)
+
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+      - feature/**
+
+concurrency:
+  group: ${{format('{0}:{1}', github.repository, github.ref)}}
+  cancel-in-progress: true
+
+env:
+  GIT_FETCH_JOBS: 8
+  NET_RETRY_COUNT: 5
+  DEFAULT_BUILD_VARIANT: debug,release
+
+jobs:
+  posix:
+    defaults:
+      run:
+        shell: bash
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Linux, gcc
+          - toolset: gcc-5
+            cxxstd: "11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - g++-5
+          - toolset: gcc-6
+            cxxstd: "11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - g++-6
+          - toolset: gcc-7
+            cxxstd: "11,14,17"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - g++-7
+          - toolset: gcc-8
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - g++-8
+          - toolset: gcc-9
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-latest
+            container: ubuntu:20.04
+            install:
+              - g++-9
+          - toolset: gcc-10
+            cxxstd: "11,14,17,20"
+            os: ubuntu-latest
+            container: ubuntu:20.04
+            install:
+              - g++-10
+          - toolset: gcc-11
+            cxxstd: "11,14,17,20,23"
+            os: ubuntu-22.04
+            install:
+              - g++-11
+          - toolset: gcc-12
+            cxxstd: "11,14,17,20,23"
+            os: ubuntu-22.04
+            install:
+              - g++-12
+          - toolset: gcc-13
+            cxxstd: "11,14,17,20,23"
+            os: ubuntu-24.04
+            install:
+              - g++-13
+          - toolset: gcc-14
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-24.04
+            install:
+              - g++-14
+          - toolset: gcc-15
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-latest
+            container: ubuntu:25.04
+            install:
+              - g++-15
+          - name: UBSAN
+            toolset: gcc-13
+            cxxstd: "11,14,17,20,23"
+            ubsan: 1
+            build_variant: debug
+            os: ubuntu-24.04
+            install:
+              - g++-13
+
+          # Linux, clang
+          - toolset: clang
+            compiler: clang++-3.5
+            cxxstd: "11"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - clang-3.5
+          - toolset: clang
+            compiler: clang++-3.6
+            cxxstd: "11,14"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - clang-3.6
+          - toolset: clang
+            compiler: clang++-3.7
+            cxxstd: "11,14"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - clang-3.7
+          - toolset: clang
+            compiler: clang++-3.8
+            cxxstd: "11,14"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - clang-3.8
+          - toolset: clang
+            compiler: clang++-3.9
+            cxxstd: "11,14"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - clang-3.9
+          - toolset: clang
+            compiler: clang++-4.0
+            cxxstd: "11,14"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - clang-4.0
+          - toolset: clang
+            compiler: clang++-5.0
+            cxxstd: "11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - clang-5.0
+          - toolset: clang
+            compiler: clang++-6.0
+            cxxstd: "11,14,17"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - clang-6.0
+          - toolset: clang
+            compiler: clang++-7
+            cxxstd: "11,14,17"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - clang-7
+          # Note: clang-8 does not fully support C++20, so it is not compatible with libstdc++-8 in this mode
+          - toolset: clang
+            compiler: clang++-8
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - clang-8
+              - g++-7
+            gcc_toolchain: 7
+          - toolset: clang
+            compiler: clang++-9
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-latest
+            container: ubuntu:20.04
+            install:
+              - clang-9
+          - toolset: clang
+            compiler: clang++-10
+            cxxstd: "11,14,17,20"
+            os: ubuntu-latest
+            container: ubuntu:20.04
+            install:
+              - clang-10
+          - toolset: clang
+            compiler: clang++-11
+            cxxstd: "11,14,17,20"
+            os: ubuntu-22.04
+            install:
+              - clang-11
+              - g++-11
+            gcc_toolchain: 11
+          - toolset: clang
+            compiler: clang++-12
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-22.04
+            install:
+              - clang-12
+              - g++-11
+            gcc_toolchain: 11
+          - toolset: clang
+            compiler: clang++-13
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-22.04
+            install:
+              - clang-13
+              - g++-11
+            gcc_toolchain: 11
+          - toolset: clang
+            compiler: clang++-14
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-22.04
+            install:
+              - clang-14
+              - g++-11
+            gcc_toolchain: 11
+          - toolset: clang
+            compiler: clang++-15
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-22.04
+            install:
+              - clang-15
+              - g++-11
+            gcc_toolchain: 11
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-24.04
+            install:
+              - clang-16
+              - g++-11
+            gcc_toolchain: 11
+          - toolset: clang
+            compiler: clang++-17
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-24.04
+            install:
+              - clang-17
+              - g++-11
+            gcc_toolchain: 11
+          - toolset: clang
+            compiler: clang++-18
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-24.04
+            install:
+              - clang-18
+              - g++-13
+          - toolset: clang
+            compiler: clang++-19
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-24.04
+            install:
+              - clang-19
+          - toolset: clang
+            compiler: clang++-20
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-latest
+            container: ubuntu:25.04
+            install:
+              - clang-20
+          - toolset: clang
+            compiler: clang++-20
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-latest
+            container: ubuntu:25.04
+            install:
+              - clang-20
+              - libc++-20-dev
+              - libc++abi-20-dev
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
+          - name: UBSAN
+            toolset: clang
+            compiler: clang++-18
+            cxxstd: "11,14,17,20,23,26"
+            cxxflags: -stdlib=libc++
+            linkflags: "-stdlib=libc++ -lubsan"
+            ubsan: 1
+            build_variant: debug
+            os: ubuntu-24.04
+            install:
+              - clang-18
+              - libc++-18-dev
+              - libc++abi-18-dev
+
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-13
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-14
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-15
+
+          - name: CMake tests
+            cmake_tests: 1
+            os: ubuntu-24.04
+
+    timeout-minutes: 20
+    runs-on: ${{matrix.os}}
+    container: ${{matrix.container}}
+
+    steps:
+      - name: Setup environment
+        run: |
+            if [ -f "/etc/debian_version" ]
+            then
+                echo "DEBIAN_FRONTEND=noninteractive" >> $GITHUB_ENV
+                export DEBIAN_FRONTEND=noninteractive
+            fi
+            if [ -n "${{matrix.container}}" ]
+            then
+                echo "GHA_CONTAINER=${{matrix.container}}" >> $GITHUB_ENV
+                if [ -f "/etc/debian_version" ]
+                then
+                    # Use Azure APT mirrors in containers to avoid HTTP errors due to DDoS filters triggered by lots of CI jobs launching concurrently.
+                    # Note that not all Ubuntu versions support "mirror+file:..." URIs in APT sources, so just use Azure mirrors exclusively.
+                    # Note also that on recent Ubuntu versions DEB822 format is used for source files.
+                    APT_SOURCES=()
+                    if [ -d "/etc/apt/sources.list.d" ]
+                    then
+                        readarray -t APT_SOURCES < <(find "/etc/apt/sources.list.d" -type f -name '*.sources' -print)
+                    fi
+                    if [ -f "/etc/apt/sources.list" ]
+                    then
+                        APT_SOURCES+=("/etc/apt/sources.list")
+                    fi
+                    if [ "${#APT_SOURCES[@]}" -gt 0 ]
+                    then
+                        sed -i -E -e 's!([^ ]+) (http|https)://(archive|security)\.ubuntu\.com/ubuntu[^ ]*(.*)!\1 http://azure.archive.ubuntu.com/ubuntu/\4!' "${APT_SOURCES[@]}"
+                    fi
+                    apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
+                    if [ "$(apt-cache search "^python-is-python3$" | wc -l)" -ne 0 ]
+                    then
+                        PYTHON_PACKAGE="python-is-python3"
+                    else
+                        PYTHON_PACKAGE="python"
+                    fi
+                    apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y sudo software-properties-common tzdata wget curl apt-transport-https ca-certificates make build-essential g++ $PYTHON_PACKAGE python3 perl git cmake
+                fi
+            fi
+            git config --global pack.threads 0
+
+      - name: Install packages
+        if: matrix.install
+        run: |
+            declare -a SOURCE_KEYS SOURCES
+            if [ -n "${{join(matrix.source_keys, ' ')}}" ]
+            then
+                SOURCE_KEYS=("${{join(matrix.source_keys, '" "')}}")
+            fi
+            if [ -n "${{join(matrix.sources, ' ')}}" ]
+            then
+                SOURCES=("${{join(matrix.sources, '" "')}}")
+            fi
+            for key in "${SOURCE_KEYS[@]}"
+            do
+                for i in {1..$NET_RETRY_COUNT}
+                do
+                    echo "Adding key: $key"
+                    wget -O - "$key" | sudo apt-key add - && break || sleep 2
+                done
+            done
+            if [ ${#SOURCES[@]} -gt 0 ]
+            then
+                APT_ADD_REPO_COMMON_ARGS=("-y")
+                APT_ADD_REPO_SUPPORTED_ARGS="$(apt-add-repository --help | perl -ne 'if (/^\s*-n/) { print "n"; } elsif (/^\s*-P/) { print "P"; } elsif (/^\s*-S/) { print "S"; } elsif (/^\s*-U/) { print "U"; }')"
+                if [ -n "$APT_ADD_REPO_SUPPORTED_ARGS" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*n*}" ]
+                then
+                    APT_ADD_REPO_COMMON_ARGS+=("-n")
+                fi
+                APT_ADD_REPO_HAS_SOURCE_ARGS="$([ -n "$APT_ADD_REPO_SUPPORTED_ARGS" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*P*}" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*S*}" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*U*}" ] && echo 1 || echo 0)"
+                for source in "${SOURCES[@]}"
+                do
+                    for i in {1..$NET_RETRY_COUNT}
+                    do
+                        APT_ADD_REPO_ARGS=("${APT_ADD_REPO_COMMON_ARGS[@]}")
+                        if [ $APT_ADD_REPO_HAS_SOURCE_ARGS -ne 0 ]
+                        then
+                            case "$source" in
+                            "ppa:"*)
+                                APT_ADD_REPO_ARGS+=("-P")
+                                ;;
+                            "deb "*)
+                                APT_ADD_REPO_ARGS+=("-S")
+                                ;;
+                            *)
+                                APT_ADD_REPO_ARGS+=("-U")
+                                ;;
+                            esac
+                        fi
+                        APT_ADD_REPO_ARGS+=("$source")
+                        echo "apt-add-repository ${APT_ADD_REPO_ARGS[@]}"
+                        sudo -E apt-add-repository "${APT_ADD_REPO_ARGS[@]}" && break || sleep 2
+                    done
+                done
+            fi
+            sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
+            sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y ${{join(matrix.install, ' ')}}
+
+      - name: Setup GCC Toolchain
+        if: matrix.gcc_toolchain
+        run: |
+            GCC_TOOLCHAIN_ROOT="$HOME/gcc-toolchain"
+            echo "GCC_TOOLCHAIN_ROOT=\"$GCC_TOOLCHAIN_ROOT\"" >> $GITHUB_ENV
+            MULTIARCH_TRIPLET="$(dpkg-architecture -qDEB_HOST_MULTIARCH)"
+            mkdir -p "$GCC_TOOLCHAIN_ROOT"
+            ln -s /usr/include "$GCC_TOOLCHAIN_ROOT/include"
+            ln -s /usr/bin "$GCC_TOOLCHAIN_ROOT/bin"
+            mkdir -p "$GCC_TOOLCHAIN_ROOT/lib/gcc/$MULTIARCH_TRIPLET"
+            ln -s "/usr/lib/gcc/$MULTIARCH_TRIPLET/${{matrix.gcc_toolchain}}" "$GCC_TOOLCHAIN_ROOT/lib/gcc/$MULTIARCH_TRIPLET/${{matrix.gcc_toolchain}}"
+
+      - name: Setup Boost
+        run: |
+            echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+            LIBRARY=${GITHUB_REPOSITORY#*/}
+            echo LIBRARY: $LIBRARY
+            echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+            echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+            echo GITHUB_REF: $GITHUB_REF
+            REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+            REF=${REF#refs/heads/}
+            echo REF: $REF
+            BOOST_BRANCH=develop && [ "$REF" = "master" ] && BOOST_BRANCH=master || true
+            echo BOOST_BRANCH: $BOOST_BRANCH
+            BUILD_JOBS=$((nproc || sysctl -n hw.ncpu) 2> /dev/null)
+            echo "BUILD_JOBS=$BUILD_JOBS" >> $GITHUB_ENV
+            echo "CMAKE_BUILD_PARALLEL_LEVEL=$BUILD_JOBS" >> $GITHUB_ENV
+            DEPINST_ARGS=()
+            GIT_VERSION="$(git --version | sed -e 's/git version //')"
+            GIT_HAS_JOBS=1
+            if [ -f "/etc/debian_version" ]
+            then
+                if $(dpkg --compare-versions "$GIT_VERSION" lt 2.8.0)
+                then
+                    GIT_HAS_JOBS=0
+                fi
+            else
+                declare -a GIT_VER=(${GIT_VERSION//./ })
+                declare -a GIT_MIN_VER=(2 8 0)
+                for ((i=0; i<${#GIT_VER[@]}; i++))
+                do
+                    if [ -z "${GIT_MIN_VER[i]}" ]
+                    then
+                        GIT_MIN_VER[i]=0
+                    fi
+                    if [ "${GIT_VER[i]}" -lt "${GIT_MIN_VER[i]}" ]
+                    then
+                        GIT_HAS_JOBS=0
+                        break
+                    fi
+                done
+            fi
+            if [ "$GIT_HAS_JOBS" -ne 0 ]
+            then
+                DEPINST_ARGS+=("--git_args" "--jobs $GIT_FETCH_JOBS")
+            fi
+            mkdir -p snapshot
+            cd snapshot
+            echo "Downloading library snapshot: https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz"
+            curl -L --retry "$NET_RETRY_COUNT" -o "${LIBRARY}-${GITHUB_SHA}.tar.gz" "https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz"
+            tar -xf "${LIBRARY}-${GITHUB_SHA}.tar.gz"
+            if [ ! -d "${LIBRARY}-${GITHUB_SHA}" ]
+            then
+                echo "Library snapshot does not contain the library directory ${LIBRARY}-${GITHUB_SHA}:"
+                ls -la
+                exit 1
+            fi
+            rm -f "${LIBRARY}-${GITHUB_SHA}.tar.gz"
+            cd ..
+            git clone -b "$BOOST_BRANCH" --depth 1 "https://github.com/boostorg/boost.git" "boost-root"
+            cd boost-root
+            mkdir -p libs
+            rm -rf "libs/$LIBRARY"
+            mv -f "../snapshot/${LIBRARY}-${GITHUB_SHA}" "libs/$LIBRARY"
+            rm -rf "../snapshot"
+            git submodule update --init tools/boostdep
+            DEPINST_ARGS+=("$LIBRARY")
+            python tools/boostdep/depinst/depinst.py "${DEPINST_ARGS[@]}"
+            if [ -z "${{matrix.cmake_tests}}" ]
+            then
+                ./bootstrap.sh
+                ./b2 headers
+                if [ -n "${{matrix.compiler}}" -o -n "$GCC_TOOLCHAIN_ROOT" ]
+                then
+                    echo -n "using ${{matrix.toolset}} : : ${{matrix.compiler}}" > ~/user-config.jam
+                    if [ -n "$GCC_TOOLCHAIN_ROOT" ]
+                    then
+                        echo -n " : <compileflags>\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\" <linkflags>\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\"" >> ~/user-config.jam
+                    fi
+                    echo " ;" >> ~/user-config.jam
+                fi
+            fi
+
+      - name: Run tests
+        if: matrix.cmake_tests == ''
+        run: |
+            cd boost-root
+            B2_ARGS=("-j" "$BUILD_JOBS" "toolset=${{matrix.toolset}}" "cxxstd=${{matrix.cxxstd}}")
+            if [ -n "${{matrix.build_variant}}" ]
+            then
+                B2_ARGS+=("variant=${{matrix.build_variant}}")
+            else
+                B2_ARGS+=("variant=$DEFAULT_BUILD_VARIANT")
+            fi
+            if [ -n "${{matrix.threading}}" ]
+            then
+                B2_ARGS+=("threading=${{matrix.threading}}")
+            fi
+            if [ -n "${{matrix.ubsan}}" ]
+            then
+                export UBSAN_OPTIONS="print_stacktrace=1"
+                B2_ARGS+=("cxxflags=-fsanitize=undefined -fno-sanitize-recover=undefined" "linkflags=-fsanitize=undefined -fuse-ld=gold" "define=UBSAN=1" "debug-symbols=on" "visibility=global")
+            fi
+            if [ -n "${{matrix.cxxflags}}" ]
+            then
+                B2_ARGS+=("cxxflags=${{matrix.cxxflags}}")
+            fi
+            if [ -n "${{matrix.linkflags}}" ]
+            then
+                B2_ARGS+=("linkflags=${{matrix.linkflags}}")
+            fi
+            B2_ARGS+=("libs/$LIBRARY/test")
+            ./b2 "${B2_ARGS[@]}"
+
+      - name: Run CMake tests
+        if: matrix.cmake_tests
+        run: |
+            if [ -n "${{matrix.macosx_version_min}}" ]
+            then
+                export MACOSX_DEPLOYMENT_TARGET="${{matrix.macosx_version_min}}"
+            fi
+            cd boost-root
+            mkdir __build_static__ && cd __build_static__
+            cmake ../libs/$LIBRARY/test/test_cmake
+            cmake --build . --target boost_${LIBRARY}_cmake_self_test -j $BUILD_JOBS
+            cd ..
+            mkdir __build_shared__ && cd __build_shared__
+            cmake -DBUILD_SHARED_LIBS=On ../libs/$LIBRARY/test/test_cmake
+            cmake --build . --target boost_${LIBRARY}_cmake_self_test -j $BUILD_JOBS
+
+  windows:
+    defaults:
+      run:
+        shell: cmd
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: msvc-14.3
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: clang-win
+            cxxstd: "14,17,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: gcc
+            cxxstd: "11,14,17,20,23"
+            addrmd: 64
+            os: windows-2022
+
+    timeout-minutes: 20
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - name: Setup Boost
+        run: |
+            echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+            for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+            echo LIBRARY: %LIBRARY%
+            echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+            echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+            echo GITHUB_REF: %GITHUB_REF%
+            if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+            set BOOST_BRANCH=develop
+            for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+            echo BOOST_BRANCH: %BOOST_BRANCH%
+            mkdir snapshot
+            cd snapshot
+            echo Downloading library snapshot: https://github.com/%GITHUB_REPOSITORY%/archive/%GITHUB_SHA%.zip
+            curl -L --retry %NET_RETRY_COUNT% -o "%LIBRARY%-%GITHUB_SHA%.zip" "https://github.com/%GITHUB_REPOSITORY%/archive/%GITHUB_SHA%.zip"
+            tar -xf "%LIBRARY%-%GITHUB_SHA%.zip"
+            if not exist "%LIBRARY%-%GITHUB_SHA%\" (
+                echo Library snapshot does not contain the library directory %LIBRARY%-%GITHUB_SHA%:
+                dir
+                exit /b 1
+            )
+            del /f "%LIBRARY%-%GITHUB_SHA%.zip"
+            cd ..
+            git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+            cd boost-root
+            if not exist "libs\" mkdir libs
+            if exist "libs\%LIBRARY%\" rmdir /s /q "libs\%LIBRARY%"
+            move /Y "..\snapshot\%LIBRARY%-%GITHUB_SHA%" "libs\%LIBRARY%"
+            rmdir /s /q "..\snapshot"
+            git submodule update --init tools/boostdep
+            python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" %LIBRARY%
+            cmd /c bootstrap
+            b2 -d0 headers
+
+      - name: Run tests
+        run: |
+            cd boost-root
+            if not "${{matrix.cxxstd}}" == "" set CXXSTD=cxxstd=${{matrix.cxxstd}}
+            if not "${{matrix.addrmd}}" == "" set ADDRMD=address-model=${{matrix.addrmd}}
+            if not "${{matrix.build_variant}}" == "" (set BUILD_VARIANT=variant=${{matrix.build_variant}}) else (set BUILD_VARIANT=variant=%DEFAULT_BUILD_VARIANT%)
+            b2 -j %NUMBER_OF_PROCESSORS% libs/%LIBRARY%/test toolset=${{matrix.toolset}} %CXXSTD% %ADDRMD% %BUILD_VARIANT% embed-manifest-via=linker

.travis.yml

@@ -1,87 +0,0 @@
-# Copyright 2016, 2017 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-language: cpp
-
-sudo: false
-
-python: "2.7"
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc CXXSTD=03,11
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc-5 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc-6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-7
-      env: TOOLSET=gcc-7 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang CXXSTD=03,11,14,1z
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang CXXSTD=03,11,14,1z
-
-install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
-  - cd ..
-  - git clone -b $BOOST_BRANCH --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 tools/boostdep
-  - cp -r $TRAVIS_BUILD_DIR/* libs/iterator
-  - python tools/boostdep/depinst/depinst.py iterator
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - ./b2 -j3 libs/iterator/test toolset=$TOOLSET cxxstd=$CXXSTD
-
-notifications:
-  email:
-    on_success: always

CMakeLists.txt

@@ -0,0 +1,27 @@
+# Copyright 2018 Peter Dimov
+# Copyright 2018 Andrey Semashev
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.20)
+
+project(boost_iterator VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_iterator INTERFACE)
+add_library(Boost::iterator ALIAS boost_iterator)
+
+target_include_directories(boost_iterator INTERFACE include)
+
+target_link_libraries(boost_iterator
+    INTERFACE
+        Boost::assert
+        Boost::concept_check
+        Boost::config
+        Boost::core
+        Boost::detail
+        Boost::fusion
+        Boost::mpl
+        Boost::optional
+        Boost::type_traits
+        Boost::utility
+)

README.md

@@ -0,0 +1,27 @@
+# Boost.Iterator
+
+Boost.Iterator, part of collection of the [Boost C++ Libraries](https://github.com/boostorg), provides tools for building and working with iterators in C++. The library also provides a number of iterator classes that can be used out of the box.
+
+### Directories
+
+* **doc** - Documentation sources
+* **include** - Interface headers of Boost.Iterator
+* **test** - Boost.Iterator unit tests
+* **example** - Boost.Iterator usage examples
+
+### More information
+
+* [Documentation](https://boost.org/libs/iterator)
+* [Report bugs](https://github.com/boostorg/iterator/issues/new). 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](https://github.com/boostorg/iterator/compare) against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).
+
+### Build status
+
+Branch          | GitHub Actions | AppVeyor | Test Matrix | Dependencies |
+:-------------: | -------------- | -------- | ----------- | ------------ |
+[`master`](https://github.com/boostorg/iterator/tree/master) | [![GitHub Actions](https://github.com/boostorg/iterator/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/iterator/actions?query=branch%3Amaster) | [![AppVeyor](https://ci.appveyor.com/api/projects/status/ud8ug5aai8vd30hg/branch/master?svg=true)](https://ci.appveyor.com/project/Lastique/iterator/branch/master) | [![Tests](https://img.shields.io/badge/matrix-master-brightgreen.svg)](http://www.boost.org/development/tests/master/developer/iterator.html) | [![Dependencies](https://img.shields.io/badge/deps-master-brightgreen.svg)](https://pdimov.github.io/boostdep-report/master/iterator.html)
+[`develop`](https://github.com/boostorg/iterator/tree/develop) | [![GitHub Actions](https://github.com/boostorg/iterator/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/iterator/actions?query=branch%3Adevelop) | [![AppVeyor](https://ci.appveyor.com/api/projects/status/ud8ug5aai8vd30hg/branch/develop?svg=true)](https://ci.appveyor.com/project/Lastique/iterator/branch/develop) | [![Tests](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](http://www.boost.org/development/tests/develop/developer/iterator.html) | [![Dependencies](https://img.shields.io/badge/deps-develop-brightgreen.svg)](https://pdimov.github.io/boostdep-report/develop/iterator.html)
+
+### License
+
+Distributed under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).

appveyor.yml

@@ -1,4 +1,5 @@
 # Copyright 2017 Edward Diener
+# Copyright 2019 Andrey Semashev
 # 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)
 
@@ -14,30 +15,81 @@ branches:
 
 environment:
   matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    - TOOLSET: msvc-14.0
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0
+      CXXSTD: 14,latest
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDRMD: 32,64
-      TOOLSET: msvc-14.0
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    - TOOLSET: msvc-14.1
-      TOOLSET: msvc-14.1
+      CXXSTD: 14,17,latest
-      CXXSTD: 14,17
+      ADDRMD: 32,64
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    - TOOLSET: msvc-14.2
+      ADDRMD: 32,64
+      CXXSTD: 14,17,20,latest
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+    - TOOLSET: msvc-14.3
+      ADDRMD: 32,64
+      CXXSTD: 14,17,20,latest
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
+    - TOOLSET: clang-win
+      ADDRMD: 32,64
+      CXXSTD: 14,17,latest
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    - TOOLSET: gcc
+      CXXSTD: 11,14,1z
+      ADDPATH: C:\cygwin\bin;
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: gcc
+      CXXSTD: 11,14,1z
+      ADDPATH: C:\cygwin64\bin;
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: gcc
+      CXXSTD: 11,14,1z
+      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: gcc
+      CXXSTD: 11,14,1z
+      ADDPATH: C:\mingw-w64\x86_64-7.3.0-posix-seh-rt_v5-rev0\mingw64\bin;
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TEST_CMAKE: 1
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
 
 install:
+  - set GIT_FETCH_JOBS=8
   - set BOOST_BRANCH=develop
   - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
   - cd ..
   - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
   - cd boost-root
-  - git submodule update --init tools/build
+  - git submodule init tools/build
-  - git submodule update --init libs/config
+  - git submodule init tools/boostdep
-  - git submodule update --init tools/boostdep
+  - git submodule init tools/boost_install
+  - git submodule init libs/headers
+  - git submodule init libs/config
+  - git submodule update --jobs %GIT_FETCH_JOBS%
   - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\iterator
-  - python tools/boostdep/depinst/depinst.py iterator
+  - python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" iterator
   - cmd /c bootstrap
   - b2 -d0 headers
 
 build: off
 
 test_script:
+  - PATH=%ADDPATH%%PATH%
   - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - b2 -j3 libs/iterator/test toolset=%TOOLSET% %CXXSTD%
+  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+  - b2 -j %NUMBER_OF_PROCESSORS% libs/iterator/test toolset=%TOOLSET% %CXXSTD% %ADDRMD%
+
+for:
+  - matrix:
+      only: [TEST_CMAKE: 1]
+    test_script:
+      - mkdir __build_static__
+      - cd __build_static__
+      - cmake ../libs/iterator/test/test_cmake
+      - cmake --build . --target boost_iterator_cmake_self_test -j %NUMBER_OF_PROCESSORS%
+      - cd ..
+      - mkdir __build_shared__
+      - cd __build_shared__
+      - cmake -DBUILD_SHARED_LIBS=On ../libs/iterator/test/test_cmake
+      - cmake --build . --target boost_iterator_cmake_self_test -j %NUMBER_OF_PROCESSORS%

build.jam

@@ -0,0 +1,32 @@
+# Copyright René Ferdinand Rivera Morell 2023-2024
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/assert//boost_assert
+    /boost/concept_check//boost_concept_check
+    /boost/config//boost_config
+    /boost/core//boost_core
+    /boost/detail//boost_detail
+    /boost/fusion//boost_fusion
+    /boost/mpl//boost_mpl
+    /boost/optional//boost_optional
+    /boost/type_traits//boost_type_traits
+    /boost/utility//boost_utility ;
+
+project /boost/iterator
+    : common-requirements
+        <include>include
+    ;
+
+explicit
+    [ alias boost_iterator : : : : <library>$(boost_dependencies) ]
+    [ alias all : boost_iterator test ]
+    ;
+
+call-if : boost-library iterator
+    ;
+

doc/Jamfile.v2

@@ -4,20 +4,20 @@
 
 using quickbook ;
 
-xml iterator 
+xml iterator
-  : 
+  :
-    quickbook/iterator.qbk 
+    quickbook/iterator.qbk
   ;
 
 boostbook standalone 
   : 
     iterator 
   :
-    <xsl:param>boost.root=../../../..
+    <xsl:param>"boost.root=../../../.."
     <xsl:param>toc.max.depth=3
     <xsl:param>toc.section.depth=3
     <xsl:param>chunk.section.depth=2
-    <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/iterator/doc
+    <format>pdf:<xsl:param>"boost.url.prefix=http://www.boost.org/doc/libs/release/libs/iterator/doc/html"
   ;
 
 ###############################################################################

doc/counting_iterator.rst

@@ -11,7 +11,6 @@
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
-:date: $Date$
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/default.css

@@ -1,8 +1,6 @@
 /*
 :Author: David Goodger
 :Contact: goodger@users.sourceforge.net
-:date: $Date$
-:version: $Revision$
 :copyright: This stylesheet has been placed in the public domain.
 
 boostinspect:nolicense

doc/docutils.sty

@@ -4,7 +4,6 @@
 %%
 %% o author: Alexander Schmolck (a.schmolck@gmx.net)
 %% o created: 2002-07-07 10:50:31+00:40
-%% o last modified: $Date: 2004/01/29 05:55:26 $
 %% o keywords: 
 %% o license: 
 %XXX titlesec

doc/facade-and-adaptor.html

@@ -2622,7 +2622,7 @@ proxy object.</p>
 <div class="section" id="header">
 <h4><a class="toc-backref" href="#id70">Header</a></h4>
 <pre class="literal-block">
-#include &lt;boost/function_output_iterator.hpp&gt;
+#include &lt;boost/iterator/function_output_iterator.hpp&gt;
 </pre>
 <pre class="literal-block">
 template &lt;class UnaryFunction&gt;

doc/facade-and-adaptor.rst

@@ -10,7 +10,6 @@
 :Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@styleadvisor.com
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, `Zephyr Associates, Inc.`_
-:date: $Date$
 
 :Number: This is a revised version of N1530_\ =03-0113, which was
          accepted for Technical Report 1 by the C++ standard

doc/filter_iterator.rst

@@ -11,7 +11,6 @@
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
-:date: $Date$
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/func_output_iter_ref.rst

@@ -7,7 +7,7 @@ Header
 
 ::
   
-  #include <boost/function_output_iterator.hpp>
+  #include <boost/iterator/function_output_iterator.hpp>
 
 ::
 

doc/function_output_iterator.html

@@ -68,7 +68,7 @@ proxy object.</td>
 <div class="section" id="header">
 <h1><a class="toc-backref" href="#id1">Header</a></h1>
 <pre class="literal-block">
-#include &lt;boost/function_output_iterator.hpp&gt;
+#include &lt;boost/iterator/function_output_iterator.hpp&gt;
 </pre>
 <pre class="literal-block">
 template &lt;class UnaryFunction&gt;

doc/function_output_iterator.rst

@@ -11,7 +11,6 @@
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
-:date: $Date$
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/generator_iterator.htm

@@ -15,7 +15,7 @@
   <h1>Generator Iterator Adaptor</h1>
 
   <p>Defined in header <a href=
-  "../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a></p>
+  "../../boost/iterator/generator_iterator.hpp">boost/iterator/generator_iterator.hpp</a></p>
 
   <p>The generator iterator adaptor makes it easier to create custom input
   iterators from 0-ary functions and function objects. The adaptor takes a
@@ -33,9 +33,7 @@
   <blockquote>
     <pre>
 namespace boost {
-  template &lt;class Generator&gt;
+namespace iterators {
-  class generator_iterator_policies;
-
   template &lt;class Generator&gt;
   class generator_iterator_generator;
 
@@ -43,6 +41,7 @@ namespace boost {
   typename generator_iterator_generator&lt;Generator&gt;::type
   make_generator_iterator(Generator &amp; gen);
 }
+}
 </pre>
   </blockquote>
   <hr>
@@ -60,8 +59,8 @@ template &lt;class Generator&gt;
 class generator_iterator_generator
 {
 public:
-  typedef <i>unspecified</i> type; // the resulting generator iterator type 
+  using type = <i>unspecified</i>; // the resulting generator iterator type
-}
+};
 </pre>
 
   <h3>Template Parameters</h3>
@@ -78,8 +77,8 @@ public:
       "http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt></td>
 
       <td>The generator (0-ary function object) type being wrapped. The
-      return type of the function must be defined as
+      return type of the function is deduced automatically from its
-      <tt>Generator::result_type</tt>. The function object must be a model of
+      <tt>operator()</tt>. The function object must be a model of
       <a href=
       "http://www.sgi.com/tech/stl/Generator.html">Generator</a>.</td>
     </tr>
@@ -122,14 +121,14 @@ make_generator_iterator(Generator &amp; gen);
   <blockquote>
     <pre>
 #include &lt;iostream&gt;
-#include &lt;boost/generator_iterator.hpp&gt;
+#include &lt;boost/iterators/generator_iterator.hpp&gt;
 
 class my_generator
 {
 public:
-  typedef int result_type;
+  using result_type = int;
   my_generator() : state(0) { }
-  int operator()() { return ++state; }
+  result_type operator()() { return ++state; }
 private:
   int state;
 };
@@ -137,7 +136,7 @@ private:
 int main()
 {
   my_generator gen;
-  boost::generator_iterator_generator&lt;my_generator&gt;::type it = boost::make_generator_iterator(gen);
+  auto it = boost::iterators::make_generator_iterator(gen);
   for(int i = 0; i &lt; 10; ++i, ++it)
     std::cout &lt;&lt; *it &lt;&lt; std::endl;
 }

doc/index.html

@@ -26,8 +26,6 @@
 <tr class="field"><th class="field-name">organizations:</th><td class="field-body"><a class="reference external" href="http://www.boost-consulting.com">Boost Consulting</a>, Indiana University <a class="reference external" href="http://www.osl.iu.edu">Open Systems
 Lab</a>, <a class="reference external" href="http://www.styleadvisor.com">Zephyr Associates, Inc.</a></td>
 </tr>
-<tr class="field"><th class="field-name">date:</th><td class="field-body">$Date$</td>
-</tr>
 <tr class="field"><th class="field-name">copyright:</th><td class="field-body">Copyright David Abrahams, Jeremy Siek, Thomas Witt 2003.</td>
 </tr>
 </tbody>
@@ -142,7 +140,7 @@ sequence, rearranged according to some sequence of integer indices.</li>
 bidirectional sequence in reverse.  Corrects many of the
 shortcomings of C++98's <tt class="docutils literal"><span class="pre">std::reverse_iterator</span></tt>.</li>
 <li><a class="reference external" href="../../utility/shared_container_iterator.html"><tt class="docutils literal"><span class="pre">shared_container_iterator</span></tt></a>: an iterator over elements of a container whose
-lifetime is maintained by a <a class="reference external" href="../../smart_ptr/shared_ptr.htm"><tt class="docutils literal"><span class="pre">shared_ptr</span></tt></a> stored in the iterator.</li>
+lifetime is maintained by a <tt class="docutils literal"><span class="pre">shared_ptr</span></tt> stored in the iterator.</li>
 <li><a class="reference external" href="transform_iterator.html"><tt class="docutils literal"><span class="pre">transform_iterator</span></tt></a> (<a class="reference external" href="transform_iterator.pdf">PDF</a>): an iterator over elements which are the result of
 applying some functional transformation to the elements of an
 underlying sequence.  This component also replaces the old

doc/index.rst

@@ -19,7 +19,6 @@ __ ../../../index.htm
 :Contact:       dave@boost-consulting.com, jsiek@osl.iu.edu, witt@styleadvisor.com
 :organizations: `Boost Consulting`_, Indiana University `Open Systems
                 Lab`_, `Zephyr Associates, Inc.`_
-:date:          $Date$
 
 :copyright:     Copyright David Abrahams, Jeremy Siek, Thomas Witt 2003.
 

doc/indirect_iterator.rst

@@ -11,7 +11,6 @@
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
-:date: $Date$
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/interoperability-revisited.rst

@@ -2,7 +2,6 @@
  Interoperability Revisited 
 ++++++++++++++++++++++++++++
 
-:date: $Date$
 :copyright: Copyright Thomas Witt 2004.
 
 .. Distributed under the Boost

doc/issues.rst

@@ -8,7 +8,6 @@
 :Author: David Abrahams and Jeremy Siek
 :Contact: dave@boost-consulting.com, jsiek@osl.iu.edu
 :Organization: `Boost Consulting`_, Indiana University Bloomington
-:date: $Date$
 :Copyright: Copyright David Abrahams, Jeremy Siek 2003. Use, modification and
       distribution is subject to the Boost Software License,
       Version 1.0. (See accompanying file LICENSE_1_0.txt or copy

doc/iterator_adaptor.rst

@@ -11,7 +11,6 @@
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
-:date: $Date$
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/iterator_archetypes.rst

@@ -10,7 +10,6 @@
 :Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@styleadvisor.com
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, `Zephyr Associates, Inc.`_
-:date: $Date$
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/iterator_concepts.rst

@@ -10,7 +10,6 @@
 :Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@styleadvisor.com
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, `Zephyr Associates, Inc.`_
-:date: $Date$
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/iterator_facade.rst

@@ -11,7 +11,6 @@
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
-:date: $Date$
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/iterator_traits.html

@@ -7,7 +7,6 @@
 <title>Iterator Traits</title>
 <meta name="author" content="David Abrahams" />
 <meta name="organization" content="Boost Consulting" />
-<meta name="date" content="$Date$" />
 <meta name="copyright" content="Copyright David Abrahams 2004." />
 <link rel="stylesheet" href="../../../rst.css" type="text/css" />
 </head>
@@ -24,8 +23,6 @@
 <td><a class="first last reference external" href="mailto:dave&#64;boost-consulting.com">dave&#64;boost-consulting.com</a></td></tr>
 <tr><th class="docinfo-name">Organization:</th>
 <td><a class="first last reference external" href="http://www.boost-consulting.com">Boost Consulting</a></td></tr>
-<tr><th class="docinfo-name">Date:</th>
-<td>$Date$</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
 <td>Copyright David Abrahams 2004.</td></tr>
 </tbody>

doc/iterator_traits.rst

@@ -9,7 +9,6 @@
 :Author: David Abrahams
 :Contact: dave@boost-consulting.com
 :organization: `Boost Consulting`_
-:date: $Date$
 :copyright: Copyright David Abrahams 2004. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/new-iter-concepts.rst

@@ -13,7 +13,6 @@
 :Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@styleadvisor.com
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, `Zephyr Associates, Inc.`_
-:date: $Date$
 
 :Number: This is a revised version of n1550_\ =03-0133, which was
          accepted for Technical Report 1 by the C++ standard

doc/permutation_iterator.rst

@@ -10,7 +10,6 @@
 :Contact: dave@boost-consulting.com, jsiek@osl.iu.edu
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_
-:date: $Date$
 :copyright: Copyright Toon Knapen, David Abrahams, Roland Richter, and Jeremy Siek 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/pointee.rst

@@ -9,7 +9,6 @@
 :Author: David Abrahams
 :Contact: dave@boost-consulting.com
 :organization: `Boost Consulting`_
-:date: $Date$
 :copyright: Copyright David Abrahams 2004. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/quickbook/adaptor.qbk

@@ -1,4 +1,3 @@
-
 [section:adaptor Iterator Adaptor]
 
 The `iterator_adaptor` class template adapts some `Base` [#base]_
@@ -47,7 +46,7 @@ that assumption.
     , class Reference           = use_default
     , class Difference = use_default
   >
-  class iterator_adaptor 
+  class iterator_adaptor
     : public iterator_facade<Derived, *V'*, *C'*, *R'*, *D'*> // see details
   {
       friend class iterator_core_access;
@@ -60,21 +59,21 @@ that assumption.
       typedef iterator_adaptor iterator_adaptor\_;
       Base const& base_reference() const;
       Base& base_reference();
-   private: // Core iterator interface for iterator_facade.  
+   private: // Core iterator interface for iterator_facade.
       typename iterator_adaptor::reference dereference() const;
 
       template <
-      class OtherDerived, class OtherIterator, class V, class C, class R, class D
+          class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >   
+      >
       bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const;
-  
+
       void advance(typename iterator_adaptor::difference_type n);
       void increment();
       void decrement();
 
       template <
           class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >   
+      >
       typename iterator_adaptor::difference_type distance_to(
           iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const;
 
@@ -133,7 +132,7 @@ above are defined as follows:
   iterator_adaptor();
 
 [*Requires:] The `Base` type must be Default Constructible.[br]
-[*Returns:] An instance of `iterator_adaptor` with 
+[*Returns:] An instance of `iterator_adaptor` with
     `m_iterator` default constructed.
 
 
@@ -167,7 +166,7 @@ above are defined as follows:
 
   template <
   class OtherDerived, class OtherIterator, class V, class C, class R, class D
-  >   
+  >
   bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const;
 
 [*Returns:] `m_iterator == x.base()`
@@ -188,7 +187,7 @@ above are defined as follows:
 
   template <
       class OtherDerived, class OtherIterator, class V, class C, class R, class D
-  >   
+  >
   typename iterator_adaptor::difference_type distance_to(
       iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const;
 
@@ -229,7 +228,7 @@ operations on the underlying pointer, via the `node_iterator`\ 's
 |dereference_and_equal|_).  The only real behavioral difference
 between `node_base*` and `node_iterator` can be observed when
 they are incremented: `node_iterator` follows the
-`m_next` pointer, while `node_base*` just applies an address offset.   
+`m_next` pointer, while `node_base*` just applies an address offset.
 
 .. |dereference_and_equal| replace:: `dereference` and `equal` member functions
 .. _dereference_and_equal: iterator_facade.html#implementing-the-core-operations
@@ -287,8 +286,8 @@ this technique is known not to work with Borland C++ 5.6.4 and
 Metrowerks CodeWarrior versions prior to 9.0]
 
 You can see an example program that exercises this version of the
-node iterators 
+node iterators
-[@../example/node_iterator3.cpp `here`].
+[example_link node_iterator3.cpp..here].
 
 
 In the case of `node_iter`, it's not very compelling to pass
@@ -306,7 +305,7 @@ types to its `Base` saves the implementor of
 
    std::iterator_traits<Iterator>::*some-associated-type*
 
-at least four times.  
+at least four times.
 
 We urge you to review the documentation and implementations of
 |reverse_iterator|_ and the other Boost `specialized iterator
@@ -330,4 +329,4 @@ __ index.html#specialized-adaptors
 
 [endsect]
 
-[endsect]
+[endsect]

doc/quickbook/archetypes.qbk

@@ -1,4 +1,3 @@
-
 [section:archetypes Iterator Archetypes]
 
 The `iterator_archetype` class constructs a minimal implementation of
@@ -41,23 +40,23 @@ The access category types provided correspond to the following
 standard iterator access concept combinations:
 
     readable_iterator_t :=
-  
+
       Readable Iterator
 
     writable_iterator_t :=
-  
+
       Writeable Iterator
 
     readable_writable_iterator_t :=
-  
+
       Readable Iterator & Writeable Iterator & Swappable Iterator
 
     readable_lvalue_iterator_t :=
-  
+
       Readable Iterator & Lvalue Iterator
 
     writeable_lvalue_iterator_t :=
-  
+
       Readable Iterator & Writeable Iterator & Swappable Iterator & Lvalue Iterator
 
 [h3 Traits]
@@ -66,25 +65,25 @@ The nested trait types are defined as follows:
 
 
    if (AccessCategory == readable_iterator_t)
-     
+
      value_type = Value
      reference  = Value
      pointer    = Value*
 
    else if (AccessCategory == writable_iterator_t)
- 
+
      value_type = void
      reference  = void
      pointer    = void
 
    else if (AccessCategory == readable_writable_iterator_t)
- 
+
      value_type = Value
 
      reference :=
 
        A type X that is convertible to Value for which the following
-       expression is valid. Given an object x of type X and v of type 
+       expression is valid. Given an object x of type X and v of type
        Value.
 
        x = v
@@ -92,13 +91,13 @@ The nested trait types are defined as follows:
      pointer    = Value*
 
    else if (AccessCategory == readable_lvalue_iterator_t)
-     
+
      value_type = Value
      reference  = Value const&
      pointer    = Value const*
 
    else if (AccessCategory == writable_lvalue_iterator_t)
-     
+
      value_type = Value
      reference  = Value&
      pointer    = Value*
@@ -108,11 +107,11 @@ The nested trait types are defined as follows:
      difference_type := ptrdiff_t
 
    else
-  
+
      difference_type := unspecified type
 
-   
+
-   iterator_category := 
+   iterator_category :=
 
      A type X satisfying the following two constraints:
 
@@ -156,5 +155,4 @@ the iterator concept specified by `AccessCategory` and
 arguments. `iterator_archetype` does not model any other access
 concepts or any more derived traversal concepts.
 
-
+[endsect]
-[endsect]

doc/quickbook/concepts.qbk

@@ -1,4 +1,3 @@
-
 [section:concepts Iterator Concepts]
 
 [section:access Access]
@@ -326,13 +325,13 @@ constant object of type `Distance`.
     [pre: there exists a value `n` of `Distance` such that `a + n == b`. `b == a + (b - a)`.]
   ]
   [
-    [`a\[n\]`]
+    [`a[n]`]
     [convertible to T]
     [`*(a + n)`]
     [pre: a is a *Readable Iterator*]
   ]
   [
-    [`a\[n\] = v`]
+    [`a[n] = v`]
     [convertible to T]
     [`*(a + n) = v`]
     [pre: a is a *Writable iterator*]

doc/quickbook/counting_iterator.qbk

@@ -1,4 +1,3 @@
-
 [section:counting Counting Iterator]
 
 A `counting_iterator` adapts an object by adding an `operator*` that
@@ -18,28 +17,30 @@ into the first array via indirection through the second array.
     std::vector<int> numbers;
     typedef std::vector<int>::iterator n_iter;
     std::copy(boost::counting_iterator<int>(0),
-             boost::counting_iterator<int>(N),
+              boost::counting_iterator<int>(N),
-             std::back_inserter(numbers));
+              std::back_inserter(numbers));
 
     std::vector<std::vector<int>::iterator> pointers;
     std::copy(boost::make_counting_iterator(numbers.begin()),
-	      boost::make_counting_iterator(numbers.end()),
+        boost::make_counting_iterator(numbers.end()),
-	      std::back_inserter(pointers));
+        std::back_inserter(pointers));
 
-    std::cout << "indirectly printing out the numbers from 0 to " 
+    std::cout << "indirectly printing out the numbers from 0 to "
-	      << N << std::endl;
+        << N << std::endl;
     std::copy(boost::make_indirect_iterator(pointers.begin()),
-	      boost::make_indirect_iterator(pointers.end()),
+        boost::make_indirect_iterator(pointers.end()),
-	      std::ostream_iterator<int>(std::cout, " "));
+        std::ostream_iterator<int>(std::cout, " "));
     std::cout << std::endl;
 
 
 The output is:
 
-    indirectly printing out the numbers from 0 to 7
+[pre
-    0 1 2 3 4 5 6 
+indirectly printing out the numbers from 0 to 7
+0 1 2 3 4 5 6
+]
 
-The source code for this example can be found [@../example/counting_iterator_example.cpp here].
+The source code for this example can be found [example_link counting_iterator_example.cpp..here].
 
 [h2 Reference]
 
@@ -86,9 +87,9 @@ algorithm:
            random_access_traversal_tag, Incrementable, const Incrementable&)
    else
        return |iterator-category|_\ (
-            iterator_traversal<Incrementable>::type, 
+            iterator_traversal<Incrementable>::type,
             Incrementable, const Incrementable&)
-        
+
 [blurb *Note:* implementers are encouraged to provide an implementation of
   `operator-` and a `difference_type` that avoids overflows in
   the cases where `std::numeric_limits<Incrementable>::is_specialized`
@@ -181,7 +182,7 @@ operations.
   counting_iterator& operator--();
 
 [*Effects: ] `--m_inc`[br]
-[*Returns: ] `*this`  
+[*Returns: ] `*this`
 
 
   Incrementable const& base() const;
@@ -189,4 +190,4 @@ operations.
 [*Returns: ] `m_inc`
 
 
-[endsect]
+[endsect]

doc/quickbook/facade.qbk

@@ -1,4 +1,3 @@
-
 [section:facade Iterator Facade]
 
 While the iterator interface is rich, there is a core subset of the

doc/quickbook/facade_tutorial.qbk

@@ -1,12 +1,11 @@
-
 [section:facade_tutorial Tutorial]
 
 In this section we'll walk through the implementation of a few
 iterators using `iterator_facade`, based around the simple
 example of a linked list of polymorphic objects.  This example was
-inspired by a 
+inspired by a
 [@http://thread.gmane.org/gmane.comp.lib.boost.user/5100 `posting`]
-by Keith Macdonald on the 
+by Keith Macdonald on the
 [@http://www.boost.org/more/mailing_lists.htm#users `Boost-Users`]
 mailing list.
 
@@ -30,16 +29,16 @@ Say we've written a polymorphic linked list node base class:
 
       // print to the stream
       virtual void print(std::ostream& s) const = 0;
-      
+
       // double the value
       virtual void double_me() = 0;
 
       void append(node_base* p)
       {
-          if (m_next) 
+          if (m_next)
-              m_next->append(p); 
+              m_next->append(p);
           else
-              m_next = p; 
+              m_next = p;
       }
 
    private:
@@ -210,7 +209,7 @@ the concepts we want our iterator to model.  Referring to the
 table__, we can see that the first three rows are applicable
 because `node_iterator` needs to satisfy the requirements for
 `readable iterator`_, `single pass iterator`_, and `incrementable
-iterator`_.  
+iterator`_.
 
 __ `core operations`_
 
@@ -254,10 +253,10 @@ make them private and grant friendship to
   };
 
 Voila; a complete and conforming readable, forward-traversal
-iterator!  For a working example of its use, see 
+iterator!  For a working example of its use, see
-[@../example/node_iterator1.cpp `this program`].
+[example_link node_iterator1.cpp..this program].
 
-__ ../example/node_iterator1.cpp
+__ ../../example/node_iterator1.cpp
 
 [h2 A constant `node_iterator`]
 
@@ -265,7 +264,7 @@ __ ../example/node_iterator1.cpp
 The term **mutable iterator** means an iterator through which
 the object it references (its "referent") can be modified.  A
 **constant iterator** is one which doesn't allow modification of
-its referent.[br][br]  
+its referent.[br][br]
 The words *constant* and *mutable* don't refer to the ability to
 modify the iterator itself.  For example, an `int const*` is a
 non-\ `const` *constant iterator*, which can be incremented
@@ -402,7 +401,7 @@ adding a templatized converting constructor [#broken]_ [#random]_:
 
       template <class OtherValue>
       bool equal(node_iter<OtherValue> const& other) const
-      { 
+      {
           return this->m_node == other.m_node;
       }
 
@@ -428,11 +427,11 @@ adding a templatized converting constructor [#broken]_ [#random]_:
    `distance_to` function as well.
 
 
-__ ../example/node_iterator2.hpp
+__ ../../example/node_iterator2.hpp
 
 You can see an example program which exercises our interoperable
-iterators 
+iterators
-[@../example/node_iterator2.cpp `here`].
+[example_link node_iterator2.cpp..here].
 
 
 [h2 Telling the Truth]
@@ -467,7 +466,7 @@ appropriate:
 
     ...
 
-  private: 
+  private:
     struct enabler {};
 
   public:

doc/quickbook/filter_iterator.qbk

@@ -1,4 +1,3 @@
-
 [section:filter Filter Iterator]
 
 The filter iterator adaptor creates a view of an iterator range in
@@ -19,7 +18,6 @@ This example uses `filter_iterator` and then
 array of integers. Then `make_filter_iterator` is is used to output
 the integers greater than `-2`.
 
-
     struct is_positive_number {
       bool operator()(int x) { return 0 < x; }
     };
@@ -33,7 +31,7 @@ the integers greater than `-2`.
       base_iterator numbers(numbers_);
 
       // Example using filter_iterator
-      typedef boost::filter_iterator<is_positive_number, base_iterator> 
+      typedef boost::filter_iterator<is_positive_number, base_iterator>
         FilterIter;
 
       is_positive_number predicate;
@@ -52,11 +50,11 @@ the integers greater than `-2`.
       // Another example using make_filter_iterator()
       std::copy(
           boost::make_filter_iterator(
-              std::bind2nd(std::greater<int>(), -2)
+              std::bind(std::greater<int>(), std::placeholders::_1, -2)
             , numbers, numbers + N)
 
         , boost::make_filter_iterator(
-              std::bind2nd(std::greater<int>(), -2)
+              std::bind(std::greater<int>(), std::placeholders::_1, -2)
             , numbers + N, numbers + N)
 
         , std::ostream_iterator<int>(std::cout, " ")
@@ -70,12 +68,13 @@ the integers greater than `-2`.
 
 The output is:
 
-    4 5 8 
+[pre
-    4 5 8 
+4 5 8
-    0 -1 4 5 8 
+4 5 8
+0 -1 4 5 8
+]
 
-
+The source code for this example can be found [example_link filter_iterator_example.cpp..here].
-The source code for this example can be found [@../example/filter_iterator_example.cpp here].
 
 [h2 Reference]
 
@@ -114,10 +113,10 @@ The source code for this example can be found [@../example/filter_iterator_examp
 
 If `Iterator` models Readable Lvalue Iterator and Bidirectional Traversal
 Iterator then `iterator_category` is convertible to
-`std::bidirectional_iterator_tag`. 
+`std::bidirectional_iterator_tag`.
 Otherwise, if `Iterator` models Readable Lvalue Iterator and Forward Traversal
 Iterator then `iterator_category` is convertible to
-`std::forward_iterator_tag`. 
+`std::forward_iterator_tag`.
 Otherwise `iterator_category` is
 convertible to `std::input_iterator_tag`.
 
@@ -164,7 +163,7 @@ following tables.
        [[Writable Lvalue Iterator, Bidirectional Iterator    ][Mutable Bidirectional Iterator]]
 ]
 
-`filter_iterator<P1, X>` is interoperable with `filter_iterator<P2, Y>` 
+`filter_iterator<P1, X>` is interoperable with `filter_iterator<P2, Y>`
 if and only if `X` is interoperable with `Y`.
 
 
@@ -179,14 +178,14 @@ operations.
   filter_iterator();
 
 [*Requires: ]`Predicate` and `Iterator` must be Default Constructible.[br]
-[*Effects: ] Constructs a `filter_iterator` whose`m_pred`,  `m_iter`, and `m_end` 
+[*Effects: ] Constructs a `filter_iterator` whose`m_pred`,  `m_iter`, and `m_end`
   members are a default constructed.
 
 
   filter_iterator(Predicate f, Iterator x, Iterator end = Iterator());
 
 [*Effects: ] Constructs a `filter_iterator` where `m_iter` is either
-    the first position in the range `[x,end)` such that `f(*m_iter) == true` 
+    the first position in the range `[x,end)` such that `f(*m_iter) == true`
     or else`m_iter == end`. The member `m_pred` is constructed from
     `f` and `m_end` from `end`.
 
@@ -197,7 +196,7 @@ operations.
 [*Requires: ] `Predicate` must be Default Constructible and
   `Predicate` is a class type (not a function pointer).[br]
 [*Effects: ] Constructs a `filter_iterator` where `m_iter` is either
-    the first position in the range `[x,end)` such that `m_pred(*m_iter) == true` 
+    the first position in the range `[x,end)` such that `m_pred(*m_iter) == true`
     or else`m_iter == end`. The member `m_pred` is default constructed.
 
 
@@ -236,7 +235,6 @@ operations.
 [*Effects: ] Increments `m_iter` and then continues to
   increment `m_iter` until either `m_iter == m_end`
   or `m_pred(*m_iter) == true`.[br]
-[*Returns: ] `*this`  
+[*Returns: ] `*this`
 
-
+[endsect]
-[endsect]

doc/quickbook/function_output_iterator.qbk

@@ -1,4 +1,3 @@
-
 [section:function_output Function Output Iterator]
 
 The function output iterator adaptor makes it easier to create custom
@@ -34,7 +33,7 @@ proxy object.
       x.push_back("!");
 
       std::string s = "";
-      std::copy(x.begin(), x.end(), 
+      std::copy(x.begin(), x.end(),
           boost::make_function_output_iterator(string_appender(s)));
 
       std::cout << s << std::endl;
@@ -68,7 +67,7 @@ proxy object.
 
 [h3 Requirements]
 
-`UnaryFunction` must be Assignable and Copy Constructible.  
+`UnaryFunction` must be Assignable and Copy Constructible.
 
 [h3 Concepts]
 
@@ -79,14 +78,14 @@ Incrementable Iterator concepts.
 
   explicit function_output_iterator(const UnaryFunction& f = UnaryFunction());
 
-[*Effects: ] Constructs an instance of `function_output_iterator` 
+[*Effects: ] Constructs an instance of `function_output_iterator`
   with `m_f` constructed from `f`.
 
   unspecified_type operator*();
 
 [*Returns: ] An object `r` of unspecified type such that `r = t`
   is equivalent to `m_f(t)` for all `t`.
-  
+
 
   function_output_iterator& operator++();
 

doc/quickbook/indirect_iterator.qbk

@@ -1,4 +1,3 @@
-
 [section:indirect Indirect Iterator]
 
 `indirect_iterator` adapts an iterator by applying an
@@ -50,30 +49,31 @@ using the `make_indirect_iterator` helper function.
       const_indirect_last(pointers_to_chars + N);
 
     std::transform(const_indirect_first, const_indirect_last,
-		   mutable_indirect_first, std::bind1st(std::plus<char>(), 1));
+      mutable_indirect_first, std::bind(std::plus<char>(), 1, std::placeholders::_1));
 
     std::copy(mutable_indirect_first, mutable_indirect_last,
-	      std::ostream_iterator<char>(std::cout, ","));
+      std::ostream_iterator<char>(std::cout, ","));
     std::cout << std::endl;
 
 
     // Example of using make_indirect_iterator()
 
-    std::copy(boost::make_indirect_iterator(pointers_to_chars), 
+    std::copy(boost::make_indirect_iterator(pointers_to_chars),
-	      boost::make_indirect_iterator(pointers_to_chars + N),
+              boost::make_indirect_iterator(pointers_to_chars + N),
-	      std::ostream_iterator<char>(std::cout, ","));
+              std::ostream_iterator<char>(std::cout, ","));
     std::cout << std::endl;
 
 
 The output is:
 
-    a,b,c,d,e,f,g,
+[pre
-    b,c,d,e,f,g,h,
+a,b,c,d,e,f,g,
-    a,b,c,d,e,f,g,
+b,c,d,e,f,g,h,
+a,b,c,d,e,f,g,
+]
 
-
+The source code for this example can be found
-The source code for this example can be found 
+[example_link indirect_iterator_example.cpp..here].
-[@../example/indirect_iterator_example.cpp here].
 
 
 [h2 Reference]
@@ -137,9 +137,9 @@ the following pseudo-code, where `V` is
   else
       typedef Reference reference;
 
-  if (Value is use_default) then 
+  if (Value is use_default) then
       typedef pointee<V>::type\* pointer;
-  else 
+  else
       typedef Value\* pointer;
 
   if (Difference is use_default)
@@ -204,7 +204,7 @@ following operations:
   indirect_iterator();
 
 [*Requires: ] `Iterator` must be Default Constructible.[br]
-[*Effects: ] Constructs an instance of `indirect_iterator` with 
+[*Effects: ] Constructs an instance of `indirect_iterator` with
    a default-constructed `m_iterator`.
 
 
@@ -226,7 +226,7 @@ following operations:
   );
 
 [*Requires: ] `Iterator2` is implicitly convertible to `Iterator`.[br]
-[*Effects: ] Constructs an instance of `indirect_iterator` whose 
+[*Effects: ] Constructs an instance of `indirect_iterator` whose
     `m_iterator` subobject is constructed from `y.base()`.
 
 
@@ -251,4 +251,4 @@ following operations:
 [*Effects: ] `--m_iterator`[br]
 [*Returns: ] `*this`
 
-[endsect]
+[endsect]

doc/quickbook/iterator.qbk

@@ -1,4 +1,3 @@
-
 [library Boost.Iterator
     [/ version 1.0.1]
     [quickbook 1.6]
@@ -31,6 +30,7 @@
 
 [def _iterator_           [@../../../iterator/doc/index.html Boost.Iterator]]
 [def _concept_check_      [@../../../concept_check/index.html Boost.ConceptCheck]]
+[template example_link[name descr]'''<ulink url="../../example/'''[name]'''">'''[descr]'''</ulink>''']
 
 [template sub[x]'''<subscript>'''[x]'''</subscript>''']
 
@@ -305,4 +305,3 @@ library you see today.
    Patterns, C++ Report, February 1995, pp. 24-27.]
 
 [endsect]
-

doc/quickbook/iterator_traits.qbk

@@ -1,4 +1,3 @@
-
 [section:iterator_traits Iterator Traits]
 
 `std::iterator_traits` provides access to five associated types

doc/quickbook/permutation_iterator.qbk

@@ -1,4 +1,3 @@
-
 [section:permutation Permutation Iterator]
 
 The permutation iterator adaptor provides a permuted view of a given
@@ -35,7 +34,7 @@ past-the-end iterator to the indices.
       *el_it = std::distance(elements.begin(), el_it);
 
     index_type indices( index_size );
-    for(index_type::iterator i_it = indices.begin() ; i_it != indices.end() ; ++i_it ) 
+    for(index_type::iterator i_it = indices.begin() ; i_it != indices.end() ; ++i_it )
       *i_it = element_range_size - index_size + std::distance(indices.begin(), i_it);
     std::reverse( indices.begin(), indices.end() );
 
@@ -75,27 +74,28 @@ past-the-end iterator to the indices.
 
 The output is:
 
-    The original range is : 0 1 2 3 4 5 6 7 8 9 
+[pre
-    The reindexing scheme is : 9 8 7 6 
+The original range is : 0 1 2 3 4 5 6 7 8 9
-    The permutated range is : 9 8 7 6 
+The reindexing scheme is : 9 8 7 6
-    Elements at even indices in the permutation : 9 7 
+The permutated range is : 9 8 7 6
-    Permutation backwards : 6 7 8 9 
+Elements at even indices in the permutation : 9 7
-    Iterate backward with stride 2 : 6 8 
+Permutation backwards : 6 7 8 9
-
+Iterate backward with stride 2 : 6 8
+]
 
 The source code for this example can be found
-[@../example/permutation_iter_example.cpp here].
+[example_link permutation_iter_example.cpp..here].
 
 [h2 Reference]
 
 [h3 Synopsis]
 
   template< class ElementIterator
-	  , class IndexIterator
+    , class IndexIterator
-	  , class ValueT        = use_default
+    , class ValueT        = use_default
-	  , class CategoryT     = use_default
+    , class CategoryT     = use_default
-	  , class ReferenceT    = use_default
+    , class ReferenceT    = use_default
-	  , class DifferenceT   = use_default >
+    , class DifferenceT   = use_default >
   class permutation_iterator
   {
   public:
@@ -104,10 +104,10 @@ The source code for this example can be found
 
     template< class OEIter, class OIIter, class V, class C, class R, class D >
     permutation_iterator(
-	permutation_iterator<OEIter, OIIter, V, C, R, D> const& r
+      permutation_iterator<OEIter, OIIter, V, C, R, D> const& r
-	, typename enable_if_convertible<OEIter, ElementIterator>::type* = 0
+      , typename enable_if_convertible<OEIter, ElementIterator>::type* = 0
-	, typename enable_if_convertible<OIIter, IndexIterator>::type* = 0
+      , typename enable_if_convertible<OIIter, IndexIterator>::type* = 0
-	);
+    );
     reference operator*() const;
     permutation_iterator& operator++();
     ElementIterator const& base() const;
@@ -117,7 +117,7 @@ The source code for this example can be found
   };
 
   template <class ElementIterator, class IndexIterator>
-  permutation_iterator<ElementIterator, IndexIterator> 
+  permutation_iterator<ElementIterator, IndexIterator>
   make_permutation_iterator( ElementIterator e, IndexIterator i);
 
 
@@ -134,15 +134,15 @@ the `IndexIterator` must be convertible to the difference type of
 as `IndexIterator` and the same iterator access concepts as
 `ElementIterator`.
 
-If `IndexIterator` models Single Pass Iterator and 
+If `IndexIterator` models Single Pass Iterator and
 `ElementIterator` models Readable Iterator then
 `permutation_iterator` models Input Iterator.
 
-If `IndexIterator` models Forward Traversal Iterator and 
+If `IndexIterator` models Forward Traversal Iterator and
 `ElementIterator` models Readable Lvalue Iterator then
 `permutation_iterator` models Forward Iterator.
 
-If `IndexIterator` models Bidirectional Traversal Iterator and 
+If `IndexIterator` models Bidirectional Traversal Iterator and
 `ElementIterator` models Readable Lvalue Iterator then
 `permutation_iterator` models Bidirectional Iterator.
 
@@ -173,10 +173,10 @@ following operations.
 
     template< class OEIter, class OIIter, class V, class C, class R, class D >
     permutation_iterator(
-	permutation_iterator<OEIter, OIIter, V, C, R, D> const& r
+      permutation_iterator<OEIter, OIIter, V, C, R, D> const& r
-	, typename enable_if_convertible<OEIter, ElementIterator>::type* = 0
+      , typename enable_if_convertible<OEIter, ElementIterator>::type* = 0
-	, typename enable_if_convertible<OIIter, IndexIterator>::type* = 0
+      , typename enable_if_convertible<OIIter, IndexIterator>::type* = 0
-	);
+    );
 
 [*Effects: ] Constructs `m_elt` from `r.m_elt` and
   `m_order` from `y.m_order`.
@@ -199,9 +199,9 @@ following operations.
 
 
   template <class ElementIterator, class IndexIterator>
-  permutation_iterator<ElementIterator, IndexIterator> 
+  permutation_iterator<ElementIterator, IndexIterator>
   make_permutation_iterator(ElementIterator e, IndexIterator i);
 
 [*Returns: ] `permutation_iterator<ElementIterator, IndexIterator>(e, i)`
 
-[endsect]
+[endsect]

doc/quickbook/reverse_iterator.qbk

@@ -1,4 +1,3 @@
-
 [section:reverse Reverse Iterator]
 
 The reverse iterator adaptor iterates through the adapted iterator
@@ -9,7 +8,6 @@ range in the opposite direction.
 The following example prints an array of characters in reverse order
 using `reverse_iterator`.
 
-    
     char letters_[] = "hello world!";
     const int N = sizeof(letters_)/sizeof(char) - 1;
     typedef char* base_iterator;
@@ -35,13 +33,14 @@ using `reverse_iterator`.
 
 The output is:
 
-    original sequence of letters:                   hello world!
+[pre
-    sequence in reverse order:                      !dlrow olleh
+original sequence of letters:                   hello world!
-    sequence in double-reversed (normal) order:     hello world!
+sequence in reverse order:                      !dlrow olleh
-
+sequence in double-reversed (normal) order:     hello world!
+]
 
 The source code for this example can be found
-[@../example/reverse_iterator_example.cpp here].
+[example_link reverse_iterator_example.cpp..here].
 
 [h2 Reference]
 
@@ -116,7 +115,7 @@ operations.
   reverse_iterator();
 
 [*Requires: ] `Iterator` must be Default Constructible.[br]
-[*Effects: ] Constructs an instance of `reverse_iterator` with `m_iterator` 
+[*Effects: ] Constructs an instance of `reverse_iterator` with `m_iterator`
   default constructed.
 
   explicit reverse_iterator(Iterator x);
@@ -132,7 +131,7 @@ operations.
     );
 
 [*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.[br]
-[*Effects: ] Constructs instance of `reverse_iterator` whose 
+[*Effects: ] Constructs instance of `reverse_iterator` whose
     `m_iterator` subobject is constructed from `y.base()`.
 
 
@@ -157,4 +156,4 @@ operations.
 [*Effects: ] `++m_iterator`[br]
 [*Returns: ] `*this`
 
-[endsect]
+[endsect]

doc/quickbook/shared_container_iterator.qbk

@@ -1,7 +1,6 @@
-
 [section:shared_container Shared Container Iterator]
 
-Defined in header [@../../../boost/shared_container_iterator.hpp `boost/shared_container_iterator.hpp`].
+Defined in header [@../../../boost/iterator/shared_container_iterator.hpp `boost/iterator/shared_container_iterator.hpp`].
 
 The purpose of the shared container iterator is to attach the lifetime
 of a container to the lifetime of its iterators. In other words, the
@@ -25,20 +24,42 @@ iterator.
 [h2 Synopsis]
 
   namespace boost {
+  namespace iterators {
     template <typename Container>
     class shared_container_iterator;
-   
+
     template <typename Container>
     shared_container_iterator<Container>
-    make_shared_container_iterator(typename Container::iterator base, 
+    make_shared_container_iterator(typename Container::iterator base,
+      std::shared_ptr<Container> const& container);
+
+    std::pair<
+      typename shared_container_iterator<Container>,
+      typename shared_container_iterator<Container>
+    >
+    make_shared_container_range(std::shared_ptr<Container> const& container);
+
+    // Backward compatibility with boost::shared_ptr
+    template <typename Container>
+    shared_container_iterator<Container>
+    make_shared_container_iterator(typename Container::iterator base,
       boost::shared_ptr<Container> const& container);
-   
+
     std::pair<
       typename shared_container_iterator<Container>,
       typename shared_container_iterator<Container>
     >
     make_shared_container_range(boost::shared_ptr<Container> const& container);
   }
+  }
+
+[note `shared_container_iterator` and its factory functions support both
+`std::shared_ptr` and `boost::shared_ptr` for a smart pointer that holds
+a shared reference to the container. However, the support for `boost::shared_ptr`
+comes at a cost of wrapping it in a `std::shared_ptr` internally. This means
+that when constructing the iterator from a `boost::shared_ptr`, the construction
+will have to allocate memory for `std::shared_ptr` shared state, which may
+potentially fail. It is recommended to use `std::shared_ptr` directly.]
 
 [section:shared_container_type The Shared Container Iterator Type]
 
@@ -46,7 +67,7 @@ iterator.
 
 The class template `shared_container_iterator` is the shared container
 iterator type. The `Container` template type argument must model the
-[@http://www.sgi.com/tech/stl/Container.html Container] concept. 
+[@http://www.sgi.com/tech/stl/Container.html Container] concept.
 
 [h2 Example]
 
@@ -56,48 +77,48 @@ original shared pointer `ints` ceases to exist after `set_range()`
 returns, the `shared_counter_iterator` objects maintain references to
 the underlying vector and thereby extend the container's lifetime.
 
-[@../../example/shared_iterator_example1.cpp `shared_iterator_example1.cpp`]:
+[example_link shared_iterator_example1.cpp..`shared_iterator_example1.cpp`]:
 
-  #include "shared_container_iterator.hpp"
+  #include <boost/iterator/shared_container_iterator.hpp>
-  #include "boost/shared_ptr.hpp"
   #include <algorithm>
   #include <iostream>
   #include <vector>
-   
+  #include <memory>
-  typedef boost::shared_container_iterator< std::vector<int> > iterator;
+
-   
+  using iterator = boost::iterators::shared_container_iterator< std::vector<int> >;
-   
+
-  void set_range(iterator& i, iterator& end)  {
+
-   
+  void set_range(iterator& i, iterator& end) {
-    boost::shared_ptr< std::vector<int> > ints(new std::vector<int>());
+    std::shared_ptr< std::vector<int> > ints(new std::vector<int>());
-    
+
     ints->push_back(0);
     ints->push_back(1);
     ints->push_back(2);
     ints->push_back(3);
     ints->push_back(4);
     ints->push_back(5);
-    
+
-    i = iterator(ints->begin(),ints);
+    i = iterator(ints->begin(), ints);
-    end = iterator(ints->end(),ints);
+    end = iterator(ints->end(), ints);
   }
-   
+
-   
+
   int main() {
-   
+    iterator i, end;
-    iterator i,end;
+
-   
+    set_range(i, end);
-    set_range(i,end);
+
-   
+    std::copy(i, end, std::ostream_iterator<int>(std::cout, ","));
-    std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
     std::cout.put('\n');
-   
+
     return 0;
   }
 
 The output from this part is:
 
-  0,1,2,3,4,5,
+[pre
+0,1,2,3,4,5,
+]
 
 [table Template Parameters
   [[Parameter][Description]]
@@ -115,8 +136,12 @@ The `shared_container_iterator` type implements the member functions
 and operators required of the
 [@http://www.sgi.com/tech/stl/RandomAccessIterator.html Random Access
 Iterator] concept, though only operations defined for the base
-iterator will be valid. In addition it has the following constructor:
+iterator will be valid. In addition it has the following constructors:
 
+  shared_container_iterator(Container::iterator const& it,
+                            std::shared_ptr<Container> const& container)
+
+  // Backward compatibility with boost::shared_ptr
   shared_container_iterator(Container::iterator const& it,
                             boost::shared_ptr<Container> const& container)
 
@@ -124,58 +149,60 @@ iterator will be valid. In addition it has the following constructor:
 
 [section:shared_container_object_generator The Shared Container Iterator Object Generator]
 
+  template <typename Container>
+  shared_container_iterator<Container>
+  make_shared_container_iterator(Container::iterator base,
+                                 std::shared_ptr<Container> const& container)
+
+  // Backward compatibility with boost::shared_ptr
   template <typename Container>
   shared_container_iterator<Container>
   make_shared_container_iterator(Container::iterator base,
                                  boost::shared_ptr<Container> const& container)
 
 This function provides an alternative to directly constructing a
-`shared_container_iterator`. Using the object generator, a 
+`shared_container_iterator`. Using the object generator, a
 `shared_container_iterator` can be created and passed to a function without
 explicitly specifying its type.
 
 [h2 Example]
 
-This example, similar to the previous, 
+This example, similar to the previous,
 uses `make_shared_container_iterator()` to create the iterators.
 
-[@../../example/shared_iterator_example2.cpp `shared_iterator_example2.cpp`]:
+[example_link shared_iterator_example2.cpp..`shared_iterator_example2.cpp`]:
 
-  #include "shared_container_iterator.hpp"
+  #include <boost/iterator/shared_container_iterator.hpp>
-  #include "boost/shared_ptr.hpp"
   #include <algorithm>
   #include <iterator>
   #include <iostream>
   #include <vector>
-   
+  #include <memory>
-   
+
+
   template <typename Iterator>
-  void print_range_nl (Iterator begin, Iterator end) {
+  void print_range_nl(Iterator begin, Iterator end) {
-    typedef typename std::iterator_traits<Iterator>::value_type val;
+    using val = typename std::iterator_traits<Iterator>::value_type;
-    std::copy(begin,end,std::ostream_iterator<val>(std::cout,","));
+    std::copy(begin, end, std::ostream_iterator<val>(std::cout, ","));
     std::cout.put('\n');
   }
-   
+
-   
   int main() {
-   
+    using ints_t = std::shared_ptr< std::vector<int> >;
-    typedef boost::shared_ptr< std::vector<int> > ints_t;
     {
       ints_t ints(new std::vector<int>());
-   
+
       ints->push_back(0);
       ints->push_back(1);
       ints->push_back(2);
       ints->push_back(3);
       ints->push_back(4);
       ints->push_back(5);
-   
+
-      print_range_nl(boost::make_shared_container_iterator(ints->begin(),ints),
+      print_range_nl(boost::iterators::make_shared_container_iterator(ints->begin(), ints),
-                     boost::make_shared_container_iterator(ints->end(),ints));
+                     boost::iterators::make_shared_container_iterator(ints->end(), ints));
     }
-    
+
-   
-   
     return 0;
   }
 
@@ -186,55 +213,63 @@ named. The output from this example is the same as the previous.
 
 [section:shared_container_generator The Shared Container Iterator Range Generator]
 
+  template <typename Container>
+  std::pair<
+    shared_container_iterator<Container>,
+    shared_container_iterator<Container>
+  >
+  make_shared_container_range(std::shared_ptr<Container> const& container);
+
+  // Backward compatibility with boost::shared_ptr
   template <typename Container>
   std::pair<
     shared_container_iterator<Container>,
     shared_container_iterator<Container>
   >
   make_shared_container_range(boost::shared_ptr<Container> const& container);
-  Class shared_container_iterator is meant primarily to return, using iterators, a range of values that we can guarantee will be alive as long as the iterators are. This is a convenience function to do just that. It is equivalent to
+
-  std::make_pair(make_shared_container_iterator(container->begin(),container),
+Class `shared_container_iterator` is meant primarily to return, using iterators,
-                 make_shared_container_iterator(container->end(),container));
+a range of values that we can guarantee will be alive as long as the iterators are.
+This is a convenience function to do just that. It is functionally equivalent to this:
+
+  std::make_pair(make_shared_container_iterator(container->begin(), container),
+                 make_shared_container_iterator(container->end(), container));
 
 [h2 Example]
 
-In the following example, a range of values is returned as a pair of shared_container_iterator objects.
+In the following example, a range of values is returned as a pair of `shared_container_iterator` objects.
 
-[@../../example/shared_iterator_example3.cpp `shared_iterator_example3.cpp`]:
+[example_link shared_iterator_example3.cpp..`shared_iterator_example3.cpp`]:
 
-  #include "shared_container_iterator.hpp"
+  #include <boost/iterator/shared_container_iterator.hpp>
-  #include "boost/shared_ptr.hpp"
+  #include <algorithm>     // for std::copy
-  #include "boost/tuple/tuple.hpp" // for boost::tie
+  #include <iostream>
-  #include <algorithm>              // for std::copy
-  #include <iostream>              
   #include <vector>
-   
+  #include <memory>
-   
+  #include <tuple>         // for std::tie
-  typedef boost::shared_container_iterator< std::vector<int> > iterator; 
+
-   
+
-  std::pair<iterator,iterator>
+  using iterator = boost::iterators::shared_container_iterator< std::vector<int> >;
+
+  std::pair<iterator, iterator>
   return_range() {
-    boost::shared_ptr< std::vector<int> > range(new std::vector<int>());
+    std::shared_ptr< std::vector<int> > range(new std::vector<int>());
     range->push_back(0);
     range->push_back(1);
     range->push_back(2);
     range->push_back(3);
     range->push_back(4);
     range->push_back(5);
-    return boost::make_shared_container_range(range);
+    return boost::iterators::make_shared_container_range(range);
   }
-   
+
-   
   int main() {
-   
-   
     iterator i,end;
-    
+    std::tie(i, end) = return_range();
-    boost::tie(i,end) = return_range();
+
-   
+    std::copy(i, end, std::ostream_iterator<int>(std::cout, ","));
-    std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
     std::cout.put('\n');
-   
+
     return 0;
   }
 
@@ -245,4 +280,4 @@ the same as the previous two.
 
 [endsect]
 
-[endsect]
+[endsect]

doc/quickbook/specialized_adaptors.qbk

@@ -1,4 +1,3 @@
-
 [section:specialized Specialized Adaptors]
 
 [include ./counting_iterator.qbk]
@@ -19,4 +18,4 @@
 
 [include ./zip_iterator.qbk]
 
-[endsect]
+[endsect]

doc/quickbook/transform_iterator.qbk

@@ -1,4 +1,3 @@
-
 [section:transform Transform Iterator]
 
 The transform iterator adapts an iterator by modifying the
@@ -14,37 +13,38 @@ generate iterators that multiply (or add to) the value returned by
 dereferencing the iterator. It would be cooler to use lambda library
 in this example.
 
-	int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
-	const int N = sizeof(x)/sizeof(int);
+  const int N = sizeof(x)/sizeof(int);
-	
+
-	typedef boost::binder1st< std::multiplies<int> > Function;
+  typedef boost::binder1st< std::multiplies<int> > Function;
-	typedef boost::transform_iterator<Function, int*> doubling_iterator;
+  typedef boost::transform_iterator<Function, int*> doubling_iterator;
-	
+
-	doubling_iterator i(x, boost::bind1st(std::multiplies<int>(), 2)),
+  doubling_iterator i(x, boost::bind1st(std::multiplies<int>(), 2)),
-	  i_end(x + N, boost::bind1st(std::multiplies<int>(), 2));
+    i_end(x + N, boost::bind1st(std::multiplies<int>(), 2));
-	
+
-	std::cout << "multiplying the array by 2:" << std::endl;
+  std::cout << "multiplying the array by 2:" << std::endl;
-	while (i != i_end)
+  while (i != i_end)
-	  std::cout << *i++ << " ";
+    std::cout << *i++ << " ";
-	std::cout << std::endl;
+  std::cout << std::endl;
-	
+
-	std::cout << "adding 4 to each element in the array:" << std::endl;
+  std::cout << "adding 4 to each element in the array:" << std::endl;
-	std::copy(boost::make_transform_iterator(x, boost::bind1st(std::plus<int>(), 4)),
+  std::copy(boost::make_transform_iterator(x, boost::bind1st(std::plus<int>(), 4)),
-	     boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
+    boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
-	     std::ostream_iterator<int>(std::cout, " "));
+    std::ostream_iterator<int>(std::cout, " "));
-	std::cout << std::endl;
+  std::cout << std::endl;
 
 
 The output is:
 
-	multiplying the array by 2:
+[pre
-	2 4 6 8 10 12 14 16 
+multiplying the array by 2:
-	adding 4 to each element in the array:
+2 4 6 8 10 12 14 16
-	5 6 7 8 9 10 11 12
+adding 4 to each element in the array:
+5 6 7 8 9 10 11 12
+]
 
-
+The source code for this example can be found
-The source code for this example can be found 
+[example_link transform_iterator_example.cpp..here].
-[@../example/transform_iterator_example.cpp here].
 
 [h2 Reference]
 
@@ -52,8 +52,8 @@ The source code for this example can be found
 [h3 Synopsis]
 
   template <class UnaryFunction,
-            class Iterator, 
+            class Iterator,
-            class Reference = use_default, 
+            class Reference = use_default,
             class Value = use_default>
   class transform_iterator
   {
@@ -116,7 +116,7 @@ where the type of `f(*i)` must be
 `result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type`.
 
 
-The argument `Iterator` shall model Readable Iterator.  
+The argument `Iterator` shall model Readable Iterator.
 
 
 [h3 Concepts]
@@ -126,11 +126,11 @@ The resulting `transform_iterator` models the most refined of the
 following that is also modeled by `Iterator`.
 
 
-* Writable Lvalue Iterator if `transform_iterator::reference` is a non-const reference. 
+* Writable Lvalue Iterator if `transform_iterator::reference` is a non-const reference.
 
 * Readable Lvalue Iterator if `transform_iterator::reference` is a const reference.
 
-* Readable Iterator otherwise. 
+* Readable Iterator otherwise.
 
 
 The `transform_iterator` models the most refined standard traversal
@@ -143,11 +143,11 @@ the `Iterator` argument models.
 
 
 [table Category
-	[[If `Iterator` models][then `transform_iterator` models]]
+[[If `Iterator` models][then `transform_iterator` models]]
-	[[Single Pass Iterator][Input Iterator]]
+[[Single Pass Iterator][Input Iterator]]
-	[[Forward Traversal Iterator][Forward Iterator]]
+[[Forward Traversal Iterator][Forward Iterator]]
-	[[Bidirectional Traversal Iterator][Bidirectional Iterator]]
+[[Bidirectional Traversal Iterator][Bidirectional Iterator]]
-	[[Random Access Traversal Iterator][Random Access Iterator]]
+[[Random Access Traversal Iterator][Random Access Iterator]]
 ]
 
 If `transform_iterator` models Writable Lvalue Iterator then it is a
@@ -177,7 +177,7 @@ operations:
   template<class F2, class I2, class R2, class V2>
   transform_iterator(
         transform_iterator<F2, I2, R2, V2> const& t
-      , typename enable_if_convertible<I2, Iterator>::type* = 0	   // exposition only
+      , typename enable_if_convertible<I2, Iterator>::type* = 0      // exposition only
       , typename enable_if_convertible<F2, UnaryFunction>::type* = 0 // exposition only
   );
 

doc/quickbook/type_traits.qbk

@@ -48,14 +48,14 @@ information is needed, call on `indirect_reference`.
 Both of these templates are essential to the correct functioning of
 [link iterator.specialized.indirect `indirect_iterator`].
 
-[h2 `minimum_category`]
+[h2 `min_category`]
 
-`minimum_category` takes two iterator categories or two iterator traversal tags
+`min_category` takes one or more iterator categories or iterator traversal tags
 and returns the one that is the weakest (i.e. least advanced). For example:
 
   static_assert(
       is_same<
-          minimum_category<
+          min_category<
               std::forward_iterator_tag,
               std::random_access_iterator_tag
           >::type,

doc/quickbook/zip_iterator.qbk

@@ -1,17 +1,16 @@
-
 [section:zip Zip Iterator]
 
 The zip iterator provides the ability to parallel-iterate
-over several controlled sequences simultaneously. A zip 
+over several controlled sequences simultaneously. A zip
 iterator is constructed from a tuple of iterators. Moving
 the zip iterator moves all the iterators in parallel.
 Dereferencing the zip iterator returns a tuple that contains
-the results of dereferencing the individual iterators. 
+the results of dereferencing the individual iterators.
 
-The tuple of iterators is now implemented in terms of a Boost fusion sequence. 
+The tuple of iterators is now implemented in terms of a Boost fusion sequence.
 Because of this the 'tuple' may be any Boost fusion sequence and, for backwards
-compatibility through a Boost fusion sequence adapter, a Boost tuple. Because the 
+compatibility through a Boost fusion sequence adapter, a Boost tuple. Because the
-'tuple' may be any boost::fusion sequence the 'tuple' may also be any type for which a 
+'tuple' may be any boost::fusion sequence the 'tuple' may also be any type for which a
 Boost fusion adapter exists. This includes, among others, a std::tuple and a std::pair.
 Just remember to include the appropriate Boost fusion adapter header files for these
 other Boost fusion adapters. The zip_iterator header file already includes the
@@ -22,9 +21,9 @@ to use a Boost tuple as your 'tuple'.
 
 There are two main types of applications of the `zip_iterator`. The first
 one concerns runtime efficiency: If one has several controlled sequences
-of the same length that must be somehow processed, e.g., with the 
+of the same length that must be somehow processed, e.g., with the
 `for_each` algorithm, then it is more efficient to perform just
-one parallel-iteration rather than several individual iterations. For an 
+one parallel-iteration rather than several individual iterations. For an
 example, assume that `vect_of_doubles` and `vect_of_ints`
 are two vectors of equal length containing doubles and ints, respectively,
 and consider the following two iterations:
@@ -53,9 +52,10 @@ These two iterations can now be replaced with a single one as follows:
 A non-generic implementation of `zip_func` could look as follows:
 
 
-      struct zip_func : 
+      struct zip_func
-        public std::unary_function<const boost::tuple<const double&, const int&>&, void>
       {
+        using result_type = void;
+
         void operator()(const boost::tuple<const double&, const int&>& t) const
         {
           m_f0(t.get<0>());
@@ -72,16 +72,16 @@ to make combining iterators. A combining iterator is an iterator
 that parallel-iterates over several controlled sequences and, upon
 dereferencing, returns the result of applying a functor to the values of the
 sequences at the respective positions. This can now be achieved by using the
-`zip_iterator` in conjunction with the `transform_iterator`. 
+`zip_iterator` in conjunction with the `transform_iterator`.
 
-Suppose, for example, that you have two vectors of doubles, say 
+Suppose, for example, that you have two vectors of doubles, say
 `vect_1` and `vect_2`, and you need to expose to a client
-a controlled sequence containing the products of the elements of 
+a controlled sequence containing the products of the elements of
 `vect_1` and `vect_2`. Rather than placing these products
 in a third vector, you can use a combining iterator that calculates the
 products on the fly. Let us assume that `tuple_multiplies` is a
 functor that works like `std::multiplies`, except that it takes
-its two arguments packaged in a tuple. Then the two iterators 
+its two arguments packaged in a tuple. Then the two iterators
 `it_begin` and `it_end` defined below delimit a controlled
 sequence containing the products of the elements of `vect_1` and
 `vect_2`:
@@ -128,7 +128,7 @@ sequence containing the products of the elements of `vect_1` and
 
   template<typename IteratorTuple>
   class zip_iterator
-  {  
+  {
 
   public:
     typedef /* see below */ reference;
@@ -154,8 +154,8 @@ sequence containing the products of the elements of `vect_1` and
     IteratorTuple m_iterator_tuple;     // exposition only
   };
 
-  template<typename IteratorTuple> 
+  template<typename IteratorTuple>
-  zip_iterator<IteratorTuple> 
+  zip_iterator<IteratorTuple>
   make_zip_iterator(IteratorTuple t);
 
 The `reference` member of `zip_iterator` is the type of the tuple
@@ -168,23 +168,23 @@ of the first of the iterator types in the `IteratorTuple` argument.
 The `iterator_category` member of `zip_iterator` is convertible to the
 minimum of the traversal categories of the iterator types in the `IteratorTuple`
 argument. For example, if the `zip_iterator` holds only vector
-iterators, then `iterator_category` is convertible to 
+iterators, then `iterator_category` is convertible to
 `boost::random_access_traversal_tag`. If you add a list iterator, then
 `iterator_category` will be convertible to `boost::bidirectional_traversal_tag`,
 but no longer to `boost::random_access_traversal_tag`.
 
 [h2 Requirements]
 
-All iterator types in the argument `IteratorTuple` shall model Readable Iterator.  
+All iterator types in the argument `IteratorTuple` shall model Readable Iterator.
 
 [h2 Concepts]
 
 The resulting `zip_iterator` models Readable Iterator.
 
-The fact that the `zip_iterator` models only Readable Iterator does not 
+The fact that the `zip_iterator` models only Readable Iterator does not
 prevent you from modifying the values that the individual iterators point
-to. The tuple returned by the `zip_iterator`'s `operator*` is a tuple 
+to. The tuple returned by the `zip_iterator`'s `operator*` is a tuple
-constructed from the reference types of the individual iterators, not 
+constructed from the reference types of the individual iterators, not
 their value types. For example, if `zip_it` is a `zip_iterator` whose
 first member iterator is an `std::vector<double>::iterator`, then the
 following line will modify the value which the first member iterator of
@@ -195,7 +195,7 @@ following line will modify the value which the first member iterator of
 
 Consider the set of standard traversal concepts obtained by taking
 the most refined standard traversal concept modeled by each individual
-iterator type in the `IteratorTuple` argument.The `zip_iterator` 
+iterator type in the `IteratorTuple` argument.The `zip_iterator`
 models the least refined standard traversal concept in this set.
 
 `zip_iterator<IteratorTuple1>` is interoperable with
@@ -254,8 +254,8 @@ operations.
 [*Effects:] Decrements each iterator in `m_iterator_tuple`.[br]
 [*Returns:] `*this`
 
-    template<typename IteratorTuple> 
+    template<typename IteratorTuple>
-    zip_iterator<IteratorTuple> 
+    zip_iterator<IteratorTuple>
     make_zip_iterator(IteratorTuple t);
 
 [*Returns:] An instance of `zip_iterator<IteratorTuple>` with `m_iterator_tuple`
@@ -263,4 +263,4 @@ operations.
 
 [endsect]
 
-[endsect]
+[endsect]

doc/ref_problem.rst

@@ -8,7 +8,6 @@
 :Author: David Abrahams and Jeremy Siek
 :Contact: dave@boost-consulting.com, jsiek@osl.iu.edu
 :Organization: `Boost Consulting`_, Indiana University Bloomington
-:date: $Date$
 :Copyright: Copyright David Abrahams, Jeremy Siek 2003. Use, modification and
       distribution is subject to the Boost Software License,
       Version 1.0. (See accompanying file LICENSE_1_0.txt or copy

doc/reverse_iterator.rst

@@ -11,7 +11,6 @@
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
-:date: $Date$
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/transform_iterator.rst

@@ -11,7 +11,6 @@
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
-:date: $Date$
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

doc/zip_iterator.rst

@@ -9,7 +9,6 @@
 :Author: David Abrahams, Thomas Becker
 :Contact: dave@boost-consulting.com, thomas@styleadvisor.com
 :organization: `Boost Consulting`_, `Zephyr Associates, Inc.`_
-:date: $Date$
 :copyright: Copyright David Abrahams and Thomas Becker 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com

example/counting_iterator_example.cpp

@@ -41,12 +41,12 @@ int main(int, char*[])
 
   // Use indirect iterator to print out numbers by accessing
   // them through the array of pointers.
-  std::cout << "indirectly printing out the numbers from 0 to " 
+  std::cout << "indirectly printing out the numbers from 0 to "
             << N << std::endl;
   std::copy(boost::make_indirect_iterator(pointers.begin()),
             boost::make_indirect_iterator(pointers.end()),
             std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
-  
+
   return boost::exit_success;
 }

example/filter_iterator_example.cpp

@@ -8,6 +8,7 @@
 #include <functional>
 #include <iostream>
 #include <boost/iterator/filter_iterator.hpp>
+#include <boost/bind/bind.hpp>
 #include <boost/cstdlib.hpp> // for exit_success
 
 struct is_positive_number {
@@ -18,10 +19,10 @@ int main()
 {
   int numbers_[] = { 0, -1, 4, -3, 5, 8, -2 };
   const int N = sizeof(numbers_)/sizeof(int);
-  
+
   typedef int* base_iterator;
   base_iterator numbers(numbers_);
-  
+
   // Example using make_filter_iterator()
   std::copy(boost::make_filter_iterator<is_positive_number>(numbers, numbers + N),
             boost::make_filter_iterator<is_positive_number>(numbers + N, numbers + N),
@@ -31,7 +32,7 @@ int main()
   // Example using filter_iterator
   typedef boost::filter_iterator<is_positive_number, base_iterator>
     FilterIter;
-  
+
   is_positive_number predicate;
   FilterIter filter_iter_first(predicate, numbers, numbers + N);
   FilterIter filter_iter_last(predicate, numbers + N, numbers + N);
@@ -42,17 +43,17 @@ int main()
   // Another example using make_filter_iterator()
   std::copy(
       boost::make_filter_iterator(
-          std::bind2nd(std::greater<int>(), -2)
+          boost::bind(std::greater<int>(), boost::placeholders::_1, -2)
         , numbers, numbers + N)
-            
+
     , boost::make_filter_iterator(
-          std::bind2nd(std::greater<int>(), -2)
+          boost::bind(std::greater<int>(), boost::placeholders::_1, -2)
         , numbers + N, numbers + N)
-      
+
     , std::ostream_iterator<int>(std::cout, " ")
   );
-  
+
   std::cout << std::endl;
-  
+
   return boost::exit_success;
 }

example/func_output_iter_example.cpp

@@ -12,14 +12,14 @@
 #include <string>
 #include <vector>
 
-#include <boost/function_output_iterator.hpp>
+#include <boost/iterator/function_output_iterator.hpp>
 
 struct string_appender
 {
     string_appender(std::string& s)
         : m_str(&s)
     {}
-    
+
     void operator()(const std::string& x) const
     {
         *m_str += x;
@@ -37,9 +37,9 @@ int main(int, char*[])
   x.push_back("!");
 
   std::string s = "";
-  std::copy(x.begin(), x.end(), 
+  std::copy(x.begin(), x.end(),
             boost::make_function_output_iterator(string_appender(s)));
-  
+
   std::cout << s << std::endl;
 
   return 0;

example/indirect_iterator_example.cpp

@@ -9,6 +9,7 @@
 #include <iterator>
 #include <functional>
 #include <algorithm>
+#include <boost/bind/bind.hpp>
 #include <boost/iterator/indirect_iterator.hpp>
 
 int main(int, char*[])
@@ -20,13 +21,13 @@ int main(int, char*[])
     pointers_to_chars[i] = &characters[i];
 
   // Example of using indirect_iterator
-  
+
   boost::indirect_iterator<char**, char>
     indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);
 
   std::copy(indirect_first, indirect_last, std::ostream_iterator<char>(std::cout, ","));
   std::cout << std::endl;
-  
+
 
   // Example of making mutable and constant indirect iterators
 
@@ -41,19 +42,19 @@ int main(int, char*[])
     const_indirect_last(pointers_to_chars + N);
 
   std::transform(const_indirect_first, const_indirect_last,
-                 mutable_indirect_first, std::bind1st(std::plus<char>(), 1));
+                 mutable_indirect_first, boost::bind(std::plus<char>(), 1, boost::placeholders::_1));
 
   std::copy(mutable_indirect_first, mutable_indirect_last,
             std::ostream_iterator<char>(std::cout, ","));
   std::cout << std::endl;
 
-  
+
   // Example of using make_indirect_iterator()
 
-  std::copy(boost::make_indirect_iterator(pointers_to_chars), 
+  std::copy(boost::make_indirect_iterator(pointers_to_chars),
             boost::make_indirect_iterator(pointers_to_chars + N),
             std::ostream_iterator<char>(std::cout, ","));
   std::cout << std::endl;
-  
+
   return 0;
 }

example/node.hpp

@@ -24,7 +24,7 @@ struct node_base
 
     virtual void print(std::ostream& s) const = 0;
     virtual void double_me() = 0;
-        
+
     void append(node_base* p)
     {
         if (m_next)
@@ -32,7 +32,7 @@ struct node_base
         else
             m_next = p;
     }
-    
+
  private:
     node_base* m_next;
 };
@@ -52,9 +52,9 @@ struct node : node_base
 
     void print(std::ostream& s) const { s << this->m_value; }
     void double_me() { m_value += m_value; }
-    
+
  private:
     T m_value;
 };
-    
+
 #endif // NODE_DWA2004110_HPP

example/node_iterator1.cpp

@@ -15,11 +15,11 @@ int main()
 #if defined(BOOST_NO_CXX11_SMART_PTR)
 
     std::auto_ptr<node<int> > nodes(new node<int>(42));
-    
+
 #else
 
     std::unique_ptr<node<int> > nodes(new node<int>(42));
-    
+
 #endif
 
     nodes->append(new node<std::string>(" is greater than "));
@@ -30,7 +30,7 @@ int main()
       , std::ostream_iterator<node_base>(std::cout, " ")
     );
     std::cout << std::endl;
-    
+
     std::for_each(
         node_iterator(nodes.get()), node_iterator()
       , std::mem_fun_ref(&node_base::double_me)

example/node_iterator1.hpp

@@ -28,10 +28,10 @@ class node_iterator
 
     void increment()
     { m_node = m_node->next(); }
-    
+
     bool equal(node_iterator const& other) const
     { return this->m_node == other.m_node; }
-    
+
     node_base& dereference() const
     { return *m_node; }
 

example/node_iterator2.cpp

@@ -16,11 +16,11 @@ int main()
 #if defined(BOOST_NO_CXX11_SMART_PTR)
 
     std::auto_ptr<node<int> > nodes(new node<int>(42));
-    
+
 #else
 
     std::unique_ptr<node<int> > nodes(new node<int>(42));
-    
+
 #endif
 
     nodes->append(new node<std::string>(" is greater than "));
@@ -29,16 +29,16 @@ int main()
     // Check interoperability
     assert(node_iterator(nodes.get()) == node_const_iterator(nodes.get()));
     assert(node_const_iterator(nodes.get()) == node_iterator(nodes.get()));
-    
+
     assert(node_iterator(nodes.get()) != node_const_iterator());
     assert(node_const_iterator(nodes.get()) != node_iterator());
-    
+
     std::copy(
         node_iterator(nodes.get()), node_iterator()
       , std::ostream_iterator<node_base>(std::cout, " ")
     );
     std::cout << std::endl;
-    
+
     std::for_each(
         node_iterator(nodes.get()), node_iterator()
       , boost::mem_fn(&node_base::double_me)

example/node_iterator2.hpp

@@ -6,11 +6,7 @@
 
 # include "node.hpp"
 # include <boost/iterator/iterator_facade.hpp>
-
+# include <type_traits>
-# ifndef BOOST_NO_SFINAE
-#  include <boost/type_traits/is_convertible.hpp>
-#  include <boost/utility/enable_if.hpp>
-# endif
 
 template <class Value>
 class node_iter
@@ -33,21 +29,13 @@ class node_iter
     template <class OtherValue>
     node_iter(
         node_iter<OtherValue> const& other
-# ifndef BOOST_NO_SFINAE
+      , typename std::enable_if<
-      , typename boost::enable_if<
+            std::is_convertible<OtherValue*,Value*>::value
-            boost::is_convertible<OtherValue*,Value*>
           , enabler
         >::type = enabler()
-# endif 
     )
       : m_node(other.m_node) {}
 
-
-# if !BOOST_WORKAROUND(__GNUC__, == 2)
- private: // GCC2 can't grant friendship to template member functions    
-    friend class boost::iterator_core_access;
-# endif 
-
     template <class OtherValue>
     bool equal(node_iter<OtherValue> const& other) const
     {
@@ -63,7 +51,7 @@ class node_iter
 # else
  private:
     template <class> friend class node_iter;
-# endif 
+# endif
     Value* m_node;
 };
 

example/node_iterator3.cpp

@@ -16,11 +16,11 @@ int main()
 #if defined(BOOST_NO_CXX11_SMART_PTR)
 
     std::auto_ptr<node<int> > nodes(new node<int>(42));
-    
+
 #else
 
     std::unique_ptr<node<int> > nodes(new node<int>(42));
-    
+
 #endif
 
     nodes->append(new node<std::string>(" is greater than "));
@@ -29,16 +29,16 @@ int main()
     // Check interoperability
     assert(node_iterator(nodes.get()) == node_const_iterator(nodes.get()));
     assert(node_const_iterator(nodes.get()) == node_iterator(nodes.get()));
-    
+
     assert(node_iterator(nodes.get()) != node_const_iterator());
     assert(node_const_iterator(nodes.get()) != node_iterator());
-    
+
     std::copy(
         node_iterator(nodes.get()), node_iterator()
       , std::ostream_iterator<node_base>(std::cout, " ")
     );
     std::cout << std::endl;
-    
+
     std::for_each(
         node_iterator(nodes.get()), node_iterator()
       , boost::mem_fn(&node_base::double_me)

example/node_iterator3.hpp

@@ -6,11 +6,7 @@
 
 # include "node.hpp"
 # include <boost/iterator/iterator_adaptor.hpp>
-
+# include <type_traits>
-# ifndef BOOST_NO_SFINAE
-#  include <boost/type_traits/is_convertible.hpp>
-#  include <boost/utility/enable_if.hpp>
-# endif
 
 template <class Value>
 class node_iter
@@ -27,7 +23,7 @@ class node_iter
     typedef boost::iterator_adaptor<
         node_iter<Value>, Value*, boost::use_default, boost::forward_traversal_tag
     > super_t;
-    
+
  public:
     node_iter()
       : super_t(0) {}
@@ -38,19 +34,17 @@ class node_iter
     template <class OtherValue>
     node_iter(
         node_iter<OtherValue> const& other
-# ifndef BOOST_NO_SFINAE
+      , typename std::enable_if<
-      , typename boost::enable_if<
+            std::is_convertible<OtherValue*,Value*>::value
-            boost::is_convertible<OtherValue*,Value*>
           , enabler
         >::type = enabler()
-# endif 
     )
       : super_t(other.base()) {}
 
 # if !BOOST_WORKAROUND(__GNUC__, == 2)
- private: // GCC2 can't grant friendship to template member functions    
+ private: // GCC2 can't grant friendship to template member functions
     friend class boost::iterator_core_access;
-# endif     
+# endif
     void increment() { this->base_reference() = this->base()->next(); }
 };
 

example/permutation_iter_example.cpp

@@ -27,7 +27,7 @@ int main() {
     *el_it = std::distance(elements.begin(), el_it);
 
   index_type indices( index_size );
-  for(index_type::iterator i_it = indices.begin() ; i_it != indices.end() ; ++i_it ) 
+  for(index_type::iterator i_it = indices.begin() ; i_it != indices.end() ; ++i_it )
     *i_it = element_range_size - index_size + std::distance(indices.begin(), i_it);
   std::reverse( indices.begin(), indices.end() );
 

example/reverse_iterator_example.cpp

@@ -15,13 +15,13 @@ int main(int, char*[])
   const int N = sizeof(letters_)/sizeof(char) - 1;
   typedef char* base_iterator;
   base_iterator letters(letters_);
-  
+
   std::cout << "original sequence of letters:\t\t\t"
             << letters_ << std::endl;
 
   // Use reverse_iterator to print a sequence of letters in reverse
   // order.
-  
+
   boost::reverse_iterator<base_iterator>
     reverse_letters_first(letters + N),
     reverse_letters_last(letters);

example/shared_iterator_example1.cpp

@@ -1,6 +1,6 @@
 // Copyright 2003 The Trustees of Indiana University.
 
-// Use, modification and distribution is subject to the Boost Software 
+// Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
@@ -16,14 +16,14 @@ typedef boost::shared_container_iterator< std::vector<int> > iterator;
 void set_range(iterator& i, iterator& end)  {
 
   boost::shared_ptr< std::vector<int> > ints(new std::vector<int>());
-  
+
   ints->push_back(0);
   ints->push_back(1);
   ints->push_back(2);
   ints->push_back(3);
   ints->push_back(4);
   ints->push_back(5);
-  
+
   i = iterator(ints->begin(),ints);
   end = iterator(ints->end(),ints);
 }

example/shared_iterator_example2.cpp

@@ -1,6 +1,6 @@
 // Copyright 2003 The Trustees of Indiana University.
 
-// Use, modification and distribution is subject to the Boost Software 
+// Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
@@ -36,7 +36,7 @@ int main() {
     print_range_nl(boost::make_shared_container_iterator(ints->begin(),ints),
                    boost::make_shared_container_iterator(ints->end(),ints));
   }
-  
+
 
 
   return 0;

example/shared_iterator_example3.cpp

@@ -1,6 +1,6 @@
 // Copyright 2003 The Trustees of Indiana University.
 
-// Use, modification and distribution is subject to the Boost Software 
+// Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
@@ -8,7 +8,7 @@
 #include "boost/shared_ptr.hpp"
 #include "boost/tuple/tuple.hpp" // for boost::tie
 #include <algorithm>              // for std::copy
-#include <iostream>              
+#include <iostream>
 #include <vector>
 
 
@@ -31,7 +31,7 @@ int main() {
 
 
   iterator i,end;
-  
+
   boost::tie(i,end) = return_range();
 
   std::copy(i,end,std::ostream_iterator<int>(std::cout,","));

example/transform_iterator_example.cpp

@@ -1,4 +1,4 @@
-// (C) Copyright Jeremy Siek 2000-2004. 
+// (C) Copyright Jeremy Siek 2000-2004.
 // 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)
@@ -15,7 +15,7 @@
 
 namespace boost {
 
-  template <class Operation> 
+  template <class Operation>
   class binder1st {
   public:
     typedef typename Operation::result_type result_type;
@@ -70,6 +70,6 @@ main(int, char*[])
             boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
             std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
-  
+
   return 0;
 }

include/boost/function_output_iterator.hpp

@@ -9,6 +9,10 @@
 // This is a deprecated header left for backward compatibility.
 // Use boost/iterator/function_output_iterator.hpp instead.
 
+#include <boost/config/header_deprecated.hpp>
+
+BOOST_HEADER_DEPRECATED("<boost/iterator/function_output_iterator.hpp>")
+
 #include <boost/iterator/function_output_iterator.hpp>
 
 #endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP

include/boost/generator_iterator.hpp

@@ -1,85 +1,14 @@
-// (C) Copyright Jens Maurer 2001.
+// (C) Copyright Andrey Semashev 2025.
 // 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)
-//
-// Revision History:
-
-// 15 Nov 2001   Jens Maurer
-//      created.
-
-//  See http://www.boost.org/libs/utility/iterator_adaptors.htm for documentation.
 
 #ifndef BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
 #define BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
 
-#include <boost/iterator/iterator_facade.hpp>
+// This is a deprecated header left for backward compatibility.
-#include <boost/ref.hpp>
+// Please use <boost/iterator/generator_iterator.hpp> instead.
 
-namespace boost {
+#include <boost/iterator/generator_iterator.hpp>
-namespace iterators {
-
-template<class Generator>
-class generator_iterator
-  : public iterator_facade<
-        generator_iterator<Generator>
-      , typename Generator::result_type
-      , single_pass_traversal_tag
-      , typename Generator::result_type const&
-    >
-{
-    typedef iterator_facade<
-        generator_iterator<Generator>
-      , typename Generator::result_type
-      , single_pass_traversal_tag
-      , typename Generator::result_type const&
-    > super_t;
-
- public:
-    generator_iterator() {}
-    generator_iterator(Generator* g) : m_g(g), m_value((*m_g)()) {}
-
-    void increment()
-    {
-        m_value = (*m_g)();
-    }
-
-    const typename Generator::result_type&
-    dereference() const
-    {
-        return m_value;
-    }
-
-    bool equal(generator_iterator const& y) const
-    {
-        return this->m_g == y.m_g && this->m_value == y.m_value;
-    }
-
- private:
-    Generator* m_g;
-    typename Generator::result_type m_value;
-};
-
-template<class Generator>
-struct generator_iterator_generator
-{
-  typedef generator_iterator<Generator> type;
-};
-
-template <class Generator>
-inline generator_iterator<Generator>
-make_generator_iterator(Generator & gen)
-{
-  typedef generator_iterator<Generator> result_t;
-  return result_t(&gen);
-}
-
-} // namespace iterators
-
-using iterators::generator_iterator;
-using iterators::generator_iterator_generator;
-using iterators::make_generator_iterator;
-
-} // namespace boost
 
 #endif // BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP

include/boost/indirect_reference.hpp

@@ -1,5 +1,5 @@
-#ifndef INDIRECT_REFERENCE_DWA200415_HPP
+#ifndef BOOST_INDIRECT_REFERENCE_DWA200415_HPP
-# define INDIRECT_REFERENCE_DWA200415_HPP
+#define BOOST_INDIRECT_REFERENCE_DWA200415_HPP
 
 //
 // Copyright David Abrahams 2004. Use, modification and distribution is
@@ -11,33 +11,36 @@
 // http://www.boost.org/libs/iterator/doc/pointee.html
 //
 
-# include <boost/detail/is_incrementable.hpp>
+#include <type_traits>
-# include <boost/iterator/iterator_traits.hpp>
+
-# include <boost/type_traits/remove_cv.hpp>
+#include <boost/detail/is_incrementable.hpp>
-# include <boost/mpl/eval_if.hpp>
+#include <boost/iterator/iterator_traits.hpp>
-# include <boost/pointee.hpp>
+#include <boost/pointee.hpp>
 
 namespace boost {
+namespace detail {
 
-namespace detail
+template< typename P >
+struct smart_ptr_reference
 {
-  template <class P>
+    using type = boost::pointee_t< P >&;
-  struct smart_ptr_reference
+};
-  {
-      typedef typename boost::pointee<P>::type& type;
-  };
-}
 
-template <class P>
+} // namespace detail
-struct indirect_reference
+
-  : mpl::eval_if<
+template< typename P >
-        detail::is_incrementable<P>
+struct indirect_reference :
-      , iterator_reference<P>
+    std::conditional<
-      , detail::smart_ptr_reference<P>
+        detail::is_incrementable< P >::value,
-    >
+        iterator_reference< P >,
+        detail::smart_ptr_reference< P >
+    >::type
 {
 };
 
+template< typename P >
+using indirect_reference_t = typename indirect_reference< P >::type;
+
 } // namespace boost
 
-#endif // INDIRECT_REFERENCE_DWA200415_HPP
+#endif // BOOST_INDIRECT_REFERENCE_DWA200415_HPP

include/boost/iterator/advance.hpp

@@ -12,72 +12,62 @@
 
 namespace boost {
 namespace iterators {
+namespace detail {
 
-    namespace detail {
+template< typename InputIterator, typename Distance >
-        template <typename InputIterator, typename Distance>
+inline BOOST_CXX14_CONSTEXPR void advance_impl(InputIterator& it, Distance n, incrementable_traversal_tag)
-        inline BOOST_CXX14_CONSTEXPR void
+{
-        advance_impl(
+    while (n > 0)
-            InputIterator& it
+    {
-          , Distance n
+        ++it;
-          , incrementable_traversal_tag
+        --n;
-        )
+    }
-        {
+}
-            while (n > 0) {
-                ++it;
-                --n;
-            }
-        }
 
-        template <typename BidirectionalIterator, typename Distance>
+template< typename BidirectionalIterator, typename Distance >
-        inline BOOST_CXX14_CONSTEXPR void
+inline BOOST_CXX14_CONSTEXPR void advance_impl(BidirectionalIterator& it, Distance n, bidirectional_traversal_tag)
-        advance_impl(
+{
-            BidirectionalIterator& it
+    if (n >= 0)
-          , Distance n
+    {
-          , bidirectional_traversal_tag
+        while (n > 0)
-        )
         {
-            if (n >= 0) {
+            ++it;
-                while (n > 0) {
+            --n;
-                    ++it;
-                    --n;
-                }
-            }
-            else {
-                while (n < 0) {
-                    --it;
-                    ++n;
-                }
-            }
-        }
-
-        template <typename RandomAccessIterator, typename Distance>
-        inline BOOST_CXX14_CONSTEXPR void
-        advance_impl(
-            RandomAccessIterator& it
-          , Distance n
-          , random_access_traversal_tag
-        )
-        {
-            it += n;
         }
     }
-
+    else
-    namespace advance_adl_barrier {
+    {
-        template <typename InputIterator, typename Distance>
+        while (n < 0)
-        inline BOOST_CXX14_CONSTEXPR void
-        advance(InputIterator& it, Distance n)
         {
-            detail::advance_impl(
+            --it;
-                it, n, typename iterator_traversal<InputIterator>::type()
+            ++n;
-            );
         }
     }
+}
 
-    using namespace advance_adl_barrier;
+template< typename RandomAccessIterator, typename Distance >
+inline BOOST_CXX14_CONSTEXPR void advance_impl(RandomAccessIterator& it, Distance n, random_access_traversal_tag)
+{
+    it += n;
+}
+
+} // namespace detail
+
+namespace advance_adl_barrier {
+
+template< typename InputIterator, typename Distance >
+inline BOOST_CXX14_CONSTEXPR void advance(InputIterator& it, Distance n)
+{
+    detail::advance_impl(it, n, typename iterator_traversal< InputIterator >::type());
+}
+
+} // namespace advance_adl_barrier
+
+using namespace advance_adl_barrier;
 
 } // namespace iterators
 
-using iterators::advance;
+using namespace iterators::advance_adl_barrier;
 
 } // namespace boost
 

include/boost/iterator/counting_iterator.hpp

@@ -2,212 +2,212 @@
 // 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)
-#ifndef COUNTING_ITERATOR_DWA200348_HPP
+#ifndef BOOST_ITERATOR_COUNTING_ITERATOR_DWA200348_HPP
-# define COUNTING_ITERATOR_DWA200348_HPP
+#define BOOST_ITERATOR_COUNTING_ITERATOR_DWA200348_HPP
 
-# include <boost/iterator/iterator_adaptor.hpp>
+#include <limits>
-# include <boost/detail/numeric_traits.hpp>
+#include <type_traits>
-# include <boost/mpl/bool.hpp>
+
-# include <boost/mpl/if.hpp>
+#include <boost/config.hpp>
-# include <boost/mpl/identity.hpp>
+#include <boost/core/use_default.hpp>
-# include <boost/mpl/eval_if.hpp>
+#include <boost/detail/numeric_traits.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/iterator/detail/if_default.hpp>
+#include <boost/iterator/detail/eval_if_default.hpp>
+#include <boost/iterator/detail/type_traits/type_identity.hpp>
 
 namespace boost {
 namespace iterators {
 
-template <
+template<
-    class Incrementable
+    typename Incrementable,
-  , class CategoryOrTraversal
+    typename CategoryOrTraversal,
-  , class Difference
+    typename Difference
 >
 class counting_iterator;
 
-namespace detail
+namespace detail {
+
+// Try to detect numeric types at compile time in ways compatible
+// with the limitations of the compiler and library.
+template< typename T >
+struct is_numeric :
+    public std::integral_constant< bool, std::numeric_limits< T >::is_specialized >
+{};
+
+template<>
+struct is_numeric< long long > :
+    public std::true_type
+{};
+
+template<>
+struct is_numeric< unsigned long long > :
+    public std::true_type
+{};
+
+#if defined(BOOST_HAS_INT128)
+template<>
+struct is_numeric< boost::int128_type > :
+    public std::true_type
+{};
+
+template<>
+struct is_numeric< boost::uint128_type > :
+    public std::true_type
+{};
+#endif
+
+// Some compilers fail to have a numeric_limits specialization
+template<>
+struct is_numeric< wchar_t > :
+    public std::true_type
+{};
+
+template< typename T >
+struct numeric_difference
 {
-  // Try to detect numeric types at compile time in ways compatible
+    using type = typename boost::detail::numeric_traits< T >::difference_type;
-  // with the limitations of the compiler and library.
+};
-  template <class T>
-  struct is_numeric_impl
-  {
-      // For a while, this wasn't true, but we rely on it below. This is a regression assert.
-      BOOST_STATIC_ASSERT(::boost::is_integral<char>::value);
 
-# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#if defined(BOOST_HAS_INT128)
+// std::numeric_limits, which is used by numeric_traits, is not specialized for __int128 in some standard libraries
+template<>
+struct numeric_difference< boost::int128_type >
+{
+    using type = boost::int128_type;
+};
 
-      BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized);
+template<>
+struct numeric_difference< boost::uint128_type >
+{
+    using type = boost::int128_type;
+};
+#endif
 
-# else
+template< typename Incrementable, typename CategoryOrTraversal, typename Difference, bool IsNumeric = is_numeric< Incrementable >::value >
+struct counting_iterator_types
+{
+    using traversal = detail::eval_if_default_t<
+        CategoryOrTraversal,
+        iterator_traversal< Incrementable >
+    >;
 
-#  if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    using difference = detail::eval_if_default_t<
-      BOOST_STATIC_CONSTANT(
+        Difference,
-          bool, value = (
+        iterator_difference< Incrementable >
-              boost::is_convertible<int,T>::value
+    >;
-           && boost::is_convertible<T,int>::value
+};
-      ));
-#  else
-    BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
-#  endif
 
-# endif
+template< typename Incrementable, typename CategoryOrTraversal, typename Difference >
-  };
+struct counting_iterator_types< Incrementable, CategoryOrTraversal, Difference, true >
+{
+    using traversal = detail::if_default_t<
+        CategoryOrTraversal,
+        random_access_traversal_tag
+    >;
 
-  template <class T>
+    using difference = detail::eval_if_default_t<
-  struct is_numeric
+        Difference,
-    : mpl::bool_<(::boost::iterators::detail::is_numeric_impl<T>::value)>
+        numeric_difference< Incrementable >
-  {};
+    >;
+};
 
-#  if defined(BOOST_HAS_LONG_LONG)
+template< typename Incrementable, typename CategoryOrTraversal, typename Difference >
-  template <>
+struct counting_iterator_base
-  struct is_numeric< ::boost::long_long_type>
+{
-    : mpl::true_ {};
+    using iterator_types = counting_iterator_types< Incrementable, CategoryOrTraversal, Difference >;
 
-  template <>
+    using type = iterator_adaptor<
-  struct is_numeric< ::boost::ulong_long_type>
+        counting_iterator< Incrementable, CategoryOrTraversal, Difference >, // self
-    : mpl::true_ {};
+        Incrementable,                                           // Base
-#  endif
+#ifndef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
+        const  // MSVC won't strip this.  Instead we enable Thomas'
+               // criterion (see boost/iterator/detail/facade_iterator_category.hpp)
+#endif
+        Incrementable,                                           // Value
+        typename iterator_types::traversal,
+        Incrementable const&,                                    // reference
+        typename iterator_types::difference
+    >;
+};
 
-  // Some compilers fail to have a numeric_limits specialization
+// A distance calculation policy for wrapped iterators
-  template <>
+template< typename Difference, typename Incrementable1, typename Incrementable2 >
-  struct is_numeric<wchar_t>
+struct iterator_distance
-    : mpl::true_ {};
+{
+    static Difference distance(Incrementable1 x, Incrementable2 y)
+    {
+        return y - x;
+    }
+};
 
-  template <class T>
+// A distance calculation policy for wrapped numbers
-  struct numeric_difference
+template< typename Difference, typename Incrementable1, typename Incrementable2 >
-  {
+struct number_distance
-      typedef typename boost::detail::numeric_traits<T>::difference_type type;
+{
-  };
+    static Difference distance(Incrementable1 x, Incrementable2 y)
+    {
+        return boost::detail::numeric_distance(x, y);
+    }
+};
 
-  BOOST_STATIC_ASSERT(is_numeric<int>::value);
+} // namespace detail
 
-  template <class Incrementable, class CategoryOrTraversal, class Difference>
+template<
-  struct counting_iterator_base
+    typename Incrementable,
-  {
+    typename CategoryOrTraversal = use_default,
-      typedef typename detail::ia_dflt_help<
+    typename Difference = use_default
-          CategoryOrTraversal
-        , mpl::eval_if<
-              is_numeric<Incrementable>
-            , mpl::identity<random_access_traversal_tag>
-            , iterator_traversal<Incrementable>
-          >
-      >::type traversal;
-
-      typedef typename detail::ia_dflt_help<
-          Difference
-        , mpl::eval_if<
-              is_numeric<Incrementable>
-            , numeric_difference<Incrementable>
-            , iterator_difference<Incrementable>
-          >
-      >::type difference;
-
-      typedef iterator_adaptor<
-          counting_iterator<Incrementable, CategoryOrTraversal, Difference> // self
-        , Incrementable                                           // Base
-        , Incrementable                                           // Value
-# ifndef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-          const  // MSVC won't strip this.  Instead we enable Thomas'
-                 // criterion (see boost/iterator/detail/facade_iterator_category.hpp)
-# endif
-        , traversal
-        , Incrementable const&                                    // reference
-        , difference
-      > type;
-  };
-
-  // Template class distance_policy_select -- choose a policy for computing the
-  // distance between counting_iterators at compile-time based on whether or not
-  // the iterator wraps an integer or an iterator, using "poor man's partial
-  // specialization".
-
-  template <bool is_integer> struct distance_policy_select;
-
-  // A policy for wrapped iterators
-  template <class Difference, class Incrementable1, class Incrementable2>
-  struct iterator_distance
-  {
-      static Difference distance(Incrementable1 x, Incrementable2 y)
-      {
-          return y - x;
-      }
-  };
-
-  // A policy for wrapped numbers
-  template <class Difference, class Incrementable1, class Incrementable2>
-  struct number_distance
-  {
-      static Difference distance(Incrementable1 x, Incrementable2 y)
-      {
-          return boost::detail::numeric_distance(x, y);
-      }
-  };
-}
-
-template <
-    class Incrementable
-  , class CategoryOrTraversal = use_default
-  , class Difference = use_default
 >
-class counting_iterator
+class counting_iterator :
-  : public detail::counting_iterator_base<
+    public detail::counting_iterator_base< Incrementable, CategoryOrTraversal, Difference >::type
-        Incrementable, CategoryOrTraversal, Difference
-    >::type
 {
-    typedef typename detail::counting_iterator_base<
-        Incrementable, CategoryOrTraversal, Difference
-    >::type super_t;
-
     friend class iterator_core_access;
 
- public:
+private:
-    typedef typename super_t::difference_type difference_type;
+    using super_t = typename detail::counting_iterator_base<
+        Incrementable, CategoryOrTraversal, Difference
+    >::type;
 
-    counting_iterator() { }
+public:
+    using reference = typename super_t::reference;
+    using difference_type = typename super_t::difference_type;
 
-    counting_iterator(counting_iterator const& rhs) : super_t(rhs.base()) {}
+    counting_iterator() = default;
 
-    counting_iterator(Incrementable x)
+    counting_iterator(counting_iterator const&) = default;
-      : super_t(x)
+    counting_iterator& operator=(counting_iterator const&) = default;
+
+    counting_iterator(Incrementable x) :
+        super_t(x)
     {
     }
 
-# if 0
+private:
-    template<class OtherIncrementable>
+    reference dereference() const
-    counting_iterator(
-        counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& t
-      , typename enable_if_convertible<OtherIncrementable, Incrementable>::type* = 0
-    )
-      : super_t(t.base())
-    {}
-# endif
-
- private:
-
-    typename super_t::reference dereference() const
     {
         return this->base_reference();
     }
 
-    template <class OtherIncrementable>
+    template< typename OtherIncrementable >
     difference_type
-    distance_to(counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& y) const
+    distance_to(counting_iterator< OtherIncrementable, CategoryOrTraversal, Difference > const& y) const
     {
-      typedef typename mpl::if_<
+        using distance_traits = typename std::conditional<
-          detail::is_numeric<Incrementable>
+            detail::is_numeric< Incrementable >::value,
-        , detail::number_distance<difference_type, Incrementable, OtherIncrementable>
+            detail::number_distance< difference_type, Incrementable, OtherIncrementable >,
-        , detail::iterator_distance<difference_type, Incrementable, OtherIncrementable>
+            detail::iterator_distance< difference_type, Incrementable, OtherIncrementable >
-      >::type d;
+        >::type;
 
-      return d::distance(this->base(), y.base());
+        return distance_traits::distance(this->base(), y.base());
     }
 };
 
 // Manufacture a counting iterator for an arbitrary incrementable type
-template <class Incrementable>
+template< typename Incrementable >
-inline counting_iterator<Incrementable>
+inline counting_iterator< Incrementable > make_counting_iterator(Incrementable x)
-make_counting_iterator(Incrementable x)
 {
-  typedef counting_iterator<Incrementable> result_t;
+    return counting_iterator< Incrementable >(x);
-  return result_t(x);
 }
 
 } // namespace iterators
@@ -217,4 +217,4 @@ using iterators::make_counting_iterator;
 
 } // namespace boost
 
-#endif // COUNTING_ITERATOR_DWA200348_HPP
+#endif // BOOST_ITERATOR_COUNTING_ITERATOR_DWA200348_HPP

include/boost/iterator/detail/any_conversion_eater.hpp

@@ -1,21 +0,0 @@
-// Copyright David Abrahams 2003. Use, modification and distribution is
-// subject to the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef ANY_CONVERSION_EATER_DWA20031117_HPP
-# define ANY_CONVERSION_EATER_DWA20031117_HPP
-
-namespace boost {
-namespace iterators {
-namespace detail {
-
-// This type can be used in traits to "eat" up the one user-defined
-// implicit conversion allowed.
-struct any_conversion_eater
-{
-    template <class T>
-    any_conversion_eater(T const&);
-};
-
-}}} // namespace boost::iterators::detail
-
-#endif // ANY_CONVERSION_EATER_DWA20031117_HPP

include/boost/iterator/detail/config_def.hpp

@@ -18,16 +18,14 @@
 
 #ifdef BOOST_ITERATOR_CONFIG_DEF
 # error you have nested config_def #inclusion.
-#else 
+#else
 # define BOOST_ITERATOR_CONFIG_DEF
-#endif 
+#endif
 
 // We enable this always now.  Otherwise, the simple case in
 // libs/iterator/test/constant_iterator_arrow.cpp fails to compile
 // because the operator-> return is improperly deduced as a non-const
 // pointer.
-#if 1 || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)           \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))
 
 // Recall that in general, compilers without partial specialization
 // can't strip constness.  Consider counting_iterator, which normally
@@ -44,85 +42,4 @@
 
 # define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
 
-#endif
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                      \
-    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
-    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))                \
-    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
-    
-# define BOOST_NO_LVALUE_RETURN_DETECTION
-
-# if 0 // test code
-  struct v  {};
-
-  typedef  char (&no)[3];
-
-  template <class T>
-  no foo(T const&, ...);
-
-  template <class T>
-  char foo(T&, int);
-
-
-  struct value_iterator
-  {
-      v operator*() const;
-  };
-
-  template <class T>
-  struct lvalue_deref_helper
-  {
-      static T& x;
-      enum { value = (sizeof(foo(*x,0)) == 1) };
-  };
-
-  int z2[(lvalue_deref_helper<v*>::value == 1) ? 1 : -1];
-  int z[(lvalue_deref_helper<value_iterator>::value) == 1 ? -1 : 1 ];
-# endif 
-
-#endif
-
-#if BOOST_WORKAROUND(__MWERKS__, <=0x2407)
-#  define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
-#endif
-
-#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-#  define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
-
-#  if 0 // test code
-    #include <boost/type_traits/is_convertible.hpp>
-    template <class T>
-    struct foo
-    {
-        foo(T);
-
-        template <class U>
-        foo(foo<U> const& other) : p(other.p) { }
-
-        T p;
-    };
-
-    bool x = boost::is_convertible<foo<int const*>, foo<int*> >::value;
-#  endif
-
-#endif
-
-
-#if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE))
-# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#endif 
-
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-
-// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
-// operators in convertibility checks, causing premature errors.
-//
-// Borland's problems are harder to diagnose due to lack of an
-// instantiation stack backtrace.  They may be due in part to the fact
-// that it drops cv-qualification willy-nilly in templates.
-#  define BOOST_NO_ONE_WAY_ITERATOR_INTEROP
-# endif 
-
 // no include guard; multiple inclusion intended

include/boost/iterator/detail/config_undef.hpp

@@ -11,14 +11,10 @@
 // 23/02/03 thw
 //
 
-#undef BOOST_NO_IS_CONVERTIBLE
+#undef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
-#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#undef BOOST_NO_LVALUE_RETURN_DETECTION
-#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
 
 #ifdef BOOST_ITERATOR_CONFIG_DEF
 # undef BOOST_ITERATOR_CONFIG_DEF
 #else
 # error missing or nested #include config_def
-#endif 
+#endif

include/boost/iterator/detail/enable_if.hpp

@@ -1,83 +0,0 @@
-// (C) Copyright David Abrahams 2002.
-// (C) Copyright Jeremy Siek    2002.
-// (C) Copyright Thomas Witt    2002.
-// 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)
-#ifndef BOOST_ENABLE_IF_23022003THW_HPP
-#define BOOST_ENABLE_IF_23022003THW_HPP
-
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/identity.hpp>
-
-#include <boost/iterator/detail/config_def.hpp>
-
-//
-// Boost iterators uses its own enable_if cause we need
-// special semantics for deficient compilers.
-// 23/02/03 thw
-//
-
-namespace boost
-{
-
-  namespace iterators
-  {
-    //
-    // Base machinery for all kinds of enable if
-    //
-    template<bool>
-    struct enabled
-    {
-      template<typename T>
-      struct base
-      {
-        typedef T type;
-      };
-    };
-
-    //
-    // For compilers that don't support "Substitution Failure Is Not An Error"
-    // enable_if falls back to always enabled. See comments
-    // on operator implementation for consequences.
-    //
-    template<>
-    struct enabled<false>
-    {
-      template<typename T>
-      struct base
-      {
-#ifdef BOOST_NO_SFINAE
-
-        typedef T type;
-
-        // This way to do it would give a nice error message containing
-        // invalid overload, but has the big disadvantage that
-        // there is no reference to user code in the error message.
-        //
-        // struct invalid_overload;
-        // typedef invalid_overload type;
-        //
-#endif
-      };
-    };
-
-
-    template <class Cond,
-              class Return>
-    struct enable_if
-# if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE)
-      : enabled<(Cond::value)>::template base<Return>
-# else
-      : mpl::identity<Return>
-# endif
-    {
-    };
-
-  } // namespace iterators
-
-} // namespace boost
-
-#include <boost/iterator/detail/config_undef.hpp>
-
-#endif // BOOST_ENABLE_IF_23022003THW_HPP

include/boost/iterator/detail/eval_if_default.hpp

@@ -0,0 +1,44 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * https://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2025 Andrey Semashev
+ */
+
+#ifndef BOOST_ITERATOR_DETAIL_EVAL_IF_DEFAULT_HPP_INCLUDED_
+#define BOOST_ITERATOR_DETAIL_EVAL_IF_DEFAULT_HPP_INCLUDED_
+
+#include <boost/core/use_default.hpp>
+#include <boost/iterator/detail/type_traits/type_identity.hpp>
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+// If T is use_default, return the result of invoking
+// DefaultNullaryFn, otherwise - of NondefaultNullaryFn.
+// By default, NondefaultNullaryFn returns T, which means
+// the metafunction can be called with just two parameters
+// and in that case will return either T or the result of
+// invoking DefaultNullaryFn.
+template< typename T, typename DefaultNullaryFn, typename NondefaultNullaryFn = detail::type_identity< T > >
+struct eval_if_default
+{
+    using type = typename NondefaultNullaryFn::type;
+};
+
+template< typename DefaultNullaryFn, typename NondefaultNullaryFn >
+struct eval_if_default< use_default, DefaultNullaryFn, NondefaultNullaryFn >
+{
+    using type = typename DefaultNullaryFn::type;
+};
+
+template< typename T, typename DefaultNullaryFn, typename NondefaultNullaryFn = detail::type_identity< T > >
+using eval_if_default_t = typename eval_if_default< T, DefaultNullaryFn, NondefaultNullaryFn >::type;
+
+} // namespace detail
+} // namespace iterators
+} // namespace boost
+
+#endif // BOOST_ITERATOR_DETAIL_EVAL_IF_DEFAULT_HPP_INCLUDED_

include/boost/iterator/detail/facade_iterator_category.hpp

@@ -2,29 +2,17 @@
 // 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)
 #ifndef FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
-# define FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
+#define FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
 
-# include <boost/iterator/iterator_categories.hpp>
+#include <iterator>
+#include <type_traits>
 
-# include <boost/mpl/or.hpp>  // used in iterator_tag inheritance logic
+#include <boost/mp11/utility.hpp>
-# include <boost/mpl/and.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/eval_if.hpp>
-# include <boost/mpl/identity.hpp>
-# include <boost/mpl/assert.hpp>
 
-# include <boost/type_traits/is_same.hpp>
+#include <boost/iterator/iterator_categories.hpp>
-# include <boost/type_traits/is_const.hpp>
+#include <boost/iterator/detail/type_traits/conjunction.hpp>
-# include <boost/type_traits/is_reference.hpp>
+#include <boost/iterator/detail/type_traits/disjunction.hpp>
-# include <boost/type_traits/is_convertible.hpp>
+#include <boost/iterator/detail/config_def.hpp> // try to keep this last
-
-# include <boost/type_traits/is_same.hpp>
-
-# include <boost/iterator/detail/config_def.hpp> // try to keep this last
-
-# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-#  include <boost/detail/indirect_traits.hpp>
-# endif
 
 //
 // iterator_category deduction for iterator_facade
@@ -32,46 +20,49 @@
 
 namespace boost {
 namespace iterators {
-
-// forward declaration
-struct use_default;
-
 namespace detail {
 
-struct input_output_iterator_tag
+#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-  : std::input_iterator_tag
+
-{
+template< typename T >
-    // Using inheritance for only input_iterator_tag helps to avoid
+struct is_const_lvalue_reference :
-    // ambiguities when a stdlib implementation dispatches on a
+    public std::false_type
-    // function which is overloaded on both input_iterator_tag and
+{};
-    // output_iterator_tag, as STLPort does, in its __valid_range
+
-    // function.  I claim it's better to avoid the ambiguity in these
+template< typename T >
-    // cases.
+struct is_const_lvalue_reference< T const& > :
-    operator std::output_iterator_tag() const
+    public std::true_type
-    {
+{};
-        return std::output_iterator_tag();
+
-    }
+#endif // BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-};
 
 //
 // True iff the user has explicitly disabled writability of this
 // iterator.  Pass the iterator_facade's Value parameter and its
 // nested ::reference type.
 //
-template <class ValueParam, class Reference>
+template< typename ValueParam, typename Reference >
-struct iterator_writability_disabled
+struct iterator_writability_disabled :
 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY // Adding Thomas' logic?
-  : mpl::or_<
+    public detail::disjunction<
-        is_const<Reference>
+        detail::is_const_lvalue_reference< Reference >,
-      , boost::detail::indirect_traits::is_reference_to_const<Reference>
+        std::is_const< Reference >,
-      , is_const<ValueParam>
+        std::is_const< ValueParam >
     >
 # else
-  : is_const<ValueParam>
+    public std::is_const< ValueParam >
 # endif
 {};
 
 
+template< typename Traversal, typename ValueParam, typename Reference >
+using is_traversal_of_input_iterator = detail::conjunction<
+    std::is_convertible< Traversal, single_pass_traversal_tag >,
+
+    // check for readability
+    std::is_convertible< Reference, ValueParam >
+>;
+
 //
 // Convert an iterator_facade's traversal category, Value parameter,
 // and ::reference type to an appropriate old-style category.
@@ -80,114 +71,109 @@ struct iterator_writability_disabled
 // to output_iterator_tag.
 //
 // Change at: https://svn.boost.org/trac/boost/changeset/21683
-template <class Traversal, class ValueParam, class Reference>
+template< typename Traversal, typename ValueParam, typename Reference >
 struct iterator_facade_default_category
-  : mpl::eval_if<
-        mpl::and_<
-            is_reference<Reference>
-          , is_convertible<Traversal,forward_traversal_tag>
-        >
-      , mpl::eval_if<
-            is_convertible<Traversal,random_access_traversal_tag>
-          , mpl::identity<std::random_access_iterator_tag>
-          , mpl::if_<
-                is_convertible<Traversal,bidirectional_traversal_tag>
-              , std::bidirectional_iterator_tag
-              , std::forward_iterator_tag
-            >
-        >
-      , typename mpl::eval_if<
-            mpl::and_<
-                is_convertible<Traversal, single_pass_traversal_tag>
-
-                // check for readability
-              , is_convertible<Reference, ValueParam>
-            >
-          , mpl::identity<std::input_iterator_tag>
-          , mpl::identity<Traversal>
-        >
-    >
 {
+    using type = typename std::conditional<
+        detail::is_traversal_of_input_iterator< Traversal, ValueParam, Reference >::value,
+        std::input_iterator_tag,
+        Traversal
+    >::type;
 };
 
+// Specialization for the (typical) case when the reference type is an actual reference
+template< typename Traversal, typename ValueParam, typename Referenced >
+struct iterator_facade_default_category< Traversal, ValueParam, Referenced& >
+{
+    using type = mp11::mp_cond<
+        std::is_convertible< Traversal, random_access_traversal_tag >, std::random_access_iterator_tag,
+        std::is_convertible< Traversal, bidirectional_traversal_tag >, std::bidirectional_iterator_tag,
+        std::is_convertible< Traversal, forward_traversal_tag >, std::forward_iterator_tag,
+        detail::is_traversal_of_input_iterator< Traversal, ValueParam, Referenced& >, std::input_iterator_tag,
+        std::true_type, Traversal
+    >;
+};
+
+template< typename Traversal, typename ValueParam, typename Reference >
+using iterator_facade_default_category_t = typename iterator_facade_default_category< Traversal, ValueParam, Reference >::type;
+
 // True iff T is convertible to an old-style iterator category.
-template <class T>
+template< typename T >
-struct is_iterator_category
+struct is_iterator_category :
-  : mpl::or_<
+    public detail::disjunction<
-        is_convertible<T,std::input_iterator_tag>
+        std::is_convertible< T, std::input_iterator_tag >,
-      , is_convertible<T,std::output_iterator_tag>
+        std::is_convertible< T, std::output_iterator_tag >
     >
-{
-};
-
-template <class T>
-struct is_iterator_traversal
-  : is_convertible<T,incrementable_traversal_tag>
 {};
 
+template< typename T >
+struct is_iterator_traversal :
+    public std::is_convertible< T, incrementable_traversal_tag >
+{};
+
+
 //
 // A composite iterator_category tag convertible to Category (a pure
 // old-style category) and Traversal (a pure traversal tag).
 // Traversal must be a strict increase of the traversal power given by
 // Category.
 //
-template <class Category, class Traversal>
+template< typename Category, typename Traversal >
-struct iterator_category_with_traversal
+struct iterator_category_with_traversal :
-  : Category, Traversal
+    public Category,
+    public Traversal
 {
     // Make sure this isn't used to build any categories where
     // convertibility to Traversal is redundant.  Should just use the
     // Category element in that case.
-    BOOST_MPL_ASSERT_NOT((
+    static_assert(
-        is_convertible<
+        !std::is_convertible< iterator_category_to_traversal_t< Category >, Traversal >::value,
-              typename iterator_category_to_traversal<Category>::type
+        "Category transformed to corresponding traversal must be convertible to Traversal."
-            , Traversal
+    );
-          >));
 
-    BOOST_MPL_ASSERT((is_iterator_category<Category>));
+    static_assert(is_iterator_category< Category >::value, "Category must be an STL iterator category.");
-    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
+    static_assert(!is_iterator_category< Traversal >::value, "Traversal must not be an STL iterator category.");
-    BOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>));
+    static_assert(!is_iterator_traversal< Category >::value, "Category must not be a traversal tag.");
-#  if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
+    static_assert(is_iterator_traversal< Traversal >::value, "Traversal must be a traversal tag.");
-    BOOST_MPL_ASSERT((is_iterator_traversal<Traversal>));
-#  endif
 };
 
 // Computes an iterator_category tag whose traversal is Traversal and
 // which is appropriate for an iterator
-template <class Traversal, class ValueParam, class Reference>
+template< typename Traversal, typename ValueParam, typename Reference >
 struct facade_iterator_category_impl
 {
-    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
+    static_assert(!is_iterator_category< Traversal >::value, "Traversal must not be an STL iterator category.");
 
-    typedef typename iterator_facade_default_category<
+    using category = iterator_facade_default_category_t< Traversal, ValueParam, Reference >;
-        Traversal,ValueParam,Reference
-    >::type category;
 
-    typedef typename mpl::if_<
+    using type = typename std::conditional<
-        is_same<
+        std::is_same<
-            Traversal
+            Traversal,
-          , typename iterator_category_to_traversal<category>::type
+            typename iterator_category_to_traversal< category >::type
-        >
+        >::value,
-      , category
+        category,
-      , iterator_category_with_traversal<category,Traversal>
+        iterator_category_with_traversal< category, Traversal >
-    >::type type;
+    >::type;
 };
 
+template< typename Traversal, typename ValueParam, typename Reference >
+using facade_iterator_category_impl_t = typename facade_iterator_category_impl< Traversal, ValueParam, Reference >::type;
+
 //
 // Compute an iterator_category for iterator_facade
 //
-template <class CategoryOrTraversal, class ValueParam, class Reference>
+template< typename CategoryOrTraversal, typename ValueParam, typename Reference >
 struct facade_iterator_category
-  : mpl::eval_if<
-        is_iterator_category<CategoryOrTraversal>
-      , mpl::identity<CategoryOrTraversal> // old-style categories are fine as-is
-      , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
-    >
 {
+    using type = mp11::mp_eval_if<
+        is_iterator_category< CategoryOrTraversal >,
+        CategoryOrTraversal, // old-style categories are fine as-is
+        facade_iterator_category_impl_t, CategoryOrTraversal, ValueParam, Reference
+    >;
 };
 
 }}} // namespace boost::iterators::detail
 
-# include <boost/iterator/detail/config_undef.hpp>
+#include <boost/iterator/detail/config_undef.hpp>
 
 #endif // FACADE_ITERATOR_CATEGORY_DWA20031118_HPP

include/boost/iterator/detail/if_default.hpp

@@ -0,0 +1,41 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * https://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2025 Andrey Semashev
+ */
+
+#ifndef BOOST_ITERATOR_DETAIL_IF_DEFAULT_HPP_INCLUDED_
+#define BOOST_ITERATOR_DETAIL_IF_DEFAULT_HPP_INCLUDED_
+
+#include <boost/core/use_default.hpp>
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+// If T is use_default, return Default, otherwise - Nondefault.
+// By default, Nondefault is T, which means
+// the metafunction can be called with just two parameters
+// and in that case will return either T or Default.
+template< typename T, typename Default, typename Nondefault = T >
+struct if_default
+{
+    using type = Nondefault;
+};
+
+template< typename Default, typename Nondefault >
+struct if_default< use_default, Default, Nondefault >
+{
+    using type = Default;
+};
+
+template< typename T, typename Default, typename Nondefault = T >
+using if_default_t = typename if_default< T, Default, Nondefault >::type;
+
+} // namespace detail
+} // namespace iterators
+} // namespace boost
+
+#endif // BOOST_ITERATOR_DETAIL_IF_DEFAULT_HPP_INCLUDED_

include/boost/iterator/detail/minimum_category.hpp

@@ -1,19 +0,0 @@
-// Copyright David Abrahams 2003. Use, modification and distribution is
-// subject to the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef MINIMUM_CATEGORY_DWA20031119_HPP
-# define MINIMUM_CATEGORY_DWA20031119_HPP
-
-# include <boost/iterator/minimum_category.hpp>
-
-namespace boost {
-
-// This import below (as well as the whole header) is for backward compatibility
-// with boost/token_iterator.hpp. It should be removed as soon as that header is fixed.
-namespace detail {
-using iterators::minimum_category;
-} // namespace detail
-
-} // namespace boost
-
-#endif // MINIMUM_CATEGORY_DWA20031119_HPP

include/boost/iterator/detail/type_traits/conjunction.hpp

@@ -0,0 +1,53 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * https://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2024 Georgiy Guminov
+ */
+/*!
+ * \file iterator/detail/type_traits/conjunction.hpp
+ *
+ * This header contains definition of \c conjunction type trait.
+ */
+
+#ifndef BOOST_ITERATOR_DETAIL_TYPE_TRAITS_CONJUNCTION_HPP_INCLUDED_
+#define BOOST_ITERATOR_DETAIL_TYPE_TRAITS_CONJUNCTION_HPP_INCLUDED_
+
+#include <type_traits>
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if (defined(__cpp_lib_logical_traits) && (__cpp_lib_logical_traits >= 201510l)) || \
+    (defined(BOOST_MSSTL_VERSION) && (BOOST_MSSTL_VERSION >= 140) && (_MSC_FULL_VER >= 190023918) && (BOOST_CXX_VERSION >= 201703l))
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+using std::conjunction;
+
+} // namespace detail
+} // namespace iterator
+} // namespace boost
+
+#else
+
+#include <boost/type_traits/conjunction.hpp>
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+using boost::conjunction;
+
+} // namespace detail
+} // namespace iterator
+} // namespace boost
+
+#endif
+
+#endif // BOOST_ITERATOR_DETAIL_TYPE_TRAITS_CONJUNCTION_HPP_INCLUDED_

include/boost/iterator/detail/type_traits/disjunction.hpp

@@ -0,0 +1,53 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * https://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2024 Georgiy Guminov
+ */
+/*!
+ * \file iterator/detail/type_traits/disjunction.hpp
+ *
+ * This header contains definition of \c disjunction type trait.
+ */
+
+#ifndef BOOST_ITERATOR_DETAIL_TYPE_TRAITS_DISJUNCTION_HPP_INCLUDED_
+#define BOOST_ITERATOR_DETAIL_TYPE_TRAITS_DISJUNCTION_HPP_INCLUDED_
+
+#include <type_traits>
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if (defined(__cpp_lib_logical_traits) && (__cpp_lib_logical_traits >= 201510l)) || \
+    (defined(BOOST_MSSTL_VERSION) && (BOOST_MSSTL_VERSION >= 140) && (_MSC_FULL_VER >= 190023918) && (BOOST_CXX_VERSION >= 201703l))
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+using std::disjunction;
+
+} // namespace detail
+} // namespace iterator
+} // namespace boost
+
+#else
+
+#include <boost/type_traits/disjunction.hpp>
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+using boost::disjunction;
+
+} // namespace detail
+} // namespace iterator
+} // namespace boost
+
+#endif
+
+#endif // BOOST_ITERATOR_DETAIL_TYPE_TRAITS_DISJUNCTION_HPP_INCLUDED_

include/boost/iterator/detail/type_traits/negation.hpp

@@ -0,0 +1,53 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * https://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2024 Georgiy Guminov
+ */
+/*!
+ * \file iterator/detail/type_traits/negation.hpp
+ *
+ * This header contains definition of \c negation type trait.
+ */
+
+#ifndef BOOST_ITERATOR_DETAIL_TYPE_TRAITS_NEGATION_HPP_INCLUDED_
+#define BOOST_ITERATOR_DETAIL_TYPE_TRAITS_NEGATION_HPP_INCLUDED_
+
+#include <type_traits>
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if (defined(__cpp_lib_logical_traits) && (__cpp_lib_logical_traits >= 201510l)) || \
+    (defined(BOOST_MSSTL_VERSION) && (BOOST_MSSTL_VERSION >= 140) && (_MSC_FULL_VER >= 190023918) && (BOOST_CXX_VERSION >= 201703l))
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+using std::negation;
+
+} // namespace detail
+} // namespace iterator
+} // namespace boost
+
+#else
+
+#include <boost/type_traits/negation.hpp>
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+using boost::negation;
+
+} // namespace detail
+} // namespace iterator
+} // namespace boost
+
+#endif
+
+#endif // BOOST_ITERATOR_DETAIL_TYPE_TRAITS_NEGATION_HPP_INCLUDED_

include/boost/iterator/detail/type_traits/type_identity.hpp

@@ -0,0 +1,54 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * https://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2025 Andrey Semashev
+ */
+/*!
+ * \file iterator/detail/type_traits/type_identity.hpp
+ *
+ * This header contains definition of \c negation type trait.
+ */
+
+#ifndef BOOST_ITERATOR_DETAIL_TYPE_TRAITS_TYPE_IDENTITY_HPP_INCLUDED_
+#define BOOST_ITERATOR_DETAIL_TYPE_TRAITS_TYPE_IDENTITY_HPP_INCLUDED_
+
+#include <type_traits>
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if (defined(__cpp_lib_type_identity) && (__cpp_lib_type_identity >= 201806l)) || \
+    /* Note: MSVC 19.21 does not define _MSVC_LANG to 202002 in c++latest (C++20) mode but to a value larger than 201703 */ \
+    (defined(BOOST_MSSTL_VERSION) && (BOOST_MSSTL_VERSION >= 142) && (_MSC_VER >= 1921) && (BOOST_CXX_VERSION > 201703l))
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+using std::type_identity;
+
+} // namespace detail
+} // namespace iterator
+} // namespace boost
+
+#else
+
+#include <boost/type_traits/type_identity.hpp>
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+using boost::type_identity;
+
+} // namespace detail
+} // namespace iterator
+} // namespace boost
+
+#endif
+
+#endif // BOOST_ITERATOR_DETAIL_TYPE_TRAITS_TYPE_IDENTITY_HPP_INCLUDED_

include/boost/iterator/distance.hpp

@@ -13,52 +13,46 @@
 
 namespace boost {
 namespace iterators {
+namespace detail {
 
-    namespace detail {
+template< typename SinglePassIterator >
-        template <typename SinglePassIterator>
+inline BOOST_CXX14_CONSTEXPR typename iterator_difference< SinglePassIterator >::type
-        inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type
+distance_impl(SinglePassIterator first, SinglePassIterator last, single_pass_traversal_tag)
-        distance_impl(
+{
-            SinglePassIterator first
+    typename iterator_difference< SinglePassIterator >::type n = 0;
-          , SinglePassIterator last
+    while (first != last)
-          , single_pass_traversal_tag
+    {
-        )
+        ++first;
-        {
+        ++n;
-            typename iterator_difference<SinglePassIterator>::type n = 0;
-            while (first != last) {
-                ++first;
-                ++n;
-            }
-            return n;
-        }
-
-        template <typename RandomAccessIterator>
-        inline BOOST_CXX14_CONSTEXPR typename iterator_difference<RandomAccessIterator>::type
-        distance_impl(
-            RandomAccessIterator first
-          , RandomAccessIterator last
-          , random_access_traversal_tag
-        )
-        {
-            return last - first;
-        }
     }
+    return n;
+}
 
-    namespace distance_adl_barrier {
+template< typename RandomAccessIterator >
-        template <typename SinglePassIterator>
+inline BOOST_CXX14_CONSTEXPR typename iterator_difference< RandomAccessIterator >::type
-        inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type
+distance_impl(RandomAccessIterator first, RandomAccessIterator last, random_access_traversal_tag)
-        distance(SinglePassIterator first, SinglePassIterator last)
+{
-        {
+    return last - first;
-            return detail::distance_impl(
+}
-                first, last, typename iterator_traversal<SinglePassIterator>::type()
-            );
-        }
-    }
 
-    using namespace distance_adl_barrier;
+} // namespace detail
+
+namespace distance_adl_barrier {
+
+template< typename SinglePassIterator >
+inline BOOST_CXX14_CONSTEXPR typename iterator_difference< SinglePassIterator >::type
+distance(SinglePassIterator first, SinglePassIterator last)
+{
+    return detail::distance_impl(first, last, typename iterator_traversal< SinglePassIterator >::type());
+}
+
+} // namespace distance_adl_barrier
+
+using namespace distance_adl_barrier;
 
 } // namespace iterators
 
-using iterators::distance;
+using namespace iterators::distance_adl_barrier;
 
 } // namespace boost
 

include/boost/iterator/enable_if_convertible.hpp

@@ -0,0 +1,84 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * https://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2025 Andrey Semashev
+ */
+
+#ifndef BOOST_ITERATOR_ENABLE_IF_CONVERTIBLE_HPP_INCLUDED_
+#define BOOST_ITERATOR_ENABLE_IF_CONVERTIBLE_HPP_INCLUDED_
+
+#include <type_traits>
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+//
+// Result type used in enable_if_convertible meta function.
+// This can be an incomplete type, as only pointers to
+// enable_if_convertible< ... >::type are used.
+// We could have used void for this, but conversion to
+// void* is just too easy.
+//
+struct enable_type;
+
+} // namespace detail
+
+//
+// enable_if for use in adapted iterators constructors.
+//
+// In order to provide interoperability between adapted constant and
+// mutable iterators, adapted iterators will usually provide templated
+// conversion constructors of the following form
+//
+// template <class BaseIterator>
+// class adapted_iterator :
+//   public iterator_adaptor< adapted_iterator<Iterator>, Iterator >
+// {
+// public:
+//
+//   ...
+//
+//   template <class OtherIterator>
+//   adapted_iterator(
+//       OtherIterator const& it
+//     , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0);
+//
+//   ...
+// };
+//
+// enable_if_convertible is used to remove those overloads from the overload
+// set that cannot be instantiated. For all practical purposes only overloads
+// for constant/mutable interaction will remain. This has the advantage that
+// meta functions like boost::is_convertible do not return false positives,
+// as they can only look at the signature of the conversion constructor
+// and not at the actual instantiation.
+//
+// enable_if_interoperable can be safely used in user code. It falls back to
+// always enabled for compilers that don't support enable_if or is_convertible.
+// There is no need for compiler specific workarounds in user code.
+//
+// The operators implementation relies on boost::is_convertible not returning
+// false positives for user/library defined iterator types. See comments
+// on operator implementation for consequences.
+//
+template< typename From, typename To >
+struct enable_if_convertible :
+    public std::enable_if<
+        std::is_convertible< From, To >::value,
+        boost::iterators::detail::enable_type
+    >
+{};
+
+template< typename From, typename To >
+using enable_if_convertible_t = typename enable_if_convertible< From, To >::type;
+
+} // namespace iterators
+
+using iterators::enable_if_convertible;
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_ENABLE_IF_CONVERTIBLE_HPP_INCLUDED_

include/boost/iterator/filter_iterator.hpp

@@ -7,124 +7,145 @@
 #ifndef BOOST_FILTER_ITERATOR_23022003THW_HPP
 #define BOOST_FILTER_ITERATOR_23022003THW_HPP
 
+#include <type_traits>
+
+#include <boost/core/use_default.hpp>
+#include <boost/core/empty_value.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/iterator/iterator_categories.hpp>
-
+#include <boost/iterator/enable_if_convertible.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <boost/static_assert.hpp>
 
 namespace boost {
 namespace iterators {
 
-  template <class Predicate, class Iterator>
+template< typename Predicate, typename Iterator >
-  class filter_iterator;
+class filter_iterator;
 
-  namespace detail
+namespace detail {
-  {
+
-    template <class Predicate, class Iterator>
+template< typename Predicate, typename Iterator >
-    struct filter_iterator_base
+using filter_iterator_base_t = iterator_adaptor<
+    filter_iterator< Predicate, Iterator >,
+    Iterator,
+    use_default,
+    typename std::conditional<
+        std::is_convertible<
+            iterator_traversal_t< Iterator >,
+            random_access_traversal_tag
+        >::value,
+        bidirectional_traversal_tag,
+        use_default
+    >::type
+>;
+
+} // namespace detail
+
+template< typename Predicate, typename Iterator >
+class filter_iterator :
+    public detail::filter_iterator_base_t< Predicate, Iterator >
+{
+    friend class iterator_core_access;
+
+    template< typename, typename >
+    friend class filter_iterator;
+
+private:
+    using super_t = detail::filter_iterator_base_t< Predicate, Iterator >;
+
+    // Storage class to leverage EBO, when possible
+    struct storage :
+        private boost::empty_value< Predicate >
     {
-        typedef iterator_adaptor<
+        using predicate_base = boost::empty_value< Predicate >;
-            filter_iterator<Predicate, Iterator>
+
-          , Iterator
+        Iterator m_end;
-          , use_default
+
-          , typename mpl::if_<
+        storage() = default;
-                is_convertible<
+
-                    typename iterator_traversal<Iterator>::type
+        template<
-                  , random_access_traversal_tag
+            typename Iter,
-                >
+            typename = typename std::enable_if<
-              , bidirectional_traversal_tag
+                !std::is_same<
-              , use_default
+                    typename std::remove_cv< typename std::remove_reference< Iter >::type >::type,
-            >::type
+                    storage
-        > type;
+                >::value
+            >
+        >
+        explicit storage(Iter&& end) :
+            predicate_base(boost::empty_init_t{}), m_end(static_cast< Iterator&& >(end))
+        {
+        }
+
+        template< typename Pred, typename Iter >
+        storage(Pred&& pred, Iter&& end) :
+            predicate_base(boost::empty_init_t{}, static_cast< Pred&& >(pred)), m_end(static_cast< Iter&& >(end))
+        {
+        }
+
+        Predicate& predicate() noexcept { return predicate_base::get(); }
+        Predicate const& predicate() const noexcept { return predicate_base::get(); }
     };
-  }
 
-  template <class Predicate, class Iterator>
+public:
-  class filter_iterator
+    filter_iterator() = default;
-    : public detail::filter_iterator_base<Predicate, Iterator>::type
-  {
-      typedef typename detail::filter_iterator_base<
-          Predicate, Iterator
-      >::type super_t;
 
-      friend class iterator_core_access;
+    filter_iterator(Predicate f, Iterator x, Iterator end = Iterator()) :
+        super_t(static_cast< Iterator&& >(x)), m_storage(static_cast< Predicate&& >(f), static_cast< Iterator&& >(end))
+    {
+        satisfy_predicate();
+    }
 
-   public:
+    template< bool Requires = std::is_class< Predicate >::value, typename = typename std::enable_if< Requires >::type >
-      filter_iterator() { }
+    filter_iterator(Iterator x, Iterator end = Iterator()) :
+        super_t(static_cast< Iterator&& >(x)), m_storage(static_cast< Iterator&& >(end))
+    {
+        satisfy_predicate();
+    }
 
-      filter_iterator(Predicate f, Iterator x, Iterator end_ = Iterator())
+    template< typename OtherIterator, typename = enable_if_convertible_t< OtherIterator, Iterator > >
-          : super_t(x), m_predicate(f), m_end(end_)
+    filter_iterator(filter_iterator< Predicate, OtherIterator > const& t) :
-      {
+        super_t(t.base()), m_storage(t.m_storage.predicate(), t.m_storage.m_end)
-          satisfy_predicate();
+    {}
-      }
 
-      filter_iterator(Iterator x, Iterator end_ = Iterator())
+    Predicate predicate() const { return m_storage.predicate(); }
-        : super_t(x), m_predicate(), m_end(end_)
+    Iterator end() const { return m_storage.m_end; }
-      {
-        // Pro8 is a little too aggressive about instantiating the
-        // body of this function.
-#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-          // Don't allow use of this constructor if Predicate is a
-          // function pointer type, since it will be 0.
-          BOOST_STATIC_ASSERT(is_class<Predicate>::value);
-#endif
-          satisfy_predicate();
-      }
 
-      template<class OtherIterator>
+private:
-      filter_iterator(
+    void increment()
-          filter_iterator<Predicate, OtherIterator> const& t
+    {
-          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
+        ++(this->base_reference());
-          )
+        satisfy_predicate();
-          : super_t(t.base()), m_predicate(t.predicate()), m_end(t.end()) {}
+    }
 
-      Predicate predicate() const { return m_predicate; }
+    void decrement()
+    {
+        while (!m_storage.predicate()(*--(this->base_reference()))) {}
+    }
 
-      Iterator end() const { return m_end; }
+    void satisfy_predicate()
+    {
+        while (this->base() != m_storage.m_end && !m_storage.predicate()(*this->base()))
+            ++(this->base_reference());
+    }
 
-   private:
+private:
-      void increment()
+    storage m_storage;
-      {
+};
-          ++(this->base_reference());
-          satisfy_predicate();
-      }
 
-      void decrement()
+template< typename Predicate, typename Iterator >
-      {
+inline filter_iterator< Predicate, Iterator > make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator())
-        while(!this->m_predicate(*--(this->base_reference()))){};
+{
-      }
+    return filter_iterator< Predicate, Iterator >(static_cast< Predicate&& >(f), static_cast< Iterator&& >(x), static_cast< Iterator&& >(end));
+}
 
-      void satisfy_predicate()
+template< typename Predicate, typename Iterator >
-      {
+inline typename std::enable_if<
-          while (this->base() != this->m_end && !this->m_predicate(*this->base()))
+    std::is_class< Predicate >::value,
-              ++(this->base_reference());
+    filter_iterator< Predicate, Iterator >
-      }
+>::type make_filter_iterator(Iterator x, Iterator end = Iterator())
-
+{
-      // Probably should be the initial base class so it can be
+    return filter_iterator< Predicate, Iterator >(static_cast< Iterator&& >(x), static_cast< Iterator&& >(end));
-      // optimized away via EBO if it is an empty class.
+}
-      Predicate m_predicate;
-      Iterator m_end;
-  };
-
-  template <class Predicate, class Iterator>
-  inline filter_iterator<Predicate,Iterator>
-  make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator())
-  {
-      return filter_iterator<Predicate,Iterator>(f,x,end);
-  }
-
-  template <class Predicate, class Iterator>
-  inline filter_iterator<Predicate,Iterator>
-  make_filter_iterator(
-      typename iterators::enable_if<
-          is_class<Predicate>
-        , Iterator
-      >::type x
-    , Iterator end = Iterator())
-  {
-      return filter_iterator<Predicate,Iterator>(x,end);
-  }
 
 } // namespace iterators
 

include/boost/iterator/function_input_iterator.hpp

@@ -6,159 +6,150 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef BOOST_FUNCTION_INPUT_ITERATOR
+#ifndef BOOST_ITERATOR_FUNCTION_INPUT_ITERATOR_HPP_INCLUDED_
-#define BOOST_FUNCTION_INPUT_ITERATOR
+#define BOOST_ITERATOR_FUNCTION_INPUT_ITERATOR_HPP_INCLUDED_
+
+#include <memory>
+#include <type_traits>
 
-#include <boost/config.hpp>
-#include <boost/assert.hpp>
-#include <boost/core/addressof.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/function_types/is_function_pointer.hpp>
-#include <boost/function_types/result_type.hpp>
 #include <boost/iterator/iterator_facade.hpp>
-#include <boost/none.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/iterator/detail/type_traits/conjunction.hpp>
 #include <boost/optional/optional.hpp>
-#include <boost/utility/result_of.hpp>
-
-#ifdef BOOST_RESULT_OF_USE_TR1
-#include <boost/type_traits/is_function.hpp>
-#endif
 
 namespace boost {
-
 namespace iterators {
 
-    namespace impl {
+template< typename Function, typename Input >
+class function_input_iterator;
 
-        // Computes the return type of an lvalue-call with an empty argument,
+namespace detail {
-        // i.e. decltype(declval<F&>()()). F should be a nullary lvalue-callable
-        // or function.
-        template <class F>
-        struct result_of_nullary_lvalue_call
-        {
-            typedef typename result_of<
-#ifdef BOOST_RESULT_OF_USE_TR1
-                typename mpl::if_<is_function<F>, F&, F>::type()
-#else
-                F&()
-#endif
-            >::type type;
-        };
 
-        template <class Function, class Input>
+template< typename Function, typename Input >
-        class function_input_iterator
+using function_input_iterator_facade_base_t = iterator_facade<
-            : public iterator_facade<
+    iterators::function_input_iterator< Function, Input >,
-            function_input_iterator<Function, Input>,
+    decltype(std::declval< Function& >()()),
-            typename result_of_nullary_lvalue_call<Function>::type,
+    single_pass_traversal_tag,
-            single_pass_traversal_tag,
+    decltype(std::declval< Function& >()()) const&
-            typename result_of_nullary_lvalue_call<Function>::type const &
+>;
-            >
-        {
-        public:
-            function_input_iterator() {}
-            function_input_iterator(Function & f_, Input state_ = Input())
-                : f(boost::addressof(f_)), state(state_) {}
 
-            void increment() {
+template< typename Function, typename Input >
-                if(value)
+class function_object_input_iterator :
-                    value = none;
+    public function_input_iterator_facade_base_t< Function, Input >
-                else
+{
-                    (*f)();
+private:
-                ++state;
+    using base_type = function_input_iterator_facade_base_t< Function, Input >;
-            }
 
-            typename result_of_nullary_lvalue_call<Function>::type const &
+protected:
-                dereference() const {
+    using function_arg_type = Function&;
-                    return (value ? value : value = (*f)()).get();
-            }
 
-            bool equal(function_input_iterator const & other) const {
+public:
-                return f == other.f && state == other.state;
+    using value_type = typename base_type::value_type;
-            }
 
-        private:
+public:
-            Function * f;
+    function_object_input_iterator(function_arg_type f, Input state) :
-            Input state;
+        m_f(std::addressof(f)), m_state(state)
-            mutable optional<typename result_of_nullary_lvalue_call<Function>::type> value;
+    {}
-        };
 
-        template <class Function, class Input>
+protected:
-        class function_pointer_input_iterator
+    typename std::add_pointer< Function >::type m_f;
-            : public iterator_facade<
+    Input m_state;
-            function_pointer_input_iterator<Function, Input>,
+    mutable optional< value_type > m_value;
-            typename function_types::result_type<Function>::type,
+};
-            single_pass_traversal_tag,
-            typename function_types::result_type<Function>::type const &
-            >
-        {
-        public:
-            function_pointer_input_iterator() {}
-            function_pointer_input_iterator(Function &f_, Input state_ = Input())
-                : f(f_), state(state_) {}
 
-            void increment() {
+template< typename Function, typename Input >
-                if(value)
+class function_pointer_input_iterator :
-                    value = none;
+    public function_input_iterator_facade_base_t< Function, Input >
-                else
+{
-                    (*f)();
+private:
-                ++state;
+    using base_type = function_input_iterator_facade_base_t< Function, Input >;
-            }
 
-            typename function_types::result_type<Function>::type const &
+protected:
-                dereference() const {
+    using function_arg_type = Function;
-                    return (value ? value : value = (*f)()).get();
-            }
 
-            bool equal(function_pointer_input_iterator const & other) const {
+public:
-                return f == other.f && state == other.state;
+    using value_type = typename base_type::value_type;
-            }
 
-        private:
+public:
-            Function f;
+    function_pointer_input_iterator(function_arg_type f, Input state) :
-            Input state;
+        m_f(f), m_state(state)
-            mutable optional<typename function_types::result_type<Function>::type> value;
+    {}
-        };
 
-    } // namespace impl
+protected:
+    Function m_f;
+    Input m_state;
+    mutable optional< value_type > m_value;
+};
 
-    template <class Function, class Input>
+template< typename Function, typename Input >
-    class function_input_iterator
+using function_input_iterator_base_t = typename std::conditional<
-        : public mpl::if_<
+    detail::conjunction<
-            function_types::is_function_pointer<Function>,
+        std::is_pointer< Function >,
-            impl::function_pointer_input_iterator<Function,Input>,
+        std::is_function< typename std::remove_pointer< Function >::type >
-            impl::function_input_iterator<Function,Input>
+    >::value,
-        >::type
+    detail::function_pointer_input_iterator< Function, Input >,
+    detail::function_object_input_iterator< Function, Input >
+>::type;
+
+} // namespace detail
+
+template< typename Function, typename Input >
+class function_input_iterator :
+    public detail::function_input_iterator_base_t< Function, Input >
+{
+private:
+    using base_type = detail::function_input_iterator_base_t< Function, Input >;
+    using function_arg_type = typename base_type::function_arg_type;
+
+public:
+    using reference = typename base_type::reference;
+
+public:
+    function_input_iterator(function_arg_type f, Input i) :
+        base_type(f, i)
+    {}
+
+    void increment()
     {
-        typedef typename mpl::if_<
+        if (this->m_value)
-            function_types::is_function_pointer<Function>,
+            this->m_value.reset();
-            impl::function_pointer_input_iterator<Function,Input>,
+        else
-            impl::function_input_iterator<Function,Input>
+            (*this->m_f)();
-        >::type base_type;
+        ++this->m_state;
-    public:
-        function_input_iterator(Function & f, Input i)
-            : base_type(f, i) {}
-    };
-
-    template <class Function, class Input>
-    inline function_input_iterator<Function, Input>
-        make_function_input_iterator(Function & f, Input state) {
-            typedef function_input_iterator<Function, Input> result_t;
-            return result_t(f, state);
     }
 
-    template <class Function, class Input>
+    reference dereference() const
-    inline function_input_iterator<Function*, Input>
+    {
-        make_function_input_iterator(Function * f, Input state) {
+        if (!this->m_value)
-            typedef function_input_iterator<Function*, Input> result_t;
+            this->m_value = (*this->m_f)();
-            return result_t(f, state);
+        return this->m_value.get();
     }
 
-    struct infinite {
+    bool equal(function_input_iterator const& other) const
-        infinite & operator++() { return *this; }
+    {
-        infinite & operator++(int) { return *this; }
+        return this->m_f == other.m_f && this->m_state == other.m_state;
-        bool operator==(infinite &) const { return false; };
+    }
-        bool operator==(infinite const &) const { return false; };
+};
-    };
+
+template< typename Function, typename Input >
+inline function_input_iterator< Function, Input > make_function_input_iterator(Function& f, Input state)
+{
+    return function_input_iterator< Function, Input >(f, state);
+}
+
+template< typename Function, typename Input >
+inline function_input_iterator< Function*, Input > make_function_input_iterator(Function* f, Input state)
+{
+    return function_input_iterator< Function*, Input >(f, state);
+}
+
+struct infinite
+{
+    infinite& operator++() { return *this; }
+    infinite& operator++(int) { return *this; }
+    bool operator==(infinite&) const { return false; };
+    bool operator==(infinite const&) const { return false; };
+};
 
 } // namespace iterators
 
@@ -168,5 +159,4 @@ using iterators::infinite;
 
 } // namespace boost
 
-#endif
+#endif // BOOST_ITERATOR_FUNCTION_INPUT_ITERATOR_HPP_INCLUDED_
-

include/boost/iterator/function_output_iterator.hpp

@@ -8,49 +8,76 @@
 // 27 Feb 2001   Jeremy Siek
 //      Initial checkin.
 
-#ifndef BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
+#ifndef BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP_INCLUDED_
-#define BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
+#define BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP_INCLUDED_
 
+#include <cstddef>
 #include <iterator>
+#include <type_traits>
 
 namespace boost {
 namespace iterators {
 
-  template <class UnaryFunction>
+template< typename UnaryFunction >
-  class function_output_iterator {
+class function_output_iterator
-    typedef function_output_iterator self;
+{
-  public:
+private:
-    typedef std::output_iterator_tag iterator_category;
+    class output_proxy
-    typedef void                value_type;
+    {
-    typedef void                difference_type;
+    public:
-    typedef void                pointer;
+        explicit output_proxy(UnaryFunction& f) noexcept :
-    typedef void                reference;
+            m_f(f)
+        {}
 
-    explicit function_output_iterator() {}
+        template< typename T >
+        typename std::enable_if<
+            !std::is_same< typename std::remove_cv< typename std::remove_reference< T >::type >::type, output_proxy >::value,
+            output_proxy const&
+        >::type operator=(T&& value) const
+        {
+            m_f(static_cast< T&& >(value));
+            return *this;
+        }
 
-    explicit function_output_iterator(const UnaryFunction& f)
+        output_proxy(output_proxy const& that) = default;
-      : m_f(f) {}
+        output_proxy& operator=(output_proxy const&) = delete;
 
-    struct output_proxy {
+    private:
-      output_proxy(UnaryFunction& f) : m_f(f) { }
+        UnaryFunction& m_f;
-      template <class T> output_proxy& operator=(const T& value) {
-        m_f(value);
-        return *this;
-      }
-      UnaryFunction& m_f;
     };
-    output_proxy operator*() { return output_proxy(m_f); }
-    self& operator++() { return *this; }
-    self& operator++(int) { return *this; }
-  private:
-    UnaryFunction m_f;
-  };
 
-  template <class UnaryFunction>
+public:
-  inline function_output_iterator<UnaryFunction>
+    using iterator_category = std::output_iterator_tag;
-  make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
+    using value_type = void;
-    return function_output_iterator<UnaryFunction>(f);
+    using difference_type = std::ptrdiff_t;
-  }
+    using pointer = void;
+    using reference = void;
+
+    template<
+        bool Requires = std::is_class< UnaryFunction >::value,
+        typename = typename std::enable_if< Requires >::type
+    >
+    function_output_iterator() :
+        m_f()
+    {}
+
+    explicit function_output_iterator(UnaryFunction const& f) :
+        m_f(f)
+    {}
+
+    output_proxy operator*() { return output_proxy(m_f); }
+    function_output_iterator& operator++() { return *this; }
+    function_output_iterator& operator++(int) { return *this; }
+
+private:
+    UnaryFunction m_f;
+};
+
+template< typename UnaryFunction >
+inline function_output_iterator< UnaryFunction > make_function_output_iterator(UnaryFunction const& f = UnaryFunction())
+{
+    return function_output_iterator< UnaryFunction >(f);
+}
 
 } // namespace iterators
 
@@ -59,4 +86,4 @@ using iterators::make_function_output_iterator;
 
 } // namespace boost
 
-#endif // BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
+#endif // BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP_INCLUDED_

include/boost/iterator/generator_iterator.hpp

@@ -0,0 +1,96 @@
+// (C) Copyright Jens Maurer 2001.
+// 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)
+//
+// Revision History:
+
+// 15 Nov 2001   Jens Maurer
+//      created.
+
+//  See http://www.boost.org/libs/utility/iterator_adaptors.htm for documentation.
+
+#ifndef BOOST_ITERATOR_GENERATOR_ITERATOR_HPP_INCLUDED_
+#define BOOST_ITERATOR_GENERATOR_ITERATOR_HPP_INCLUDED_
+
+#include <memory>
+#include <type_traits>
+
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+namespace boost {
+namespace iterators {
+
+template< typename Generator >
+class generator_iterator :
+    public iterator_facade<
+        generator_iterator< Generator >,
+        decltype(std::declval< Generator& >()()),
+        single_pass_traversal_tag,
+        decltype(std::declval< Generator& >()()) const&
+    >
+{
+    friend class iterator_core_access;
+
+private:
+    using super_t = iterator_facade<
+        generator_iterator< Generator >,
+        decltype(std::declval< Generator& >()()),
+        single_pass_traversal_tag,
+        decltype(std::declval< Generator& >()()) const&
+    >;
+
+public:
+    generator_iterator() :
+        m_g(nullptr),
+        m_value()
+    {}
+
+    generator_iterator(Generator* g) :
+        m_g(g),
+        m_value((*m_g)())
+    {}
+
+private:
+    void increment()
+    {
+        m_value = (*m_g)();
+    }
+
+    typename super_t::reference dereference() const
+    {
+        return m_value;
+    }
+
+    bool equal(generator_iterator const& y) const
+    {
+        return m_g == y.m_g && m_value == y.m_value;
+    }
+
+private:
+    Generator* m_g;
+    typename Generator::result_type m_value;
+};
+
+template< typename Generator >
+struct generator_iterator_generator
+{
+    using type = generator_iterator< Generator >;
+};
+
+template< typename Generator >
+inline generator_iterator< Generator > make_generator_iterator(Generator& gen)
+{
+    return generator_iterator< Generator >(std::addressof(gen));
+}
+
+} // namespace iterators
+
+using iterators::generator_iterator;
+using iterators::generator_iterator_generator;
+using iterators::make_generator_iterator;
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_GENERATOR_ITERATOR_HPP_INCLUDED_

include/boost/iterator/indirect_iterator.hpp

@@ -7,131 +7,109 @@
 #ifndef BOOST_INDIRECT_ITERATOR_23022003THW_HPP
 #define BOOST_INDIRECT_ITERATOR_23022003THW_HPP
 
+#include <iterator>
+#include <type_traits>
+
 #include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/enable_if_convertible.hpp>
+#include <boost/iterator/detail/eval_if_default.hpp>
 
 #include <boost/pointee.hpp>
 #include <boost/indirect_reference.hpp>
 
-#include <boost/detail/indirect_traits.hpp>
+#include <boost/core/use_default.hpp>
-
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/add_reference.hpp>
-
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/has_xxx.hpp>
-
-#include <iterator>
-
-#ifdef BOOST_MPL_CFG_NO_HAS_XXX
-# include <boost/shared_ptr.hpp>
-# include <boost/scoped_ptr.hpp>
-# include <boost/mpl/bool.hpp>
-# include <memory>
-#endif
-
-#include <boost/iterator/detail/config_def.hpp> // must be last #include
 
 namespace boost {
 namespace iterators {
 
-  template <class Iter, class Value, class Category, class Reference, class Difference>
+template< typename Iter, typename Value, typename Category, typename Reference, typename Difference >
-  class indirect_iterator;
+class indirect_iterator;
 
-  namespace detail
+namespace detail {
-  {
-    template <class Iter, class Value, class Category, class Reference, class Difference>
-    struct indirect_base
-    {
-        typedef typename std::iterator_traits<Iter>::value_type dereferenceable;
 
-        typedef iterator_adaptor<
+template< typename Iter, typename Value, typename Category, typename Reference, typename Difference >
-            indirect_iterator<Iter, Value, Category, Reference, Difference>
+struct indirect_base
-          , Iter
+{
-          , typename ia_dflt_help<
+    using dereferenceable = typename std::iterator_traits< Iter >::value_type;
-                Value, pointee<dereferenceable>
-            >::type
-          , Category
-          , typename ia_dflt_help<
-                Reference
-              , mpl::eval_if<
-                    is_same<Value,use_default>
-                  , indirect_reference<dereferenceable>
-                  , add_reference<Value>
-                >
-            >::type
-          , Difference
-        > type;
-    };
 
-    template <>
+    using type = iterator_adaptor<
-    struct indirect_base<int, int, int, int, int> {};
+        indirect_iterator< Iter, Value, Category, Reference, Difference >,
-  } // namespace detail
+        Iter,
+        detail::eval_if_default_t<
+            Value,
+            pointee< dereferenceable >
+        >,
+        Category,
+        detail::eval_if_default_t<
+            Reference,
+            detail::eval_if_default<
+                Value,
+                indirect_reference< dereferenceable >,
+                std::add_lvalue_reference< Value >
+            >
+        >,
+        Difference
+    >;
+};
+
+} // namespace detail
 
 
-  template <
+template<
-      class Iterator
+    typename Iterator,
-    , class Value = use_default
+    typename Value = use_default,
-    , class Category = use_default
+    typename Category = use_default,
-    , class Reference = use_default
+    typename Reference = use_default,
-    , class Difference = use_default
+    typename Difference = use_default
-  >
+>
-  class indirect_iterator
+class indirect_iterator :
-    : public detail::indirect_base<
+    public detail::indirect_base<
         Iterator, Value, Category, Reference, Difference
-      >::type
+    >::type
-  {
+{
-      typedef typename detail::indirect_base<
+    using super_t = typename detail::indirect_base<
-          Iterator, Value, Category, Reference, Difference
+        Iterator, Value, Category, Reference, Difference
-      >::type super_t;
+    >::type;
 
-      friend class iterator_core_access;
+    friend class iterator_core_access;
 
-   public:
+public:
-      indirect_iterator() {}
+    indirect_iterator() = default;
 
-      indirect_iterator(Iterator iter)
+    indirect_iterator(Iterator iter) :
-        : super_t(iter) {}
+        super_t(iter)
+    {}
 
-      template <
+    template<
-          class Iterator2, class Value2, class Category2
+        typename Iterator2,
-        , class Reference2, class Difference2
+        typename Value2,
-      >
+        typename Category2,
-      indirect_iterator(
+        typename Reference2,
-          indirect_iterator<
+        typename Difference2,
-               Iterator2, Value2, Category2, Reference2, Difference2
+        typename = enable_if_convertible_t< Iterator2, Iterator >
-          > const& y
+    >
-        , typename enable_if_convertible<Iterator2, Iterator>::type* = 0
+    indirect_iterator(indirect_iterator< Iterator2, Value2, Category2, Reference2, Difference2 > const& y) :
-      )
+        super_t(y.base())
-        : super_t(y.base())
+    {}
-      {}
 
-  private:
+private:
-      typename super_t::reference dereference() const
+    typename super_t::reference dereference() const
-      {
+    {
-# if BOOST_WORKAROUND(__BORLANDC__, < 0x5A0 )
+        return **this->base();
-          return const_cast<super_t::reference>(**this->base());
+    }
-# else
+};
-          return **this->base();
-# endif
-      }
-  };
 
-  template <class Iter>
+template< typename Iter >
-  inline
+inline indirect_iterator< Iter > make_indirect_iterator(Iter x)
-  indirect_iterator<Iter> make_indirect_iterator(Iter x)
+{
-  {
+    return indirect_iterator< Iter >(x);
-    return indirect_iterator<Iter>(x);
+}
-  }
 
-  template <class Traits, class Iter>
+template< typename Value, typename Iter >
-  inline
+inline indirect_iterator< Iter, Value > make_indirect_iterator(Iter x)
-  indirect_iterator<Iter,Traits> make_indirect_iterator(Iter x, Traits* = 0)
+{
-  {
+    return indirect_iterator< Iter, Value >(x);
-    return indirect_iterator<Iter, Traits>(x);
+}
-  }
 
 } // namespace iterators
 
@@ -140,6 +118,4 @@ using iterators::make_indirect_iterator;
 
 } // namespace boost
 
-#include <boost/iterator/detail/config_undef.hpp>
-
 #endif // BOOST_INDIRECT_ITERATOR_23022003THW_HPP

include/boost/iterator/interoperable.hpp

@@ -5,43 +5,33 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 #ifndef BOOST_INTEROPERABLE_23022003THW_HPP
-# define BOOST_INTEROPERABLE_23022003THW_HPP
+#define BOOST_INTEROPERABLE_23022003THW_HPP
 
-# include <boost/mpl/bool.hpp>
+#include <type_traits>
-# include <boost/mpl/or.hpp>
+#include <boost/iterator/detail/type_traits/disjunction.hpp>
-
-# include <boost/type_traits/is_convertible.hpp>
-
-# include <boost/iterator/detail/config_def.hpp> // must appear last
 
 namespace boost {
 namespace iterators {
 
-  //
+//
-  // Meta function that determines whether two
+// Meta function that determines whether two
-  // iterator types are considered interoperable.
+// iterator types are considered interoperable.
-  //
+//
-  // Two iterator types A,B are considered interoperable if either
+// Two iterator types A,B are considered interoperable if either
-  // A is convertible to B or vice versa.
+// A is convertible to B or vice versa.
-  // This interoperability definition is in sync with the
+// This interoperability definition is in sync with the
-  // standards requirements on constant/mutable container
+// standards requirements on constant/mutable container
-  // iterators (23.1 [lib.container.requirements]).
+// iterators (23.1 [lib.container.requirements]).
-  //
+//
-  // For compilers that don't support is_convertible
+// For compilers that don't support is_convertible
-  // is_interoperable gives false positives. See comments
+// is_interoperable gives false positives. See comments
-  // on operator implementation for consequences.
+// on operator implementation for consequences.
-  //
+//
-  template <typename A, typename B>
+template< typename A, typename B >
-  struct is_interoperable
+struct is_interoperable :
-# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+    public detail::disjunction< std::is_convertible< A, B >, std::is_convertible< B, A > >
-    : mpl::true_
+{
-# else
+};
-    : mpl::or_<
-          is_convertible< A, B >
-        , is_convertible< B, A > >
-# endif
-  {
-  };
 
 } // namespace iterators
 
@@ -49,6 +39,4 @@ using iterators::is_interoperable;
 
 } // namespace boost
 
-# include <boost/iterator/detail/config_undef.hpp>
-
 #endif // BOOST_INTEROPERABLE_23022003THW_HPP

include/boost/iterator/is_iterator.hpp

@@ -0,0 +1,148 @@
+/*
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * https://www.boost.org/LICENSE_1_0.txt)
+ *
+ * Copyright (c) 2023 Andrey Semashev
+ */
+/*!
+ * \file iterator/is_iterator.hpp
+ *
+ * This header contains definition of the \c is_iterator type trait.
+ */
+
+#ifndef BOOST_ITERATOR_IS_ITERATOR_HPP_INCLUDED_
+#define BOOST_ITERATOR_IS_ITERATOR_HPP_INCLUDED_
+
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/type_traits/is_complete.hpp>
+#include <boost/iterator/detail/type_traits/conjunction.hpp>
+#include <boost/iterator/detail/type_traits/negation.hpp>
+#if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
+#include <iterator>
+#endif
+
+#include <type_traits>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+// The trait attempts to detect if the T type is an iterator class. Class-type iterators are assumed
+// to have the nested type iterator_category. Strictly speaking, this is not required to be the
+// case (e.g. a user can specialize iterator_traits for T without defining T::iterator_category).
+// Still, this is a good heuristic in practice, and we can't do anything better anyway.
+// Since C++17 we can test for iterator_traits<T>::iterator_category presence instead as it is
+// required to be only present for iterators.
+namespace has_iterator_category_detail {
+
+typedef char yes_type;
+struct no_type { char padding[2]; };
+
+template< typename T >
+yes_type check(
+#if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
+    typename std::iterator_traits< T >::iterator_category*
+#else
+    typename T::iterator_category*
+#endif
+);
+template< typename >
+no_type check(...);
+
+} // namespace has_iterator_category_detail
+
+template< typename T >
+struct is_iterator_impl :
+    public std::integral_constant<
+        bool,
+        sizeof(has_iterator_category_detail::check<T>(0)) == sizeof(has_iterator_category_detail::yes_type)
+    >
+{
+};
+
+template< typename T >
+struct is_iterator_impl< T* > :
+    public conjunction<
+        boost::is_complete<T>,
+        negation< std::is_function< T > >
+    >::type
+{
+};
+
+template< typename T, typename U >
+struct is_iterator_impl< T U::* > :
+    public std::false_type
+{
+};
+
+template< typename T >
+struct is_iterator_impl<T&> :
+    public std::false_type
+{
+};
+
+template< typename T, std::size_t N >
+struct is_iterator_impl< T[N] > :
+    public std::false_type
+{
+};
+
+#if !defined(BOOST_TT_HAS_WORKING_IS_COMPLETE)
+template< typename T >
+struct is_iterator_impl< T[] > :
+    public std::false_type
+{
+};
+
+template< >
+struct is_iterator_impl< void > :
+    public std::false_type
+{
+};
+
+template< >
+struct is_iterator_impl< void* > :
+    public std::false_type
+{
+};
+#endif // !defined(BOOST_TT_HAS_WORKING_IS_COMPLETE)
+
+} // namespace detail
+
+/*!
+ * \brief The type trait detects whether the type \c T is an iterator type.
+ *
+ * The type trait yields \c true if its argument type \c T, after stripping top level
+ * cv qualifiers, is one of the following:
+ *
+ * - A pointer type, other than a pointer to function, a pointer to a class member,
+ *   or a pointer to an incomplete type, including `void`.
+ * - A class type for which an iterator category is obtainable. Prior to C++17,
+ *   the iterator category must be defined as a public `T::iterator_category` type.
+ *   Since C++17, the expression `std::iterator_traits< T >::iterator_category` must
+ *   be valid and produce the iterator category type.
+ *
+ * Otherwise, the type trait yields \c false.
+ */
+template< typename T >
+struct is_iterator : public detail::is_iterator_impl< T >::type {};
+template< typename T >
+struct is_iterator< const T > : public detail::is_iterator_impl< T >::type {};
+template< typename T >
+struct is_iterator< volatile T > : public detail::is_iterator_impl< T >::type {};
+template< typename T >
+struct is_iterator< const volatile T > : public detail::is_iterator_impl< T >::type {};
+
+} // namespace iterators
+
+using iterators::is_iterator;
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_IS_ITERATOR_HPP_INCLUDED_

include/boost/iterator/is_lvalue_iterator.hpp

@@ -2,152 +2,73 @@
 // 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)
 #ifndef IS_LVALUE_ITERATOR_DWA2003112_HPP
-# define IS_LVALUE_ITERATOR_DWA2003112_HPP
+#define IS_LVALUE_ITERATOR_DWA2003112_HPP
 
-#include <boost/detail/workaround.hpp>
+#include <boost/iterator/detail/type_traits/conjunction.hpp>
-
-#include <boost/type_traits/add_lvalue_reference.hpp>
-#include <boost/iterator/detail/any_conversion_eater.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/aux_/lambda_support.hpp>
 
 #include <iterator>
-
+#include <type_traits>
-// should be the last #includes
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/iterator/detail/config_def.hpp>
-
-#ifndef BOOST_NO_IS_CONVERTIBLE
 
 namespace boost {
-
 namespace iterators {
+namespace detail {
 
-namespace detail
+// Guts of is_lvalue_iterator.  It is the iterator type and
+// Value is the iterator's value_type.
+template< typename It, typename Value >
+struct is_lvalue_iterator_impl :
+    public detail::conjunction<
+        std::is_convertible< decltype(*std::declval< It& >()), typename std::add_lvalue_reference< Value >::type >,
+        std::is_lvalue_reference< decltype(*std::declval< It& >()) >
+    >::type
 {
-#ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-  // Calling lvalue_preserver( <expression>, 0 ) returns a reference
-  // to the expression's result if <expression> is an lvalue, or
-  // not_an_lvalue() otherwise.
-  struct not_an_lvalue {};
-
-  template <class T>
-  T& lvalue_preserver(T&, int);
-
-  template <class U>
-  not_an_lvalue lvalue_preserver(U const&, ...);
-
-# define BOOST_LVALUE_PRESERVER(expr) detail::lvalue_preserver(expr,0)
-
-#else
-
-# define BOOST_LVALUE_PRESERVER(expr) expr
-
-#endif
-
-  // Guts of is_lvalue_iterator.  Value is the iterator's value_type
-  // and the result is computed in the nested rebind template.
-  template <class Value>
-  struct is_lvalue_iterator_impl
-  {
-      // Eat implicit conversions so we don't report true for things
-      // convertible to Value const&
-      struct conversion_eater
-      {
-          conversion_eater(typename add_lvalue_reference<Value>::type);
-      };
-
-      static char tester(conversion_eater, int);
-      static char (& tester(any_conversion_eater, ...) )[2];
-
-      template <class It>
-      struct rebind
-      {
-          static It& x;
-
-          BOOST_STATIC_CONSTANT(
-              bool
-            , value = (
-                sizeof(
-                    is_lvalue_iterator_impl<Value>::tester(
-                        BOOST_LVALUE_PRESERVER(*x), 0
-                    )
-                ) == 1
-            )
-          );
-      };
-  };
-
-#undef BOOST_LVALUE_PRESERVER
-
-  //
-  // void specializations to handle std input and output iterators
-  //
-  template <>
-  struct is_lvalue_iterator_impl<void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-  template <>
-  struct is_lvalue_iterator_impl<const void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-
-  template <>
-  struct is_lvalue_iterator_impl<volatile void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-
-  template <>
-  struct is_lvalue_iterator_impl<const volatile void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-#endif
-
-  //
-  // This level of dispatching is required for Borland.  We might save
-  // an instantiation by removing it for others.
-  //
-  template <class It>
-  struct is_readable_lvalue_iterator_impl
-    : is_lvalue_iterator_impl<
-          BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type const
-      >::template rebind<It>
-  {};
-
-  template <class It>
-  struct is_non_const_lvalue_iterator_impl
-    : is_lvalue_iterator_impl<
-          BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type
-      >::template rebind<It>
-  {};
-} // namespace detail
-
-template< typename T > struct is_lvalue_iterator
-: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_lvalue_iterator_impl<T>::value>
-{
-public:
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_lvalue_iterator,(T))
 };
 
-template< typename T > struct is_non_const_lvalue_iterator
+//
-: public ::boost::integral_constant<bool,::boost::iterators::detail::is_non_const_lvalue_iterator_impl<T>::value>
+// void specializations to handle std input and output iterators
+//
+template< typename It >
+struct is_lvalue_iterator_impl< It, void > :
+    public std::false_type
+{
+};
+
+template< typename It >
+struct is_lvalue_iterator_impl< It, const void > :
+    public std::false_type
+{
+};
+
+template< typename It >
+struct is_lvalue_iterator_impl< It, volatile void > :
+    public std::false_type
+{
+};
+
+template< typename It >
+struct is_lvalue_iterator_impl< It, const volatile void > :
+    public std::false_type
+{
+};
+
+} // namespace detail
+
+template< typename T >
+struct is_lvalue_iterator :
+    public iterators::detail::is_lvalue_iterator_impl<
+        T,
+        typename std::iterator_traits< T >::value_type const
+    >::type
+{
+};
+
+template< typename T >
+struct is_non_const_lvalue_iterator :
+    public iterators::detail::is_lvalue_iterator_impl<
+        T,
+        typename std::iterator_traits< T >::value_type
+    >::type
 {
-public:
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_non_const_lvalue_iterator,(T))
 };
 
 } // namespace iterators
@@ -157,8 +78,4 @@ using iterators::is_non_const_lvalue_iterator;
 
 } // namespace boost
 
-#endif
-
-#include <boost/iterator/detail/config_undef.hpp>
-
 #endif // IS_LVALUE_ITERATOR_DWA2003112_HPP

include/boost/iterator/is_readable_iterator.hpp

@@ -2,108 +2,62 @@
 // 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)
 #ifndef IS_READABLE_ITERATOR_DWA2003112_HPP
-# define IS_READABLE_ITERATOR_DWA2003112_HPP
+#define IS_READABLE_ITERATOR_DWA2003112_HPP
-
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/aux_/lambda_support.hpp>
-#include <boost/type_traits/add_lvalue_reference.hpp>
-
-#include <boost/iterator/detail/any_conversion_eater.hpp>
 
 #include <iterator>
-
+#include <type_traits>
-// should be the last #include
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/iterator/detail/config_def.hpp>
-
-#ifndef BOOST_NO_IS_CONVERTIBLE
 
 namespace boost {
-
 namespace iterators {
+namespace detail {
 
-namespace detail
+// Guts of is_readable_iterator.  It is the iterator type and
+// Value is the iterator's value_type.
+template< typename It, typename Value >
+struct is_readable_iterator_impl :
+    public std::is_convertible<
+        decltype(*std::declval< It& >()),
+        typename std::add_lvalue_reference< Value >::type
+    >
 {
-  // Guts of is_readable_iterator.  Value is the iterator's value_type
+};
-  // and the result is computed in the nested rebind template.
-  template <class Value>
-  struct is_readable_iterator_impl
-  {
-      static char tester(typename add_lvalue_reference<Value>::type, int);
-      static char (& tester(any_conversion_eater, ...) )[2];
 
-      template <class It>
+//
-      struct rebind
+// void specializations to handle std input and output iterators
-      {
+//
-          static It& x;
+template< typename It >
+struct is_readable_iterator_impl< It, void > :
+    public std::false_type
+{
+};
 
-          BOOST_STATIC_CONSTANT(
+template< typename It >
-              bool
+struct is_readable_iterator_impl< It, const void > :
-            , value = (
+    public std::false_type
-                sizeof(
+{
-                    is_readable_iterator_impl<Value>::tester(*x, 1)
+};
-                ) == 1
-            )
-          );
-      };
-  };
 
-#undef BOOST_READABLE_PRESERVER
+template< typename It >
+struct is_readable_iterator_impl< It, volatile void > :
+    public std::false_type
+{
+};
 
-  //
+template< typename It >
-  // void specializations to handle std input and output iterators
+struct is_readable_iterator_impl< It, const volatile void > :
-  //
+    public std::false_type
-  template <>
+{
-  struct is_readable_iterator_impl<void>
+};
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
 
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-  template <>
-  struct is_readable_iterator_impl<const void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-
-  template <>
-  struct is_readable_iterator_impl<volatile void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-
-  template <>
-  struct is_readable_iterator_impl<const volatile void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-#endif
-
-  //
-  // This level of dispatching is required for Borland.  We might save
-  // an instantiation by removing it for others.
-  //
-  template <class It>
-  struct is_readable_iterator_impl2
-    : is_readable_iterator_impl<
-          BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type const
-      >::template rebind<It>
-  {};
 } // namespace detail
 
-template< typename T > struct is_readable_iterator
+template< typename T >
-: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_iterator_impl2<T>::value>
+struct is_readable_iterator :
+    public iterators::detail::is_readable_iterator_impl<
+        T,
+        typename std::iterator_traits< T >::value_type const
+    >::type
 {
-public:
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_readable_iterator,(T))
 };
 
 } // namespace iterators
@@ -112,8 +66,4 @@ using iterators::is_readable_iterator;
 
 } // namespace boost
 
-#endif
-
-#include <boost/iterator/detail/config_undef.hpp>
-
 #endif // IS_READABLE_ITERATOR_DWA2003112_HPP

include/boost/iterator/iterator_adaptor.hpp

@@ -7,349 +7,202 @@
 #ifndef BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
 #define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
 
-#include <boost/static_assert.hpp>
+#include <type_traits>
+
+#include <boost/core/use_default.hpp>
 
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/iterator/iterator_facade.hpp>
-#include <boost/iterator/detail/enable_if.hpp>
-
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/or.hpp>
-
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-
-#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-# include <boost/type_traits/remove_reference.hpp>
-#endif
-
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/iterator/detail/config_def.hpp>
-
 #include <boost/iterator/iterator_traits.hpp>
+#include <boost/iterator/enable_if_convertible.hpp> // for backward compatibility; remove once downstream users are updated
+#include <boost/iterator/detail/eval_if_default.hpp>
+
+#include <boost/iterator/detail/config_def.hpp>
 
 namespace boost {
 namespace iterators {
 
-  // Used as a default template argument internally, merely to
+// Used as a default template argument internally, merely to
-  // indicate "use the default", this can also be passed by users
+// indicate "use the default", this can also be passed by users
-  // explicitly in order to specify that the default should be used.
+// explicitly in order to specify that the default should be used.
-  struct use_default;
+using boost::use_default;
 
-} // namespace iterators
+namespace detail {
 
-using iterators::use_default;
+// A metafunction which computes an iterator_adaptor's base class,
+// a specialization of iterator_facade.
+template<
+    typename Derived,
+    typename Base,
+    typename Value,
+    typename Traversal,
+    typename Reference,
+    typename Difference
+>
+using iterator_adaptor_base_t = iterator_facade<
+    Derived,
 
-// the incompleteness of use_default causes massive problems for
+#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-// is_convertible (naturally).  This workaround is fortunately not
+    detail::eval_if_default_t<
-// needed for vc6/vc7.
+        Value,
-template<class To>
+        detail::eval_if_default<
-struct is_convertible<use_default,To>
+            Reference,
-  : mpl::false_ {};
+            iterator_value< Base >,
-
+            std::remove_reference< Reference >
-namespace iterators {
-
-  namespace detail
-  {
-
-    //
-    // Result type used in enable_if_convertible meta function.
-    // This can be an incomplete type, as only pointers to
-    // enable_if_convertible< ... >::type are used.
-    // We could have used void for this, but conversion to
-    // void* is just to easy.
-    //
-    struct enable_type;
-  }
-
-
-  //
-  // enable_if for use in adapted iterators constructors.
-  //
-  // In order to provide interoperability between adapted constant and
-  // mutable iterators, adapted iterators will usually provide templated
-  // conversion constructors of the following form
-  //
-  // template <class BaseIterator>
-  // class adapted_iterator :
-  //   public iterator_adaptor< adapted_iterator<Iterator>, Iterator >
-  // {
-  // public:
-  //
-  //   ...
-  //
-  //   template <class OtherIterator>
-  //   adapted_iterator(
-  //       OtherIterator const& it
-  //     , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0);
-  //
-  //   ...
-  // };
-  //
-  // enable_if_convertible is used to remove those overloads from the overload
-  // set that cannot be instantiated. For all practical purposes only overloads
-  // for constant/mutable interaction will remain. This has the advantage that
-  // meta functions like boost::is_convertible do not return false positives,
-  // as they can only look at the signature of the conversion constructor
-  // and not at the actual instantiation.
-  //
-  // enable_if_interoperable can be safely used in user code. It falls back to
-  // always enabled for compilers that don't support enable_if or is_convertible.
-  // There is no need for compiler specific workarounds in user code.
-  //
-  // The operators implementation relies on boost::is_convertible not returning
-  // false positives for user/library defined iterator types. See comments
-  // on operator implementation for consequences.
-  //
-#  if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
-
-  template <class From, class To>
-  struct enable_if_convertible
-  {
-      typedef boost::iterators::detail::enable_type type;
-  };
-
-#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292))
-
-  // For some reason vc7.1 needs us to "cut off" instantiation
-  // of is_convertible in a few cases.
-  template<typename From, typename To>
-  struct enable_if_convertible
-    : iterators::enable_if<
-        mpl::or_<
-            is_same<From,To>
-          , is_convertible<From, To>
         >
-      , boost::iterators::detail::enable_type
+    >,
+#else
+    detail::eval_if_default_t<
+        Value,
+        iterator_value< Base >
+    >,
+#endif
+
+    detail::eval_if_default_t<
+        Traversal,
+        iterator_traversal< Base >
+    >,
+
+    detail::eval_if_default_t<
+        Reference,
+        detail::eval_if_default<
+            Value,
+            iterator_reference< Base >,
+            std::add_lvalue_reference< Value >
+        >
+    >,
+
+    detail::eval_if_default_t<
+        Difference,
+        iterator_difference< Base >
     >
-  {};
+>;
 
-#  else
+} // namespace detail
 
-  template<typename From, typename To>
+//
-  struct enable_if_convertible
+// Iterator Adaptor
-    : iterators::enable_if<
+//
-          is_convertible<From, To>
+// The parameter ordering changed slightly with respect to former
-        , boost::iterators::detail::enable_type
+// versions of iterator_adaptor The idea is that when the user needs
-      >
+// to fiddle with the reference type it is highly likely that the
-  {};
+// iterator category has to be adjusted as well.  Any of the
-
+// following four template arguments may be omitted or explicitly
-# endif
+// replaced by use_default.
-
+//
-  //
+//   Value - if supplied, the value_type of the resulting iterator, unless
-  // Default template argument handling for iterator_adaptor
+//      const. If const, a conforming compiler strips constness for the
-  //
+//      value_type. If not supplied, iterator_traits<Base>::value_type is used
-  namespace detail
+//
-  {
+//   Category - the traversal category of the resulting iterator. If not
-    // If T is use_default, return the result of invoking
+//      supplied, iterator_traversal<Base>::type is used.
-    // DefaultNullaryFn, otherwise return T.
+//
-    template <class T, class DefaultNullaryFn>
+//   Reference - the reference type of the resulting iterator, and in
-    struct ia_dflt_help
+//      particular, the result type of operator*(). If not supplied but
-      : mpl::eval_if<
+//      Value is supplied, Value& is used. Otherwise
-            is_same<T, use_default>
+//      iterator_traits<Base>::reference is used.
-          , DefaultNullaryFn
+//
-          , mpl::identity<T>
+//   Difference - the difference_type of the resulting iterator. If not
-        >
+//      supplied, iterator_traits<Base>::difference_type is used.
-    {
+//
-    };
+template<
-
+    typename Derived,
-    // A metafunction which computes an iterator_adaptor's base class,
+    typename Base,
-    // a specialization of iterator_facade.
+    typename Value        = use_default,
-    template <
+    typename Traversal    = use_default,
-        class Derived
+    typename Reference    = use_default,
-      , class Base
+    typename Difference   = use_default
-      , class Value
+>
-      , class Traversal
+class iterator_adaptor :
-      , class Reference
+    public detail::iterator_adaptor_base_t<
-      , class Difference
-    >
-    struct iterator_adaptor_base
-    {
-        typedef iterator_facade<
-            Derived
-
-# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-          , typename boost::iterators::detail::ia_dflt_help<
-                Value
-              , mpl::eval_if<
-                    is_same<Reference,use_default>
-                  , iterator_value<Base>
-                  , remove_reference<Reference>
-                >
-            >::type
-# else
-          , typename boost::iterators::detail::ia_dflt_help<
-                Value, iterator_value<Base>
-            >::type
-# endif
-
-          , typename boost::iterators::detail::ia_dflt_help<
-                Traversal
-              , iterator_traversal<Base>
-            >::type
-
-          , typename boost::iterators::detail::ia_dflt_help<
-                Reference
-              , mpl::eval_if<
-                    is_same<Value,use_default>
-                  , iterator_reference<Base>
-                  , add_reference<Value>
-                >
-            >::type
-
-          , typename boost::iterators::detail::ia_dflt_help<
-                Difference, iterator_difference<Base>
-            >::type
-        >
-        type;
-    };
-
-    // workaround for aC++ CR JAGaf33512
-    template <class Tr1, class Tr2>
-    inline void iterator_adaptor_assert_traversal ()
-    {
-      BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
-    }
-  }
-
-  //
-  // Iterator Adaptor
-  //
-  // The parameter ordering changed slightly with respect to former
-  // versions of iterator_adaptor The idea is that when the user needs
-  // to fiddle with the reference type it is highly likely that the
-  // iterator category has to be adjusted as well.  Any of the
-  // following four template arguments may be ommitted or explicitly
-  // replaced by use_default.
-  //
-  //   Value - if supplied, the value_type of the resulting iterator, unless
-  //      const. If const, a conforming compiler strips constness for the
-  //      value_type. If not supplied, iterator_traits<Base>::value_type is used
-  //
-  //   Category - the traversal category of the resulting iterator. If not
-  //      supplied, iterator_traversal<Base>::type is used.
-  //
-  //   Reference - the reference type of the resulting iterator, and in
-  //      particular, the result type of operator*(). If not supplied but
-  //      Value is supplied, Value& is used. Otherwise
-  //      iterator_traits<Base>::reference is used.
-  //
-  //   Difference - the difference_type of the resulting iterator. If not
-  //      supplied, iterator_traits<Base>::difference_type is used.
-  //
-  template <
-      class Derived
-    , class Base
-    , class Value        = use_default
-    , class Traversal    = use_default
-    , class Reference    = use_default
-    , class Difference   = use_default
-  >
-  class iterator_adaptor
-    : public boost::iterators::detail::iterator_adaptor_base<
         Derived, Base, Value, Traversal, Reference, Difference
-      >::type
+    >
-  {
+{
-      friend class iterator_core_access;
+    friend class iterator_core_access;
 
-   protected:
+protected:
-      typedef typename boost::iterators::detail::iterator_adaptor_base<
+    using super_t = detail::iterator_adaptor_base_t<
-          Derived, Base, Value, Traversal, Reference, Difference
+        Derived, Base, Value, Traversal, Reference, Difference
-      >::type super_t;
+    >;
-   public:
-      iterator_adaptor() {}
 
-      explicit iterator_adaptor(Base const &iter)
+public:
-          : m_iterator(iter)
+    using base_type = Base;
-      {
-      }
 
-      typedef Base base_type;
+    iterator_adaptor() = default;
 
-      Base const& base() const
+    explicit iterator_adaptor(Base const& iter) :
-        { return m_iterator; }
+        m_iterator(iter)
+    {
+    }
 
-   protected:
+    base_type const& base() const { return m_iterator; }
-      // for convenience in derived classes
-      typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;
 
-      //
+protected:
-      // lvalue access to the Base object for Derived
+    // for convenience in derived classes
-      //
+    using iterator_adaptor_ = iterator_adaptor< Derived, Base, Value, Traversal, Reference, Difference >;
-      Base const& base_reference() const
-        { return m_iterator; }
 
-      Base& base_reference()
+    //
-        { return m_iterator; }
+    // lvalue access to the Base object for Derived
+    //
+    Base& base_reference() { return m_iterator; }
+    Base const& base_reference() const { return m_iterator; }
 
-   private:
+private:
-      //
+    //
-      // Core iterator interface for iterator_facade.  This is private
+    // Core iterator interface for iterator_facade.  This is private
-      // to prevent temptation for Derived classes to use it, which
+    // to prevent temptation for Derived classes to use it, which
-      // will often result in an error.  Derived classes should use
+    // will often result in an error.  Derived classes should use
-      // base_reference(), above, to get direct access to m_iterator.
+    // base_reference(), above, to get direct access to m_iterator.
-      //
+    //
-      typename super_t::reference dereference() const
+    typename super_t::reference dereference() const { return *m_iterator; }
-        { return *m_iterator; }
 
-      template <
+    template< typename OtherDerived, typename OtherIterator, typename V, typename C, typename R, typename D >
-      class OtherDerived, class OtherIterator, class V, class C, class R, class D
+    bool equal(iterator_adaptor< OtherDerived, OtherIterator, V, C, R, D > const& x) const
-      >
+    {
-      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
-      {
         // Maybe readd with same_distance
         //           BOOST_STATIC_ASSERT(
         //               (detail::same_category_and_difference<Derived,OtherDerived>::value)
         //               );
-          return m_iterator == x.base();
+        return m_iterator == x.base();
-      }
+    }
 
-      typedef typename iterator_category_to_traversal<
+    using my_traversal = typename iterator_category_to_traversal< typename super_t::iterator_category >::type;
-          typename super_t::iterator_category
-      >::type my_traversal;
 
-# define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \
+    void advance(typename super_t::difference_type n)
-      boost::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, cat>();
+    {
+        static_assert(detail::is_traversal_at_least< my_traversal, random_access_traversal_tag >::value,
+            "Iterator must support random access traversal.");
+        m_iterator += n;
+    }
 
-      void advance(typename super_t::difference_type n)
+    void increment() { ++m_iterator; }
-      {
-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
-          m_iterator += n;
-      }
 
-      void increment() { ++m_iterator; }
+    void decrement()
+    {
+        static_assert(detail::is_traversal_at_least< my_traversal, bidirectional_traversal_tag >::value,
+            "Iterator must support bidirectional traversal.");
+        --m_iterator;
+    }
 
-      void decrement()
+    template< typename OtherDerived, typename OtherIterator, typename V, typename C, typename R, typename D >
-      {
+    typename super_t::difference_type distance_to(iterator_adaptor< OtherDerived, OtherIterator, V, C, R, D > const& y) const
-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag)
+    {
-           --m_iterator;
+        static_assert(detail::is_traversal_at_least< my_traversal, random_access_traversal_tag >::value,
-      }
+            "Super iterator must support random access traversal.");
+        // Maybe readd with same_distance
+        //           BOOST_STATIC_ASSERT(
+        //               (detail::same_category_and_difference<Derived,OtherDerived>::value)
+        //               );
+        return y.base() - m_iterator;
+    }
 
-      template <
+private: // data members
-          class OtherDerived, class OtherIterator, class V, class C, class R, class D
+    Base m_iterator;
-      >
+};
-      typename super_t::difference_type distance_to(
-          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
-      {
-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
-          // Maybe readd with same_distance
-          //           BOOST_STATIC_ASSERT(
-          //               (detail::same_category_and_difference<Derived,OtherDerived>::value)
-          //               );
-          return y.base() - m_iterator;
-      }
-
-# undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL
-
-   private: // data members
-      Base m_iterator;
-  };
 
 } // namespace iterators
 
 using iterators::iterator_adaptor;
-using iterators::enable_if_convertible;
 
 } // namespace boost
 

include/boost/iterator/iterator_archetypes.hpp

@@ -7,27 +7,14 @@
 #define BOOST_ITERATOR_ARCHETYPES_HPP
 
 #include <boost/iterator/iterator_categories.hpp>
-#include <boost/operators.hpp>
-#include <boost/static_assert.hpp>
-
 #include <boost/iterator/detail/facade_iterator_category.hpp>
 
-#include <boost/type_traits/is_const.hpp>
+#include <boost/operators.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-
 #include <boost/concept_archetype.hpp>
-
+#include <boost/mp11/utility.hpp>
-#include <boost/mpl/bitand.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/equal_to.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/identity.hpp>
 
 #include <cstddef>
+#include <type_traits>
 
 namespace boost {
 namespace iterators {
@@ -38,252 +25,253 @@ struct access_archetype;
 template <class Derived, class Value, class AccessCategory, class TraversalCategory>
 struct traversal_archetype;
 
-namespace archetypes
+namespace archetypes {
+
+enum
 {
-  enum {
+    readable_iterator_bit = 1,
-      readable_iterator_bit = 1
+    writable_iterator_bit = 2,
-    , writable_iterator_bit = 2
+    swappable_iterator_bit = 4,
-    , swappable_iterator_bit = 4
+    lvalue_iterator_bit = 8
-    , lvalue_iterator_bit = 8
+};
-  };
 
-  // Not quite tags, since dispatching wouldn't work.
+// Not quite tags, since dispatching wouldn't work.
-  typedef mpl::int_<readable_iterator_bit>::type readable_iterator_t;
+using readable_iterator_t = std::integral_constant<unsigned int, readable_iterator_bit>;
-  typedef mpl::int_<writable_iterator_bit>::type writable_iterator_t;
+using writable_iterator_t = std::integral_constant<unsigned int, writable_iterator_bit>;
 
-  typedef mpl::int_<
+using readable_writable_iterator_t = std::integral_constant<
-      (readable_iterator_bit|writable_iterator_bit)
+    unsigned int,
-          >::type readable_writable_iterator_t;
+    (readable_iterator_bit | writable_iterator_bit)
+>;
 
-  typedef mpl::int_<
+using readable_lvalue_iterator_t = std::integral_constant<
-      (readable_iterator_bit|lvalue_iterator_bit)
+    unsigned int,
-          >::type readable_lvalue_iterator_t;
+    (readable_iterator_bit | lvalue_iterator_bit)
+>;
 
-  typedef mpl::int_<
+using writable_lvalue_iterator_t = std::integral_constant<
-      (lvalue_iterator_bit|writable_iterator_bit)
+    unsigned int,
-          >::type writable_lvalue_iterator_t;
+    (lvalue_iterator_bit | writable_iterator_bit)
+>;
 
-  typedef mpl::int_<swappable_iterator_bit>::type swappable_iterator_t;
+using swappable_iterator_t = std::integral_constant<unsigned int, swappable_iterator_bit>;
-  typedef mpl::int_<lvalue_iterator_bit>::type lvalue_iterator_t;
+using lvalue_iterator_t = std::integral_constant<unsigned int, lvalue_iterator_bit>;
 
-  template <class Derived, class Base>
+template <class Derived, class Base>
-  struct has_access
+struct has_access :
-    : mpl::equal_to<
+    public std::integral_constant<bool, (Derived::value & Base::value) == Base::value>
-          mpl::bitand_<Derived,Base>
+{};
-        , Base
-      >
-  {};
-}
 
-namespace detail
+} // namespace archetypes
+
+namespace detail {
+
+template <class T>
+struct assign_proxy
 {
-  template <class T>
+    assign_proxy& operator=(T) { return *this; }
-  struct assign_proxy
+};
-  {
-      assign_proxy& operator=(T) { return *this; }
-  };
 
-  template <class T>
+template <class T>
-  struct read_proxy
+struct read_proxy
-  {
+{
-      operator T() { return static_object<T>::get(); }
+    operator T() { return static_object<T>::get(); }
-  };
+};
 
-  template <class T>
+template <class T>
-  struct read_write_proxy
+struct read_write_proxy :
-    : read_proxy<T> // Use to inherit from assign_proxy, but that doesn't work. -JGS
+    public read_proxy<T> // Used to inherit from assign_proxy, but that doesn't work. -JGS
-  {
+{
-      read_write_proxy& operator=(T) { return *this; }
+    read_write_proxy& operator=(T) { return *this; }
-  };
+};
 
-  template <class T>
+template <class T>
-  struct arrow_proxy
+struct arrow_proxy
-  {
+{
-      T const* operator->() const { return 0; }
+    T const* operator->() const { return 0; }
-  };
+};
 
-  struct no_operator_brackets {};
+struct no_operator_brackets {};
 
-  template <class ValueType>
+template <class ValueType>
-  struct readable_operator_brackets
+struct readable_operator_brackets
-  {
+{
-      read_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_proxy<ValueType>(); }
+    read_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_proxy<ValueType>(); }
-  };
+};
 
-  template <class ValueType>
+template <class ValueType>
-  struct writable_operator_brackets
+struct writable_operator_brackets
-  {
+{
-      read_write_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_write_proxy<ValueType>(); }
+    read_write_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_write_proxy<ValueType>(); }
-  };
+};
 
-  template <class Value, class AccessCategory, class TraversalCategory>
+template <class Value, class AccessCategory, class TraversalCategory>
-  struct operator_brackets
+struct operator_brackets :
-    : mpl::eval_if<
+    public mp11::mp_eval_if_c<
-          is_convertible<TraversalCategory, random_access_traversal_tag>
+        !std::is_convertible<TraversalCategory, random_access_traversal_tag>::value,
-        , mpl::eval_if<
+        no_operator_brackets,
-              archetypes::has_access<
+        mp11::mp_cond,
-                  AccessCategory
+            archetypes::has_access<AccessCategory, archetypes::writable_iterator_t>, writable_operator_brackets<Value>,
-                , archetypes::writable_iterator_t
+            archetypes::has_access<AccessCategory, archetypes::readable_iterator_t>, readable_operator_brackets<Value>,
-              >
+            std::true_type, no_operator_brackets
-            , mpl::identity<writable_operator_brackets<Value> >
+    >
-            , mpl::if_<
+{};
-                  archetypes::has_access<
-                      AccessCategory
-                    , archetypes::readable_iterator_t
-                  >
-                , readable_operator_brackets<Value>
-                , no_operator_brackets
-              >
-          >
-        , mpl::identity<no_operator_brackets>
-      >::type
-  {};
 
-  template <class TraversalCategory>
+template <class TraversalCategory>
-  struct traversal_archetype_impl
+struct traversal_archetype_impl
-  {
+{
-      template <class Derived,class Value> struct archetype;
+    template <class Derived,class Value> struct archetype;
-  };
+};
 
-  // Constructor argument for those iterators that
+// Constructor argument for those iterators that
-  // are not default constructible
+// are not default constructible
-  struct ctor_arg {};
+struct ctor_arg {};
 
-  template <class Derived, class Value, class TraversalCategory>
+template <class Derived, class Value, class TraversalCategory>
-  struct traversal_archetype_
+struct traversal_archetype_ :
-    : traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
+    public traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
-  {
+{
-      typedef typename
+    using base = typename traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>;
-        traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
-      base;
 
-      traversal_archetype_() {}
+    traversal_archetype_() {}
 
-      traversal_archetype_(ctor_arg arg)
+    traversal_archetype_(ctor_arg arg) : base(arg)
-        : base(arg)
+    {}
-      {}
+};
-  };
 
-  template <>
+template <>
-  struct traversal_archetype_impl<incrementable_traversal_tag>
+struct traversal_archetype_impl<incrementable_traversal_tag>
-  {
+{
-      template<class Derived, class Value>
+    template<class Derived, class Value>
-      struct archetype
+    struct archetype
-      {
+    {
-          explicit archetype(ctor_arg) {}
+        explicit archetype(ctor_arg) {}
 
-          struct bogus { }; // This use to be void, but that causes trouble for iterator_facade. Need more research. -JGS
+        struct bogus { }; // This used to be void, but that causes trouble for iterator_facade. Need more research. -JGS
-          typedef bogus difference_type;
+        using difference_type = bogus;
 
-          Derived& operator++() { return (Derived&)static_object<Derived>::get(); }
+        Derived& operator++() { return (Derived&)static_object<Derived>::get(); }
-          Derived  operator++(int) const { return (Derived&)static_object<Derived>::get(); }
+        Derived  operator++(int) const { return (Derived&)static_object<Derived>::get(); }
-      };
+    };
-  };
+};
 
-  template <>
+template <>
-  struct traversal_archetype_impl<single_pass_traversal_tag>
+struct traversal_archetype_impl<single_pass_traversal_tag>
-  {
+{
-      template<class Derived, class Value>
+    template<class Derived, class Value>
-      struct archetype
+    struct archetype :
-        : public equality_comparable< traversal_archetype_<Derived, Value, single_pass_traversal_tag> >,
+        public equality_comparable< traversal_archetype_<Derived, Value, single_pass_traversal_tag> >,
-          public traversal_archetype_<Derived, Value, incrementable_traversal_tag>
+        public traversal_archetype_<Derived, Value, incrementable_traversal_tag>
-      {
+    {
-          explicit archetype(ctor_arg arg)
+        explicit archetype(ctor_arg arg) :
-            : traversal_archetype_<Derived, Value, incrementable_traversal_tag>(arg)
+            traversal_archetype_<Derived, Value, incrementable_traversal_tag>(arg)
-          {}
+        {}
 
-          typedef std::ptrdiff_t difference_type;
+        using difference_type = std::ptrdiff_t;
-      };
+    };
-  };
+};
 
-  template <class Derived, class Value>
+template <class Derived, class Value>
-  bool operator==(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,
+bool operator==(
-                  traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }
+    traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,
+    traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }
 
-  template <>
+template <>
-  struct traversal_archetype_impl<forward_traversal_tag>
+struct traversal_archetype_impl<forward_traversal_tag>
-  {
+{
-      template<class Derived, class Value>
+    template<class Derived, class Value>
-      struct archetype
+    struct archetype :
-        : public traversal_archetype_<Derived, Value, single_pass_traversal_tag>
+        public traversal_archetype_<Derived, Value, single_pass_traversal_tag>
-      {
+    {
-          archetype()
+        archetype() :
-            : traversal_archetype_<Derived, Value, single_pass_traversal_tag>(ctor_arg())
+            traversal_archetype_<Derived, Value, single_pass_traversal_tag>(ctor_arg())
-          {}
+        {}
-      };
+    };
-  };
+};
 
-  template <>
+template <>
-  struct traversal_archetype_impl<bidirectional_traversal_tag>
+struct traversal_archetype_impl<bidirectional_traversal_tag>
-  {
+{
-      template<class Derived, class Value>
+    template<class Derived, class Value>
-      struct archetype
+    struct archetype :
-        : public traversal_archetype_<Derived, Value, forward_traversal_tag>
+        public traversal_archetype_<Derived, Value, forward_traversal_tag>
-      {
+    {
-          Derived& operator--() { return static_object<Derived>::get(); }
+        Derived& operator--() { return static_object<Derived>::get(); }
-          Derived  operator--(int) const { return static_object<Derived>::get(); }
+        Derived  operator--(int) const { return static_object<Derived>::get(); }
-      };
+    };
-  };
+};
 
-  template <>
+template <>
-  struct traversal_archetype_impl<random_access_traversal_tag>
+struct traversal_archetype_impl<random_access_traversal_tag>
-  {
+{
-      template<class Derived, class Value>
+    template<class Derived, class Value>
-      struct archetype
+    struct archetype :
-        : public traversal_archetype_<Derived, Value, bidirectional_traversal_tag>
+        public traversal_archetype_<Derived, Value, bidirectional_traversal_tag>
-      {
+    {
-          Derived& operator+=(std::ptrdiff_t) { return static_object<Derived>::get(); }
+        Derived& operator+=(std::ptrdiff_t) { return static_object<Derived>::get(); }
-          Derived& operator-=(std::ptrdiff_t) { return static_object<Derived>::get(); }
+        Derived& operator-=(std::ptrdiff_t) { return static_object<Derived>::get(); }
-      };
+    };
-  };
+};
 
-  template <class Derived, class Value>
+template <class Derived, class Value>
-  Derived& operator+(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+Derived& operator+(
-                     std::ptrdiff_t) { return static_object<Derived>::get(); }
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+    std::ptrdiff_t) { return static_object<Derived>::get(); }
 
-  template <class Derived, class Value>
+template <class Derived, class Value>
-  Derived& operator+(std::ptrdiff_t,
+Derived& operator+(
-                     traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+    std::ptrdiff_t,
-      { return static_object<Derived>::get(); }
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+    { return static_object<Derived>::get(); }
 
-  template <class Derived, class Value>
+template <class Derived, class Value>
-  Derived& operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+Derived& operator-(
-                     std::ptrdiff_t)
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-      { return static_object<Derived>::get(); }
+    std::ptrdiff_t) { return static_object<Derived>::get(); }
 
-  template <class Derived, class Value>
+template <class Derived, class Value>
-  std::ptrdiff_t operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+std::ptrdiff_t operator-(
-                           traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-      { return 0; }
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+    { return 0; }
 
-  template <class Derived, class Value>
+template <class Derived, class Value>
-  bool operator<(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+bool operator<(
-                 traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-      { return true; }
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+    { return true; }
 
-  template <class Derived, class Value>
+template <class Derived, class Value>
-  bool operator>(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+bool operator>(
-                 traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-      { return true; }
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+    { return true; }
 
-  template <class Derived, class Value>
+template <class Derived, class Value>
-  bool operator<=(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+bool operator<=(
-                 traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-      { return true; }
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+    { return true; }
 
-  template <class Derived, class Value>
+template <class Derived, class Value>
-  bool operator>=(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+bool operator>=(
-                 traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-      { return true; }
+    traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+    { return true; }
 
-  struct bogus_type;
+struct bogus_type;
 
-  template <class Value>
+template <class Value>
-  struct convertible_type
+struct convertible_type
-    : mpl::if_< is_const<Value>,
+{
-                typename remove_const<Value>::type,
+    using type = bogus_type;
-                bogus_type >
+};
-  {};
+
+template <class Value>
+struct convertible_type<const Value>
+{
+    using type = Value;
+};
 
 } // namespace detail
 
@@ -297,24 +285,20 @@ struct iterator_access_archetype_impl
 };
 
 template <class Value, class AccessCategory>
-struct iterator_access_archetype
+struct iterator_access_archetype :
-  : iterator_access_archetype_impl<
+    public iterator_access_archetype_impl<AccessCategory>::template archetype<Value>
-        AccessCategory
-    >::template archetype<Value>
 {
 };
 
 template <>
-struct iterator_access_archetype_impl<
+struct iterator_access_archetype_impl<archetypes::readable_iterator_t>
-    archetypes::readable_iterator_t
->
 {
     template <class Value>
     struct archetype
     {
-        typedef typename remove_cv<Value>::type value_type;
+        using value_type = typename std::remove_cv<Value>::type;
-        typedef Value                           reference;
+        using reference = Value;
-        typedef Value*                          pointer;
+        using pointer = Value*;
 
         value_type operator*() const { return static_object<value_type>::get(); }
 
@@ -323,34 +307,28 @@ struct iterator_access_archetype_impl<
 };
 
 template <>
-struct iterator_access_archetype_impl<
+struct iterator_access_archetype_impl<archetypes::writable_iterator_t>
-    archetypes::writable_iterator_t
->
 {
     template <class Value>
     struct archetype
     {
-        BOOST_STATIC_ASSERT(!is_const<Value>::value);
+        static_assert(!std::is_const<Value>::value, "Value type must not be const.");
-        typedef void value_type;
+        using value_type = void;
-        typedef void reference;
+        using reference = void;
-        typedef void pointer;
+        using pointer = void;
 
         detail::assign_proxy<Value> operator*() const { return detail::assign_proxy<Value>(); }
     };
 };
 
 template <>
-struct iterator_access_archetype_impl<
+struct iterator_access_archetype_impl<archetypes::readable_writable_iterator_t>
-    archetypes::readable_writable_iterator_t
->
 {
     template <class Value>
-    struct archetype
+    struct archetype :
-      : public virtual iterator_access_archetype<
+        public virtual iterator_access_archetype<Value, archetypes::readable_iterator_t>
-            Value, archetypes::readable_iterator_t
-        >
     {
-        typedef detail::read_write_proxy<Value>    reference;
+        using reference = detail::read_write_proxy<Value>;
 
         detail::read_write_proxy<Value> operator*() const { return detail::read_write_proxy<Value>(); }
     };
@@ -360,12 +338,10 @@ template <>
 struct iterator_access_archetype_impl<archetypes::readable_lvalue_iterator_t>
 {
     template <class Value>
-    struct archetype
+    struct archetype :
-      : public virtual iterator_access_archetype<
+        public virtual iterator_access_archetype<Value, archetypes::readable_iterator_t>
-            Value, archetypes::readable_iterator_t
-        >
     {
-        typedef Value&    reference;
+        using reference = Value&;
 
         Value& operator*() const { return static_object<Value>::get(); }
         Value* operator->() const { return 0; }
@@ -376,12 +352,10 @@ template <>
 struct iterator_access_archetype_impl<archetypes::writable_lvalue_iterator_t>
 {
     template <class Value>
-    struct archetype
+    struct archetype :
-      : public virtual iterator_access_archetype<
+        public virtual iterator_access_archetype<Value, archetypes::readable_lvalue_iterator_t>
-            Value, archetypes::readable_lvalue_iterator_t
-        >
     {
-        BOOST_STATIC_ASSERT((!is_const<Value>::value));
+        static_assert(!std::is_const<Value>::value, "Value type must not be const.");
     };
 };
 
@@ -390,57 +364,59 @@ template <class Value, class AccessCategory, class TraversalCategory>
 struct iterator_archetype;
 
 template <class Value, class AccessCategory, class TraversalCategory>
-struct traversal_archetype_base
+struct traversal_archetype_base :
-  : detail::operator_brackets<
+    public detail::operator_brackets<
-        typename remove_cv<Value>::type
+        typename std::remove_cv<Value>::type,
-      , AccessCategory
+        AccessCategory,
-      , TraversalCategory
+        TraversalCategory
-    >
+    >,
-  , detail::traversal_archetype_<
+    public detail::traversal_archetype_<
-        iterator_archetype<Value, AccessCategory, TraversalCategory>
+        iterator_archetype<Value, AccessCategory, TraversalCategory>,
-      , Value
+        Value,
-      , TraversalCategory
+        TraversalCategory
     >
 {
 };
 
-namespace detail
+namespace detail {
-{
-  template <class Value, class AccessCategory, class TraversalCategory>
-  struct iterator_archetype_base
-    : iterator_access_archetype<Value, AccessCategory>
-    , traversal_archetype_base<Value, AccessCategory, TraversalCategory>
-  {
-      typedef iterator_access_archetype<Value, AccessCategory> access;
-
-      typedef typename detail::facade_iterator_category<
-          TraversalCategory
-        , typename mpl::eval_if<
-              archetypes::has_access<
-                  AccessCategory, archetypes::writable_iterator_t
-              >
-            , remove_const<Value>
-            , add_const<Value>
-          >::type
-        , typename access::reference
-      >::type iterator_category;
-
-      // Needed for some broken libraries (see below)
-      typedef boost::iterator<
-          iterator_category
-        , Value
-        , typename traversal_archetype_base<
-              Value, AccessCategory, TraversalCategory
-          >::difference_type
-        , typename access::pointer
-        , typename access::reference
-      > workaround_iterator_base;
-  };
-}
 
 template <class Value, class AccessCategory, class TraversalCategory>
-struct iterator_archetype
+struct iterator_archetype_base :
-  : public detail::iterator_archetype_base<Value, AccessCategory, TraversalCategory>
+    public iterator_access_archetype<Value, AccessCategory>,
+    public traversal_archetype_base<Value, AccessCategory, TraversalCategory>
+{
+    using access = iterator_access_archetype<Value, AccessCategory>;
+
+    using iterator_category = typename detail::facade_iterator_category<
+        TraversalCategory,
+        typename std::conditional<
+            archetypes::has_access<
+                AccessCategory, archetypes::writable_iterator_t
+            >::value,
+            std::remove_const<Value>,
+            std::add_const<Value>
+        >::type::type,
+        typename access::reference
+    >::type;
+
+    // Needed for some broken libraries (see below)
+    struct workaround_iterator_base
+    {
+        using iterator_category = typename iterator_archetype_base::iterator_category;
+        using value_type = Value;
+        using difference_type = typename traversal_archetype_base<
+            Value, AccessCategory, TraversalCategory
+        >::difference_type;
+        using pointer = typename access::pointer;
+        using reference = typename access::reference;
+    };
+};
+
+} // namespace detail
+
+template <class Value, class AccessCategory, class TraversalCategory>
+struct iterator_archetype :
+    public detail::iterator_archetype_base<Value, AccessCategory, TraversalCategory>
 
     // These broken libraries require derivation from std::iterator
     // (or related magic) in order to handle iter_swap and other
@@ -458,28 +434,23 @@ struct iterator_archetype
 # if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310)           \
     || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101))
 
-    typedef detail::iterator_archetype_base<
+    using base = detail::iterator_archetype_base<
-        Value,AccessCategory,TraversalCategory
+        Value, AccessCategory, TraversalCategory
-    > base;
+    >;
 
-    typedef typename base::value_type value_type;
+    using value_type = typename base::value_type;
-    typedef typename base::reference reference;
+    using reference = typename base::reference;
-    typedef typename base::pointer pointer;
+    using pointer = typename base::pointer;
-    typedef typename base::difference_type difference_type;
+    using difference_type = typename base::difference_type;
-    typedef typename base::iterator_category iterator_category;
+    using iterator_category = typename base::iterator_category;
 # endif
 
     iterator_archetype() { }
-    iterator_archetype(iterator_archetype const& x)
+    iterator_archetype(iterator_archetype const& x) :
-      : detail::iterator_archetype_base<
+        detail::iterator_archetype_base<Value, AccessCategory, TraversalCategory>(x)
-            Value
-          , AccessCategory
-          , TraversalCategory
-        >(x)
     {}
 
-    iterator_archetype& operator=(iterator_archetype const&)
+    iterator_archetype& operator=(iterator_archetype const&) { return *this; }
-        { return *this; }
 
 # if 0
     // Optional conversion from mutable