Added a CMake test.

Fixes https://github.com/boostorg/iterator/issues/81.

.github/workflows/ci.yml

@@ -0,0 +1,508 @@
+# Copyright 2021-2022 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-4.6
+            cxxstd: "0x"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - g++-4.6
+            sources:
+              - "ppa:ubuntu-toolchain-r/test"
+          - toolset: gcc-4.7
+            cxxstd: "11"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - g++-4.7
+          - toolset: gcc-4.8
+            cxxstd: "11"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - g++-4.8
+          - toolset: gcc-4.9
+            cxxstd: "11"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - g++-4.9
+          - 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-20.04
+            install:
+              - g++-9
+          - toolset: gcc-10
+            cxxstd: "11,14,17,20"
+            os: 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
+          - name: UBSAN
+            toolset: gcc-11
+            cxxstd: "11,14,17,20,23"
+            ubsan: 1
+            build_variant: debug
+            os: ubuntu-22.04
+            install:
+              - g++-11
+
+          # 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-20.04
+            install:
+              - clang-9
+          - toolset: clang
+            compiler: clang++-10
+            cxxstd: "11,14,17,20"
+            os: ubuntu-20.04
+            install:
+              - clang-10
+          - toolset: clang
+            compiler: clang++-11
+            cxxstd: "11,14,17,20"
+            os: ubuntu-22.04
+            install:
+              - clang-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++-15
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-22.04
+            install:
+              - clang-15
+              - libc++-15-dev
+              - libc++abi-15-dev
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-22.04
+            install:
+              - clang-16
+            sources:
+              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-16 main"
+            source_keys:
+              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-22.04
+            install:
+              - clang-16
+              - libc++-16-dev
+              - libc++abi-16-dev
+            sources:
+              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-16 main"
+            source_keys:
+              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
+          - name: UBSAN
+            toolset: clang
+            compiler: clang++-15
+            cxxstd: "11,14,17,20,2b"
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
+            ubsan: 1
+            build_variant: debug
+            os: ubuntu-22.04
+            install:
+              - clang-15
+              - libc++-15-dev
+              - libc++abi-15-dev
+
+          - toolset: clang
+            cxxstd: "11,14,17,2a"
+            os: macos-11
+
+          - name: CMake tests
+            cmake_tests: 1
+            os: ubuntu-20.04
+
+    timeout-minutes: 60
+    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
+                    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
+
+      - uses: actions/checkout@v3
+
+      - 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
+            cd ..
+            git clone -b "$BOOST_BRANCH" --depth 1 "https://github.com/boostorg/boost.git" "boost-root"
+            cd boost-root
+            mkdir -p libs/$LIBRARY
+            cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+            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

CMakeLists.txt

@@ -0,0 +1,30 @@
+# 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::function_types
+        Boost::fusion
+        Boost::mpl
+        Boost::optional
+        Boost::smart_ptr
+        Boost::static_assert
+        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

@@ -0,0 +1,102 @@
+# 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)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+environment:
+  matrix:
+    - TOOLSET: msvc-12.0
+      ADDRMD: 32,64
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: msvc-14.0
+      CXXSTD: 14,latest
+      ADDRMD: 32,64
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: msvc-14.1
+      CXXSTD: 14,17,latest
+      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\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 init tools/build
+  - git submodule 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 --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%
+  - 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%

doc/Jamfile.v2

@@ -4,20 +4,24 @@
 
 using quickbook ;
 
-xml iterator 
-  : 
-    quickbook/iterator.qbk 
+xml iterator
+  :
+    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=4
-    <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/iterator/doc
+    <xsl:param>chunk.section.depth=2
+    <format>pdf:<xsl:param>"boost.url.prefix=http://www.boost.org/doc/libs/release/libs/iterator/doc/html"
   ;
 
-
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : standalone ;
+explicit boostrelease ;

doc/advance.rst

@@ -0,0 +1,75 @@
+.. Copyright (C) 2017 Michel Morin.
+   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)
+
+=======
+advance
+=======
+
+``boost::iterators::advance`` is an adapted version of ``std::advance`` for
+the Boost iterator traversal concepts.
+
+
+Header
+------
+
+``<boost/iterator/advance.hpp>``
+
+
+Synopsis
+--------
+
+::
+
+    template <typename Iterator, typename Distance>
+    constexpr void advance(Iterator& it, Distance n);
+
+
+Description
+-----------
+
+Moves ``it`` forward by ``n`` increments
+(or backward by ``|n|`` decrements if ``n`` is negative).
+
+
+Requirements
+------------
+
+``Iterator`` should model Incrementable Iterator.
+
+
+Preconditions
+-------------
+
+Let ``it``\ :sub:`i` be the iterator obtained by incrementing
+(or decrementing if ``n`` is negative) ``it`` by *i*. All the iterators
+``it``\ :sub:`i` for *i* = 0, 1, 2, ..., ``|n|`` should be valid.
+
+If ``Iterator`` does not model Bidirectional Traversal Iterator,
+``n`` should be non-negative.
+
+
+Complexity
+----------
+
+If ``Iterator`` models Random Access Traversal Iterator, it takes constant time;
+otherwise it takes linear time.
+
+
+Notes
+-----
+
+- This function is not a customization point and is protected against
+  being found by argument-dependent lookup (ADL).
+- This function is ``constexpr`` only in C++14 or later.
+
+
+--------------------------------------------------------------------------------
+
+| Author: Michel Morin
+| Copyright |C| 2017 Michel Morin
+| Distributed under the `Boost Software License, Version 1.0
+  <http://www.boost.org/LICENSE_1_0.txt>`_.
+
+.. |C| unicode:: U+00A9 .. COPYRIGHT SIGN

doc/distance.rst

@@ -0,0 +1,72 @@
+.. Copyright (C) 2017 Michel Morin.
+   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)
+
+========
+distance
+========
+
+``boost::iterators::distance`` is an adapted version of ``std::distance`` for 
+the Boost iterator traversal concepts.
+
+
+Header
+------
+
+``<boost/iterator/distance.hpp>``
+
+
+Synopsis
+--------
+
+::
+
+    template <typename Iterator>
+    constexpr typename iterator_difference<Iterator>::type
+    distance(Iterator first, Iterator last);
+
+
+Description
+-----------
+
+Computes the (signed) distance from ``first`` to ``last``.
+
+
+Requirements
+------------
+
+``Iterator`` should model Single Pass Iterator.
+
+
+Preconditions
+-------------
+
+If ``Iterator`` models Random Access Traversal Iterator, 
+``[first, last)`` or ``[last, first)`` should be valid;
+otherwise ``[first, last)`` should be valid.
+
+
+Complexity
+----------
+
+If ``Iterator`` models Random Access Traversal Iterator, it takes constant time;
+otherwise it takes linear time.
+
+
+Notes
+-----
+
+- This function is not a customization point and is protected against
+  being found by argument-dependent lookup (ADL).
+- This function is ``constexpr`` only in C++14 or later.
+
+
+--------------------------------------------------------------------------------
+
+| Author: Michel Morin
+| Copyright |C| 2017 Michel Morin
+| Distributed under the `Boost Software License, Version 1.0
+  <http://www.boost.org/LICENSE_1_0.txt>`_.
+
+.. |C| unicode:: U+00A9 .. COPYRIGHT SIGN

doc/index.html

@@ -131,6 +131,9 @@ is called to get the value to return.</li>
 <li><a class="reference external" href="function_output_iterator.html"><tt class="docutils literal"><span class="pre">function_output_iterator</span></tt></a> (<a class="reference external" href="function_output_iterator.pdf">PDF</a>): an output iterator wrapping a unary function
 object; each time an element is written into the dereferenced
 iterator, it is passed as a parameter to the function object.</li>
+<li><a class="reference external" href="generator_iterator.htm"><tt class="docutils literal"><span class="pre">generator_iterator</span></tt></a>: an input iterator wrapping a reference to a generator (nullary function object);
+each time the iterator is dereferenced, the function object
+is called to get the value to return. This is a more outdated analogue of <tt class="docutils literal"><span class="pre">function_input_iterator</span></tt>.</li>
 <li><a class="reference external" href="indirect_iterator.html"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt></a> (<a class="reference external" href="indirect_iterator.pdf">PDF</a>): an iterator over the objects <em>pointed-to</em> by the
 elements of some sequence.</li>
 <li><a class="reference external" href="permutation_iterator.html"><tt class="docutils literal"><span class="pre">permutation_iterator</span></tt></a> (<a class="reference external" href="permutation_iterator.pdf">PDF</a>): an iterator over the elements of some random-access

doc/index.rst

@@ -115,8 +115,8 @@ __ iterator_facade.pdf
 __ iterator_adaptor.pdf
 
 Both |facade| and |adaptor| as well as many of the `specialized
-adaptors`_ mentioned below have been proposed for standardization,
-and accepted into the first C++ technical report; see our
+adaptors`_ mentioned below have been proposed for standardization;
+see our
 
    `Standard Proposal For Iterator Facade and Adaptor`__ (PDF__)
 
@@ -146,6 +146,10 @@ iterator templates based on the Boost `iterator facade and adaptor`_.
   object; each time an element is written into the dereferenced
   iterator, it is passed as a parameter to the function object.
 
+* |generator|_: an input iterator wrapping a generator (nullary
+  function object); each time the iterator is dereferenced, the function object
+  is called to get the value to return. This is an outdated analogue of |function_input|_.
+
 * |indirect|_ (PDF__): an iterator over the objects *pointed-to* by the
   elements of some sequence.
 
@@ -183,6 +187,9 @@ __ function_input_iterator.pdf
 .. _function_output: function_output_iterator.html
 __ function_output_iterator.pdf
 
+.. |generator| replace:: ``generator_iterator``
+.. _generator: generator_iterator.htm
+
 .. |indirect| replace:: ``indirect_iterator``
 .. _indirect: indirect_iterator.html
 __ indirect_iterator.pdf
@@ -213,6 +220,23 @@ __ zip_iterator.pdf
  Iterator Utilities
 ====================
 
+Operations
+----------
+
+The standard library does not handle new-style iterators properly,
+because it knows nothing about the iterator traversal concepts.
+The Boost.Iterator library provides implementations that fully understand
+the new concepts for the two basic operations:
+
+- |advance|_
+- |distance|_
+
+.. |advance| replace:: ``advance``
+.. _advance: advance.html
+
+.. |distance| replace:: ``distance``
+.. _distance: distance.html
+
 Traits
 ------
 

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;
 
@@ -132,8 +131,8 @@ above are defined as follows:
 
   iterator_adaptor();
 
-[*Requires:] The `Base` type must be Default Constructible.\n
-[*Returns:] An instance of `iterator_adaptor` with 
+[*Requires:] The `Base` type must be Default Constructible.[br]
+[*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;
 
@@ -206,7 +205,7 @@ we're going to pick up right where it left off.
 .. |fac_tut| replace:: `iterator_facade` tutorial
 .. _fac_tut: iterator_facade.html#tutorial-example
 
-[blurb [*`node_base*` really *is* an iterator]\n\n
+[blurb [*`node_base*` really *is* an iterator][br][br]
   It's not really a very interesting iterator, since `node_base`
   is an abstract class: a pointer to a `node_base` just points
   at some base subobject of an instance of some other class, and
@@ -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 
-[@../example/node_iterator3.cpp `here`].
+node iterators
+[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/algorithms.qbk

@@ -0,0 +1,149 @@
+[section:algorithms Algorithms]
+
+[section:advance Function template `advance()`]
+
+The `boost::iterators::advance` function template is an adapted version of `std::advance` for the Boost iterator [link iterator.concepts.traversal traversal concepts].
+
+[heading Header]
+
+    <boost/iterator/advance.hpp>
+
+[heading Synopsis]
+
+    template <typename Iterator, typename Distance>
+    constexpr void advance(Iterator& it, Distance n);
+
+
+[heading Description]
+
+Moves `it` forward by `n` increments (or backward by `|n|` decrements if `n` is negative).
+
+[heading Requirements]
+
+`Iterator` should model Incrementable Iterator.
+
+[heading Preconditions]
+
+Let `it`[sub `i`] be the iterator obtained by incrementing (or decrementing if `n` is negative) `it` by `i`. All the iterators `it`[sub `i`] for `i` = 0, 1, 2, ..., `|n|` should be valid.
+
+If `Iterator` does not model [link iterator.concepts.traversal.bidirectional Bidirectional Traversal Iterator], `n` should be non-negative.
+
+[heading Complexity]
+
+If `Iterator` models [link iterator.concepts.traversal.random_access Random Access Traversal Iterator], it takes constant time; otherwise it takes linear time.
+
+[heading Notes]
+
+* This function is not a customization point and is protected against being found by argument-dependent lookup (ADL).
+* This function is `constexpr` only in C++14 or later.
+
+[heading Acknowledgements]
+
+Contributed by Michel Morin.
+
+[endsect]
+
+[section:distance Function template `distance()`]
+
+The `boost::iterators::distance` function template is an adapted version of `std::distance` for the Boost iterator [link iterator.concepts.traversal traversal concepts].
+
+[heading Header]
+
+    <boost/iterator/distance.hpp>
+
+[heading Synopsis]
+
+    template <typename Iterator>
+    constexpr typename iterator_difference<Iterator>::type
+    distance(Iterator first, Iterator last);
+
+[heading Description]
+
+Computes the (signed) distance from `first` to `last`.
+
+[heading Requirements]
+
+`Iterator` should model [link iterator.concepts.traversal.single_pass Single Pass Iterator].
+
+[heading Preconditions]
+
+If `Iterator` models [link iterator.concepts.traversal.random_access Random Access Traversal Iterator], `[first, last)` or `[last, first)` should be valid; otherwise `[first, last)` should be valid.
+
+[heading Complexity]
+
+If `Iterator` models [link iterator.concepts.traversal.random_access Random Access Traversal Iterator], it takes constant time; otherwise it takes linear time.
+
+[heading Notes]
+
+* This function is not a customization point and is protected against being found by argument-dependent lookup (ADL).
+* This function is `constexpr` only in C++14 or later.
+
+[heading Acknowledgements]
+
+Contributed by Michel Morin.
+
+[endsect]
+
+[section:next_prior Function templates `next()` and `prior()`]
+
+Certain data types, such as the C++ Standard Library's forward and bidirectional iterators, do not provide addition and subtraction via `operator+()` or `operator-()`. This means that non-modifying computation of the next or prior value requires a temporary, even though `operator++()` or `operator--()` is provided. It also means that writing code like `itr+1` inside a template restricts the iterator category to random access iterators.
+
+The `next()` and `prior()` functions defined in `boost/next_prior.hpp` provide a simple way around these problems.
+
+[heading Synopsis]
+
+    template <class T>
+    T next(T x)
+    {
+        return ++x;
+    }
+
+    template <class T, class Distance>
+    T next(T x, Distance n)
+    {
+        std::advance(x, n);
+        return x;
+    }
+
+    template <class T>
+    T prior(T x)
+    {
+        return --x;
+    }
+
+    template <class T, class Distance>
+    T prior(T x, Distance n)
+    {
+        std::advance(x, -n);
+        return x;
+    }
+
+[note Function implementations above are given for exposition only. The actual implementation has the same effect for iterators, but has different properties, as documented later.]
+
+[heading Usage]
+
+Usage is simple:
+
+    const std::list<T>::iterator p = get_some_iterator();
+    const std::list<T>::iterator prev = boost::prior(p);
+    const std::list<T>::iterator next = boost::next(prev, 2);
+
+The distance from the given iterator should be supplied as an absolute value. For example, the iterator four iterators prior to the given iterator `p` may be obtained by `prior(p, 4)`.
+
+With C++11, the Standard Library provides `std::next()` and `std::prev()` function templates, which serve the same purpose. However, there are advantages to `boost::next()` and `boost::prior()`.
+
+First, `boost::next()` and `boost::prior()` are compatible not only with iterators but with any type that provides arithmetic operators `operator++()`, `operator--()`, `operator+()`, `operator-()`, `operator+=()` or `operator-=()`. For example, this is possible:
+
+    int x = 10;
+    int y = boost::next(x, 5);
+    assert(y == 15);
+
+Second, `boost::next()` and `boost::prior()` use [link iterator.concepts.traversal traversal categories] to select the most efficient implementation. For some kinds of iterators, such as [link iterator.specialized.transform transform iterators], the standard iterator category does not reflect the traversal category correctly and therefore `std::next()` and `std::prev()` will fall back to linear complexity.
+
+[heading Acknowledgements]
+
+Contributed by [@http://www.boost.org/people/dave_abrahams.htm Dave Abrahams]. Two-argument versions by Daniel Walker.
+
+[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/concept_checking.qbk

@@ -4,7 +4,7 @@ The iterator concept checking classes provide a mechanism for a
 template to report better error messages when a user instantiates the
 template with a type that does not meet the requirements of the
 template. For an introduction to using concept checking classes, see
-the documentation for the boost::concept_check library.
+the documentation for the _concept_check_ library.
 
 [h2 `iterator_concepts.hpp` Synopsis]
 
@@ -51,4 +51,4 @@ the documentation for the boost::concept_check library.
 
     }
 
-[endsect]
+[endsect]

doc/quickbook/concepts.qbk

@@ -1,9 +1,8 @@
-
 [section:concepts Iterator Concepts]
 
-[section:concepts_access Access]
+[section:access Access]
 
-[h2 Readable Iterator Concept]
+[section:readable Readable Iterator Concept]
 
 A class or built-in type `X` models the *Readable Iterator* concept
 for value type `T` if, in addition to `X` being Assignable and
@@ -32,17 +31,18 @@ type `T`.
     [`U&`]
     [pre: `(*a).m` is well-defined. Equivalent to `(*a).m`.]
   ]
-]                              
-                               
-[h2 Writable Iterator Concept  ]
-                               
-                               
+]
+
+[endsect]
+
+[section:writable Writable Iterator Concept]
+
 A class or built-in type `X`   models the *Writable Iterator* concept
 if, in addition to `X` being   Copy Constructible, the following
 expressions are valid and respect the stated semantics.  Writable
 Iterators have an associated *set of value types*.
 
-[table Writable Iterator Requirements (in addition to Copy Constructible) 
+[table Writable Iterator Requirements (in addition to Copy Constructible)
   [
     [Expression]
     [Return Type]
@@ -55,13 +55,15 @@ Iterators have an associated *set of value types*.
   ]
 ]
 
-[h2 Swappable Iterator Concept]
+[endsect]
+
+[section:swappable Swappable Iterator Concept]
 
 A class or built-in type `X` models the *Swappable Iterator* concept
 if, in addition to `X` being Copy Constructible, the following
 expressions are valid and respect the stated semantics.
 
-[table Swappable Iterator Requirements (in addition to Copy Constructible) 
+[table Swappable Iterator Requirements (in addition to Copy Constructible)
   [
     [Expression]
     [Return Type]
@@ -77,7 +79,9 @@ expressions are valid and respect the stated semantics.
 [blurb *Note:* An iterator that is a model of the *Readable* and *Writable Iterator* concepts
   is also a model of *Swappable Iterator*.  *--end note*]
 
-[h2 Lvalue Iterator Concept]
+[endsect]
+
+[section:lvalue Lvalue Iterator Concept]
 
 The *Lvalue Iterator* concept adds the requirement that the return
 type of `operator*` type be a reference to the value type of the
@@ -101,17 +105,17 @@ iterator.
 
 [endsect]
 
-[section:concepts_traversal Traversal]
+[endsect]
 
-[h2 Incrementable Iterator Concept]
+[section:traversal Traversal]
 
+[section:incrementable Incrementable Iterator Concept]
 
 A class or built-in type `X` models the *Incrementable Iterator*
 concept if, in addition to `X` being Assignable and Copy
 Constructible, the following expressions are valid and respect the
 stated semantics.
 
-
 [table Incrementable Iterator Requirements (in addition to Assignable, Copy Constructible)
   [
     [Expression ]
@@ -129,7 +133,7 @@ stated semantics.
     [``
        {
          X tmp = r;
-         ++r;    
+         ++r;
          return tmp;
        }
     ``]
@@ -141,7 +145,9 @@ stated semantics.
   ]
 ]
 
-[h2 Single Pass Iterator Concept]
+[endsect]
+
+[section:single_pass Single Pass Iterator Concept]
 
 A class or built-in type `X` models the *Single Pass Iterator*
 concept if the following expressions are valid and respect the stated
@@ -156,7 +162,7 @@ semantics.
   [
     [`++r`]
     [`X&`]
-    [pre:\n`r` is dereferenceable;\npost:\n`r` is dereferenceable or\n`r` is past-the-end]
+    [pre:[br]`r` is dereferenceable;[br]post:[br]`r` is dereferenceable or[br]`r` is past-the-end]
   ]
   [
     [`a == b`]
@@ -168,6 +174,11 @@ semantics.
     [convertible to `bool`]
     [`!(a == b)`]
   ]
+  [
+    [`iterator_traits<X>::difference_type`]
+    [A signed integral type representing the distance between iterators]
+    []
+  ]
   [
     [`iterator_traversal<X>::type`]
     [Convertible to`single_pass_traversal_tag`]
@@ -175,8 +186,9 @@ semantics.
   ]
 ]
 
+[endsect]
 
-[h2 Forward Traversal Concept]
+[section:forward Forward Traversal Concept]
 
 A class or built-in type `X` models the *Forward Traversal*
 concept if, in addition to `X` meeting the requirements of Default
@@ -199,11 +211,6 @@ valid and respect the stated semantics.
     [`X&`]
     [`r == s` and `r` is dereferenceable implies `++r == ++s.`]
   ]
-  [
-    [`iterator_traits<X>::difference_type`]
-    [A signed integral type representing the distance between iterators]
-    []
-  ]
   [
     [`iterator_traversal<X>::type`]
     [Convertible to `forward_traversal_tag`]
@@ -211,7 +218,9 @@ valid and respect the stated semantics.
   ]
 ]
 
-[h2 Bidirectional Traversal Concept]
+[endsect]
+
+[section:bidirectional Bidirectional Traversal Concept]
 
 A class or built-in type `X` models the *Bidirectional Traversal*
 concept if, in addition to `X` meeting the requirements of Forward
@@ -223,11 +232,11 @@ the stated semantics.
     [Expression]
     [Return Type]
     [Assertion/Semantics/Pre-/Post-condition]
-  ] 
+  ]
   [
     [`--r`]
     [`X&`]
-    [pre: there exists `s` such that `r == ++s`.\n post: `s` is dereferenceable. `--(++r) == r`. `--r == --s` implies `r == s`. `&r == &--r`.]
+    [pre: there exists `s` such that `r == ++s`.[br] post: `s` is dereferenceable. `--(++r) == r`. `--r == --s` implies `r == s`. `&r == &--r`.]
   ]
   [
     [`r--`]
@@ -247,7 +256,9 @@ the stated semantics.
   ]
 ]
 
-[h2 Random Access Traversal Concept]
+[endsect]
+
+[section:random_access Random Access Traversal Concept]
 
 A class or built-in type `X` models the *Random Access Traversal*
 concept if the following expressions are valid and respect the stated
@@ -255,8 +266,8 @@ semantics.  In the table below, `Distance` is
 `iterator_traits<X>::difference_type` and `n` represents a
 constant object of type `Distance`.
 
-[table Random Access Traversal Iterator Requirements (in addition to Bidirectional Traversal) 
-  [ 
+[table Random Access Traversal Iterator Requirements (in addition to Bidirectional Traversal)
+  [
     [Expression]
     [Return Type]
     [Operational Semantics]
@@ -266,10 +277,10 @@ constant object of type `Distance`.
     [`r += n`]
     [ `X&`]
     [``
-        { 
+        {
           Distance m = n;
           if (m >= 0)
-            while (m--) 
+            while (m--)
               ++r;
           else
             while (m++)
@@ -279,18 +290,18 @@ constant object of type `Distance`.
     ``]
     [ ]
   ]
-  [ 
+  [
     [`a + n`, `n + a`]
     [`X`]
     [``
-        { 
+        {
           X tmp = a;
           return tmp+= n;
         }
     ``]
     []
   ]
-  [ 
+  [
     [`r -= n`]
     [`X&`]
     [`return r += -n`]
@@ -300,9 +311,9 @@ constant object of type `Distance`.
     [`a - n`]
     [`X`]
     [``
-        { 
+        {
           X tmp = a;
-          return tmp-= n; 
+          return tmp-= n;
         }
     ``]
     []
@@ -314,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*]
@@ -359,4 +370,6 @@ constant object of type `Distance`.
 
 [endsect]
 
-[endsect]
+[endsect]
+
+[endsect]

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),
-             std::back_inserter(numbers));
+              boost::counting_iterator<int>(N),
+              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()),
-	      std::back_inserter(pointers));
+        boost::make_counting_iterator(numbers.end()),
+        std::back_inserter(pointers));
 
-    std::cout << "indirectly printing out the numbers from 0 to " 
-	      << N << std::endl;
+    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, " "));
+        boost::make_indirect_iterator(pointers.end()),
+        std::ostream_iterator<int>(std::cout, " "));
     std::cout << std::endl;
 
 
 The output is:
 
-    indirectly printing out the numbers from 0 to 7
-    0 1 2 3 4 5 6 
+[pre
+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`
@@ -152,7 +153,7 @@ operations.
 
   counting_iterator();
 
-[*Requires: ] `Incrementable` is Default Constructible.\n
+[*Requires: ] `Incrementable` is Default Constructible.[br]
 [*Effects: ] Default construct the member `m_inc`.
 
 
@@ -174,14 +175,14 @@ operations.
 
   counting_iterator& operator++();
 
-[*Effects: ] `++m_inc`\n
+[*Effects: ] `++m_inc`[br]
 [*Returns: ] `*this`
 
 
   counting_iterator& operator--();
 
-[*Effects: ] `--m_inc`\n
-[*Returns: ] `*this`  
+[*Effects: ] `--m_inc`[br]
+[*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
@@ -68,6 +67,7 @@ requirements.
   [
     [`i.dereference()`]
     [Access the value referred to]
+  ]
   [
     [`i.equal(j)`]
     [Compare for equality with `j`]
@@ -83,6 +83,7 @@ requirements.
   [
     [`i.advance(n)`]
     [Advance by `n` positions]
+  ]
   [
     [`i.distance_to(j)`]
     [Measure the distance to `j`]
@@ -139,7 +140,7 @@ standardize the gateway protocol.  Note that even if
 open a safety loophole, as every core member function preserves the
 invariants of the iterator.
 
-[h2 `operator\[\]`]
+[h2 `operator[]`]
 
 The indexing operator for a generalized iterator presents special
 challenges.  A random access iterator's `operator[]` is only
@@ -287,7 +288,7 @@ The `iterator_category` member of `iterator_facade` is
 
 .. parsed-literal::
 
-  *iterator-category*\ (CategoryOrTraversal, value_type, reference)
+  *iterator-category*\ (CategoryOrTraversal, reference, value_type)
 
 where *iterator-category* is defined as follows:
 
@@ -295,10 +296,10 @@ where *iterator-category* is defined as follows:
 
 The `enable_if_interoperable` template used above is for exposition
 purposes.  The member operators should only be in an overload set
-provided the derived types `Dr1` and `Dr2` are interoperable, 
+provided the derived types `Dr1` and `Dr2` are interoperable,
 meaning that at least one of the types is convertible to the other.  The
 `enable_if_interoperable` approach uses SFINAE to take the operators
-out of the overload set when the types are not interoperable.  
+out of the overload set when the types are not interoperable.
 The operators should behave *as-if* `enable_if_interoperable`
 were defined to be:
 
@@ -398,7 +399,7 @@ through member functions of class `iterator_core_access`.
 __ `operator arrow`_
 
 [*Returns:] If `reference` is a reference type, an object of type `pointer` equal to: `&static_cast<Derived const*>(this)->dereference()`
-Otherwise returns an object of unspecified type such that, 
+Otherwise returns an object of unspecified type such that,
 `(*static_cast<Derived const*>(this))->m` is equivalent to `(w = **static_cast<Derived const*>(this),
 w.m)` for some temporary object `w` of type `value_type`.
 
@@ -415,7 +416,7 @@ w.m)` for some temporary object `w` of type `value_type`.
 
   Derived& operator++();
 
-[*Effects:] 
+[*Effects:]
 
     static_cast<Derived*>(this)->increment();
     return *static_cast<Derived*>(this);
@@ -455,7 +456,7 @@ w.m)` for some temporary object `w` of type `value_type`.
   Derived& operator-=(difference_type n);
 
 [*Effects:]
- 
+
       static_cast<Derived*>(this)->advance(-n);
       return *static_cast<Derived*>(this);
 
@@ -487,14 +488,16 @@ w.m)` for some temporary object `w` of type `value_type`.
               iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
 [*Returns:]
- 
+
+[pre
   if `is_convertible<Dr2,Dr1>::value`
 
-  then 
+  then
     `((Dr1 const&)lhs).equal((Dr2 const&)rhs)`.
 
-  Otherwise, 
+  Otherwise,
     `((Dr2 const&)rhs).equal((Dr1 const&)lhs)`.
+]
 
 
   template <class Dr1, class V1, class TC1, class R1, class D1,
@@ -504,14 +507,16 @@ w.m)` for some temporary object `w` of type `value_type`.
               iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
 [*Returns:]
- 
+
+[pre
   if `is_convertible<Dr2,Dr1>::value`
 
-  then 
+  then
     `!((Dr1 const&)lhs).equal((Dr2 const&)rhs)`.
 
-  Otherwise, 
+  Otherwise,
     `!((Dr2 const&)rhs).equal((Dr1 const&)lhs)`.
+]
 
 
   template <class Dr1, class V1, class TC1, class R1, class D1,
@@ -521,14 +526,16 @@ w.m)` for some temporary object `w` of type `value_type`.
              iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
 [*Returns:]
- 
+
+[pre
   if `is_convertible<Dr2,Dr1>::value`
 
-  then 
+  then
     `((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) < 0`.
 
-  Otherwise, 
+  Otherwise,
     `((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) > 0`.
+]
 
 
   template <class Dr1, class V1, class TC1, class R1, class D1,
@@ -538,14 +545,16 @@ w.m)` for some temporary object `w` of type `value_type`.
               iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
 [*Returns:]
- 
+
+[pre
   if `is_convertible<Dr2,Dr1>::value`
 
-  then 
+  then
     `((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) <= 0`.
 
-  Otherwise, 
+  Otherwise,
     `((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) >= 0`.
+]
 
 
   template <class Dr1, class V1, class TC1, class R1, class D1,
@@ -555,14 +564,16 @@ w.m)` for some temporary object `w` of type `value_type`.
              iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
 [*Returns:]
- 
+
+[pre
   if `is_convertible<Dr2,Dr1>::value`
 
-  then 
+  then
     `((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) > 0`.
 
-  Otherwise, 
+  Otherwise,
     `((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) < 0`.
+]
 
 
   template <class Dr1, class V1, class TC1, class R1, class D1,
@@ -572,14 +583,16 @@ w.m)` for some temporary object `w` of type `value_type`.
               iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
 [*Returns:]
- 
+
+[pre
   if `is_convertible<Dr2,Dr1>::value`
 
-  then 
+  then
     `((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) >= 0`.
 
-  Otherwise, 
+  Otherwise,
     `((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) <= 0`.
+]
 
 .. _minus:
 
@@ -591,29 +604,33 @@ w.m)` for some temporary object `w` of type `value_type`.
              iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
 [*Return Type:]
- 
+
+[pre
   if `is_convertible<Dr2,Dr1>::value`
 
-   then 
+   then
     `difference` shall be
     `iterator_traits<Dr1>::difference_type`.
 
-   Otherwise 
+   Otherwise
     `difference` shall be `iterator_traits<Dr2>::difference_type`
+]
 
 [*Returns:]
- 
+
+[pre
   if `is_convertible<Dr2,Dr1>::value`
 
-  then 
+  then
     `-((Dr1 const&)lhs).distance_to((Dr2 const&)rhs)`.
 
-  Otherwise, 
+  Otherwise,
     `((Dr2 const&)rhs).distance_to((Dr1 const&)lhs)`.
+]
 
 
 [endsect]
 
 [include facade_tutorial.qbk]
 
-[endsect]
+[endsect]

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) 
-              m_next->append(p); 
+          if (m_next)
+              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,24 +253,24 @@ make them private and grant friendship to
   };
 
 Voila; a complete and conforming readable, forward-traversal
-iterator!  For a working example of its use, see 
-[@../example/node_iterator1.cpp `this program`].
+iterator!  For a working example of its use, see
+[example_link node_iterator1.cpp..this program].
 
-__ ../example/node_iterator1.cpp
+__ ../../example/node_iterator1.cpp
 
 [h2 A constant `node_iterator`]
 
-[blurb *Constant and Mutable iterators*\n\n
+[blurb *Constant and Mutable iterators*[br][br]
 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.\n\n  
+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
 but doesn't allow modification of its referent, and `int*
 const` is a `const` *mutable iterator*, which cannot be
-modified but which allows modification of its referent.\n\n
+modified but which allows modification of its referent.[br][br]
 Confusing?  We agree, but those are the standard terms.  It
 probably doesn't help much that a container's constant iterator
 is called `const_iterator`.
@@ -285,7 +284,7 @@ changes:
 
   class const_node_iterator
     : public boost::iterator_facade<
-          node_iterator
+          const_node_iterator
         , node_base **const**
         , boost::forward_traversal_tag
       >
@@ -312,7 +311,7 @@ changes:
       node_base **const**\ * m_node;
   };
 
-[blurb `const` and an iterator's `value_type`\n\n
+[blurb `const` and an iterator's `value_type`[br][br]
 The C++ standard requires an iterator's `value_type` *not* be
 `const`\ -qualified, so `iterator_facade` strips the
 `const` from its `Value` parameter in order to produce the
@@ -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 
-[@../example/node_iterator2.cpp `here`].
+iterators
+[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 
-    4 5 8 
-    0 -1 4 5 8 
+[pre
+4 5 8
+4 5 8
+0 -1 4 5 8
+]
 
-
-The source code for this example can be found [@../example/filter_iterator_example.cpp here].
+The source code for this example can be found [example_link 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`.
 
 
@@ -178,15 +177,15 @@ operations.
 
   filter_iterator();
 
-[*Requires: ]`Predicate` and `Iterator` must be Default Constructible.\n
-[*Effects: ] Constructs a `filter_iterator` whose`m_pred`,  `m_iter`, and `m_end` 
+[*Requires: ]`Predicate` and `Iterator` must be Default Constructible.[br]
+[*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`.
 
@@ -195,9 +194,9 @@ operations.
   filter_iterator(Iterator x, Iterator end = Iterator());
 
 [*Requires: ] `Predicate` must be Default Constructible and
-  `Predicate` is a class type (not a function pointer).\n
+  `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.
 
 
@@ -205,9 +204,9 @@ operations.
     filter_iterator(
         filter_iterator<Predicate, OtherIterator> const& t
         , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
-        );`
+        );
 
-[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.\n
+[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.[br]
 [*Effects: ] Constructs a filter iterator whose members are copied from `t`.
 
 
@@ -235,8 +234,7 @@ operations.
 
 [*Effects: ] Increments `m_iter` and then continues to
   increment `m_iter` until either `m_iter == m_end`
-  or `m_pred(*m_iter) == true`.\n
-[*Returns: ] `*this`  
+  or `m_pred(*m_iter) == true`.[br]
+[*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,8 +33,8 @@ proxy object.
       x.push_back("!");
 
       std::string s = "";
-      std::copy(x.begin(), x.end(), 
-		boost::make_function_output_iterator(string_appender(s)));
+      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++();
 
@@ -97,4 +96,4 @@ Incrementable Iterator concepts.
 
 [*Returns: ] `*this`.
 
-[endsect]
+[endsect]

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), 
-	      boost::make_indirect_iterator(pointers_to_chars + N),
-	      std::ostream_iterator<char>(std::cout, ","));
+    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;
 
 
 The output is:
 
-    a,b,c,d,e,f,g,
-    b,c,d,e,f,g,h,
-    a,b,c,d,e,f,g,
+[pre
+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 
-[@../example/indirect_iterator_example.cpp here].
+The source code for this example can be found
+[example_link 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)
@@ -203,8 +203,8 @@ following operations:
 
   indirect_iterator();
 
-[*Requires: ] `Iterator` must be Default Constructible.\n
-[*Effects: ] Constructs an instance of `indirect_iterator` with 
+[*Requires: ] `Iterator` must be Default Constructible.[br]
+[*Effects: ] Constructs an instance of `indirect_iterator` with
    a default-constructed `m_iterator`.
 
 
@@ -225,8 +225,8 @@ following operations:
     , typename enable_if_convertible<Iterator2, Iterator>::type* = 0 // exposition
   );
 
-[*Requires: ] `Iterator2` is implicitly convertible to `Iterator`.\n
-[*Effects: ] Constructs an instance of `indirect_iterator` whose 
+[*Requires: ] `Iterator2` is implicitly convertible to `Iterator`.[br]
+[*Effects: ] Constructs an instance of `indirect_iterator` whose
     `m_iterator` subobject is constructed from `y.base()`.
 
 
@@ -242,13 +242,13 @@ following operations:
 
   indirect_iterator& operator++();
 
-[*Effects: ] `++m_iterator`\n
+[*Effects: ] `++m_iterator`[br]
 [*Returns: ] `*this`
 
 
   indirect_iterator& operator--();
 
-[*Effects: ] `--m_iterator`\n
+[*Effects: ] `--m_iterator`[br]
 [*Returns: ] `*this`
 
-[endsect]
+[endsect]

doc/quickbook/iterator.qbk

@@ -1,6 +1,6 @@
-
 [library Boost.Iterator
     [/ version 1.0.1]
+    [quickbook 1.6]
     [authors [Abrahams, David], [Siek, Jeremy], [Witt, Thomas]]
     [copyright 2003 2005 David Abrahams Jeremy Siek Thomas Witt]
     [category iterator]
@@ -28,7 +28,11 @@
 
 [/  Links   ]
 
-[def _iterator_           [@../../libs/iterator/doc/index.html Boost.Iterator]]
+[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>''']
 
 [section:intro Introduction]
 
@@ -70,19 +74,23 @@ and a _GOTW_50_.  New-style iterators go well beyond
 patching up `vector<bool>`, though: there are lots of other
 iterators already in use which can't be adequately represented by
 the existing concepts.  For details about the new iterator
-concepts, see our [@./new-iter-concepts.html Standard Proposal for New-Style Iterators].
+concepts, see our [@../new-iter-concepts.html Standard Proposal for New-Style Iterators].
 
 [h2 Iterator Facade and Adaptor]
 
-[def _facade_ [@./iterator_facade.html facade]]
-[def _adaptor_ [@./iterator_adaptor.html adaptor]]
+[/
+[def _facade_ [link iterator.generic.facade facade]]
+[def _adaptor_ [link iterator.generic.adaptor adaptor]]
+]
+[def _facade_ [@../iterator_facade.html facade]]
+[def _adaptor_ [@../iterator_adaptor.html adaptor]]
 
 Writing standard-conforming iterators is tricky, but the need comes
 up often.  In order to ease the implementation of new iterators,
 the Boost.Iterator library provides the _facade_ class template,
 which implements many useful defaults and compile-time checks
 designed to help the iterator author ensure that his iterator is
-correct.  
+correct.
 
 It is also common to define a new iterator that is similar to some
 underlying iterator or iterator-like type, but that modifies some
@@ -91,26 +99,28 @@ library supplies the _adaptor_ class template, which is specially
 designed to take advantage of as much of the underlying type's
 behavior as possible.
 
-Both _facade_ and _adaptor_ as well as many of the `specialized
-adaptors`_ mentioned below have been proposed for standardization 
-([@./facade-and-adaptor.html Standard Proposal For Iterator Facade and Adaptor]).
+Both _facade_ and _adaptor_ as well as many of the [link iterator.specialized specialized
+adaptors] mentioned below have been proposed for standardization
+([@../facade-and-adaptor.html Standard Proposal For Iterator Facade and Adaptor]).
 
 [h2 Specialized Adaptors]
 
 The iterator library supplies a useful suite of standard-conforming
 iterator templates based on the Boost [link
-intro.iterator_facade_and_adaptor iterator facade and adaptor]
+iterator.intro.iterator_facade_and_adaptor iterator facade and adaptor]
 templates.
 
-[def _counting_    [@./counting_iterator.html         `counting_iterator`]]
-[def _filter_      [@./filter_iterator.html           `filter_iterator`]]
-[def _function_    [@./function_output_iterator.html  `function_output_iterator`]]
-[def _indirect_    [@./indirect_iterator.html         `indirect_iterator`]]
-[def _permutation_ [@./permutation_iterator.html      `permutation_iterator`]]
-[def _reverse_     [@./reverse_iterator.html          `reverse_iterator`]]
-[def _shared_      [@./shared_container_iterator.html `shared_container_iterator`]]
-[def _transform_   [@./transform_iterator.html        `transform_iterator`]]
-[def _zip_         [@./zip_iterator.html              `zip_iterator`]]
+[def _counting_    [link iterator.specialized.counting `counting_iterator`]]
+[def _filter_      [link iterator.specialized.filter `filter_iterator`]]
+[def _function_input_ [@../function_input_iterator.html `function_input_iterator`]]
+[def _function_output_ [link iterator.specialized.function_output `function_output_iterator`]]
+[def _generator_   [@../generator_iterator.htm `generator_iterator`]]
+[def _indirect_    [link iterator.specialized.indirect `indirect_iterator`]]
+[def _permutation_ [link iterator.specialized.permutation `permutation_iterator`]]
+[def _reverse_     [link iterator.specialized.reverse `reverse_iterator`]]
+[def _shared_      [link iterator.specialized.shared_container `shared_container_iterator`]]
+[def _transform_   [link iterator.specialized.transform `transform_iterator`]]
+[def _zip_         [link iterator.specialized.zip `zip_iterator`]]
 
 [def _shared_ptr_  [@../../smart_ptr/shared_ptr.htm `shared_ptr`]]
 
@@ -120,10 +130,18 @@ templates.
 * _filter_: an iterator over the subset of elements of some
   sequence which satisfy a given predicate
 
-* _function_: an output iterator wrapping a unary function
+* _function_input_: an input iterator wrapping a generator (nullary
+  function object); each time the iterator is dereferenced, the function object
+  is called to get the value to return.
+
+* _function_output_: an output iterator wrapping a unary function
   object; each time an element is written into the dereferenced
   iterator, it is passed as a parameter to the function object.
 
+* _generator_: an input iterator wrapping a generator (nullary
+  function object); each time the iterator is dereferenced, the function object
+  is called to get the value to return. An outdated analogue of _function_input_.
+
 * _indirect_: an iterator over the objects *pointed-to* by the
   elements of some sequence.
 
@@ -132,7 +150,7 @@ templates.
 
 * _reverse_: an iterator which traverses the elements of some
   bidirectional sequence in reverse.  Corrects many of the
-  shortcomings of C++98's ``std::reverse_iterator``.
+  shortcomings of C++98's `std::reverse_iterator`.
 
 * _shared_: an iterator over elements of a container whose
   lifetime is maintained by a _shared_ptr_ stored in the iterator.
@@ -140,7 +158,7 @@ templates.
 * _transform_: 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
-  ``projection_iterator_adaptor``.
+  `projection_iterator_adaptor`.
 
 * _zip_: an iterator over tuples of the elements at corresponding
   positions of heterogeneous underlying iterators.
@@ -149,9 +167,9 @@ templates.
 
 [h3 Traits]
 
-[def _pointee_          [@./pointee.html         `pointee.hpp`]]
-[def _iterator_traits_  [@./iterator_traits.html `iterator_traits.hpp`]]
-[def _interoperable_    [@./interoperable.html   `interoperable.hpp`]]
+[def _pointee_          [link iterator.utilities.traits `pointee.hpp`]]
+[def _iterator_traits_  [link iterator.utilities.iterator_traits `iterator_traits.hpp`]]
+[def _interoperable_    [@../interoperable.html   `interoperable.hpp`]]
 [def _MPL_              [@../../mpl/doc/index.html   [*MPL]]]
 
 * _pointee_: Provides the capability to deduce the referent types
@@ -162,19 +180,40 @@ templates.
   retrieve an iterator's traits.  Also corrects for the deficiencies
   of broken implementations of `std::iterator_traits`.
 
-[\ * |interoperable|_ (PDF__): Provides an _MPL_ compatible metafunction for
-     testing iterator interoperability
+[/
+* _interoperable_: Provides an _MPL_ compatible metafunction for
+  testing iterator interoperability
 ]
 
 [h3 Testing and Concept Checking]
 
-[def _iterator_concepts_  [@./iterator_concepts.html `iterator_concepts.hpp`]]
-[def _iterator_archetypes_  [@./iterator_archetypes.html `iterator_archetypes.hpp`]]
+[def _iterator_concepts_  [link iterator.concepts `iterator_concepts.hpp`]]
+[def _iterator_archetypes_  [link iterator.utilities.archetypes `iterator_archetypes.hpp`]]
 
 * _iterator_concepts_: Concept checking classes for the new iterator concepts.
 
 * _iterator_archetypes_: Concept archetype classes for the new iterators concepts.
 
+[h2 Iterator Algorithms]
+
+The library provides a number of generic algorithms for use with iterators. These
+algorithms take advantage of the new concepts defined by the library to provide
+better performance and functionality.
+
+[def _advance_          [link iterator.algorithms.advance `advance.hpp`]]
+[def _distance_         [link iterator.algorithms.distance `distance.hpp`]]
+[def _next_prior_       [link iterator.algorithms.next_prior `next_prior.hpp`]]
+
+* _advance_: Provides `advance()` function for advancing an iterator a given number
+  of positions forward or backward.
+
+* _distance_: Provides `distance()` function for computing distance between two
+  iterators.
+
+* _next_prior_: Provides `next()` and `prior()` functions for obtaining
+  next and prior iterators to a given iterator. The functions are also compatible
+  with non-iterator types.
+
 [endsect]
 
 [include concepts.qbk]
@@ -195,12 +234,14 @@ templates.
 
 [include concept_checking.qbk]
 
-[include traits.qbk]
+[include iterator_traits.qbk]
 
-[include utilities.qbk]
+[include type_traits.qbk]
 
 [endsect]
 
+[include algorithms.qbk]
+
 [section:upgrading Upgrading from the old Boost Iterator Adaptor Library]
 
 [def _type_generator_ [@http://www.boost.org/more/generic_programming.html#type_generator type generator]]
@@ -264,5 +305,3 @@ library you see today.
    Patterns, C++ Report, February 1995, pp. 24-27.]
 
 [endsect]
-
-  

doc/quickbook/iterator_traits.qbk

@@ -1,5 +1,4 @@
-
-[section:traits Iterator Traits]
+[section:iterator_traits Iterator Traits]
 
 `std::iterator_traits` provides access to five associated types
 of any iterator: its `value_type`, `reference`, `pointer`,
@@ -15,15 +14,15 @@ Header `<boost/iterator/iterator_traits.hpp>`:
   template <class Iterator>
   struct iterator_value
   {
-      typedef typename 
-        std::iterator_traits<Iterator>::value_type 
+      typedef typename
+        std::iterator_traits<Iterator>::value_type
       type;
   };
 
   template <class Iterator>
   struct iterator_reference
   {
-      typedef typename 
+      typedef typename
         std::iterator_traits<Iterator>::reference
       type;
   };
@@ -31,8 +30,8 @@ Header `<boost/iterator/iterator_traits.hpp>`:
   template <class Iterator>
   struct iterator_pointer
   {
-      typedef typename 
-        std::iterator_traits<Iterator>::pointer 
+      typedef typename
+        std::iterator_traits<Iterator>::pointer
       type;
   };
 

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 
-    The reindexing scheme is : 9 8 7 6 
-    The permutated range is : 9 8 7 6 
-    Elements at even indices in the permutation : 9 7 
-    Permutation backwards : 6 7 8 9 
-    Iterate backward with stride 2 : 6 8 
-
+[pre
+The original range is : 0 1 2 3 4 5 6 7 8 9
+The reindexing scheme is : 9 8 7 6
+The permutated range is : 9 8 7 6
+Elements at even indices in the permutation : 9 7
+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 ValueT        = use_default
-	  , class CategoryT     = use_default
-	  , class ReferenceT    = use_default
-	  , class DifferenceT   = use_default >
+    , class IndexIterator
+    , class ValueT        = use_default
+    , class CategoryT     = use_default
+    , class ReferenceT    = 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
-	, typename enable_if_convertible<OEIter, ElementIterator>::type* = 0
-	, typename enable_if_convertible<OIIter, IndexIterator>::type* = 0
-	);
+      permutation_iterator<OEIter, OIIter, V, C, R, D> const& r
+      , typename enable_if_convertible<OEIter, ElementIterator>::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
-	, typename enable_if_convertible<OEIter, ElementIterator>::type* = 0
-	, typename enable_if_convertible<OIIter, IndexIterator>::type* = 0
-	);
+      permutation_iterator<OEIter, OIIter, V, C, R, D> const& r
+      , typename enable_if_convertible<OEIter, ElementIterator>::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`.
@@ -189,7 +189,7 @@ following operations.
 
   permutation_iterator& operator++();
 
-[*Effects: ] `++m_order`\n
+[*Effects: ] `++m_order`[br]
 [*Returns: ] `*this`
 
 
@@ -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!
-    sequence in reverse order:                      !dlrow olleh
-    sequence in double-reversed (normal) order:     hello world!
-
+[pre
+original sequence of letters:                   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]
 
@@ -115,8 +114,8 @@ operations.
 
   reverse_iterator();
 
-[*Requires: ] `Iterator` must be Default Constructible.\n
-[*Effects: ] Constructs an instance of `reverse_iterator` with `m_iterator` 
+[*Requires: ] `Iterator` must be Default Constructible.[br]
+[*Effects: ] Constructs an instance of `reverse_iterator` with `m_iterator`
   default constructed.
 
   explicit reverse_iterator(Iterator x);
@@ -131,8 +130,8 @@ operations.
       , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
     );
 
-[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.\n
-[*Effects: ] Constructs instance of `reverse_iterator` whose 
+[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.[br]
+[*Effects: ] Constructs instance of `reverse_iterator` whose
     `m_iterator` subobject is constructed from `y.base()`.
 
 
@@ -149,12 +148,12 @@ operations.
 
   reverse_iterator& operator++();
 
-[*Effects: ] `--m_iterator`\n
+[*Effects: ] `--m_iterator`[br]
 [*Returns: ] `*this`
 
   reverse_iterator& operator--();
 
-[*Effects: ] `++m_iterator`\n
+[*Effects: ] `++m_iterator`[br]
 [*Returns: ] `*this`
 
-[endsect]
+[endsect]

doc/quickbook/shared_container_iterator.qbk

@@ -1,4 +1,3 @@
-
 [section:shared_container Shared Container Iterator]
 
 Defined in header [@../../../boost/shared_container_iterator.hpp `boost/shared_container_iterator.hpp`].
@@ -27,12 +26,12 @@ iterator.
   namespace boost {
     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,
       boost::shared_ptr<Container> const& container);
-   
+
     std::pair<
       typename shared_container_iterator<Container>,
       typename shared_container_iterator<Container>
@@ -46,7 +45,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 +55,50 @@ 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.
 
-[@../../../libs/utility/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/shared_ptr.hpp"
   #include <algorithm>
   #include <iostream>
   #include <vector>
-   
+
   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);
   }
-   
-   
+
+
   int main() {
-   
+
     iterator i,end;
-   
+
     set_range(i,end);
-   
+
     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]]
@@ -130,16 +131,16 @@ iterator will be valid. In addition it has the following constructor:
                                  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.
 
-[@../../../libs/utility/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/shared_ptr.hpp"
@@ -147,35 +148,35 @@ uses `make_shared_container_iterator()` to create the iterators.
   #include <iterator>
   #include <iostream>
   #include <vector>
-   
-   
+
+
   template <typename Iterator>
   void print_range_nl (Iterator begin, Iterator end) {
     typedef typename std::iterator_traits<Iterator>::value_type val;
     std::copy(begin,end,std::ostream_iterator<val>(std::cout,","));
     std::cout.put('\n');
   }
-   
-   
+
+
   int main() {
-   
+
     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),
                      boost::make_shared_container_iterator(ints->end(),ints));
     }
-    
-   
-   
+
+
+
     return 0;
   }
 
@@ -200,18 +201,18 @@ named. The output from this example is the same as the previous.
 
 In the following example, a range of values is returned as a pair of shared_container_iterator objects.
 
-[@../../../libs/utility/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/shared_ptr.hpp"
   #include "boost/tuple/tuple.hpp" // for boost::tie
   #include <algorithm>              // for std::copy
-  #include <iostream>              
+  #include <iostream>
   #include <vector>
-   
-   
-  typedef boost::shared_container_iterator< std::vector<int> > iterator; 
-   
+
+
+  typedef boost::shared_container_iterator< std::vector<int> > iterator;
+
   std::pair<iterator,iterator>
   return_range() {
     boost::shared_ptr< std::vector<int> > range(new std::vector<int>());
@@ -223,18 +224,18 @@ In the following example, a range of values is returned as a pair of shared_cont
     range->push_back(5);
     return boost::make_shared_container_range(range);
   }
-   
-   
+
+
   int main() {
-   
-   
+
+
     iterator i,end;
-    
+
     boost::tie(i,end) = return_range();
-   
+
     std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
     std::cout.put('\n');
-   
+
     return 0;
   }
 
@@ -245,4 +246,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 };
-	const int N = sizeof(x)/sizeof(int);
-	
-	typedef boost::binder1st< std::multiplies<int> > Function;
-	typedef boost::transform_iterator<Function, int*> doubling_iterator;
-	
-	doubling_iterator i(x, 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;
-	while (i != i_end)
-	  std::cout << *i++ << " ";
-	std::cout << 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)),
-	     boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
-	     std::ostream_iterator<int>(std::cout, " "));
-	std::cout << std::endl;
+  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+  const int N = sizeof(x)/sizeof(int);
+
+  typedef boost::binder1st< std::multiplies<int> > Function;
+  typedef boost::transform_iterator<Function, int*> doubling_iterator;
+
+  doubling_iterator i(x, 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;
+  while (i != i_end)
+    std::cout << *i++ << " ";
+  std::cout << 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)),
+    boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
+    std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
 
 
 The output is:
 
-	multiplying the array by 2:
-	2 4 6 8 10 12 14 16 
-	adding 4 to each element in the array:
-	5 6 7 8 9 10 11 12
+[pre
+multiplying the array by 2:
+2 4 6 8 10 12 14 16
+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 
-[@../example/transform_iterator_example.cpp here].
+The source code for this example can be found
+[example_link 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 Reference = use_default, 
+            class Iterator,
+            class Reference = use_default,
             class Value = use_default>
   class transform_iterator
   {
@@ -85,8 +85,8 @@ The source code for this example can be found
 
 
 If `Reference` is `use_default` then the `reference` member of
-`transform_iterator` is\n
-`result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type`.
+`transform_iterator` is[br]
+`result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type`.
 Otherwise, `reference` is `Reference`.
 
 
@@ -110,13 +110,13 @@ convertible to `input_iterator_tag`.
 
 
 The type `UnaryFunction` must be Assignable, Copy Constructible, and
-the expression `f(*i)` must be valid where `f` is an object of
+the expression `f(*i)` must be valid where `f` is a const object of
 type `UnaryFunction`, `i` is an object of type `Iterator`, and
 where the type of `f(*i)` must be
-`result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type`.
+`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]]
-	[[Single Pass Iterator][Input Iterator]]
-	[[Forward Traversal Iterator][Forward Iterator]]
-	[[Bidirectional Traversal Iterator][Bidirectional Iterator]]
-	[[Random Access Traversal Iterator][Random Access Iterator]]
+[[If `Iterator` models][then `transform_iterator` models]]
+[[Single Pass Iterator][Input Iterator]]
+[[Forward Traversal Iterator][Forward Iterator]]
+[[Bidirectional Traversal Iterator][Bidirectional Iterator]]
+[[Random Access Traversal Iterator][Random Access Iterator]]
 ]
 
 If `transform_iterator` models Writable Lvalue Iterator then it is a
@@ -160,7 +160,7 @@ interoperable with `Y`.
 
 [h3 Operations]
 
-In addition to the operations required by the [link transform.concepts concepts] modeled by
+In addition to the operations required by the [link iterator.specialized.transform.concepts concepts] modeled by
 `transform_iterator`, `transform_iterator` provides the following
 operations:
 
@@ -177,13 +177,13 @@ 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
   );
 
 [*Returns: ] An instance of `transform_iterator` with `m_f`
   initialized to `t.functor()` and `m_iterator` initialized to
-  `t.base()`.\n
+  `t.base()`.[br]
 [*Requires: ]  `OtherIterator` is implicitly convertible to `Iterator`.
 
 
@@ -204,13 +204,13 @@ operations:
 
  transform_iterator& operator++();
 
-[*Effects: ] `++m_iterator`\n
+[*Effects: ] `++m_iterator`[br]
 [*Returns: ]  `*this`
 
 
   transform_iterator& operator--();
 
-[*Effects: ]  `--m_iterator`\n
+[*Effects: ]  `--m_iterator`[br]
 [*Returns: ] `*this`
 
 [endsect]

doc/quickbook/type_traits.qbk

@@ -1,7 +1,4 @@
-
-[section:utilities Iterator Utilities]
-
-[section:utilities_traits Traits]
+[section:traits Type Traits]
 
 [h2 Overview]
 
@@ -49,7 +46,7 @@ proxy references or return the pointee by value.  When that
 information is needed, call on `indirect_reference`.
 
 Both of these templates are essential to the correct functioning of
-[link boost_iterator.indirect `indirect_iterator`].
+[link iterator.specialized.indirect `indirect_iterator`].
 
 [h2 `minimum_category`]
 
@@ -103,9 +100,9 @@ or not), these additional tags are not considered.
 
   if ( ++x is ill-formed )
   {
-      return `Dereferenceable::element_type`
+      return Dereferenceable::element_type
   }
-  else if (`*x` is a mutable reference to
+  else if (*x is a mutable reference to
            std::iterator_traits<Dereferenceable>::value_type)
   {
       return iterator_traits<Dereferenceable>::value_type
@@ -135,7 +132,7 @@ or not), these additional tags are not considered.
 `x` is an object of type `Dereferenceable`:
 
   if ( ++x is ill-formed )
-      return `pointee<Dereferenceable>::type&`
+      return pointee<Dereferenceable>::type&
   else
       std::iterator_traits<Dereferenceable>::reference
 
@@ -212,113 +209,3 @@ Otherwise, `type` is defined to the closest iterator traversal tag matching `C`.
 [*Requires:] `Iterator` shall be an iterator.
 
 [endsect]
-
-[section:utilities_testing Testing and Concept Checking]
-
-The iterator concept checking classes provide a mechanism for a
-template to report better error messages when a user instantiates
-the template with a type that does not meet the requirements of the
-template.
-
-For an introduction to using concept checking classes, see
-the documentation for the 
-[@../../concept_check/index.html `boost::concept_check`] library.
-
-
-[h2 Reference]
-
-[h3 Iterator Access Concepts]
-
-* |Readable|_ 
-* |Writable|_ 
-* |Swappable|_ 
-* |Lvalue|_ 
-
-[/ .. |Readable| replace:: *Readable Iterator* ]
-[/ .. _Readable: ReadableIterator.html            ]
-[/                                                ]
-[/ .. |Writable| replace:: *Writable Iterator*    ]
-[/ .. _Writable: WritableIterator.html            ]
-[/                                                ]
-[/ .. |Swappable| replace:: *Swappable Iterator*  ]
-[/ .. _Swappable: SwappableIterator.html          ]
-[/                                                ]
-[/ .. |Lvalue| replace:: *Lvalue Iterator*        ]
-[/ .. _Lvalue: LvalueIterator.html                ]
-
-
-Iterator Traversal Concepts
-...........................
-
-* |Incrementable|_
-* |SinglePass|_
-* |Forward|_
-* |Bidir|_
-* |Random|_
-
-
-[/ .. |Incrementable| replace:: *Incrementable Iterator* ]
-[/ .. _Incrementable: IncrementableIterator.html         ]
-[/                                                       ]
-[/ .. |SinglePass| replace:: *Single Pass Iterator*      ]
-[/ .. _SinglePass: SinglePassIterator.html               ]
-[/                                                       ]
-[/ .. |Forward| replace:: *Forward Traversal*            ]
-[/ .. _Forward: ForwardTraversal.html                    ]
-[/                                                       ]
-[/ .. |Bidir| replace:: *Bidirectional Traversal*        ]
-[/ .. _Bidir: BidirectionalTraversal.html                ]
-[/                                                       ]
-[/ .. |Random| replace:: *Random Access Traversal*       ]
-[/ .. _Random: RandomAccessTraversal.html                ]
-
-
-
-[h3 `iterator_concepts.hpp` Synopsis]
-
-    namespace boost_concepts {
-
-        // Iterator Access Concepts
-
-        template <typename Iterator>
-        class ReadableIteratorConcept;
-
-        template <
-            typename Iterator
-          , typename ValueType = std::iterator_traits<Iterator>::value_type
-        >
-        class WritableIteratorConcept;
-
-        template <typename Iterator>
-        class SwappableIteratorConcept;
-
-        template <typename Iterator>
-        class LvalueIteratorConcept;
-
-        // Iterator Traversal Concepts
-
-        template <typename Iterator>
-        class IncrementableIteratorConcept;
-
-        template <typename Iterator>
-        class SinglePassIteratorConcept;
-
-        template <typename Iterator>
-        class ForwardTraversalConcept;
-
-        template <typename Iterator>
-        class BidirectionalTraversalConcept;
-
-        template <typename Iterator>
-        class RandomAccessTraversalConcept;
-
-        // Interoperability
-
-        template <typename Iterator, typename ConstIterator>
-        class InteroperableIteratorConcept;
-
-    }
-
-[endsect]
-
-[endsect]

doc/quickbook/zip_iterator.qbk

@@ -1,20 +1,29 @@
-
 [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.
+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
+'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
+Boost fusion adapter header file for Boost tuple, so you need not include it yourself
+to use a Boost tuple as your 'tuple'.
 
 [section:zip_example Example]
 
 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:
@@ -43,7 +52,7 @@ 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>
       {
         void operator()(const boost::tuple<const double&, const int&>& t) const
@@ -62,16 +71,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`:
@@ -118,7 +127,7 @@ sequence containing the products of the elements of `vect_1` and
 
   template<typename IteratorTuple>
   class zip_iterator
-  {  
+  {
 
   public:
     typedef /* see below */ reference;
@@ -144,8 +153,8 @@ sequence containing the products of the elements of `vect_1` and
     IteratorTuple m_iterator_tuple;     // exposition only
   };
 
-  template<typename IteratorTuple> 
-  zip_iterator<IteratorTuple> 
+  template<typename IteratorTuple>
+  zip_iterator<IteratorTuple>
   make_zip_iterator(IteratorTuple t);
 
 The `reference` member of `zip_iterator` is the type of the tuple
@@ -158,23 +167,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 
-constructed from the reference types of the individual iterators, not 
+to. The tuple returned by the `zip_iterator`'s `operator*` is a tuple
+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
@@ -185,7 +194,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
@@ -218,7 +227,7 @@ operations.
               , IteratorTuple>::type* = 0     // exposition only
     );
 
-[*Returns:] An instance of `zip_iterator` that is a copy of `other`.\n
+[*Returns:] An instance of `zip_iterator` that is a copy of `other`.[br]
 [*Requires:] `OtherIteratorTuple` is implicitly convertible to `IteratorTuple`.
 
 
@@ -235,17 +244,17 @@ operations.
 
   zip_iterator& operator++();
 
-[*Effects:] Increments each iterator in `m_iterator_tuple`.\n
+[*Effects:] Increments each iterator in `m_iterator_tuple`.[br]
 [*Returns:] `*this`
 
 
   zip_iterator& operator--();
 
-[*Effects:] Decrements each iterator in `m_iterator_tuple`.\n
+[*Effects:] Decrements each iterator in `m_iterator_tuple`.[br]
 [*Returns:] `*this`
 
-    template<typename IteratorTuple> 
-    zip_iterator<IteratorTuple> 
+    template<typename IteratorTuple>
+    zip_iterator<IteratorTuple>
     make_zip_iterator(IteratorTuple t);
 
 [*Returns:] An instance of `zip_iterator<IteratorTuple>` with `m_iterator_tuple`
@@ -253,4 +262,4 @@ operations.
 
 [endsect]
 
-[endsect]
+[endsect]

doc/zip_iterator_abstract.rst

@@ -8,3 +8,13 @@ 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 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 
+'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
+Boost fusion adapter header file for Boost tuple, so you need not include it yourself
+to use a Boost tuple as your 'tuple'.

doc/zip_iterator_eg.rst

@@ -45,8 +45,7 @@ A non-generic implementation of ``zip_func`` could look as follows:
 ::
 
 
-      struct zip_func : 
-        public std::unary_function<const boost::tuple<const double&, const int&>&, void>
+      struct zip_func
       {
         void operator()(const boost::tuple<const double&, const int&>& t) const
         {

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

@@ -11,7 +11,17 @@
 
 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 "));
     nodes->append(new node<int>(13));
 
@@ -20,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

@@ -12,23 +12,33 @@
 
 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 "));
     nodes->append(new node<int>(13));
 
     // 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

@@ -38,15 +38,15 @@ class node_iter
             boost::is_convertible<OtherValue*,Value*>
           , enabler
         >::type = enabler()
-# endif 
+# endif
     )
       : m_node(other.m_node) {}
 
 
 # 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
 
     template <class OtherValue>
     bool equal(node_iter<OtherValue> const& other) const
@@ -63,7 +63,7 @@ class node_iter
 # else
  private:
     template <class> friend class node_iter;
-# endif 
+# endif
     Value* m_node;
 };
 

example/node_iterator3.cpp

@@ -12,23 +12,33 @@
 
 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 "));
     nodes->append(new node<int>(13));
 
     // 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

@@ -27,7 +27,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) {}
@@ -43,14 +43,14 @@ class node_iter
             boost::is_convertible<OtherValue*,Value*>
           , enabler
         >::type = enabler()
-# endif 
+# 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

@@ -0,0 +1,42 @@
+// Copyright 2003 The Trustees of Indiana University.
+
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include "boost/shared_container_iterator.hpp"
+#include "boost/shared_ptr.hpp"
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+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);
+}
+
+
+int main() {
+
+  iterator i,end;
+
+  set_range(i,end);
+
+  std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
+  std::cout.put('\n');
+
+  return 0;
+}

example/shared_iterator_example2.cpp

@@ -0,0 +1,43 @@
+// Copyright 2003 The Trustees of Indiana University.
+
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include "boost/shared_container_iterator.hpp"
+#include "boost/shared_ptr.hpp"
+#include <algorithm>
+#include <iterator>
+#include <iostream>
+#include <vector>
+
+
+template <typename Iterator>
+void print_range_nl (Iterator begin, Iterator end) {
+  typedef typename std::iterator_traits<Iterator>::value_type val;
+  std::copy(begin,end,std::ostream_iterator<val>(std::cout,","));
+  std::cout.put('\n');
+}
+
+
+int main() {
+
+  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),
+                   boost::make_shared_container_iterator(ints->end(),ints));
+  }
+
+
+
+  return 0;
+}

example/shared_iterator_example3.cpp

@@ -0,0 +1,41 @@
+// Copyright 2003 The Trustees of Indiana University.
+
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include "boost/shared_container_iterator.hpp"
+#include "boost/shared_ptr.hpp"
+#include "boost/tuple/tuple.hpp" // for boost::tie
+#include <algorithm>              // for std::copy
+#include <iostream>
+#include <vector>
+
+
+typedef boost::shared_container_iterator< std::vector<int> > iterator;
+
+std::pair<iterator,iterator>
+return_range() {
+  boost::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);
+}
+
+
+int main() {
+
+
+  iterator i,end;
+
+  boost::tie(i,end) = return_range();
+
+  std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
+  std::cout.put('\n');
+
+  return 0;
+}

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,10 +15,11 @@
 
 namespace boost {
 
-  template <class Operation> 
-  class binder1st
-    : public std::unary_function<typename Operation::second_argument_type,
-                                 typename Operation::result_type> {
+  template <class Operation>
+  class binder1st {
+  public:
+    typedef typename Operation::result_type result_type;
+    typedef typename Operation::second_argument_type argument_type;
   protected:
     Operation op;
     typename Operation::first_argument_type value;
@@ -29,7 +30,7 @@ namespace boost {
         : op(x), value(y) {}
     typename Operation::result_type
     operator()(const typename Operation::second_argument_type& x) const {
-      return op(value, x); 
+      return op(value, x);
     }
   };
 
@@ -69,8 +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

@@ -1,62 +1,18 @@
-// (C) Copyright Jeremy Siek 2001.
+// (C) Copyright Andrey Semashev 2017.
 // 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:
-
-// 27 Feb 2001   Jeremy Siek
-//      Initial checkin.
-
 #ifndef BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
 #define BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
 
-#include <iterator>
+// This is a deprecated header left for backward compatibility.
+// Use boost/iterator/function_output_iterator.hpp instead.
 
-namespace boost {
-namespace iterators {
+#include <boost/config/header_deprecated.hpp>
 
-  template <class UnaryFunction>
-  class function_output_iterator {
-    typedef function_output_iterator self;
-  public:
-    typedef std::output_iterator_tag iterator_category;
-    typedef void                value_type;
-    typedef void                difference_type;
-    typedef void                pointer;
-    typedef void                reference;
+BOOST_HEADER_DEPRECATED("<boost/iterator/function_output_iterator.hpp>")
 
-    explicit function_output_iterator() {}
-
-    explicit function_output_iterator(const UnaryFunction& f)
-      : m_f(f) {}
-
-    struct output_proxy {
-      output_proxy(UnaryFunction& f) : m_f(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>
-  inline function_output_iterator<UnaryFunction>
-  make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
-    return function_output_iterator<UnaryFunction>(f);
-  }
-
-} // namespace iterators
-
-using iterators::function_output_iterator;
-using iterators::make_function_output_iterator;
-
-} // namespace boost
+#include <boost/iterator/function_output_iterator.hpp>
 
 #endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP

include/boost/iterator/advance.hpp

@@ -0,0 +1,95 @@
+// Copyright (C) 2017 Michel Morin.
+//
+// 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_ITERATOR_ADVANCE_HPP
+#define BOOST_ITERATOR_ADVANCE_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+namespace boost {
+namespace iterators {
+
+    namespace detail {
+        template <typename InputIterator, typename Distance>
+        inline BOOST_CXX14_CONSTEXPR void
+        advance_impl(
+            InputIterator& it
+          , Distance n
+          , incrementable_traversal_tag
+        )
+        {
+            while (n > 0) {
+                ++it;
+                --n;
+            }
+        }
+
+#if BOOST_WORKAROUND(BOOST_GCC_VERSION, >= 40600)
+// type-limits warning issued below when n is an unsigned integral
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wtype-limits"
+#endif
+
+        template <typename BidirectionalIterator, typename Distance>
+        inline BOOST_CXX14_CONSTEXPR void
+        advance_impl(
+            BidirectionalIterator& it
+          , Distance n
+          , bidirectional_traversal_tag
+        )
+        {
+            if (n >= 0) {
+                while (n > 0) {
+                    ++it;
+                    --n;
+                }
+            }
+            else {
+                while (n < 0) {
+                    --it;
+                    ++n;
+                }
+            }
+        }
+
+#if BOOST_WORKAROUND(BOOST_GCC_VERSION, >= 40600)
+#pragma GCC diagnostic pop
+#endif
+
+        template <typename RandomAccessIterator, typename Distance>
+        inline BOOST_CXX14_CONSTEXPR void
+        advance_impl(
+            RandomAccessIterator& it
+          , Distance n
+          , random_access_traversal_tag
+        )
+        {
+            it += n;
+        }
+    }
+
+    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()
+            );
+        }
+    }
+
+    using namespace advance_adl_barrier;
+
+} // namespace iterators
+
+using namespace iterators::advance_adl_barrier;
+
+} // namespace boost
+
+#endif

include/boost/iterator/counting_iterator.hpp

@@ -5,12 +5,21 @@
 #ifndef COUNTING_ITERATOR_DWA200348_HPP
 # define COUNTING_ITERATOR_DWA200348_HPP
 
-# include <boost/iterator/iterator_adaptor.hpp>
+# include <boost/config.hpp>
+# include <boost/static_assert.hpp>
+# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+# include <limits>
+# elif !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
+# include <boost/type_traits/is_convertible.hpp>
+# else
+# include <boost/type_traits/is_arithmetic.hpp>
+# endif
+# include <boost/type_traits/is_integral.hpp>
+# include <boost/type_traits/type_identity.hpp>
+# include <boost/type_traits/conditional.hpp>
+# include <boost/type_traits/integral_constant.hpp>
 # include <boost/detail/numeric_traits.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/identity.hpp>
-# include <boost/mpl/eval_if.hpp>
+# include <boost/iterator/iterator_adaptor.hpp>
 
 namespace boost {
 namespace iterators {
@@ -38,14 +47,14 @@ namespace detail
 
 # else
 
-#  if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+#  if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
       BOOST_STATIC_CONSTANT(
           bool, value = (
               boost::is_convertible<int,T>::value
            && boost::is_convertible<T,int>::value
       ));
 #  else
-    BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
+      BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
 #  endif
 
 # endif
@@ -53,23 +62,33 @@ namespace detail
 
   template <class T>
   struct is_numeric
-    : mpl::bool_<(::boost::iterators::detail::is_numeric_impl<T>::value)>
+    : boost::integral_constant<bool, ::boost::iterators::detail::is_numeric_impl<T>::value>
   {};
 
 #  if defined(BOOST_HAS_LONG_LONG)
   template <>
-  struct is_numeric< ::boost::long_long_type>
-    : mpl::true_ {};
+  struct is_numeric<boost::long_long_type>
+    : boost::true_type {};
 
   template <>
-  struct is_numeric< ::boost::ulong_long_type>
-    : mpl::true_ {};
+  struct is_numeric<boost::ulong_long_type>
+    : boost::true_type {};
+#  endif
+
+#  if defined(BOOST_HAS_INT128)
+  template <>
+  struct is_numeric<boost::int128_type>
+    : boost::true_type {};
+
+  template <>
+  struct is_numeric<boost::uint128_type>
+    : boost::true_type {};
 #  endif
 
   // Some compilers fail to have a numeric_limits specialization
   template <>
   struct is_numeric<wchar_t>
-    : mpl::true_ {};
+    : true_type {};
 
   template <class T>
   struct numeric_difference
@@ -77,27 +96,40 @@ namespace detail
       typedef typename boost::detail::numeric_traits<T>::difference_type type;
   };
 
-  BOOST_STATIC_ASSERT(is_numeric<int>::value);
+#  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>
+  {
+      typedef boost::int128_type type;
+  };
+
+  template <>
+  struct numeric_difference<boost::uint128_type>
+  {
+      typedef boost::int128_type type;
+  };
+#  endif
 
   template <class Incrementable, class CategoryOrTraversal, class Difference>
   struct counting_iterator_base
   {
       typedef typename detail::ia_dflt_help<
           CategoryOrTraversal
-        , mpl::eval_if<
-              is_numeric<Incrementable>
-            , mpl::identity<random_access_traversal_tag>
+        , typename boost::conditional<
+              is_numeric<Incrementable>::value
+            , boost::type_identity<random_access_traversal_tag>
             , iterator_traversal<Incrementable>
-          >
+          >::type
       >::type traversal;
 
       typedef typename detail::ia_dflt_help<
           Difference
-        , mpl::eval_if<
-              is_numeric<Incrementable>
+        , typename boost::conditional<
+              is_numeric<Incrementable>::value
             , numeric_difference<Incrementable>
             , iterator_difference<Incrementable>
-          >
+          >::type
       >::type difference;
 
       typedef iterator_adaptor<
@@ -161,9 +193,9 @@ class counting_iterator
  public:
     typedef typename super_t::difference_type difference_type;
 
-    counting_iterator() { }
+    BOOST_DEFAULTED_FUNCTION(counting_iterator(), {})
 
-    counting_iterator(counting_iterator const& rhs) : super_t(rhs.base()) {}
+    BOOST_DEFAULTED_FUNCTION(counting_iterator(counting_iterator const& rhs), : super_t(rhs.base()) {})
 
     counting_iterator(Incrementable x)
       : super_t(x)
@@ -180,6 +212,8 @@ class counting_iterator
     {}
 # endif
 
+    BOOST_DEFAULTED_FUNCTION(counting_iterator& operator=(counting_iterator const& rhs), { *static_cast< super_t* >(this) = static_cast< super_t const& >(rhs); return *this; })
+
  private:
 
     typename super_t::reference dereference() const
@@ -191,13 +225,13 @@ class counting_iterator
     difference_type
     distance_to(counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& y) const
     {
-      typedef typename mpl::if_<
-          detail::is_numeric<Incrementable>
-        , detail::number_distance<difference_type, Incrementable, OtherIncrementable>
-        , detail::iterator_distance<difference_type, Incrementable, OtherIncrementable>
-      >::type d;
+        typedef typename boost::conditional<
+            detail::is_numeric<Incrementable>::value
+          , detail::number_distance<difference_type, Incrementable, OtherIncrementable>
+          , detail::iterator_distance<difference_type, Incrementable, OtherIncrementable>
+        >::type d;
 
-      return d::distance(this->base(), y.base());
+        return d::distance(this->base(), y.base());
     }
 };
 
@@ -206,8 +240,8 @@ template <class Incrementable>
 inline counting_iterator<Incrementable>
 make_counting_iterator(Incrementable x)
 {
-  typedef counting_iterator<Incrementable> result_t;
-  return result_t(x);
+    typedef counting_iterator<Incrementable> result_t;
+    return result_t(x);
 }
 
 } // namespace iterators

include/boost/iterator/detail/config_def.hpp

@@ -18,16 +18,16 @@
 
 #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))
+    || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x531))
 
 // Recall that in general, compilers without partial specialization
 // can't strip constness.  Consider counting_iterator, which normally
@@ -46,11 +46,11 @@
 
 #endif
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                      \
+#if BOOST_WORKAROUND(BOOST_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
@@ -79,7 +79,7 @@
 
   int z2[(lvalue_deref_helper<v*>::value == 1) ? 1 : -1];
   int z[(lvalue_deref_helper<value_iterator>::value) == 1 ? -1 : 1 ];
-# endif 
+# endif
 
 #endif
 
@@ -88,7 +88,7 @@
 #endif
 
 #if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
 #  define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
 
 #  if 0 // test code
@@ -112,9 +112,9 @@
 
 #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 
+#endif
 
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
 
 // GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
 // operators in convertibility checks, causing premature errors.
@@ -123,6 +123,6 @@
 // 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 
+# endif
 
 // no include guard; multiple inclusion intended

include/boost/iterator/detail/config_undef.hpp

@@ -21,4 +21,4 @@
 # undef BOOST_ITERATOR_CONFIG_DEF
 #else
 # error missing or nested #include config_def
-#endif 
+#endif

include/boost/iterator/detail/enable_if.hpp

@@ -7,10 +7,11 @@
 #ifndef BOOST_ENABLE_IF_23022003THW_HPP
 #define BOOST_ENABLE_IF_23022003THW_HPP
 
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/identity.hpp>
-
+#include <boost/config.hpp>
 #include <boost/iterator/detail/config_def.hpp>
+#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE)
+#include <boost/type_traits/type_identity.hpp>
+#endif
 
 //
 // Boost iterators uses its own enable_if cause we need
@@ -48,7 +49,6 @@ namespace boost
       struct base
       {
 #ifdef BOOST_NO_SFINAE
-
         typedef T type;
 
         // This way to do it would give a nice error message containing
@@ -69,7 +69,7 @@ namespace boost
 # if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE)
       : enabled<(Cond::value)>::template base<Return>
 # else
-      : mpl::identity<Return>
+      : boost::type_identity<Return>
 # endif
     {
     };

include/boost/iterator/detail/facade_iterator_category.hpp

@@ -4,6 +4,8 @@
 #ifndef FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
 # define FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
 
+# include <boost/core/use_default.hpp>
+
 # include <boost/iterator/iterator_categories.hpp>
 
 # include <boost/mpl/or.hpp>  // used in iterator_tag inheritance logic
@@ -11,15 +13,14 @@
 # include <boost/mpl/if.hpp>
 # include <boost/mpl/eval_if.hpp>
 # include <boost/mpl/identity.hpp>
-# include <boost/mpl/assert.hpp>
+
+# include <boost/static_assert.hpp>
 
 # include <boost/type_traits/is_same.hpp>
 # include <boost/type_traits/is_const.hpp>
 # include <boost/type_traits/is_reference.hpp>
 # include <boost/type_traits/is_convertible.hpp>
 
-# 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
@@ -33,8 +34,7 @@
 namespace boost {
 namespace iterators {
 
-// forward declaration
-struct use_default;
+using boost::use_default;
 
 namespace detail {
 
@@ -138,17 +138,17 @@ struct iterator_category_with_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((
-        is_convertible<
+    BOOST_STATIC_ASSERT((
+        !is_convertible<
               typename iterator_category_to_traversal<Category>::type
             , Traversal
-          >));
+          >::value));
 
-    BOOST_MPL_ASSERT((is_iterator_category<Category>));
-    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
-    BOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>));
+    BOOST_STATIC_ASSERT(is_iterator_category<Category>::value);
+    BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value);
+    BOOST_STATIC_ASSERT(!is_iterator_traversal<Category>::value);
 #  if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
-    BOOST_MPL_ASSERT((is_iterator_traversal<Traversal>));
+    BOOST_STATIC_ASSERT(is_iterator_traversal<Traversal>::value);
 #  endif
 };
 
@@ -157,7 +157,7 @@ struct iterator_category_with_traversal
 template <class Traversal, class ValueParam, class Reference>
 struct facade_iterator_category_impl
 {
-    BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
+    BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value);
 
     typedef typename iterator_facade_default_category<
         Traversal,ValueParam,Reference

include/boost/iterator/distance.hpp

@@ -0,0 +1,65 @@
+// Copyright (C) 2017 Michel Morin.
+//
+// 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_ITERATOR_DISTANCE_HPP
+#define BOOST_ITERATOR_DISTANCE_HPP
+
+#include <boost/config.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost {
+namespace iterators {
+
+    namespace detail {
+        template <typename SinglePassIterator>
+        inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type
+        distance_impl(
+            SinglePassIterator first
+          , SinglePassIterator last
+          , single_pass_traversal_tag
+        )
+        {
+            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;
+        }
+    }
+
+    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()
+            );
+        }
+    }
+
+    using namespace distance_adl_barrier;
+
+} // namespace iterators
+
+using namespace iterators::distance_adl_barrier;
+
+} // namespace boost
+
+#endif

include/boost/iterator/filter_iterator.hpp

@@ -7,12 +7,19 @@
 #ifndef BOOST_FILTER_ITERATOR_23022003THW_HPP
 #define BOOST_FILTER_ITERATOR_23022003THW_HPP
 
-#include <boost/iterator.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/iterator/iterator_categories.hpp>
 
 #include <boost/type_traits/is_class.hpp>
 #include <boost/static_assert.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_ITERATOR_DETAIL_MOVE(_type, _value) static_cast< _type&& >(_value)
+#else
+#define BOOST_ITERATOR_DETAIL_MOVE(_type, _value) _value
+#endif
 
 namespace boost {
 namespace iterators {
@@ -55,13 +62,13 @@ namespace iterators {
       filter_iterator() { }
 
       filter_iterator(Predicate f, Iterator x, Iterator end_ = Iterator())
-          : super_t(x), m_predicate(f), m_end(end_)
+          : super_t(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x)), m_predicate(BOOST_ITERATOR_DETAIL_MOVE(Predicate, f)), m_end(BOOST_ITERATOR_DETAIL_MOVE(Iterator, end_))
       {
           satisfy_predicate();
       }
 
       filter_iterator(Iterator x, Iterator end_ = Iterator())
-        : super_t(x), m_predicate(), m_end(end_)
+        : super_t(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x)), m_predicate(), m_end(BOOST_ITERATOR_DETAIL_MOVE(Iterator, end_))
       {
         // Pro8 is a little too aggressive about instantiating the
         // body of this function.
@@ -112,7 +119,7 @@ namespace iterators {
   inline filter_iterator<Predicate,Iterator>
   make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator())
   {
-      return filter_iterator<Predicate,Iterator>(f,x,end);
+      return filter_iterator<Predicate,Iterator>(BOOST_ITERATOR_DETAIL_MOVE(Predicate, f), BOOST_ITERATOR_DETAIL_MOVE(Iterator, x), BOOST_ITERATOR_DETAIL_MOVE(Iterator, end));
   }
 
   template <class Predicate, class Iterator>
@@ -124,7 +131,7 @@ namespace iterators {
       >::type x
     , Iterator end = Iterator())
   {
-      return filter_iterator<Predicate,Iterator>(x,end);
+      return filter_iterator<Predicate,Iterator>(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x), BOOST_ITERATOR_DETAIL_MOVE(Iterator, end));
   }
 
 } // namespace iterators
@@ -134,4 +141,6 @@ using iterators::make_filter_iterator;
 
 } // namespace boost
 
+#undef BOOST_ITERATOR_DETAIL_MOVE
+
 #endif // BOOST_FILTER_ITERATOR_23022003THW_HPP

include/boost/iterator/function_input_iterator.hpp

@@ -9,65 +9,91 @@
 #ifndef BOOST_FUNCTION_INPUT_ITERATOR
 #define BOOST_FUNCTION_INPUT_ITERATOR
 
+#include <boost/config.hpp>
 #include <boost/assert.hpp>
-#include <boost/mpl/if.hpp>
+#include <boost/core/addressof.hpp>
+#include <boost/type_traits/conditional.hpp>
 #include <boost/function_types/is_function_pointer.hpp>
-#include <boost/function_types/is_function_reference.hpp>
 #include <boost/function_types/result_type.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/none.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 {
 
+    template <class Function, class Input>
+    class function_input_iterator;
+
     namespace impl {
 
+        // Computes the return type of an lvalue-call with an empty argument,
+        // 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 boost::conditional<is_function<F>::value, F&, F>::type()
+#else
+                F&()
+#endif
+            >::type type;
+        };
+
         template <class Function, class Input>
-        class function_input_iterator
-            : public iterator_facade<
-            function_input_iterator<Function, Input>,
-            typename Function::result_type,
-            single_pass_traversal_tag,
-            typename Function::result_type const &
+        class function_object_input_iterator :
+            public iterator_facade<
+                iterators::function_input_iterator<Function, Input>,
+                typename result_of_nullary_lvalue_call<Function>::type,
+                single_pass_traversal_tag,
+                typename result_of_nullary_lvalue_call<Function>::type const &
             >
         {
         public:
-            function_input_iterator() {}
-            function_input_iterator(Function & f_, Input state_ = Input())
-                : f(&f_), state(state_) {}
+            function_object_input_iterator() {}
+            function_object_input_iterator(Function & f_, Input state_ = Input())
+                : f(boost::addressof(f_)), state(state_) {}
 
             void increment() {
-                if(value)
+                if (value)
                     value = none;
                 else
                     (*f)();
                 ++state;
             }
 
-            typename Function::result_type const &
+            typename result_of_nullary_lvalue_call<Function>::type const &
                 dereference() const {
-                    return (value ? value : value = (*f)()).get();
+                if (!value)
+                    value = (*f)();
+                return value.get();
             }
 
-            bool equal(function_input_iterator const & other) const {
+            bool equal(function_object_input_iterator const & other) const {
                 return f == other.f && state == other.state;
             }
 
         private:
             Function * f;
             Input state;
-            mutable optional<typename Function::result_type> value;
+            mutable optional<typename result_of_nullary_lvalue_call<Function>::type> value;
         };
 
         template <class Function, class Input>
-        class function_pointer_input_iterator
-            : public iterator_facade<
-            function_pointer_input_iterator<Function, Input>,
-            typename function_types::result_type<Function>::type,
-            single_pass_traversal_tag,
-            typename function_types::result_type<Function>::type const &
+        class function_pointer_input_iterator :
+            public iterator_facade<
+                iterators::function_input_iterator<Function, Input>,
+                typename function_types::result_type<Function>::type,
+                single_pass_traversal_tag,
+                typename function_types::result_type<Function>::type const &
             >
         {
         public:
@@ -76,7 +102,7 @@ namespace iterators {
                 : f(f_), state(state_) {}
 
             void increment() {
-                if(value)
+                if (value)
                     value = none;
                 else
                     (*f)();
@@ -85,7 +111,9 @@ namespace iterators {
 
             typename function_types::result_type<Function>::type const &
                 dereference() const {
-                    return (value ? value : value = (*f)()).get();
+                if (!value)
+                    value = (*f)();
+                return value.get();
             }
 
             bool equal(function_pointer_input_iterator const & other) const {
@@ -98,38 +126,20 @@ namespace iterators {
             mutable optional<typename function_types::result_type<Function>::type> value;
         };
 
-        template <class Function, class Input>
-        class function_reference_input_iterator
-            : public function_pointer_input_iterator<Function*,Input>
-        {
-        public:
-            function_reference_input_iterator(Function & f_, Input state_ = Input())
-                : function_pointer_input_iterator<Function*,Input>(&f_, state_)
-            {}
-        };
-
     } // namespace impl
 
     template <class Function, class Input>
-    class function_input_iterator
-        : public mpl::if_<
-            function_types::is_function_pointer<Function>,
+    class function_input_iterator :
+        public boost::conditional<
+            function_types::is_function_pointer<Function>::value,
             impl::function_pointer_input_iterator<Function,Input>,
-            typename mpl::if_<
-                function_types::is_function_reference<Function>,
-                impl::function_reference_input_iterator<Function,Input>,
-                impl::function_input_iterator<Function,Input>
-            >::type
+            impl::function_object_input_iterator<Function,Input>
         >::type
     {
-        typedef typename mpl::if_<
-            function_types::is_function_pointer<Function>,
+        typedef typename boost::conditional<
+            function_types::is_function_pointer<Function>::value,
             impl::function_pointer_input_iterator<Function,Input>,
-            typename mpl::if_<
-                function_types::is_function_reference<Function>,
-                impl::function_reference_input_iterator<Function,Input>,
-                impl::function_input_iterator<Function,Input>
-            >::type
+            impl::function_object_input_iterator<Function,Input>
         >::type base_type;
     public:
         function_input_iterator(Function & f, Input i)
@@ -150,7 +160,8 @@ namespace iterators {
             return result_t(f, state);
     }
 
-    struct infinite {
+    struct infinite
+    {
         infinite & operator++() { return *this; }
         infinite & operator++(int) { return *this; }
         bool operator==(infinite &) const { return false; };

include/boost/iterator/function_output_iterator.hpp

@@ -0,0 +1,95 @@
+// (C) Copyright Jeremy Siek 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:
+
+// 27 Feb 2001   Jeremy Siek
+//      Initial checkin.
+
+#ifndef BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
+#define BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
+
+#include <iterator>
+#include <boost/config.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#include <boost/type_traits/remove_reference.hpp>
+#endif
+
+namespace boost {
+namespace iterators {
+
+  template <class UnaryFunction>
+  class function_output_iterator {
+  private:
+    typedef function_output_iterator self;
+
+    class output_proxy {
+    public:
+      explicit output_proxy(UnaryFunction& f) BOOST_NOEXCEPT : m_f(f) { }
+
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+      template <class T>
+      typename boost::disable_if_c<
+        boost::is_same< typename boost::remove_cv< T >::type, output_proxy >::value,
+        output_proxy&
+      >::type operator=(const T& value) {
+        m_f(value);
+        return *this;
+      }
+#else
+      template <class T>
+      typename boost::disable_if_c<
+        boost::is_same< typename boost::remove_cv< typename boost::remove_reference< T >::type >::type, output_proxy >::value,
+        output_proxy&
+      >::type operator=(T&& value) {
+        m_f(static_cast< T&& >(value));
+        return *this;
+      }
+#endif
+
+      BOOST_DEFAULTED_FUNCTION(output_proxy(output_proxy const& that), BOOST_NOEXCEPT : m_f(that.m_f) {})
+      BOOST_DELETED_FUNCTION(output_proxy& operator=(output_proxy const&))
+
+    private:
+      UnaryFunction& m_f;
+    };
+
+  public:
+    typedef std::output_iterator_tag iterator_category;
+    typedef void                value_type;
+    typedef void                difference_type;
+    typedef void                pointer;
+    typedef void                reference;
+
+    explicit function_output_iterator() {}
+
+    explicit function_output_iterator(const UnaryFunction& f)
+      : m_f(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>
+  inline function_output_iterator<UnaryFunction>
+  make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
+    return function_output_iterator<UnaryFunction>(f);
+  }
+
+} // namespace iterators
+
+using iterators::function_output_iterator;
+using iterators::make_function_output_iterator;
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP

include/boost/iterator/indirect_iterator.hpp

@@ -7,12 +7,10 @@
 #ifndef BOOST_INDIRECT_ITERATOR_23022003THW_HPP
 #define BOOST_INDIRECT_ITERATOR_23022003THW_HPP
 
-#include <boost/iterator.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 
 #include <boost/pointee.hpp>
 #include <boost/indirect_reference.hpp>
-#include <boost/detail/iterator.hpp>
 
 #include <boost/detail/indirect_traits.hpp>
 
@@ -25,6 +23,8 @@
 #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>
@@ -45,7 +45,7 @@ namespace iterators {
     template <class Iter, class Value, class Category, class Reference, class Difference>
     struct indirect_base
     {
-        typedef typename boost::detail::iterator_traits<Iter>::value_type dereferenceable;
+        typedef typename std::iterator_traits<Iter>::value_type dereferenceable;
 
         typedef iterator_adaptor<
             indirect_iterator<Iter, Value, Category, Reference, Difference>
@@ -111,7 +111,7 @@ namespace iterators {
   private:
       typename super_t::reference dereference() const
       {
-# if BOOST_WORKAROUND(__BORLANDC__, < 0x5A0 )
+# if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x5A0 )
           return const_cast<super_t::reference>(**this->base());
 # else
           return **this->base();

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/integral_constant.hpp>
+#include <boost/type_traits/negation.hpp>
+#include <boost/type_traits/conjunction.hpp>
+#include <boost/type_traits/is_complete.hpp>
+#include <boost/type_traits/is_function.hpp>
+#if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
+#include <iterator>
+#endif
+
+#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 boost::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 boost::conjunction<
+        boost::is_complete< T >,
+        boost::negation< boost::is_function< T > >
+    >::type
+{
+};
+
+template< typename T, typename U >
+struct is_iterator_impl< T U::* > :
+    public boost::false_type
+{
+};
+
+template< typename T >
+struct is_iterator_impl< T& > :
+    public boost::false_type
+{
+};
+
+template< typename T, std::size_t N >
+struct is_iterator_impl< T[N] > :
+    public boost::false_type
+{
+};
+
+#if !defined(BOOST_TT_HAS_WORKING_IS_COMPLETE)
+template< typename T >
+struct is_iterator_impl< T[] > :
+    public boost::false_type
+{
+};
+
+template< >
+struct is_iterator_impl< void > :
+    public boost::false_type
+{
+};
+
+template< >
+struct is_iterator_impl< void* > :
+    public boost::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

@@ -4,15 +4,17 @@
 #ifndef IS_LVALUE_ITERATOR_DWA2003112_HPP
 # define IS_LVALUE_ITERATOR_DWA2003112_HPP
 
-#include <boost/iterator.hpp>
-
 #include <boost/detail/workaround.hpp>
-#include <boost/detail/iterator.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>
 
 // should be the last #includes
-#include <boost/type_traits/detail/bool_trait_def.hpp>
+#include <boost/type_traits/integral_constant.hpp>
 #include <boost/iterator/detail/config_def.hpp>
 
 #ifndef BOOST_NO_IS_CONVERTIBLE
@@ -52,7 +54,7 @@ namespace detail
       // convertible to Value const&
       struct conversion_eater
       {
-          conversion_eater(Value&);
+          conversion_eater(typename add_lvalue_reference<Value>::type);
       };
 
       static char tester(conversion_eater, int);
@@ -122,25 +124,31 @@ namespace detail
   template <class It>
   struct is_readable_lvalue_iterator_impl
     : is_lvalue_iterator_impl<
-          BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<It>::value_type const
+          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 boost::detail::iterator_traits<It>::value_type
+          BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type
       >::template rebind<It>
   {};
 } // namespace detail
 
-// Define the trait with full mpl lambda capability and various broken
-// compiler workarounds
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_lvalue_iterator,T,::boost::iterators::detail::is_readable_lvalue_iterator_impl<T>::value)
+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))
+};
 
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_non_const_lvalue_iterator,T,::boost::iterators::detail::is_non_const_lvalue_iterator_impl<T>::value)
+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>
+{
+public:
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_non_const_lvalue_iterator,(T))
+};
 
 } // namespace iterators
 
@@ -152,6 +160,5 @@ using iterators::is_non_const_lvalue_iterator;
 #endif
 
 #include <boost/iterator/detail/config_undef.hpp>
-#include <boost/type_traits/detail/bool_trait_undef.hpp>
 
 #endif // IS_LVALUE_ITERATOR_DWA2003112_HPP

include/boost/iterator/is_readable_iterator.hpp

@@ -5,12 +5,15 @@
 # define IS_READABLE_ITERATOR_DWA2003112_HPP
 
 #include <boost/mpl/bool.hpp>
-#include <boost/detail/iterator.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/type_traits/add_lvalue_reference.hpp>
 
-#include <boost/type_traits/detail/bool_trait_def.hpp>
 #include <boost/iterator/detail/any_conversion_eater.hpp>
 
+#include <iterator>
+
 // should be the last #include
+#include <boost/type_traits/integral_constant.hpp>
 #include <boost/iterator/detail/config_def.hpp>
 
 #ifndef BOOST_NO_IS_CONVERTIBLE
@@ -26,7 +29,7 @@ namespace detail
   template <class Value>
   struct is_readable_iterator_impl
   {
-      static char tester(Value&, int);
+      static char tester(typename add_lvalue_reference<Value>::type, int);
       static char (& tester(any_conversion_eater, ...) )[2];
 
       template <class It>
@@ -91,15 +94,17 @@ namespace detail
   template <class It>
   struct is_readable_iterator_impl2
     : is_readable_iterator_impl<
-          BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<It>::value_type const
+          BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type const
       >::template rebind<It>
   {};
 } // namespace detail
 
-// Define the trait with full mpl lambda capability and various broken
-// compiler workarounds
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_readable_iterator,T,::boost::iterators::detail::is_readable_iterator_impl2<T>::value)
+template< typename T > struct is_readable_iterator
+: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_iterator_impl2<T>::value>
+{
+public:
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_readable_iterator,(T))
+};
 
 } // namespace iterators
 

include/boost/iterator/iterator_adaptor.hpp

@@ -8,8 +8,8 @@
 #define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
 
 #include <boost/static_assert.hpp>
-#include <boost/iterator.hpp>
-#include <boost/detail/iterator.hpp>
+
+#include <boost/core/use_default.hpp>
 
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/iterator/iterator_facade.hpp>
@@ -37,12 +37,10 @@ namespace iterators {
   // Used as a default template argument internally, merely to
   // indicate "use the default", this can also be passed by users
   // explicitly in order to specify that the default should be used.
-  struct use_default;
+  using boost::use_default;
 
 } // namespace iterators
 
-using iterators::use_default;
-
 // the incompleteness of use_default causes massive problems for
 // is_convertible (naturally).  This workaround is fortunately not
 // needed for vc6/vc7.

include/boost/iterator/iterator_archetypes.hpp

@@ -9,7 +9,6 @@
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/operators.hpp>
 #include <boost/static_assert.hpp>
-#include <boost/iterator.hpp>
 
 #include <boost/iterator/detail/facade_iterator_category.hpp>
 
@@ -427,15 +426,16 @@ namespace detail
       >::type iterator_category;
 
       // Needed for some broken libraries (see below)
-      typedef boost::iterator<
-          iterator_category
-        , Value
-        , typename traversal_archetype_base<
+      struct workaround_iterator_base
+      {
+        typedef typename iterator_archetype_base::iterator_category iterator_category;
+        typedef Value value_type;
+        typedef typename traversal_archetype_base<
               Value, AccessCategory, TraversalCategory
-          >::difference_type
-        , typename access::pointer
-        , typename access::reference
-      > workaround_iterator_base;
+          >::difference_type difference_type;
+        typedef typename access::pointer pointer;
+        typedef typename access::reference reference;
+      };
   };
 }
 

include/boost/iterator/iterator_categories.hpp

@@ -7,7 +7,6 @@
 # define BOOST_ITERATOR_CATEGORIES_HPP
 
 # include <boost/config.hpp>
-# include <boost/detail/iterator.hpp>
 # include <boost/iterator/detail/config_def.hpp>
 
 # include <boost/detail/workaround.hpp>
@@ -21,6 +20,8 @@
 
 # include <boost/static_assert.hpp>
 
+#include <iterator>
+
 namespace boost {
 namespace iterators {
 
@@ -116,7 +117,7 @@ struct iterator_category_to_traversal
 template <class Iterator = mpl::_1>
 struct iterator_traversal
   : iterator_category_to_traversal<
-        typename boost::detail::iterator_traits<Iterator>::iterator_category
+        typename std::iterator_traits<Iterator>::iterator_category
     >
 {};
 
@@ -168,13 +169,6 @@ struct pure_traversal_tag
 {
 };
 
-// This import is needed for backward compatibility with Boost.Range:
-// boost/range/detail/demote_iterator_traversal_tag.hpp
-// It should be removed when that header is fixed.
-namespace detail {
-using iterators::pure_traversal_tag;
-} // namespace detail
-
 //
 // Trait to retrieve one of the iterator traversal tags from the iterator category or traversal.
 //

include/boost/iterator/iterator_concepts.hpp

@@ -9,9 +9,6 @@
 #include <boost/concept_check.hpp>
 #include <boost/iterator/iterator_categories.hpp>
 
-// Use boost::detail::iterator_traits to work around some MSVC/Dinkumware problems.
-#include <boost/detail/iterator.hpp>
-
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_integral.hpp>
 
@@ -27,6 +24,7 @@
 #include <boost/config.hpp>
 
 #include <algorithm>
+#include <iterator>
 
 #include <boost/concept/detail/concept_def.hpp>
 
@@ -44,8 +42,8 @@ namespace boost_concepts
     , boost::CopyConstructible<Iterator>
 
   {
-      typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type value_type;
-      typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference reference;
+      typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type value_type;
+      typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference reference;
 
       BOOST_CONCEPT_USAGE(ReadableIterator)
       {
@@ -59,7 +57,7 @@ namespace boost_concepts
 
   template <
       typename Iterator
-    , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
+    , typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type
   >
   struct WritableIterator
     : boost::CopyConstructible<Iterator>
@@ -75,7 +73,7 @@ namespace boost_concepts
 
   template <
       typename Iterator
-    , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
+    , typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type
   >
   struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
 
@@ -92,7 +90,7 @@ namespace boost_concepts
 
   BOOST_concept(LvalueIterator,(Iterator))
   {
-      typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
+      typedef typename std::iterator_traits<Iterator>::value_type value_type;
 
       BOOST_CONCEPT_USAGE(LvalueIterator)
       {
@@ -144,10 +142,10 @@ namespace boost_concepts
     : SinglePassIterator<Iterator>
     , boost::DefaultConstructible<Iterator>
   {
-      typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
+      typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
 
-      BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
-      BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
+      BOOST_STATIC_ASSERT(boost::is_integral<difference_type>::value);
+      BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_signed);
 
       BOOST_CONCEPT_ASSERT((
           boost::Convertible<
@@ -221,7 +219,7 @@ namespace boost_concepts
         boost::random_access_traversal_tag, boost::random_access_traversal_tag)
     {
         bool b;
-        typename boost::detail::iterator_traits<Iterator2>::difference_type n;
+        typename std::iterator_traits<Iterator2>::difference_type n;
         b = i1 <  i2;
         b = i1 <= i2;
         b = i1 >  i2;

include/boost/iterator/iterator_facade.hpp

@@ -8,7 +8,6 @@
 #define BOOST_ITERATOR_FACADE_23022003THW_HPP
 
 #include <boost/config.hpp>
-#include <boost/iterator.hpp>
 #include <boost/iterator/interoperable.hpp>
 #include <boost/iterator/iterator_traits.hpp>
 #include <boost/iterator/iterator_categories.hpp>
@@ -17,11 +16,12 @@
 #include <boost/iterator/detail/enable_if.hpp>
 
 #include <boost/static_assert.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/core/addressof.hpp>
 
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_pointer.hpp>
+#include <boost/type_traits/add_lvalue_reference.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/is_convertible.hpp>
@@ -36,6 +36,8 @@
 #include <boost/mpl/apply.hpp>
 #include <boost/mpl/identity.hpp>
 
+#include <cstddef>
+
 #include <boost/iterator/detail/config_def.hpp> // this goes last
 
 namespace boost {
@@ -152,79 +154,160 @@ namespace iterators {
     class postfix_increment_proxy
     {
         typedef typename iterator_value<Iterator>::type value_type;
+
      public:
         explicit postfix_increment_proxy(Iterator const& x)
-          : stored_value(*x)
+          : stored_iterator(x)
+          , stored_value(*x)
         {}
 
         // Returning a mutable reference allows nonsense like
         // (*r++).mutate(), but it imposes fewer assumptions about the
         // behavior of the value_type.  In particular, recall that
         // (*r).mutate() is legal if operator* returns by value.
-        value_type&
-        operator*() const
-        {
-            return this->stored_value;
-        }
-     private:
-        mutable value_type stored_value;
-    };
-
-    //
-    // In general, we can't determine that such an iterator isn't
-    // writable -- we also need to store a copy of the old iterator so
-    // that it can be written into.
-    template <class Iterator>
-    class writable_postfix_increment_proxy
-    {
-        typedef typename iterator_value<Iterator>::type value_type;
-     public:
-        explicit writable_postfix_increment_proxy(Iterator const& x)
-          : stored_value(*x)
-          , stored_iterator(x)
-        {}
-
-        // Dereferencing must return a proxy so that both *r++ = o and
-        // value_type(*r++) can work.  In this case, *r is the same as
-        // *r++, and the conversion operator below is used to ensure
-        // readability.
-        writable_postfix_increment_proxy const&
-        operator*() const
-        {
-            return *this;
-        }
-
         // Provides readability of *r++
-        operator value_type&() const
+        value_type& operator*() const
         {
             return stored_value;
         }
 
-        // Provides writability of *r++
-        template <class T>
-        T const& operator=(T const& x) const
-        {
-            *this->stored_iterator = x;
-            return x;
-        }
-
-        // This overload just in case only non-const objects are writable
-        template <class T>
-        T& operator=(T& x) const
-        {
-            *this->stored_iterator = x;
-            return x;
-        }
-
         // Provides X(r++)
         operator Iterator const&() const
         {
             return stored_iterator;
         }
 
+        // Provides (r++)->foo()
+        value_type* operator->() const
+        {
+            return boost::addressof(stored_value);
+        }
+
      private:
-        mutable value_type stored_value;
         Iterator stored_iterator;
+        mutable value_type stored_value;
+    };
+
+
+    template <class Iterator>
+    class writable_postfix_increment_dereference_proxy;
+
+    template <class T>
+    struct is_not_writable_postfix_increment_dereference_proxy :
+        public boost::true_type
+    {};
+
+    template <class Iterator>
+    struct is_not_writable_postfix_increment_dereference_proxy<
+        writable_postfix_increment_dereference_proxy<Iterator>
+    > :
+        public boost::false_type
+    {};
+
+    template <class Iterator>
+    class writable_postfix_increment_proxy;
+
+    //
+    // In general, we can't determine that such an iterator isn't
+    // writable -- we also need to store a copy of the old iterator so
+    // that it can be written into.
+    template <class Iterator>
+    class writable_postfix_increment_dereference_proxy
+    {
+        friend class writable_postfix_increment_proxy<Iterator>;
+
+        typedef typename iterator_value<Iterator>::type value_type;
+
+     public:
+        explicit writable_postfix_increment_dereference_proxy(Iterator const& x)
+          : stored_iterator(x)
+          , stored_value(*x)
+        {}
+
+        // Provides readability of *r++
+        operator value_type&() const
+        {
+            return this->stored_value;
+        }
+
+        template <class OtherIterator>
+        writable_postfix_increment_dereference_proxy const&
+        operator=(writable_postfix_increment_dereference_proxy<OtherIterator> const& x) const
+        {
+            typedef typename iterator_value<OtherIterator>::type other_value_type;
+            *this->stored_iterator = static_cast<other_value_type&>(x);
+            return *this;
+        }
+
+        // Provides writability of *r++
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        template <class T>
+        typename iterators::enable_if<
+            is_not_writable_postfix_increment_dereference_proxy< T >,
+            writable_postfix_increment_dereference_proxy const&
+        >::type operator=(T&& x) const
+        {
+            *this->stored_iterator = static_cast< T&& >(x);
+            return *this;
+        }
+#else
+        template <class T>
+        typename iterators::enable_if<
+            is_not_writable_postfix_increment_dereference_proxy< T >,
+            writable_postfix_increment_dereference_proxy const&
+        >::type operator=(T const& x) const
+        {
+            *this->stored_iterator = x;
+            return *this;
+        }
+
+        // This overload just in case only non-const objects are writable
+        template <class T>
+        typename iterators::enable_if<
+            is_not_writable_postfix_increment_dereference_proxy< T >,
+            writable_postfix_increment_dereference_proxy const&
+        >::type operator=(T& x) const
+        {
+            *this->stored_iterator = x;
+            return *this;
+        }
+#endif
+
+     private:
+        Iterator stored_iterator;
+        mutable value_type stored_value;
+    };
+
+    template <class Iterator>
+    class writable_postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+
+     public:
+        explicit writable_postfix_increment_proxy(Iterator const& x)
+          : dereference_proxy(x)
+        {}
+
+        writable_postfix_increment_dereference_proxy<Iterator> const&
+        operator*() const
+        {
+            return dereference_proxy;
+        }
+
+        // Provides X(r++)
+        operator Iterator const&() const
+        {
+            return dereference_proxy.stored_iterator;
+        }
+
+        // Provides (r++)->foo()
+        value_type* operator->() const
+        {
+            return boost::addressof(dereference_proxy.stored_value);
+        }
+
+     private:
+        writable_postfix_increment_dereference_proxy<Iterator> dereference_proxy;
     };
 
 # ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@@ -284,7 +367,15 @@ namespace iterators {
       : mpl::eval_if<
             mpl::and_<
                 // A proxy is only needed for readable iterators
-                is_convertible<Reference,Value const&>
+                is_convertible<
+                    Reference
+                    // Use add_lvalue_reference to form `reference to Value` due to
+                    // some (strict) C++03 compilers (e.g. `gcc -std=c++03`) reject
+                    // 'reference-to-reference' in the template which described in CWG
+                    // DR106.
+                    // http://www.open-std.org/Jtc1/sc22/wg21/docs/cwg_defects.html#106
+                  , typename add_lvalue_reference<Value const>::type
+                >
 
                 // No multipass iterator can have values that disappear
                 // before positions can be re-visited

include/boost/iterator/iterator_traits.hpp

@@ -5,9 +5,10 @@
 #ifndef ITERATOR_TRAITS_DWA200347_HPP
 # define ITERATOR_TRAITS_DWA200347_HPP
 
-# include <boost/detail/iterator.hpp>
 # include <boost/detail/workaround.hpp>
 
+#include <iterator>
+
 namespace boost {
 namespace iterators {
 
@@ -19,32 +20,32 @@ namespace iterators {
 template <class Iterator>
 struct iterator_value
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::value_type type;
+    typedef typename std::iterator_traits<Iterator>::value_type type;
 };
 
 template <class Iterator>
 struct iterator_reference
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::reference type;
+    typedef typename std::iterator_traits<Iterator>::reference type;
 };
 
 
 template <class Iterator>
 struct iterator_pointer
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::pointer type;
+    typedef typename std::iterator_traits<Iterator>::pointer type;
 };
 
 template <class Iterator>
 struct iterator_difference
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::difference_type type;
+    typedef typename std::iterator_traits<Iterator>::difference_type type;
 };
 
 template <class Iterator>
 struct iterator_category
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::iterator_category type;
+    typedef typename std::iterator_traits<Iterator>::iterator_category type;
 };
 
 } // namespace iterators

include/boost/iterator/new_iterator_tests.hpp

@@ -29,17 +29,18 @@
 //              (David Abrahams)
 
 # include <iterator>
-# include <boost/type_traits.hpp>
 # include <boost/static_assert.hpp>
 # include <boost/concept_archetype.hpp> // for detail::dummy_constructor
-# include <boost/detail/iterator.hpp>
 # include <boost/pending/iterator_tests.hpp>
 # include <boost/iterator/is_readable_iterator.hpp>
 # include <boost/iterator/is_lvalue_iterator.hpp>
+# include <boost/type_traits/is_same.hpp>
+# include <boost/mpl/bool.hpp>
+# include <boost/mpl/and.hpp>
 
 # include <boost/iterator/detail/config_def.hpp>
 # include <boost/detail/is_incrementable.hpp>
-# include <boost/detail/lightweight_test.hpp>
+# include <boost/core/lightweight_test.hpp>
 
 namespace boost {
 
@@ -76,7 +77,7 @@ template <class Iterator, class T>
 void readable_iterator_test(const Iterator i1, T v)
 {
   Iterator i2(i1); // Copy Constructible
-  typedef typename detail::iterator_traits<Iterator>::reference ref_t;
+  typedef typename std::iterator_traits<Iterator>::reference ref_t;
   ref_t r1 = *i1;
   ref_t r2 = *i2;
   T v1 = r1;
@@ -86,11 +87,11 @@ void readable_iterator_test(const Iterator i1, T v)
 
 # if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
   readable_iterator_traversal_test(i1, v, detail::is_postfix_incrementable<Iterator>());
-      
+
   // I think we don't really need this as it checks the same things as
   // the above code.
   BOOST_STATIC_ASSERT(is_readable_iterator<Iterator>::value);
-# endif 
+# endif
 }
 
 template <class Iterator, class T>
@@ -105,16 +106,16 @@ void writable_iterator_test(Iterator i, T v, T v2)
           detail::is_incrementable<Iterator>
         , detail::is_postfix_incrementable<Iterator>
       >());
-# endif 
+# endif
 }
 
 template <class Iterator>
 void swappable_iterator_test(Iterator i, Iterator j)
 {
   Iterator i2(i), j2(j);
-  typename detail::iterator_traits<Iterator>::value_type bi = *i, bj = *j;
+  typename std::iterator_traits<Iterator>::value_type bi = *i, bj = *j;
   iter_swap(i2, j2);
-  typename detail::iterator_traits<Iterator>::value_type ai = *i, aj = *j;
+  typename std::iterator_traits<Iterator>::value_type ai = *i, aj = *j;
   BOOST_TEST(bi == aj && bj == ai);
 }
 
@@ -122,37 +123,37 @@ template <class Iterator, class T>
 void constant_lvalue_iterator_test(Iterator i, T v1)
 {
   Iterator i2(i);
-  typedef typename detail::iterator_traits<Iterator>::value_type value_type;
-  typedef typename detail::iterator_traits<Iterator>::reference reference;
+  typedef typename std::iterator_traits<Iterator>::value_type value_type;
+  typedef typename std::iterator_traits<Iterator>::reference reference;
   BOOST_STATIC_ASSERT((is_same<const value_type&, reference>::value));
   const T& v2 = *i2;
   BOOST_TEST(v1 == v2);
 # ifndef BOOST_NO_LVALUE_RETURN_DETECTION
   BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
   BOOST_STATIC_ASSERT(!is_non_const_lvalue_iterator<Iterator>::value);
-# endif 
+# endif
 }
 
 template <class Iterator, class T>
 void non_const_lvalue_iterator_test(Iterator i, T v1, T v2)
 {
   Iterator i2(i);
-  typedef typename detail::iterator_traits<Iterator>::value_type value_type;
-  typedef typename detail::iterator_traits<Iterator>::reference reference;
+  typedef typename std::iterator_traits<Iterator>::value_type value_type;
+  typedef typename std::iterator_traits<Iterator>::reference reference;
   BOOST_STATIC_ASSERT((is_same<value_type&, reference>::value));
   T& v3 = *i2;
   BOOST_TEST(v1 == v3);
-  
+
   // A non-const lvalue iterator is not neccessarily writable, but we
   // are assuming the value_type is assignable here
   *i = v2;
-  
+
   T& v4 = *i2;
   BOOST_TEST(v2 == v4);
 # ifndef BOOST_NO_LVALUE_RETURN_DETECTION
   BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
   BOOST_STATIC_ASSERT(is_non_const_lvalue_iterator<Iterator>::value);
-# endif 
+# endif
 }
 
 template <class Iterator, class T>
@@ -229,7 +230,7 @@ void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals)
   {
     BOOST_TEST(i == j + c);
     BOOST_TEST(*i == vals[c]);
-    typename detail::iterator_traits<Iterator>::value_type x = j[c];
+    typename std::iterator_traits<Iterator>::value_type x = j[c];
     BOOST_TEST(*i == x);
     BOOST_TEST(*i == *(j + c));
     BOOST_TEST(*i == *(c + j));
@@ -245,9 +246,9 @@ void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals)
   {
     BOOST_TEST(i == k - c);
     BOOST_TEST(*i == vals[N - 1 - c]);
-    typename detail::iterator_traits<Iterator>::value_type x = j[N - 1 - c];
+    typename std::iterator_traits<Iterator>::value_type x = j[N - 1 - c];
     BOOST_TEST(*i == x);
-    Iterator q = k - c; 
+    Iterator q = k - c;
     BOOST_TEST(*i == *q);
     BOOST_TEST(i > j);
     BOOST_TEST(i >= j);

include/boost/iterator/permutation_iterator.hpp

@@ -21,13 +21,13 @@ template< class ElementIterator
 class permutation_iterator
   : public iterator_adaptor<
              permutation_iterator<ElementIterator, IndexIterator>
-           , IndexIterator, typename boost::detail::iterator_traits<ElementIterator>::value_type
-           , use_default, typename boost::detail::iterator_traits<ElementIterator>::reference>
+           , IndexIterator, typename std::iterator_traits<ElementIterator>::value_type
+           , use_default, typename std::iterator_traits<ElementIterator>::reference>
 {
   typedef iterator_adaptor<
             permutation_iterator<ElementIterator, IndexIterator>
-          , IndexIterator, typename boost::detail::iterator_traits<ElementIterator>::value_type
-          , use_default, typename boost::detail::iterator_traits<ElementIterator>::reference> super_t;
+          , IndexIterator, typename std::iterator_traits<ElementIterator>::value_type
+          , use_default, typename std::iterator_traits<ElementIterator>::reference> super_t;
 
   friend class iterator_core_access;
 

include/boost/iterator/reverse_iterator.hpp

@@ -7,8 +7,6 @@
 #ifndef BOOST_REVERSE_ITERATOR_23022003THW_HPP
 #define BOOST_REVERSE_ITERATOR_23022003THW_HPP
 
-#include <boost/next_prior.hpp>
-#include <boost/iterator.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 
 namespace boost {
@@ -40,14 +38,19 @@ namespace iterators {
       {}
 
    private:
-      typename super_t::reference dereference() const { return *boost::prior(this->base()); }
+      typename super_t::reference dereference() const
+      {
+          Iterator it = this->base_reference();
+          --it;
+          return *it;
+      }
 
       void increment() { --this->base_reference(); }
       void decrement() { ++this->base_reference(); }
 
       void advance(typename super_t::difference_type n)
       {
-          this->base_reference() += -n;
+          this->base_reference() -= n;
       }
 
       template <class OtherIterator>

include/boost/iterator/transform_iterator.hpp

@@ -7,12 +7,11 @@
 #ifndef BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
 #define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
 
-#include <boost/iterator.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/iterator/detail/enable_if.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/iterator/iterator_categories.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/bool.hpp>
 #include <boost/type_traits/function_traits.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_class.hpp>
@@ -22,11 +21,16 @@
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/utility/result_of.hpp>
 
+#include <iterator>
 
 #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
-# include <boost/type_traits/is_base_and_derived.hpp>
-
+#include <boost/type_traits/is_base_and_derived.hpp>
 #endif
+
+#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+#include <boost/static_assert.hpp>
+#endif
+
 #include <boost/iterator/detail/config_def.hpp>
 
 
@@ -47,7 +51,11 @@ namespace iterators {
         // the function.
         typedef typename ia_dflt_help<
             Reference
+#ifdef BOOST_RESULT_OF_USE_TR1
           , result_of<const UnaryFunc(typename std::iterator_traits<Iterator>::reference)>
+#else
+          , result_of<const UnaryFunc&(typename std::iterator_traits<Iterator>::reference)>
+#endif
         >::type reference;
 
         // To get the default for Value: remove any reference on the
@@ -150,7 +158,7 @@ namespace iterators {
       return transform_iterator<UnaryFunc, Iterator>(it, UnaryFunc());
   }
 
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
   template <class Return, class Argument, class Iterator>
   inline transform_iterator< Return (*)(Argument), Iterator, Return>
   make_transform_iterator(Iterator it, Return (*fun)(Argument))

include/boost/iterator/zip_iterator.hpp

@@ -1,30 +1,38 @@
-// Copyright David Abrahams and Thomas Becker 2000-2006. Distributed
-// under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at
+// Copyright David Abrahams and Thomas Becker 2000-2006.
+// Copyright Kohei Takahashi 2012-2014.
+//
+// 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_ZIP_ITERATOR_TMB_07_13_2003_HPP_
 # define BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
 
 #include <stddef.h>
-#include <boost/iterator.hpp>
 #include <boost/iterator/iterator_traits.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/iterator_adaptor.hpp> // for enable_if_convertible
 #include <boost/iterator/iterator_categories.hpp>
-#include <boost/detail/iterator.hpp>
 
 #include <boost/iterator/minimum_category.hpp>
 
-#include <boost/tuple/tuple.hpp>
+#include <utility> // for std::pair
+#include <boost/fusion/adapted/boost_tuple.hpp> // for backward compatibility
 
-#include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/apply.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/lambda.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/transform.hpp>
 #include <boost/mpl/placeholders.hpp>
-#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <boost/fusion/algorithm/transformation/transform.hpp>
+#include <boost/fusion/sequence/convert.hpp>
+#include <boost/fusion/sequence/intrinsic/at_c.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/support/tag_of_fwd.hpp>
 
 namespace boost {
 namespace iterators {
@@ -33,24 +41,6 @@ namespace iterators {
   template<typename IteratorTuple>
   class zip_iterator;
 
-  // One important design goal of the zip_iterator is to isolate all
-  // functionality whose implementation relies on the current tuple
-  // implementation. This goal has been achieved as follows: Inside
-  // the namespace detail there is a namespace tuple_impl_specific.
-  // This namespace encapsulates all functionality that is specific
-  // to the current Boost tuple implementation. More precisely, the
-  // namespace tuple_impl_specific provides the following tuple
-  // algorithms and meta-algorithms for the current Boost tuple
-  // implementation:
-  //
-  // tuple_meta_transform
-  // tuple_meta_accumulate
-  // tuple_transform
-  // tuple_for_each
-  //
-  // If the tuple implementation changes, all that needs to be
-  // replaced is the implementation of these four (meta-)algorithms.
-
   namespace detail
   {
 
@@ -73,313 +63,96 @@ namespace iterators {
     struct increment_iterator
     {
       template<typename Iterator>
-      void operator()(Iterator& it)
+      void operator()(Iterator& it) const
       { ++it; }
     };
     //
     struct decrement_iterator
     {
       template<typename Iterator>
-      void operator()(Iterator& it)
+      void operator()(Iterator& it) const
       { --it; }
     };
     //
     struct dereference_iterator
     {
-      template<typename Iterator>
-      struct apply
+      template<typename>
+      struct result;
+
+      template<typename This, typename Iterator>
+      struct result<This(Iterator)>
       {
         typedef typename
-          boost::detail::iterator_traits<Iterator>::reference
-        type;
+          remove_cv<typename remove_reference<Iterator>::type>::type
+        iterator;
+
+        typedef typename iterator_reference<iterator>::type type;
       };
 
       template<typename Iterator>
-        typename apply<Iterator>::type operator()(Iterator const& it)
+        typename result<dereference_iterator(Iterator)>::type
+        operator()(Iterator const& it) const
       { return *it; }
     };
 
-
-    // The namespace tuple_impl_specific provides two meta-
-    // algorithms and two algorithms for tuples.
-    //
-    namespace tuple_impl_specific
-    {
-      // Meta-transform algorithm for tuples
-      //
-      template<typename Tuple, class UnaryMetaFun>
-      struct tuple_meta_transform;
-
-      template<typename Tuple, class UnaryMetaFun>
-      struct tuple_meta_transform_impl
-      {
-          typedef tuples::cons<
-              typename mpl::apply1<
-                  typename mpl::lambda<UnaryMetaFun>::type
-                , typename Tuple::head_type
-              >::type
-            , typename tuple_meta_transform<
-                  typename Tuple::tail_type
-                , UnaryMetaFun
-              >::type
-          > type;
-      };
-
-      template<typename Tuple, class UnaryMetaFun>
-      struct tuple_meta_transform
-        : mpl::eval_if<
-              boost::is_same<Tuple, tuples::null_type>
-            , mpl::identity<tuples::null_type>
-            , tuple_meta_transform_impl<Tuple, UnaryMetaFun>
-        >
-      {
-      };
-
-      // Meta-accumulate algorithm for tuples. Note: The template
-      // parameter StartType corresponds to the initial value in
-      // ordinary accumulation.
-      //
-      template<class Tuple, class BinaryMetaFun, class StartType>
-      struct tuple_meta_accumulate;
-
-      template<
-          typename Tuple
-        , class BinaryMetaFun
-        , typename StartType
-      >
-      struct tuple_meta_accumulate_impl
-      {
-         typedef typename mpl::apply2<
-             typename mpl::lambda<BinaryMetaFun>::type
-           , typename Tuple::head_type
-           , typename tuple_meta_accumulate<
-                 typename Tuple::tail_type
-               , BinaryMetaFun
-               , StartType
-             >::type
-         >::type type;
-      };
-
-      template<
-          typename Tuple
-        , class BinaryMetaFun
-        , typename StartType
-      >
-      struct tuple_meta_accumulate
-        : mpl::eval_if<
-                  boost::is_same<Tuple, tuples::null_type>
-            , mpl::identity<StartType>
-            , tuple_meta_accumulate_impl<
-                  Tuple
-                , BinaryMetaFun
-                , StartType
-              >
-          >
-      {
-      };
-
-#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)                            \
-    || (                                                                    \
-      BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, != 0) && defined(_MSC_VER)  \
-    )
-// Not sure why intel's partial ordering fails in this case, but I'm
-// assuming int's an MSVC bug-compatibility feature.
-
-# define BOOST_TUPLE_ALGO_DISPATCH
-# define BOOST_TUPLE_ALGO(algo) algo##_impl
-# define BOOST_TUPLE_ALGO_TERMINATOR , int
-# define BOOST_TUPLE_ALGO_RECURSE , ...
-#else
-# define BOOST_TUPLE_ALGO(algo) algo
-# define BOOST_TUPLE_ALGO_TERMINATOR
-# define BOOST_TUPLE_ALGO_RECURSE
-#endif
-
-      // transform algorithm for tuples. The template parameter Fun
-      // must be a unary functor which is also a unary metafunction
-      // class that computes its return type based on its argument
-      // type. For example:
-      //
-      // struct to_ptr
-      // {
-      //     template <class Arg>
-      //     struct apply
-      //     {
-      //          typedef Arg* type;
-      //     }
-      //
-      //     template <class Arg>
-      //     Arg* operator()(Arg x);
-      // };
-      template<typename Fun>
-      inline tuples::null_type BOOST_TUPLE_ALGO(tuple_transform)
-          (tuples::null_type const&, Fun BOOST_TUPLE_ALGO_TERMINATOR)
-      { return tuples::null_type(); }
-
-      template<typename Tuple, typename Fun>
-      inline typename tuple_meta_transform<
-          Tuple
-        , Fun
-      >::type
-
-      BOOST_TUPLE_ALGO(tuple_transform)(
-        const Tuple& t,
-        Fun f
-        BOOST_TUPLE_ALGO_RECURSE
-      )
-      {
-          typedef typename tuple_meta_transform<
-              BOOST_DEDUCED_TYPENAME Tuple::tail_type
-            , Fun
-          >::type transformed_tail_type;
-
-        return tuples::cons<
-            BOOST_DEDUCED_TYPENAME mpl::apply1<
-                Fun, BOOST_DEDUCED_TYPENAME Tuple::head_type
-             >::type
-           , transformed_tail_type
-        >(
-            f(boost::tuples::get<0>(t)), tuple_transform(t.get_tail(), f)
-        );
-      }
-
-#ifdef BOOST_TUPLE_ALGO_DISPATCH
-      template<typename Tuple, typename Fun>
-      inline typename tuple_meta_transform<
-          Tuple
-        , Fun
-      >::type
-
-      tuple_transform(
-        const Tuple& t,
-        Fun f
-      )
-      {
-          return tuple_transform_impl(t, f, 1);
-      }
-#endif
-
-      // for_each algorithm for tuples.
-      //
-      template<typename Fun>
-      inline Fun BOOST_TUPLE_ALGO(tuple_for_each)(
-          tuples::null_type
-        , Fun f BOOST_TUPLE_ALGO_TERMINATOR
-      )
-      { return f; }
-
-
-      template<typename Tuple, typename Fun>
-      inline Fun BOOST_TUPLE_ALGO(tuple_for_each)(
-          Tuple& t
-        , Fun f BOOST_TUPLE_ALGO_RECURSE)
-      {
-          f( t.get_head() );
-          return tuple_for_each(t.get_tail(), f);
-      }
-
-#ifdef BOOST_TUPLE_ALGO_DISPATCH
-      template<typename Tuple, typename Fun>
-      inline Fun
-      tuple_for_each(
-        Tuple& t,
-        Fun f
-      )
-      {
-          return tuple_for_each_impl(t, f, 1);
-      }
-#endif
-
-      // Equality of tuples. NOTE: "==" for tuples currently (7/2003)
-      // has problems under some compilers, so I just do my own.
-      // No point in bringing in a bunch of #ifdefs here. This is
-      // going to go away with the next tuple implementation anyway.
-      //
-      inline bool tuple_equal(tuples::null_type, tuples::null_type)
-      { return true; }
-
-      template<typename Tuple1, typename Tuple2>
-      inline bool tuple_equal(Tuple1 const& t1, Tuple2 const& t2)
-      {
-          return t1.get_head() == t2.get_head() &&
-          tuple_equal(t1.get_tail(), t2.get_tail());
-      }
-    }
-    //
-    // end namespace tuple_impl_specific
-
-    template<typename Iterator>
-    struct iterator_reference
-    {
-        typedef typename boost::detail::iterator_traits<Iterator>::reference type;
-    };
-
-#ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
-    // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
-    // out well.  Instantiating the nested apply template also
-    // requires instantiating iterator_traits on the
-    // placeholder. Instead we just specialize it as a metafunction
-    // class.
-    template<>
-    struct iterator_reference<mpl::_1>
-    {
-        template <class T>
-        struct apply : iterator_reference<T> {};
-    };
-#endif
-
     // Metafunction to obtain the type of the tuple whose element types
     // are the reference types of an iterator tuple.
     //
     template<typename IteratorTuple>
     struct tuple_of_references
-      : tuple_impl_specific::tuple_meta_transform<
+      : mpl::transform<
             IteratorTuple,
             iterator_reference<mpl::_1>
           >
     {
     };
 
+    // Specialization for std::pair
+    template<typename Iterator1, typename Iterator2>
+    struct tuple_of_references<std::pair<Iterator1, Iterator2> >
+    {
+        typedef std::pair<
+            typename iterator_reference<Iterator1>::type
+          , typename iterator_reference<Iterator2>::type
+        > type;
+    };
+
     // Metafunction to obtain the minimal traversal tag in a tuple
     // of iterators.
     //
     template<typename IteratorTuple>
     struct minimum_traversal_category_in_iterator_tuple
     {
-      typedef typename tuple_impl_specific::tuple_meta_transform<
+      typedef typename mpl::transform<
           IteratorTuple
         , pure_traversal_tag<iterator_traversal<> >
       >::type tuple_of_traversal_tags;
 
-      typedef typename tuple_impl_specific::tuple_meta_accumulate<
+      typedef typename mpl::fold<
           tuple_of_traversal_tags
-        , minimum_category<>
         , random_access_traversal_tag
+        , minimum_category<>
       >::type type;
     };
 
-      // We need to call tuple_meta_accumulate with mpl::and_ as the
-      // accumulating functor. To this end, we need to wrap it into
-      // a struct that has exactly two arguments (that is, template
-      // parameters) and not five, like mpl::and_ does.
-      //
-      template<typename Arg1, typename Arg2>
-      struct and_with_two_args
-        : mpl::and_<Arg1, Arg2>
-      {
-      };
+    template<typename Iterator1, typename Iterator2>
+    struct minimum_traversal_category_in_iterator_tuple<std::pair<Iterator1, Iterator2> >
+    {
+        typedef typename pure_traversal_tag<
+            typename iterator_traversal<Iterator1>::type
+        >::type iterator1_traversal;
+        typedef typename pure_traversal_tag<
+            typename iterator_traversal<Iterator2>::type
+        >::type iterator2_traversal;
 
-# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
-  // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
-  // out well.  In this case I think it's an MPL bug
-      template<>
-      struct and_with_two_args<mpl::_1,mpl::_2>
-      {
-          template <class A1, class A2>
-          struct apply : mpl::and_<A1,A2>
-          {};
-      };
-# endif
+        typedef typename minimum_category<
+            iterator1_traversal
+          , typename minimum_category<
+                iterator2_traversal
+              , random_access_traversal_tag
+            >::type
+        >::type type;
+    };
 
     ///////////////////////////////////////////////////////////////////
     //
@@ -401,9 +174,9 @@ namespace iterators {
         typedef reference value_type;
 
         // Difference type is the first iterator's difference type
-        typedef typename boost::detail::iterator_traits<
-            typename tuples::element<0, IteratorTuple>::type
-            >::difference_type difference_type;
+        typedef typename iterator_difference<
+            typename mpl::at_c<IteratorTuple, 0>::type
+        >::type difference_type;
 
         // Traversal catetgory is the minimum traversal category in the
         // iterator tuple.
@@ -429,6 +202,30 @@ namespace iterators {
     {
         typedef int type;
     };
+
+    template <typename reference>
+    struct converter
+    {
+        template <typename Seq>
+        static reference call(Seq seq)
+        {
+            typedef typename fusion::traits::tag_of<reference>::type tag;
+            return fusion::convert<tag>(seq);
+        }
+    };
+
+    template <typename Reference1, typename Reference2>
+    struct converter<std::pair<Reference1, Reference2> >
+    {
+        typedef std::pair<Reference1, Reference2> reference;
+        template <typename Seq>
+        static reference call(Seq seq)
+        {
+            return reference(
+                fusion::at_c<0>(seq)
+              , fusion::at_c<1>(seq));
+        }
+    };
   }
 
   /////////////////////////////////////////////////////////////////////
@@ -484,10 +281,11 @@ namespace iterators {
     // iterators in the iterator tuple.
     typename super_t::reference dereference() const
     {
-      return detail::tuple_impl_specific::tuple_transform(
-        get_iterator_tuple(),
-        detail::dereference_iterator()
-       );
+        typedef typename super_t::reference reference;
+        typedef detail::converter<reference> gen;
+        return gen::call(fusion::transform(
+          get_iterator_tuple(),
+          detail::dereference_iterator()));
     }
 
     // Two zip iterators are equal if all iterators in the iterator
@@ -503,39 +301,35 @@ namespace iterators {
     template<typename OtherIteratorTuple>
     bool equal(const zip_iterator<OtherIteratorTuple>& other) const
     {
-      return detail::tuple_impl_specific::tuple_equal(
-        get_iterator_tuple(),
-        other.get_iterator_tuple()
-        );
+        return fusion::equal_to(
+          get_iterator_tuple(),
+          other.get_iterator_tuple());
     }
 
     // Advancing a zip iterator means to advance all iterators in the
     // iterator tuple.
     void advance(typename super_t::difference_type n)
     {
-      detail::tuple_impl_specific::tuple_for_each(
+        fusion::for_each(
           m_iterator_tuple,
-          detail::advance_iterator<BOOST_DEDUCED_TYPENAME super_t::difference_type>(n)
-          );
+          detail::advance_iterator<BOOST_DEDUCED_TYPENAME super_t::difference_type>(n));
     }
     // Incrementing a zip iterator means to increment all iterators in
     // the iterator tuple.
     void increment()
     {
-      detail::tuple_impl_specific::tuple_for_each(
-        m_iterator_tuple,
-        detail::increment_iterator()
-        );
+        fusion::for_each(
+          m_iterator_tuple,
+          detail::increment_iterator());
     }
 
     // Decrementing a zip iterator means to decrement all iterators in
     // the iterator tuple.
     void decrement()
     {
-      detail::tuple_impl_specific::tuple_for_each(
-        m_iterator_tuple,
-        detail::decrement_iterator()
-        );
+        fusion::for_each(
+          m_iterator_tuple,
+          detail::decrement_iterator());
     }
 
     // Distance is calculated using the first iterator in the tuple.
@@ -544,8 +338,8 @@ namespace iterators {
         const zip_iterator<OtherIteratorTuple>& other
         ) const
     {
-        return boost::tuples::get<0>(other.get_iterator_tuple()) -
-            boost::tuples::get<0>(this->get_iterator_tuple());
+        return fusion::at_c<0>(other.get_iterator_tuple()) -
+            fusion::at_c<0>(this->get_iterator_tuple());
     }
 
     // Data Members

include/boost/next_prior.hpp

@@ -0,0 +1,154 @@
+//  Boost next_prior.hpp header file  ---------------------------------------//
+
+//  (C) Copyright Dave Abrahams and Daniel Walker 1999-2003.
+//  Copyright (c) Andrey Semashev 2017
+//
+//  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)
+
+//  See http://www.boost.org/libs/utility for documentation.
+
+//  Revision History
+//  13 Dec 2003  Added next(x, n) and prior(x, n) (Daniel Walker)
+
+#ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
+#define BOOST_NEXT_PRIOR_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/type_traits/has_plus.hpp>
+#include <boost/type_traits/has_plus_assign.hpp>
+#include <boost/type_traits/has_minus.hpp>
+#include <boost/type_traits/has_minus_assign.hpp>
+#include <boost/iterator/is_iterator.hpp>
+#include <boost/iterator/advance.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
+
+namespace boost {
+
+//  Helper functions for classes like bidirectional iterators not supporting
+//  operator+ and operator-
+//
+//  Usage:
+//    const std::list<T>::iterator p = get_some_iterator();
+//    const std::list<T>::iterator prev = boost::prior(p);
+//    const std::list<T>::iterator next = boost::next(prev, 2);
+
+//  Contributed by Dave Abrahams
+
+namespace next_prior_detail {
+
+template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
+struct next_plus_impl;
+
+template< typename T, typename Distance >
+struct next_plus_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        return x + n;
+    }
+};
+
+template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value >
+struct next_plus_assign_impl :
+    public next_plus_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct next_plus_assign_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        x += n;
+        return x;
+    }
+};
+
+template< typename T, typename Distance, bool IsIterator = boost::iterators::is_iterator< T >::value >
+struct next_advance_impl :
+    public next_plus_assign_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct next_advance_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        boost::iterators::advance(x, n);
+        return x;
+    }
+};
+
+
+template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value >
+struct prior_minus_impl;
+
+template< typename T, typename Distance >
+struct prior_minus_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        return x - n;
+    }
+};
+
+template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value >
+struct prior_minus_assign_impl :
+    public prior_minus_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct prior_minus_assign_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        x -= n;
+        return x;
+    }
+};
+
+template< typename T, typename Distance, bool IsIterator = boost::iterators::is_iterator< T >::value >
+struct prior_advance_impl :
+    public prior_minus_assign_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct prior_advance_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        // Avoid negating n to sidestep possible integer overflow
+        boost::iterators::reverse_iterator< T > rx(x);
+        boost::iterators::advance(rx, n);
+        return rx.base();
+    }
+};
+
+} // namespace next_prior_detail
+
+template <class T>
+inline T next(T x) { return ++x; }
+
+template <class T, class Distance>
+inline T next(T x, Distance n)
+{
+    return next_prior_detail::next_advance_impl< T, Distance >::call(x, n);
+}
+
+template <class T>
+inline T prior(T x) { return --x; }
+
+template <class T, class Distance>
+inline T prior(T x, Distance n)
+{
+    return next_prior_detail::prior_advance_impl< T, Distance >::call(x, n);
+}
+
+} // namespace boost
+
+#endif  // BOOST_NEXT_PRIOR_HPP_INCLUDED

include/boost/pending/detail/int_iterator.hpp

@@ -6,11 +6,12 @@
 #ifndef BOOST_INT_ITERATOR_H
 #define BOOST_INT_ITERATOR_H
 
-#include <boost/iterator.hpp>
 #if !defined BOOST_MSVC
 #include <boost/operators.hpp>
 #endif
 #include <iostream>
+#include <iterator>
+#include <cstddef>
 //using namespace std;
 
 #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE

include/boost/pending/iterator_tests.hpp

@@ -20,11 +20,13 @@
 //              (David Abrahams)
 
 # include <iterator>
-# include <assert.h>
-# include <boost/type_traits.hpp>
 # include <boost/static_assert.hpp>
 # include <boost/concept_archetype.hpp> // for detail::dummy_constructor
-# include <boost/implicit_cast.hpp>
+# include <boost/core/ignore_unused.hpp>
+# include <boost/core/lightweight_test.hpp>
+# include <boost/type_traits/is_same.hpp>
+# include <boost/type_traits/is_pointer.hpp>
+# include <boost/type_traits/is_reference.hpp>
 
 namespace boost {
 
@@ -50,27 +52,29 @@ template <class Iterator, class T>
 void trivial_iterator_test(const Iterator i, const Iterator j, T val)
 {
   Iterator k;
-  assert(i == i);
-  assert(j == j);
-  assert(i != j);
+  BOOST_TEST(i == i);
+  BOOST_TEST(j == j);
+  BOOST_TEST(i != j);
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
   T v = *i;
 #else
   typename std::iterator_traits<Iterator>::value_type v = *i;
 #endif
-  assert(v == val);
+  BOOST_TEST(v == val);
+  boost::ignore_unused(v);
 #if 0
   // hmm, this will give a warning for transform_iterator...  perhaps
   // this should be separated out into a stand-alone test since there
   // are several situations where it can't be used, like for
   // integer_range::iterator.
-  assert(v == i->foo());
+  BOOST_TEST(v == i->foo());
 #endif
   k = i;
-  assert(k == k);
-  assert(k == i);
-  assert(k != j);
-  assert(*k == val);
+  BOOST_TEST(k == k);
+  BOOST_TEST(k == i);
+  BOOST_TEST(k != j);
+  BOOST_TEST(*k == val);
+  boost::ignore_unused(k);
 }
 
 
@@ -89,8 +93,8 @@ void input_iterator_test(Iterator i, T v1, T v2)
 {
   Iterator i1(i);
 
-  assert(i == i1);
-  assert(!(i != i1));
+  BOOST_TEST(i == i1);
+  BOOST_TEST(!(i != i1));
 
   // I can see no generic way to create an input iterator
   // that is in the domain of== of i and != i.
@@ -99,23 +103,25 @@ void input_iterator_test(Iterator i, T v1, T v2)
   //
   //   Iterator i2;
   //
-  //   assert(i != i2);
-  //   assert(!(i == i2));
+  //   BOOST_TEST(i != i2);
+  //   BOOST_TEST(!(i == i2));
 
-  assert(*i1 == v1);
-  assert(*i  == v1);
+  BOOST_TEST(*i1 == v1);
+  BOOST_TEST(*i  == v1);
 
   // we cannot test for equivalence of (void)++i & (void)i++
   // as i is only guaranteed to be single pass.
-  assert(*i++ == v1);
+  BOOST_TEST(*i++ == v1);
+  boost::ignore_unused(i1);
 
   i1 = i;
 
-  assert(i == i1);
-  assert(!(i != i1));
+  BOOST_TEST(i == i1);
+  BOOST_TEST(!(i != i1));
 
-  assert(*i1 == v2);
-  assert(*i  == v2);
+  BOOST_TEST(*i1 == v2);
+  BOOST_TEST(*i  == v2);
+  boost::ignore_unused(i1);
 
   // i is dereferencable, so it must be incrementable.
   ++i;
@@ -157,15 +163,15 @@ void forward_iterator_test(Iterator i, T v1, T v2)
 
   Iterator i1 = i, i2 = i;
 
-  assert(i == i1++);
-  assert(i != ++i2);
+  BOOST_TEST(i == i1++);
+  BOOST_TEST(i != ++i2);
 
   trivial_iterator_test(i, i1, v1);
   trivial_iterator_test(i, i2, v1);
 
   ++i;
-  assert(i == i1);
-  assert(i == i2);
+  BOOST_TEST(i == i1);
+  BOOST_TEST(i == i2);
   ++i1;
   ++i2;
 
@@ -173,7 +179,7 @@ void forward_iterator_test(Iterator i, T v1, T v2)
   trivial_iterator_test(i, i2, v2);
 
  // borland doesn't allow non-type template parameters
-# if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
+# if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
   lvalue_test<(boost::is_pointer<Iterator>::value)>::check(i);
 #endif
 }
@@ -187,15 +193,15 @@ void bidirectional_iterator_test(Iterator i, T v1, T v2)
 
   Iterator i1 = i, i2 = i;
 
-  assert(i == i1--);
-  assert(i != --i2);
+  BOOST_TEST(i == i1--);
+  BOOST_TEST(i != --i2);
 
   trivial_iterator_test(i, i1, v2);
   trivial_iterator_test(i, i2, v2);
 
   --i;
-  assert(i == i1);
-  assert(i == i2);
+  BOOST_TEST(i == i1);
+  BOOST_TEST(i == i2);
   ++i1;
   ++i2;
 
@@ -215,32 +221,37 @@ void random_access_iterator_test(Iterator i, int N, TrueVals vals)
   const Iterator j = i;
   int c;
 
-  typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
+  typedef typename std::iterator_traits<Iterator>::value_type value_type;
+  struct local
+  {
+    static value_type to_value_type(value_type v) { return v; }
+  };
 
   for (c = 0; c < N-1; ++c) {
-    assert(i == j + c);
-    assert(*i == vals[c]);
-    assert(*i == boost::implicit_cast<value_type>(j[c]));
-    assert(*i == *(j + c));
-    assert(*i == *(c + j));
+    BOOST_TEST(i == j + c);
+    BOOST_TEST(*i == vals[c]);
+    BOOST_TEST(*i == local::to_value_type(j[c]));
+    BOOST_TEST(*i == *(j + c));
+    BOOST_TEST(*i == *(c + j));
     ++i;
-    assert(i > j);
-    assert(i >= j);
-    assert(j <= i);
-    assert(j < i);
+    BOOST_TEST(i > j);
+    BOOST_TEST(i >= j);
+    BOOST_TEST(j <= i);
+    BOOST_TEST(j < i);
   }
 
   Iterator k = j + N - 1;
   for (c = 0; c < N-1; ++c) {
-    assert(i == k - c);
-    assert(*i == vals[N - 1 - c]);
-    assert(*i == boost::implicit_cast<value_type>(j[N - 1 - c]));
+    BOOST_TEST(i == k - c);
+    BOOST_TEST(*i == vals[N - 1 - c]);
+    BOOST_TEST(*i == local::to_value_type(j[N - 1 - c]));
     Iterator q = k - c;
-    assert(*i == *q);
-    assert(i > j);
-    assert(i >= j);
-    assert(j <= i);
-    assert(j < i);
+    boost::ignore_unused(q);
+    BOOST_TEST(*i == *q);
+    BOOST_TEST(i > j);
+    BOOST_TEST(i >= j);
+    BOOST_TEST(j <= i);
+    BOOST_TEST(j < i);
     --i;
   }
 }
@@ -249,16 +260,17 @@ void random_access_iterator_test(Iterator i, int N, TrueVals vals)
 template <class Iterator, class ConstIterator>
 void const_nonconst_iterator_test(Iterator i, ConstIterator j)
 {
-  assert(i != j);
-  assert(j != i);
+  BOOST_TEST(i != j);
+  BOOST_TEST(j != i);
 
   ConstIterator k(i);
-  assert(k == i);
-  assert(i == k);
+  BOOST_TEST(k == i);
+  BOOST_TEST(i == k);
 
   k = i;
-  assert(k == i);
-  assert(i == k);
+  BOOST_TEST(k == i);
+  BOOST_TEST(i == k);
+  boost::ignore_unused(k);
 }
 
 } // namespace iterators

include/boost/pointee.hpp

@@ -20,6 +20,8 @@
 # include <boost/mpl/if.hpp>
 # include <boost/mpl/eval_if.hpp>
 
+#include <iterator>
+
 namespace boost {
 
 namespace detail
@@ -33,7 +35,7 @@ namespace detail
   template <class Iterator>
   struct iterator_pointee
   {
-      typedef typename iterator_traits<Iterator>::value_type value_type;
+      typedef typename std::iterator_traits<Iterator>::value_type value_type;
 
       struct impl
       {
@@ -48,7 +50,7 @@ namespace detail
       BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1);
 
       typedef typename mpl::if_c<
-#  if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+#  if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
           ::boost::detail::iterator_pointee<Iterator>::is_constant
 #  else
           is_constant

include/boost/shared_container_iterator.hpp

@@ -5,8 +5,8 @@
 
 // See http://www.boost.org/libs/utility/shared_container_iterator.html for documentation.
 
-#ifndef SHARED_CONTAINER_ITERATOR_RG08102002_HPP
-#define SHARED_CONTAINER_ITERATOR_RG08102002_HPP
+#ifndef BOOST_SHARED_CONTAINER_ITERATOR_HPP
+#define BOOST_SHARED_CONTAINER_ITERATOR_HPP
 
 #include "boost/iterator_adaptors.hpp"
 #include "boost/shared_ptr.hpp"
@@ -66,4 +66,4 @@ using iterators::make_shared_container_range;
 
 } // namespace boost
 
-#endif  // SHARED_CONTAINER_ITERATOR_RG08102002_HPP
+#endif

meta/libraries.json

@@ -14,5 +14,6 @@
         "David Abrahams <dave -at- boost-consulting.com>",
         "Thomas Witt <witt - at - acm.org>",
         "Jeffrey Lee Hellrung Jr. <jeffrey.hellrung -at- gmail.com>"
-    ]
+    ],
+    "cxxstd": "03"
 }

test/Jamfile.v2

@@ -14,11 +14,19 @@ test-suite iterator
 
     [ run zip_iterator_test.cpp
         : : :
-
         # stlport's debug mode generates long symbols which overwhelm
         # vc6
         #<msvc-stlport><*><runtime-build>release
     ]
+    [ run zip_iterator_test2_std_tuple.cpp ]
+    [ run zip_iterator_test2_fusion_vector.cpp ]
+    [ run zip_iterator_test2_fusion_list.cpp ]
+#    [ run zip_iterator_test2_fusion_deque.cpp ] // See bug report for fusion https://svn.boost.org/trac/boost/ticket/11572
+    [ run zip_iterator_test_fusion.cpp ]
+    [ run zip_iterator_test_std_tuple.cpp ]
+    [ run zip_iterator_test_std_pair.cpp ]
+
+    [ run is_iterator.cpp ]
 
     # These tests should work for just about everything.
     [ compile is_lvalue_iterator.cpp ]
@@ -44,9 +52,19 @@ test-suite iterator
     [ run permutation_iterator_test.cpp : : : # <stlport-iostream>on
     ]
     [ run function_input_iterator_test.cpp ]
+    [ run function_output_iterator_test.cpp ]
+    [ compile-fail function_output_iterator_cf.cpp ]
 
     [ run generator_iterator_test.cpp ]
 
     [ run minimum_category.cpp ]
     [ compile-fail minimum_category_compile_fail.cpp ]
+
+    [ run next_prior_test.cpp ]
+    [ run advance_test.cpp ]
+    [ run distance_test.cpp ]
+    [ compile adl_test.cpp ]
+    [ compile range_distance_compat_test.cpp ]
+
+    [ run shared_iterator_test.cpp ]
 ;

test/adl_test.cpp

@@ -0,0 +1,25 @@
+// Copyright (C) 2017 Michel Morin.
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <vector>
+#include <boost/array.hpp>
+#include <boost/iterator/advance.hpp>
+#include <boost/iterator/distance.hpp>
+
+int main()
+{
+    // Test that boost::advance/distance are not found by ADL.
+    // (https://github.com/boostorg/iterator/issues/43)
+
+    typedef boost::array<int, 1> boost_type;
+    std::vector<boost_type> std_boost(2);
+    std::vector<boost_type>::iterator it = std_boost.begin();
+
+    advance(it, 2);
+    (void)distance(it, it);
+
+    return 0;
+}

test/advance_test.cpp

@@ -0,0 +1,91 @@
+// Copyright (C) 2017 Michel Morin.
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <vector>
+#include <list>
+#include <boost/container/slist.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/iterator/advance.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+
+int twice(int x) { return x + x; }
+
+template <typename Iterator>
+void test_advance(Iterator it_from, Iterator it_to, int n)
+{
+    boost::advance(it_from,  n);
+    BOOST_TEST(it_from == it_to);
+}
+
+int main()
+{
+    int array[3] = {1, 2, 3};
+    int* ptr1 = array;
+    int* ptr2 = array + 3;
+
+    {
+        test_advance(ptr1, ptr2,  3);
+        test_advance(ptr2, ptr1, -3);
+
+        test_advance(
+            boost::make_transform_iterator(ptr1, twice)
+          , boost::make_transform_iterator(ptr2, twice)
+          , 3
+        );
+        test_advance(
+            boost::make_transform_iterator(ptr2, twice)
+          , boost::make_transform_iterator(ptr1, twice)
+          , -3
+        );
+    }
+
+    {
+        std::vector<int> ints(ptr1, ptr2);
+        test_advance(ints.begin(), ints.end(),  3);
+        test_advance(ints.end(), ints.begin(), -3);
+
+        test_advance(
+            boost::make_transform_iterator(ints.begin(), twice)
+          , boost::make_transform_iterator(ints.end(), twice)
+          , 3
+        );
+        test_advance(
+            boost::make_transform_iterator(ints.end(), twice)
+          , boost::make_transform_iterator(ints.begin(), twice)
+          , -3
+        );
+    }
+
+    {
+        std::list<int> ints(ptr1, ptr2);
+        test_advance(ints.begin(), ints.end(),  3);
+        test_advance(ints.end(), ints.begin(), -3);
+
+        test_advance(
+            boost::make_transform_iterator(ints.begin(), twice)
+          , boost::make_transform_iterator(ints.end(), twice)
+          , 3
+        );
+        test_advance(
+            boost::make_transform_iterator(ints.end(), twice)
+          , boost::make_transform_iterator(ints.begin(), twice)
+          , -3
+        );
+    }
+
+    {
+        boost::container::slist<int> ints(ptr1, ptr2);
+        test_advance(ints.begin(), ints.end(),  3);
+
+        test_advance(
+            boost::make_transform_iterator(ints.begin(), twice)
+          , boost::make_transform_iterator(ints.end(), twice)
+          , 3
+        );
+    }
+
+    return boost::report_errors();
+}

test/concept_tests.cpp

@@ -7,14 +7,22 @@
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/operators.hpp>
 
+#include <iterator>
+#include <cstddef>
+
 struct new_random_access
   : std::random_access_iterator_tag
   , boost::random_access_traversal_tag
 {};
 
 struct new_iterator
-  : public boost::iterator< new_random_access, int >
 {
+  typedef new_random_access iterator_category;
+  typedef int value_type;
+  typedef std::ptrdiff_t difference_type;
+  typedef int* pointer;
+  typedef int& reference;
+
   int& operator*() const { return *m_x; }
   new_iterator& operator++() { return *this; }
   new_iterator operator++(int) { return *this; }
@@ -33,8 +41,13 @@ struct new_iterator
 new_iterator operator+(std::ptrdiff_t, new_iterator x) { return x; }
 
 struct old_iterator
-  : public boost::iterator<std::random_access_iterator_tag, int>
 {
+  typedef std::random_access_iterator_tag iterator_category;
+  typedef int value_type;
+  typedef std::ptrdiff_t difference_type;
+  typedef int* pointer;
+  typedef int& reference;
+
   int& operator*() const { return *m_x; }
   old_iterator& operator++() { return *this; }
   old_iterator operator++(int) { return *this; }
@@ -58,7 +71,7 @@ main()
   boost::iterator_traversal<new_iterator>::type tc;
   boost::random_access_traversal_tag derived = tc;
   (void)derived;
-  
+
   boost::function_requires<
     boost_concepts::WritableIteratorConcept<int*> >();
   boost::function_requires<

test/counting_iterator_test.cpp

@@ -17,7 +17,7 @@
 
 #include <boost/config.hpp>
 
-#ifdef __BORLANDC__     // Borland mis-detects our custom iterators
+#ifdef BOOST_BORLANDC     // Borland mis-detects our custom iterators
 # pragma warn -8091     // template argument ForwardIterator passed to '...' is a output iterator
 # pragma warn -8071     // Conversion may lose significant digits (due to counting_iterator<char> += n).
 #endif
@@ -26,13 +26,11 @@
 # pragma warning(disable:4786) // identifier truncated in debug info
 #endif
 
-#include <boost/detail/iterator.hpp>
 #include <boost/iterator/counting_iterator.hpp>
 #include <boost/iterator/new_iterator_tests.hpp>
 
 #include <boost/next_prior.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/detail/iterator.hpp>
+#include <boost/type_traits/conditional.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/limits.hpp>
 
@@ -40,12 +38,12 @@
 #include <climits>
 #include <iterator>
 #include <stdlib.h>
-#ifndef __BORLANDC__
+#ifndef BOOST_BORLANDC
 # include <boost/tuple/tuple.hpp>
-#endif 
+#endif
 #include <vector>
 #include <list>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #ifndef BOOST_NO_SLIST
 # ifdef BOOST_SLIST_HEADER
 #   include BOOST_SLIST_HEADER
@@ -70,7 +68,7 @@ struct unsigned_assert_nonnegative
 
 template <class T>
 struct assert_nonnegative
-  : boost::mpl::if_c<
+  : boost::conditional<
         std::numeric_limits<T>::is_signed
       , signed_assert_nonnegative<T>
       , unsigned_assert_nonnegative<T>
@@ -88,19 +86,19 @@ void category_test(
     std::random_access_iterator_tag)
 {
     typedef typename
-        boost::detail::iterator_traits<CountingIterator>::difference_type
+        std::iterator_traits<CountingIterator>::difference_type
         difference_type;
-    difference_type distance = boost::detail::distance(start, finish);
+    difference_type distance = std::distance(start, finish);
 
     // Pick a random position internal to the range
     difference_type offset = (unsigned)rand() % distance;
-    
+
 #ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
     BOOST_TEST(offset >= 0);
-#else 
+#else
     assert_nonnegative<difference_type>::test(offset);
 #endif
-    
+
     CountingIterator internal = start;
     std::advance(internal, offset);
 
@@ -111,8 +109,8 @@ void category_test(
     std::pair<CountingIterator,CountingIterator> xy(
         std::equal_range(start, finish, *internal));
     CountingIterator x = xy.first, y = xy.second;
-    
-    BOOST_TEST(boost::detail::distance(x, y) == 1);
+
+    BOOST_TEST(std::distance(x, y) == 1);
 
     // Show that values outside the range can't be found
     BOOST_TEST(!std::binary_search(start, boost::prior(finish), *finish));
@@ -122,7 +120,7 @@ void category_test(
     std::vector<value_type> v;
     for (value_type z = *start; !(z == *finish); ++z)
         v.push_back(z);
-    
+
     // Note that this test requires a that the first argument is
     // dereferenceable /and/ a valid iterator prior to the first argument
     boost::random_access_iterator_test(start, v.size(), v.begin());
@@ -153,7 +151,6 @@ template <class CountingIterator, class Value>
 void test_aux(CountingIterator start, CountingIterator finish, Value v1)
 {
     typedef typename CountingIterator::iterator_category category;
-    typedef typename CountingIterator::value_type value_type;
 
     // If it's a RandomAccessIterator we can do a few delicate tests
     category_test(start, finish, v1, category());
@@ -201,11 +198,11 @@ void test_container(Container* = 0)  // default arg works around MSVC bug
     Container c(1 + (unsigned)rand() % 1673);
 
     const typename Container::iterator start = c.begin();
-    
+
     // back off by 1 to leave room for dereferenceable value at the end
     typename Container::iterator finish = start;
     std::advance(finish, c.size() - 1);
-    
+
     test(start, finish);
 
     typedef typename Container::const_iterator const_iterator;
@@ -274,8 +271,12 @@ int main()
     test_integer<long>();
     test_integer<unsigned long>();
 #if defined(BOOST_HAS_LONG_LONG)
-    test_integer< ::boost::long_long_type>();
-    test_integer< ::boost::ulong_long_type>();
+    test_integer<boost::long_long_type>();
+    test_integer<boost::ulong_long_type>();
+#endif
+#if defined(BOOST_HAS_INT128)
+    test_integer<boost::int128_type>();
+    test_integer<boost::uint128_type>();
 #endif
 
     // Test user-defined type.
@@ -284,14 +285,14 @@ int main()
     test_integer3<long, std::random_access_iterator_tag, int>();
     test_integer<my_int2>();
     test_integer<my_int3>();
-    
+
    // Some tests on container iterators, to prove we handle a few different categories
     test_container<std::vector<int> >();
     test_container<std::list<int> >();
 # ifndef BOOST_NO_SLIST
     test_container<BOOST_STD_EXTENSION_NAMESPACE::slist<int> >();
 # endif
-    
+
     // Also prove that we can handle raw pointers.
     int array[2000];
     test(boost::make_counting_iterator(array), boost::make_counting_iterator(array+2000-1));

test/detail/zip_iterator_test.ipp

@@ -0,0 +1,85 @@
+// Copyright (c) 2014 Kohei Takahashi.
+//
+// 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)
+//
+//  See http://www.boost.org for most recent version including documentation.
+
+#include <boost/core/lightweight_test.hpp>
+
+#include <boost/assign/list_of.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/iterator/zip_iterator.hpp>
+#include <vector>
+#include <string>
+
+
+int main()
+{
+    typedef TUPLE<
+        std::vector<int>::iterator,
+        std::vector<std::string>::iterator
+    > iterator_tuple;
+
+    std::vector<int>         vi = boost::assign::list_of(42)(72);
+    std::vector<std::string> vs = boost::assign::list_of("kokoro")("pyonpyon");
+
+    {
+        boost::zip_iterator<iterator_tuple> i1(MAKE_TUPLE(vi.begin(), vs.begin()));
+        boost::zip_iterator<iterator_tuple> i2 = i1;
+
+        BOOST_TEST( i1      ==   i2);
+        BOOST_TEST( i1++    ==   i2);
+        BOOST_TEST( i1      ==  (i2 + 1));
+        BOOST_TEST((i1 - 1) ==   i2);
+        BOOST_TEST( i1--    == ++i2);
+        BOOST_TEST( i1      == --i2);
+    }
+
+    {
+        boost::zip_iterator<iterator_tuple> i1(MAKE_TUPLE(vi.begin(), vs.begin()));
+        boost::zip_iterator<iterator_tuple> i2 = i1 + 1;
+
+        BOOST_TEST( i1      !=   i2);
+        BOOST_TEST( i1++    !=   i2);
+        BOOST_TEST( i1      !=  (i2 + 1));
+        BOOST_TEST((i1 - 1) !=   i2);
+        BOOST_TEST( i1--    != ++i2);
+        BOOST_TEST( i1      != --i2);
+    }
+
+    {
+        boost::zip_iterator<iterator_tuple> i(MAKE_TUPLE(vi.begin(), vs.begin()));
+
+        BOOST_TEST(boost::fusion::at_c<0>(* i     ) == 42);
+        BOOST_TEST(boost::fusion::at_c<1>(* i     ) == "kokoro");
+        BOOST_TEST(boost::fusion::at_c<0>(*(i + 1)) == 72);
+        BOOST_TEST(boost::fusion::at_c<1>(*(i + 1)) == "pyonpyon");
+    }
+
+    {
+        // Trac #12895
+        boost::zip_iterator<
+            TUPLE<int*, std::string*>
+        > i(MAKE_TUPLE(&vi[0], &vs[0]));
+
+        BOOST_TEST(boost::fusion::at_c<0>(* i     ) == 42);
+        BOOST_TEST(boost::fusion::at_c<1>(* i     ) == "kokoro");
+        BOOST_TEST(boost::fusion::at_c<0>(*(i + 1)) == 72);
+        BOOST_TEST(boost::fusion::at_c<1>(*(i + 1)) == "pyonpyon");
+    }
+
+    {
+        boost::zip_iterator<iterator_tuple> i1(MAKE_TUPLE(vi.begin(), vs.begin()));
+        boost::zip_iterator<iterator_tuple> i2(MAKE_TUPLE(vi.end(),   vs.end()));
+
+        BOOST_TEST((i2 - i1) == 2);
+        ++i1;
+        BOOST_TEST((i2 - i1) == 1);
+        --i2;
+        BOOST_TEST((i2 - i1) == 0);
+    }
+
+    return boost::report_errors();
+}

test/detail/zip_iterator_test_original.ipp

@@ -0,0 +1,857 @@
+// (C) Copyright Dave Abrahams and Thomas Becker 2003. Distributed
+// under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// File:
+// =====
+// zip_iterator_test_main.cpp
+
+// Author:
+// =======
+// Thomas Becker
+
+// Created:
+// ========
+// Jul 15, 2003
+
+// Purpose:
+// ========
+// Test driver for zip_iterator.hpp
+
+// Compilers Tested:
+// =================
+// Metrowerks Codewarrior Pro 7.2, 8.3
+// gcc 2.95.3
+// gcc 3.2
+// Microsoft VC 6sp5 (test fails due to some compiler bug)
+// Microsoft VC 7 (works)
+// Microsoft VC 7.1
+// Intel 5
+// Intel 6
+// Intel 7.1
+// Intel 8
+// Borland 5.5.1 (broken due to lack of support from Boost.Tuples)
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Includes
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#include <boost/iterator/zip_iterator.hpp>
+#include <boost/iterator/zip_iterator.hpp> // 2nd #include tests #include guard.
+#include <iostream>
+#include <vector>
+#include <list>
+#include <set>
+#include <string>
+#include <functional>
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/iterator/is_readable_iterator.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/detail/workaround.hpp>
+#include <stddef.h>
+
+
+/// Tests for https://svn.boost.org/trac/boost/ticket/1517
+int to_value(int const &v)
+{
+    return v;
+}
+
+void category_test()
+{
+    std::list<int> rng1;
+    std::string rng2;
+
+    boost::make_zip_iterator(
+        ZI_MAKE_TUPLE(
+            boost::make_transform_iterator(rng1.begin(), &to_value), // BidirectionalInput
+            rng2.begin() // RandomAccess
+        )
+    );
+}
+///
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Das Main Funktion
+//
+/////////////////////////////////////////////////////////////////////////////
+
+int main( void )
+{
+
+  category_test();
+
+  std::cout << "\n"
+            << "***********************************************\n"
+            << "*                                             *\n"
+            << "* Test driver for boost::zip_iterator         *\n"
+            << "* Copyright Thomas Becker 2003                *\n"
+            << "*                                             *\n"
+            << "***********************************************\n\n"
+            << std::flush;
+
+  size_t num_successful_tests = 0;
+  size_t num_failed_tests = 0;
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator construction and dereferencing
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator construction and dereferencing: "
+            << std::flush;
+
+  std::vector<double> vect1(3);
+  vect1[0] = 42.;
+  vect1[1] = 43.;
+  vect1[2] = 44.;
+
+  std::set<int> intset;
+  intset.insert(52);
+  intset.insert(53);
+  intset.insert(54);
+  //
+
+  typedef
+  boost::zip_iterator<
+      ZI_TUPLE<
+          std::set<int>::iterator
+        , std::vector<double>::iterator
+      >
+  > zit_mixed;
+
+  zit_mixed zip_it_mixed = zit_mixed(
+    ZI_MAKE_TUPLE(
+        intset.begin()
+      , vect1.begin()
+    )
+  );
+
+  ZI_TUPLE<int, double> val_tuple(
+      *zip_it_mixed);
+
+  ZI_TUPLE<const int&, double&> ref_tuple(
+      *zip_it_mixed);
+
+  double dblOldVal = ZI_TUPLE_GET(1)(ref_tuple);
+  ZI_TUPLE_GET(1)(ref_tuple) -= 41.;
+
+  if( 52 == ZI_TUPLE_GET(0)(val_tuple) &&
+      42. == ZI_TUPLE_GET(1)(val_tuple) &&
+      52 == ZI_TUPLE_GET(0)(ref_tuple)  &&
+      1. == ZI_TUPLE_GET(1)(ref_tuple)  &&
+      1. == *vect1.begin()
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  // Undo change to vect1
+  ZI_TUPLE_GET(1)(ref_tuple) = dblOldVal;
+  
+#if defined(ZI_USE_BOOST_TUPLE)
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator with 12 components
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterators with 12 components:            "
+            << std::flush;
+
+  // Declare 12 containers
+  //
+  std::list<int> li1;
+  li1.push_back(1);
+  std::set<int> se1;
+  se1.insert(2);
+  std::vector<int> ve1;
+  ve1.push_back(3);
+  //
+  std::list<int> li2;
+  li2.push_back(4);
+  std::set<int> se2;
+  se2.insert(5);
+  std::vector<int> ve2;
+  ve2.push_back(6);
+  //
+  std::list<int> li3;
+  li3.push_back(7);
+  std::set<int> se3;
+  se3.insert(8);
+  std::vector<int> ve3;
+  ve3.push_back(9);
+  //
+  std::list<int> li4;
+  li4.push_back(10);
+  std::set<int> se4;
+  se4.insert(11);
+  std::vector<int> ve4;
+  ve4.push_back(12);
+
+  // typedefs for cons lists of iterators.
+  typedef boost::tuples::cons<
+    std::set<int>::iterator,
+    ZI_TUPLE<
+      std::vector<int>::iterator,
+      std::list<int>::iterator,
+      std::set<int>::iterator,
+      std::vector<int>::iterator,
+      std::list<int>::iterator,
+      std::set<int>::iterator,
+      std::vector<int>::iterator,
+      std::list<int>::iterator,
+      std::set<int>::iterator,
+      std::vector<int>::const_iterator
+      >::inherited
+    > cons_11_its_type;
+  //
+  typedef boost::tuples::cons<
+    std::list<int>::const_iterator,
+    cons_11_its_type
+    > cons_12_its_type;
+
+  // typedefs for cons lists for dereferencing the zip iterator
+  // made from the cons list above.
+  typedef boost::tuples::cons<
+    const int&,
+    ZI_TUPLE<
+      int&,
+      int&,
+      const int&,
+      int&,
+      int&,
+      const int&,
+      int&,
+      int&,
+      const int&,
+      const int&
+      >::inherited
+    > cons_11_refs_type;
+  //
+  typedef boost::tuples::cons<
+    const int&,
+    cons_11_refs_type
+    > cons_12_refs_type;
+
+  // typedef for zip iterator with 12 elements
+  typedef boost::zip_iterator<cons_12_its_type> zip_it_12_type;
+
+  // Declare a 12-element zip iterator.
+  zip_it_12_type zip_it_12(
+    cons_12_its_type(
+      li1.begin(),
+      cons_11_its_type(
+        se1.begin(),
+        ZI_MAKE_TUPLE(
+          ve1.begin(),
+          li2.begin(),
+          se2.begin(),
+          ve2.begin(),
+          li3.begin(),
+          se3.begin(),
+          ve3.begin(),
+          li4.begin(),
+          se4.begin(),
+          ve4.begin()
+          )
+        )
+      )
+    );
+
+  // Dereference, mess with the result a little.
+  cons_12_refs_type zip_it_12_dereferenced(*zip_it_12);
+  ZI_TUPLE_GET(9)(zip_it_12_dereferenced) = 42;
+
+  // Make a copy and move it a little to force some instantiations.
+  zip_it_12_type zip_it_12_copy(zip_it_12);
+  ++zip_it_12_copy;
+
+  if( ZI_TUPLE_GET(11)(zip_it_12.get_iterator_tuple()) == ve4.begin() &&
+      ZI_TUPLE_GET(11)(zip_it_12_copy.get_iterator_tuple()) == ve4.end() &&
+      1 == ZI_TUPLE_GET(0)(zip_it_12_dereferenced) &&
+      12 == ZI_TUPLE_GET(11)(zip_it_12_dereferenced) &&
+      42 == *(li4.begin())
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+  
+#endif
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator incrementing and dereferencing
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator ++ and *:                       "
+            << std::flush;
+
+  std::vector<double> vect2(3);
+  vect2[0] = 2.2;
+  vect2[1] = 3.3;
+  vect2[2] = 4.4;
+
+  boost::zip_iterator<
+    ZI_TUPLE<
+      std::vector<double>::const_iterator,
+      std::vector<double>::const_iterator
+      >
+    >
+  zip_it_begin(
+    ZI_MAKE_TUPLE(
+     vect1.begin(),
+     vect2.begin()
+     )
+  );
+
+  boost::zip_iterator<
+    ZI_TUPLE<
+      std::vector<double>::const_iterator,
+      std::vector<double>::const_iterator
+      >
+    >
+  zip_it_run(
+    ZI_MAKE_TUPLE(
+     vect1.begin(),
+     vect2.begin()
+     )
+  );
+
+  boost::zip_iterator<
+    ZI_TUPLE<
+      std::vector<double>::const_iterator,
+      std::vector<double>::const_iterator
+      >
+    >
+  zip_it_end(
+    ZI_MAKE_TUPLE(
+     vect1.end(),
+     vect2.end()
+     )
+  );
+
+  if( zip_it_run == zip_it_begin &&
+      42. == ZI_TUPLE_GET(0)(*zip_it_run) &&
+      2.2 == ZI_TUPLE_GET(1)(*zip_it_run) &&
+      43. == ZI_TUPLE_GET(0)(*(++zip_it_run)) &&
+      3.3 == ZI_TUPLE_GET(1)(*zip_it_run) &&
+      44. == ZI_TUPLE_GET(0)(*(++zip_it_run)) &&
+      4.4 == ZI_TUPLE_GET(1)(*zip_it_run) &&
+      zip_it_end == ++zip_it_run
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator decrementing and dereferencing
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator -- and *:                       "
+            << std::flush;
+
+  if( zip_it_run == zip_it_end &&
+      zip_it_end == zip_it_run-- &&
+      44. == ZI_TUPLE_GET(0)(*zip_it_run) &&
+      4.4 == ZI_TUPLE_GET(1)(*zip_it_run) &&
+      43. == ZI_TUPLE_GET(0)(*(--zip_it_run)) &&
+      3.3 == ZI_TUPLE_GET(1)(*zip_it_run) &&
+      42. == ZI_TUPLE_GET(0)(*(--zip_it_run)) &&
+      2.2 == ZI_TUPLE_GET(1)(*zip_it_run) &&
+      zip_it_begin == zip_it_run
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator copy construction and equality
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator copy construction and equality: "
+            << std::flush;
+
+  boost::zip_iterator<
+    ZI_TUPLE<
+      std::vector<double>::const_iterator,
+      std::vector<double>::const_iterator
+      >
+    > zip_it_run_copy(zip_it_run);
+
+  if(zip_it_run == zip_it_run && zip_it_run == zip_it_run_copy)
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator inequality
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator inequality:                     "
+            << std::flush;
+
+  if(!(zip_it_run != zip_it_run_copy) && zip_it_run != ++zip_it_run_copy)
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator less than
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator less than:                      "
+            << std::flush;
+
+  // Note: zip_it_run_copy == zip_it_run + 1
+  //
+  if( zip_it_run < zip_it_run_copy  &&
+      !( zip_it_run < --zip_it_run_copy) &&
+      zip_it_run == zip_it_run_copy
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator less than or equal
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "zip iterator less than or equal:             "
+            << std::flush;
+
+  // Note: zip_it_run_copy == zip_it_run
+  //
+  ++zip_it_run;
+  zip_it_run_copy += 2;
+
+  if( zip_it_run <= zip_it_run_copy &&
+      zip_it_run <= --zip_it_run_copy &&
+      !( zip_it_run <= --zip_it_run_copy) &&
+      zip_it_run <= zip_it_run
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator greater than
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator greater than:                   "
+            << std::flush;
+
+  // Note: zip_it_run_copy == zip_it_run - 1
+  //
+  if( zip_it_run > zip_it_run_copy &&
+      !( zip_it_run > ++zip_it_run_copy) &&
+      zip_it_run == zip_it_run_copy
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator greater than or equal
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator greater than or equal:          "
+            << std::flush;
+
+  ++zip_it_run;
+
+  // Note: zip_it_run == zip_it_run_copy + 1
+  //
+  if( zip_it_run >= zip_it_run_copy &&
+      --zip_it_run >= zip_it_run_copy &&
+      ! (zip_it_run >= ++zip_it_run_copy)
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator + int
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator + int:                          "
+            << std::flush;
+
+  // Note: zip_it_run == zip_it_run_copy - 1
+  //
+  zip_it_run = zip_it_run + 2;
+  ++zip_it_run_copy;
+
+  if( zip_it_run == zip_it_run_copy && zip_it_run == zip_it_begin + 3 )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator - int
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator - int:                          "
+            << std::flush;
+
+  // Note: zip_it_run == zip_it_run_copy, and both are at end position
+  //
+  zip_it_run = zip_it_run - 2;
+  --zip_it_run_copy;
+  --zip_it_run_copy;
+
+  if( zip_it_run == zip_it_run_copy && (zip_it_run - 1) == zip_it_begin )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator +=
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator +=:                             "
+            << std::flush;
+
+  // Note: zip_it_run == zip_it_run_copy, and both are at begin + 1
+  //
+  zip_it_run += 2;
+  if( zip_it_run == zip_it_begin + 3 )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator -=
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator -=:                             "
+            << std::flush;
+
+  // Note: zip_it_run is at end position, zip_it_run_copy is at
+  // begin plus one.
+  //
+  zip_it_run -= 2;
+  if( zip_it_run == zip_it_run_copy )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator getting member iterators
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator member iterators:               "
+            << std::flush;
+
+  // Note: zip_it_run and zip_it_run_copy are both at
+  // begin plus one.
+  //
+  if( ZI_TUPLE_GET(0)(zip_it_run.get_iterator_tuple()) == vect1.begin() + 1 &&
+      ZI_TUPLE_GET(1)(zip_it_run.get_iterator_tuple()) == vect2.begin() + 1
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Making zip iterators
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Making zip iterators:                        "
+            << std::flush;
+
+  std::vector<ZI_TUPLE<double, double> >
+    vect_of_tuples(3);
+
+  std::copy(
+    boost::make_zip_iterator(
+    ZI_MAKE_TUPLE(
+      vect1.begin(),
+      vect2.begin()
+      )
+    ),
+    boost::make_zip_iterator(
+    ZI_MAKE_TUPLE(
+      vect1.end(),
+      vect2.end()
+      )
+    ),
+    vect_of_tuples.begin()
+  );
+
+  if( 42. == ZI_TUPLE_GET(0)(*vect_of_tuples.begin()) &&
+      2.2 == ZI_TUPLE_GET(1)(*vect_of_tuples.begin()) &&
+      43. == ZI_TUPLE_GET(0)(*(vect_of_tuples.begin() + 1)) &&
+      3.3 == ZI_TUPLE_GET(1)(*(vect_of_tuples.begin() + 1)) &&
+      44. == ZI_TUPLE_GET(0)(*(vect_of_tuples.begin() + 2)) &&
+      4.4 == ZI_TUPLE_GET(1)(*(vect_of_tuples.begin() + 2))
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator non-const --> const conversion
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator non-const to const conversion:  "
+            << std::flush;
+
+  boost::zip_iterator<
+    ZI_TUPLE<
+      std::set<int>::const_iterator,
+      std::vector<double>::const_iterator
+      >
+    >
+  zip_it_const(
+    ZI_MAKE_TUPLE(
+      intset.begin(),
+      vect2.begin()
+    )
+  );
+  //
+  boost::zip_iterator<
+    ZI_TUPLE<
+      std::set<int>::iterator,
+      std::vector<double>::const_iterator
+      >
+    >
+  zip_it_half_const(
+    ZI_MAKE_TUPLE(
+      intset.begin(),
+      vect2.begin()
+    )
+  );
+  //
+  boost::zip_iterator<
+    ZI_TUPLE<
+      std::set<int>::iterator,
+      std::vector<double>::iterator
+      >
+    >
+  zip_it_non_const(
+    ZI_MAKE_TUPLE(
+      intset.begin(),
+      vect2.begin()
+    )
+  );
+
+  zip_it_half_const = ++zip_it_non_const;
+  zip_it_const = zip_it_half_const;
+  ++zip_it_const;
+//  zip_it_non_const = ++zip_it_const;  // Error: can't convert from const to non-const
+
+  if( 54 == ZI_TUPLE_GET(0)(*zip_it_const) &&
+      4.4 == ZI_TUPLE_GET(1)(*zip_it_const)  &&
+      53 == ZI_TUPLE_GET(0)(*zip_it_half_const)  &&
+      3.3 == ZI_TUPLE_GET(1)(*zip_it_half_const)
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+
+
+#if defined(ZI_USE_BOOST_TUPLE)
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Zip iterator categories
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  std::cout << "Zip iterator categories:                     "
+            << std::flush;
+
+  // The big iterator of the previous test has vector, list, and set iterators.
+  // Therefore, it must be bidirectional, but not random access.
+  bool bBigItIsBidirectionalIterator = boost::is_convertible<
+    boost::iterator_traversal<zip_it_12_type>::type
+        , boost::bidirectional_traversal_tag
+        >::value;
+
+  bool bBigItIsRandomAccessIterator = boost::is_convertible<
+    boost::iterator_traversal<zip_it_12_type>::type
+        , boost::random_access_traversal_tag
+        >::value;
+
+  // A combining iterator with all vector iterators must have random access
+  // traversal.
+  //
+  typedef boost::zip_iterator<
+    ZI_TUPLE<
+      std::vector<double>::const_iterator,
+      std::vector<double>::const_iterator
+      >
+    > all_vects_type;
+
+  bool bAllVectsIsRandomAccessIterator = boost::is_convertible<
+    boost::iterator_traversal<all_vects_type>::type
+        , boost::random_access_traversal_tag
+    >::value;
+
+  // The big test.
+  if( bBigItIsBidirectionalIterator &&
+      ! bBigItIsRandomAccessIterator &&
+      bAllVectsIsRandomAccessIterator
+    )
+  {
+    ++num_successful_tests;
+    std::cout << "OK" << std::endl;
+  }
+  else
+  {
+    ++num_failed_tests;
+    std::cout << "not OK" << std::endl;
+  }
+  
+#endif
+
+  // Done
+  //
+  std::cout << "\nTest Result:"
+            << "\n============"
+            << "\nNumber of successful tests: " << static_cast<unsigned int>(num_successful_tests)
+            << "\nNumber of failed tests: " << static_cast<unsigned int>(num_failed_tests)
+            << std::endl;
+
+  return num_failed_tests;
+}
+

test/distance_test.cpp

@@ -0,0 +1,84 @@
+// Copyright (C) 2017 Michel Morin.
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <vector>
+#include <list>
+#include <boost/container/slist.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/iterator/distance.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+
+int twice(int x) { return x + x; }
+
+template <typename Iterator>
+void test_distance(Iterator it_from, Iterator it_to, int n)
+{
+    BOOST_TEST(boost::distance(it_from, it_to) == n);
+}
+
+int main()
+{
+    int array[3] = {1, 2, 3};
+    int* ptr1 = array;
+    int* ptr2 = array + 3;
+
+    {
+        test_distance(ptr1, ptr2,  3);
+        test_distance(ptr2, ptr1, -3);
+
+        test_distance(
+            boost::make_transform_iterator(ptr1, twice)
+          , boost::make_transform_iterator(ptr2, twice)
+          , 3
+        );
+        test_distance(
+            boost::make_transform_iterator(ptr2, twice)
+          , boost::make_transform_iterator(ptr1, twice)
+          , -3
+        );
+    }
+
+    {
+        std::vector<int> ints(ptr1, ptr2);
+        test_distance(ints.begin(), ints.end(),  3);
+        test_distance(ints.end(), ints.begin(), -3);
+
+        test_distance(
+            boost::make_transform_iterator(ints.begin(), twice)
+          , boost::make_transform_iterator(ints.end(), twice)
+          , 3
+        );
+        test_distance(
+            boost::make_transform_iterator(ints.end(), twice)
+          , boost::make_transform_iterator(ints.begin(), twice)
+          , -3
+        );
+    }
+
+    {
+        std::list<int> ints(ptr1, ptr2);
+        test_distance(ints.begin(), ints.end(),  3);
+
+        test_distance(
+            boost::make_transform_iterator(ints.begin(), twice)
+          , boost::make_transform_iterator(ints.end(), twice)
+          , 3
+        );
+    }
+
+    {
+        boost::container::slist<int> ints(ptr1, ptr2);
+        test_distance(ints.begin(), ints.end(),  3);
+
+        test_distance(
+            boost::make_transform_iterator(ints.begin(), twice)
+          , boost::make_transform_iterator(ints.end(), twice)
+          , 3
+        );
+    }
+
+    return boost::report_errors();
+}

test/filter_iterator_test.cpp

@@ -1,4 +1,4 @@
-// Copyright David Abrahams 2003, Jeremy Siek 2004. 
+// Copyright David Abrahams 2003, Jeremy Siek 2004.
 
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -18,7 +18,7 @@
 #include <iostream>
 
 using boost::dummyT;
-    
+
 struct one_or_four
 {
     bool operator()(dummyT x) const
@@ -116,7 +116,7 @@ int main()
       boost::function_requires< boost_concepts::WritableIteratorConcept<Iter> >();
       boost::function_requires< boost_concepts::SinglePassIteratorConcept<Iter> >();
     }
-#endif 
+#endif
     {
       typedef boost::iterator_archetype<
           const dummyT
@@ -128,7 +128,7 @@ int main()
       boost::function_requires< boost_concepts::ReadableIteratorConcept<Iter> >();
       boost::function_requires< boost_concepts::ForwardTraversalConcept<Iter> >();
     }
-    
+
 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1200)  // Causes Internal Error in linker.
     {
       typedef boost::iterator_archetype<
@@ -165,7 +165,7 @@ int main()
       boost::function_requires< boost_concepts::LvalueIteratorConcept<Iter> >();
       boost::function_requires< boost_concepts::ForwardTraversalConcept<Iter> >();
     }
-#endif 
+#endif
 
     {
       typedef boost::iterator_archetype<
@@ -178,7 +178,7 @@ int main()
       boost::function_requires< boost_concepts::ReadableIteratorConcept<Iter> >();
       boost::function_requires< boost_concepts::BidirectionalTraversalConcept<Iter> >();
     }
-    
+
 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1200)  // Causes Internal Error in linker.
     {
       typedef boost::iterator_archetype<
@@ -215,11 +215,11 @@ int main()
       boost::function_requires< boost_concepts::LvalueIteratorConcept<Iter> >();
       boost::function_requires< boost_concepts::BidirectionalTraversalConcept<Iter> >();
     }
-#endif 
+#endif
 
     // Run-time tests
 
-    dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
+    dummyT array[] = { dummyT(0), dummyT(1), dummyT(2),
                        dummyT(3), dummyT(4), dummyT(5) };
     const int N = sizeof(array)/sizeof(dummyT);
 
@@ -235,9 +235,9 @@ int main()
            , boost::random_access_traversal_tag
          >::value
         ));
-    
+
     //# endif
-    
+
     // On compilers not supporting partial specialization, we can do more type
     // deduction with deque iterators than with pointers... unless the library
     // is broken ;-(
@@ -258,7 +258,7 @@ int main()
             , boost::make_reverse_iterator(array2.begin())
             ),
         dummyT(4), dummyT(1));
-    
+
     boost::bidirectional_readable_iterator_test(
         filter_iter(array+0, array+N),
         dummyT(1), dummyT(4));

test/function_input_iterator_test.cpp

@@ -3,14 +3,24 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#include <cassert>
 #include <cstddef>
 
 #include <algorithm>
-#include <iostream>
 #include <iterator>
 #include <vector>
 
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX11_DECLTYPE)
+// Force boost::result_of use decltype, even on compilers that don't support N3276.
+// This enables this test to also verify if the iterator works with lambdas
+// on such compilers with this config macro. Note that without the macro result_of
+// (and consequently the iterator) is guaranteed to _not_ work, so this case is not
+// worth testing anyway.
+#define BOOST_RESULT_OF_USE_DECLTYPE
+#endif
+
+#include <boost/core/lightweight_test.hpp>
 #include <boost/iterator/function_input_iterator.hpp>
 
 namespace {
@@ -39,13 +49,13 @@ struct counter {
 
 using namespace std;
 
-int main(int argc, char * argv[])
+int main()
 {
     // test the iterator with function objects
     ones ones_generator;
     vector<int> values(10);
     generate(values.begin(), values.end(), ones());
-    
+
     vector<int> generated;
     copy(
         boost::make_function_input_iterator(ones_generator, 0),
@@ -53,9 +63,7 @@ int main(int argc, char * argv[])
         back_inserter(generated)
         );
 
-    assert(values.size() == generated.size());
-    assert(equal(values.begin(), values.end(), generated.begin()));
-    cout << "function iterator test with function objects successful." << endl;
+    BOOST_TEST_ALL_EQ(values.begin(), values.end(), generated.begin(), generated.end());
 
     // test the iterator with normal functions
     vector<int>().swap(generated);
@@ -65,9 +73,7 @@ int main(int argc, char * argv[])
         back_inserter(generated)
         );
 
-    assert(values.size() == generated.size());
-    assert(equal(values.begin(), values.end(), generated.begin()));
-    cout << "function iterator test with pointer to function successful." << endl;
+    BOOST_TEST_ALL_EQ(values.begin(), values.end(), generated.begin(), generated.end());
 
     // test the iterator with a reference to a function
     vector<int>().swap(generated);
@@ -77,9 +83,7 @@ int main(int argc, char * argv[])
         back_inserter(generated)
         );
 
-    assert(values.size() == generated.size());
-    assert(equal(values.begin(), values.end(), generated.begin()));
-    cout << "function iterator test with reference to function successful." << endl;
+    BOOST_TEST_ALL_EQ(values.begin(), values.end(), generated.begin(), generated.end());
 
     // test the iterator with a stateful function object
     counter counter_generator(42);
@@ -90,12 +94,36 @@ int main(int argc, char * argv[])
         back_inserter(generated)
         );
 
-    assert(generated.size() == 10);
-    assert(counter_generator.n == 42 + 10);
+    BOOST_TEST_EQ(generated.size(), 10u);
+    BOOST_TEST_EQ(counter_generator.n, 42 + 10);
     for(std::size_t i = 0; i != 10; ++i)
-        assert(generated[i] == 42 + i);
-    cout << "function iterator test with stateful function object successful." << endl;
+        BOOST_TEST_EQ(generated[i], static_cast<int>(42 + i));
 
-    return 0;
+    // Test that incrementing the iterator returns a reference to the iterator type
+    {
+        typedef boost::iterators::function_input_iterator<counter, int> function_counter_iterator_t;
+        function_counter_iterator_t it1(counter_generator, 0);
+        function_counter_iterator_t it2(++it1);
+        function_counter_iterator_t it3(it2++);
+        BOOST_TEST_EQ(*it3, 54);
+    }
+
+#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) \
+    && defined(BOOST_RESULT_OF_USE_DECLTYPE)
+    // test the iterator with lambda expressions
+    int num = 42;
+    auto lambda_generator = [&num] { return num++; };
+    vector<int>().swap(generated);
+    copy(
+        boost::make_function_input_iterator(lambda_generator, 0),
+        boost::make_function_input_iterator(lambda_generator, 10),
+        back_inserter(generated)
+        );
+
+    BOOST_TEST_EQ(generated.size(), 10u);
+    for(std::size_t i = 0; i != 10; ++i)
+        BOOST_TEST_EQ(generated[i], static_cast<int>(42 + i));
+#endif // BOOST_NO_CXX11_LAMBDAS
+
+    return boost::report_errors();
 }
-

test/function_output_iterator_cf.cpp

@@ -0,0 +1,37 @@
+// Copyright 2022 (c) Andrey Semashev
+// Distributed under the Boost Software License Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/iterator/function_output_iterator.hpp>
+
+namespace {
+
+struct sum_func
+{
+    typedef void result_type;
+
+    explicit sum_func(int& n) : m_n(n) {}
+    result_type operator() (int x) const
+    {
+        m_n += x;
+    }
+
+private:
+    int& m_n;
+};
+
+} // namespace
+
+int main()
+{
+    int n = 0;
+    boost::iterators::function_output_iterator< sum_func > it1 =
+        boost::iterators::make_function_output_iterator(sum_func(n));
+    boost::iterators::function_output_iterator< sum_func > it2 =
+        boost::iterators::make_function_output_iterator(sum_func(n));
+
+    *it1 = *it2;
+
+    return 0;
+}

test/function_output_iterator_test.cpp

@@ -0,0 +1,61 @@
+// Copyright 2022 (c) Andrey Semashev
+// Distributed under the Boost Software License Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/config.hpp>
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/iterator/function_output_iterator.hpp>
+
+namespace {
+
+struct sum_func
+{
+    typedef void result_type;
+
+    explicit sum_func(int& n) : m_n(n) {}
+    result_type operator() (int x) const
+    {
+        m_n += x;
+    }
+
+private:
+    int& m_n;
+};
+
+} // namespace
+
+int main()
+{
+    {
+        int n = 0;
+        boost::iterators::function_output_iterator< sum_func > it =
+            boost::iterators::make_function_output_iterator(sum_func(n));
+
+        *it = 1;
+        ++it;
+        *it = 2;
+        ++it;
+        *it = 3;
+
+        BOOST_TEST_EQ(n, 6);
+    }
+
+#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
+    {
+        int n = 0;
+        auto it = boost::iterators::make_function_output_iterator([&n](int x) { n -= x; });
+
+        *it = 1;
+        ++it;
+        *it = 2;
+        ++it;
+        *it = 3;
+
+        BOOST_TEST_EQ(n, -6);
+    }
+#endif
+
+    return boost::report_errors();
+}

test/generator_iterator_test.cpp

@@ -7,7 +7,7 @@
 //
 
 #include <boost/generator_iterator.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <algorithm>
 
 class X

test/indirect_iter_member_types.cpp

@@ -30,16 +30,16 @@ struct my_ptr {
 
 // Borland 5.6.4 and earlier drop const all over the place, so this
 // test will fail in the lines marked with (**)
-    
+
 int main()
 {
   {
     typedef boost::indirect_iterator<int**> Iter;
     STATIC_ASSERT_SAME(Iter::value_type, int);
-    STATIC_ASSERT_SAME(Iter::reference, int&);  
-    STATIC_ASSERT_SAME(Iter::pointer, int*);  
+    STATIC_ASSERT_SAME(Iter::reference, int&);
+    STATIC_ASSERT_SAME(Iter::pointer, int*);
     STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
-    
+
     BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
              std::random_access_iterator_tag>::value));
     BOOST_STATIC_ASSERT((boost::is_convertible<boost::iterator_traversal<Iter>::type,
@@ -54,13 +54,13 @@ int main()
   {
     typedef boost::indirect_iterator<int**, int> Iter;
     STATIC_ASSERT_SAME(Iter::value_type, int);
-    STATIC_ASSERT_SAME(Iter::reference, int&);  
-    STATIC_ASSERT_SAME(Iter::pointer, int*);  
+    STATIC_ASSERT_SAME(Iter::reference, int&);
+    STATIC_ASSERT_SAME(Iter::pointer, int*);
   }
   {
     typedef boost::indirect_iterator<int**, const int> Iter;
     STATIC_ASSERT_SAME(Iter::value_type, int);
-    STATIC_ASSERT_SAME(Iter::reference, const int&);  
+    STATIC_ASSERT_SAME(Iter::reference, const int&);
     STATIC_ASSERT_SAME(Iter::pointer, const int*);    // (**)
   }
   {
@@ -68,9 +68,9 @@ int main()
     STATIC_ASSERT_SAME(Iter::value_type, zow);
     STATIC_ASSERT_SAME(Iter::reference, const zow&);  // (**)
     STATIC_ASSERT_SAME(Iter::pointer, const zow*);    // (**)
-    
+
     STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
-    
+
     BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
              std::random_access_iterator_tag>::value));
     BOOST_STATIC_ASSERT((boost::is_convertible<boost::iterator_traversal<Iter>::type,
@@ -79,9 +79,9 @@ int main()
   {
     typedef boost::indirect_iterator<char**, int, std::random_access_iterator_tag, long&, short> Iter;
     STATIC_ASSERT_SAME(Iter::value_type, int);
-    STATIC_ASSERT_SAME(Iter::reference, long&);  
-    STATIC_ASSERT_SAME(Iter::pointer, int*);  
-    STATIC_ASSERT_SAME(Iter::difference_type, short);  
+    STATIC_ASSERT_SAME(Iter::reference, long&);
+    STATIC_ASSERT_SAME(Iter::pointer, int*);
+    STATIC_ASSERT_SAME(Iter::difference_type, short);
   }
   return 0;
 }

test/indirect_iterator_test.cpp

@@ -24,14 +24,16 @@
 #include <boost/concept_check.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/utility.hpp>
+#include <boost/next_prior.hpp>
 
 #include <boost/mpl/has_xxx.hpp>
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 #include <vector>
 #include <stdlib.h>
 #include <set>
+#include <iterator>
 
 #if !defined(__SGI_STL_PORT)                            \
     && (defined(BOOST_MSVC_STD_ITERATOR)                \
@@ -42,7 +44,7 @@
 // interoperability (but may support const/mutable interop).
 # define NO_MUTABLE_CONST_STD_SET_ITERATOR_INTEROPERABILITY
 
-#endif 
+#endif
 
 
 template <class T> struct see_type;
@@ -51,7 +53,7 @@ template <int I> struct see_val;
 struct my_iterator_tag : public std::random_access_iterator_tag { };
 
 using boost::dummyT;
-    
+
 typedef std::vector<int> storage;
 typedef std::vector<int*> pointer_ra_container;
 typedef std::set<storage::iterator> iterator_set;
@@ -60,7 +62,7 @@ template <class Container>
 struct indirect_iterator_pair_generator
 {
     typedef boost::indirect_iterator<typename Container::iterator> iterator;
-    
+
     typedef boost::indirect_iterator<
         typename Container::iterator
       , typename iterator::value_type const
@@ -71,7 +73,7 @@ void more_indirect_iterator_tests()
 {
     storage store(1000);
     std::generate(store.begin(), store.end(), rand);
-    
+
     pointer_ra_container ptr_ra_container;
     iterator_set iter_set;
 
@@ -88,27 +90,27 @@ void more_indirect_iterator_tests()
     BOOST_TEST(static_cast<std::size_t>(de - db) == store.size());
     BOOST_TEST(db + store.size() == de);
     indirect_ra_container::const_iterator dci = db;
-    
+
     BOOST_TEST(dci == db);
-    
+
 #ifndef NO_MUTABLE_CONST_RA_ITERATOR_INTEROPERABILITY
     BOOST_TEST(db == dci);
 #endif
-    
+
     BOOST_TEST(dci != de);
     BOOST_TEST(dci < de);
     BOOST_TEST(dci <= de);
-    
+
 #ifndef NO_MUTABLE_CONST_RA_ITERATOR_INTEROPERABILITY
     BOOST_TEST(de >= dci);
     BOOST_TEST(de > dci);
 #endif
-    
+
     dci = de;
     BOOST_TEST(dci == de);
 
     boost::random_access_iterator_test(db + 1, store.size() - 1, boost::next(store.begin()));
-    
+
     *db = 999;
     BOOST_TEST(store.front() == 999);
 
@@ -123,15 +125,15 @@ void more_indirect_iterator_tests()
     indirect_set_iterator se(iter_set.end());
     const_indirect_set_iterator sci(iter_set.begin());
     BOOST_TEST(sci == sb);
-    
+
 # ifndef NO_MUTABLE_CONST_STD_SET_ITERATOR_INTEROPERABILITY
     BOOST_TEST(se != sci);
 # endif
-    
+
     BOOST_TEST(sci != se);
     sci = se;
     BOOST_TEST(sci == se);
-    
+
     *boost::prior(se) = 888;
     BOOST_TEST(store.back() == 888);
     BOOST_TEST(std::equal(sb, se, store.begin()));
@@ -143,31 +145,31 @@ void more_indirect_iterator_tests()
 // element_type detector; defaults to true so the test passes when
 // has_xxx isn't implemented
 BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_element_type, element_type, true)
-    
+
 int
 main()
 {
-  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
+  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2),
                      dummyT(3), dummyT(4), dummyT(5) };
   const int N = sizeof(array)/sizeof(dummyT);
 
 # if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
   boost::shared_ptr<dummyT> zz((dummyT*)0);  // Why? I don't know, but it suppresses a bad instantiation.
 # endif
-  
+
   typedef std::vector<boost::shared_ptr<dummyT> > shared_t;
   shared_t shared;
-  
+
   // Concept checks
   {
     typedef boost::indirect_iterator<shared_t::iterator> iter_t;
 
     BOOST_STATIC_ASSERT(
         has_element_type<
-            boost::detail::iterator_traits<shared_t::iterator>::value_type
+            std::iterator_traits<shared_t::iterator>::value_type
         >::value
         );
-    
+
     typedef boost::indirect_iterator<
         shared_t::iterator
       , boost::iterator_value<shared_t::iterator>::type const
@@ -175,14 +177,14 @@ main()
 
 # ifndef NO_MUTABLE_CONST_RA_ITERATOR_INTEROPERABILITY
     boost::function_requires< boost_concepts::InteroperableIteratorConcept<iter_t, c_iter_t> >();
-# endif 
+# endif
   }
 
   // Test indirect_iterator_generator
   {
       for (int jj = 0; jj < N; ++jj)
           shared.push_back(boost::shared_ptr<dummyT>(new dummyT(jj)));
-      
+
       dummyT* ptr[N];
       for (int k = 0; k < N; ++k)
           ptr[k] = array + k;
@@ -200,16 +202,16 @@ main()
           , N, array);
 
       boost::random_access_iterator_test(boost::make_indirect_iterator(ptr), N, array);
-    
+
       // check operator->
       assert((*i).m_x == i->foo());
 
       const_indirect_iterator j(ptr);
       boost::random_access_iterator_test(j, N, array);
-    
+
       dummyT const*const* const_ptr = ptr;
       boost::random_access_iterator_test(boost::make_indirect_iterator(const_ptr), N, array);
-      
+
       boost::const_nonconst_iterator_test(i, ++j);
 
       more_indirect_iterator_tests();

test/interoperable.cpp

@@ -4,16 +4,16 @@
 
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/pending/iterator_tests.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <cassert>
 
 struct mutable_it : boost::iterator_adaptor<mutable_it,int*>
 {
     typedef boost::iterator_adaptor<mutable_it,int*> super_t;
-    
+
     mutable_it();
     explicit mutable_it(int* p) : super_t(p) {}
-    
+
     bool equal(mutable_it const& rhs) const
     {
         return this->base() == rhs.base();
@@ -23,7 +23,7 @@ struct mutable_it : boost::iterator_adaptor<mutable_it,int*>
 struct constant_it : boost::iterator_adaptor<constant_it,int const*>
 {
     typedef boost::iterator_adaptor<constant_it,int const*> super_t;
-    
+
     constant_it();
     explicit constant_it(int* p) : super_t(p) {}
     constant_it(mutable_it const& x) : super_t(x.base()) {}
@@ -37,7 +37,7 @@ struct constant_it : boost::iterator_adaptor<constant_it,int const*>
 int main()
 {
     int data[] = { 49, 77 };
-    
+
     mutable_it i(data);
     constant_it j(data + 1);
     BOOST_TEST(i < j);
@@ -46,7 +46,7 @@ int main()
     BOOST_TEST(j >= i);
     BOOST_TEST(j - i == 1);
     BOOST_TEST(i - j == -1);
-    
+
     constant_it k = i;
 
     BOOST_TEST(!(i < k));
@@ -55,6 +55,6 @@ int main()
     BOOST_TEST(k >= i);
     BOOST_TEST(k - i == 0);
     BOOST_TEST(i - k == 0);
-    
+
     return boost::report_errors();
 }

test/is_iterator.cpp

@@ -0,0 +1,164 @@
+/*
+ * 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 is_iterator.cpp
+ *
+ * This header contains tests for the \c is_iterator type trait.
+ */
+
+#include <boost/iterator/is_iterator.hpp>
+#include <cstddef>
+#include <list>
+#include <vector>
+#include <string>
+#include <iterator>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template< typename T >
+struct value_iterator
+{
+    typedef std::input_iterator_tag iterator_category;
+    typedef T value_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef T* pointer;
+    typedef T& reference;
+
+    value_type operator*() const;
+};
+
+template< typename T >
+struct proxy_iterator
+{
+    typedef T value_type;
+    typedef std::output_iterator_tag iterator_category;
+    typedef std::ptrdiff_t difference_type;
+    typedef T* pointer;
+    typedef T& reference;
+
+    struct proxy
+    {
+        operator value_type&() const;
+        proxy& operator=(value_type) const;
+    };
+
+    proxy operator*() const;
+};
+
+template< typename T >
+struct lvalue_iterator
+{
+    typedef T value_type;
+    typedef T& reference;
+    typedef T difference_type;
+    typedef std::input_iterator_tag iterator_category;
+    typedef T* pointer;
+
+    T& operator*() const;
+    lvalue_iterator& operator++();
+    lvalue_iterator operator++(int);
+};
+
+template< typename T >
+struct constant_lvalue_iterator
+{
+    typedef T value_type;
+    typedef T const& reference;
+    typedef T difference_type;
+    typedef std::input_iterator_tag iterator_category;
+    typedef T const* pointer;
+
+    T const& operator*() const;
+    constant_lvalue_iterator& operator++();
+    constant_lvalue_iterator operator++(int);
+};
+
+template< typename Iterator >
+class adapted_iterator :
+    public boost::iterators::iterator_adaptor< adapted_iterator< Iterator >, Iterator >
+{
+    friend class iterator_core_access;
+
+private:
+    typedef boost::iterators::iterator_adaptor< adapted_iterator< Iterator >, Iterator > base_type;
+
+private:
+    typename base_type::reference dereference() const;
+    void increment();
+    void decrement();
+    void advance(typename base_type::difference_type n);
+    template< typename OtherIterator >
+    typename base_type::difference_type distance_to(adapted_iterator< OtherIterator > const& y) const;
+};
+
+struct complete {};
+struct incomplete;
+
+int main()
+{
+    BOOST_TEST(boost::iterators::is_iterator< int* >::value);
+    BOOST_TEST(boost::iterators::is_iterator< const int* >::value);
+    BOOST_TEST(boost::iterators::is_iterator< complete* >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::reverse_iterator< int* > >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::reverse_iterator< complete* > >::value);
+    BOOST_TEST(boost::iterators::is_iterator< adapted_iterator< int* > >::value);
+
+    BOOST_TEST(boost::iterators::is_iterator< std::string::iterator >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::string::const_iterator >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::string::reverse_iterator >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::string::const_reverse_iterator >::value);
+
+    BOOST_TEST(boost::iterators::is_iterator< std::list< int >::iterator >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::list< int >::const_iterator >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::list< int >::reverse_iterator >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::list< int >::const_reverse_iterator >::value);
+
+    BOOST_TEST(boost::iterators::is_iterator< std::vector< int >::iterator >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::vector< int >::const_iterator >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::vector< int >::reverse_iterator >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::vector< int >::const_reverse_iterator >::value);
+
+    BOOST_TEST(boost::iterators::is_iterator< std::insert_iterator< std::vector< int > > >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::back_insert_iterator< std::vector< int > > >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::front_insert_iterator< std::vector< int > > >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::istream_iterator< int > >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::ostream_iterator< int > >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::istreambuf_iterator< char > >::value);
+    BOOST_TEST(boost::iterators::is_iterator< std::ostreambuf_iterator< char > >::value);
+
+    BOOST_TEST(!boost::iterators::is_iterator< int >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< complete >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< void >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< const void >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< void* >::value);
+#if defined(BOOST_TT_HAS_WORKING_IS_COMPLETE)
+    BOOST_TEST(!boost::iterators::is_iterator< incomplete >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< incomplete* >::value);
+#endif
+    BOOST_TEST(!boost::iterators::is_iterator< int (int) >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< int (*)(int) >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< int complete::* >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< int (complete::*)(int) >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< int (complete::*)(int) const >::value);
+#if defined(__cpp_noexcept_function_type) && (__cpp_noexcept_function_type >= 201510L)
+    BOOST_TEST(!boost::iterators::is_iterator< int (*)(int) noexcept >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< int (complete::*)(int) noexcept >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< int (complete::*)(int) const noexcept >::value);
+#endif
+    BOOST_TEST(!boost::iterators::is_iterator< int[] >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< int[10] >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< int*[] >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< int*[10] >::value);
+
+    BOOST_TEST(!boost::iterators::is_iterator< int& >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< int*& >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< int (&)(int) >::value);
+    BOOST_TEST(!boost::iterators::is_iterator< int (&)[10] >::value);
+
+    return boost::report_errors();
+}

test/is_lvalue_iterator.cpp

@@ -5,10 +5,10 @@
 #include <deque>
 #include <iterator>
 #include <iostream>
+#include <cstddef> // std::ptrdiff_t
 #include <boost/static_assert.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/iterator/is_lvalue_iterator.hpp>
-#include <boost/iterator.hpp>
 
 // Last, for BOOST_NO_LVALUE_RETURN_DETECTION
 #include <boost/iterator/detail/config_def.hpp>
@@ -20,36 +20,43 @@ struct v
 };
 
 
-struct value_iterator : boost::iterator<std::input_iterator_tag,v>
+struct value_iterator
 {
+    typedef std::input_iterator_tag iterator_category;
+    typedef v value_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef v* pointer;
+    typedef v& reference;
+
     v operator*() const;
 };
 
-struct noncopyable_iterator : boost::iterator<std::forward_iterator_tag,boost::noncopyable>
+struct noncopyable_iterator
 {
+    typedef std::forward_iterator_tag iterator_category;
+    typedef boost::noncopyable value_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef boost::noncopyable* pointer;
+    typedef boost::noncopyable& reference;
+
     boost::noncopyable const& operator*() const;
 };
 
 template <class T>
 struct proxy_iterator
-  : boost::iterator<std::output_iterator_tag,T>
 {
     typedef T value_type;
-    
-#if BOOST_WORKAROUND(__GNUC__, == 2)
-    typedef boost::iterator<std::input_iterator_tag,value_type> base;
-    typedef base::iterator_category iterator_category;
-    typedef base::difference_type difference_type;
-    typedef base::pointer pointer;
-    typedef base::reference reference;
-#endif 
-    
+    typedef std::output_iterator_tag iterator_category;
+    typedef std::ptrdiff_t difference_type;
+    typedef T* pointer;
+    typedef T& reference;
+
     struct proxy
     {
         operator value_type&() const;
         proxy& operator=(value_type) const;
     };
-        
+
     proxy operator*() const;
 };
 
@@ -104,14 +111,14 @@ int main()
     BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<char*> >::value);
     BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<float> >::value);
 
-    
+
     BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<v> >::value);
     BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<int> >::value);
     BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<char*> >::value);
     BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<float> >::value);
 
-    
-    
+
+
     BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<v*>::value);
     BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<v const*>::value);
     BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<std::deque<v>::iterator>::value);
@@ -124,18 +131,18 @@ int main()
     BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<value_iterator>::value);
 #endif
     BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<noncopyable_iterator>::value);
-    
+
     BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<v> >::value);
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
     BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<int> >::value);
-#endif 
+#endif
     BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<char*> >::value);
     BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<float> >::value);
-    
+
     BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<v> >::value);
     BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<int> >::value);
     BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<char*> >::value);
     BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<float> >::value);
-    
+
     return 0;
 }