Merge pull request #60 from CaseyCarter/patch-1

MSVC also has C++20 ostream_iterator
MSVC also has C++20 output_iterator
2025-07-02 23:37:09 +02:00 · 2020-10-14 12:15:55 +03:00 · 2020-10-13 19:23:49 -07:00 · 2020-05-24 00:29:51 +03:00 · 2020-05-23 19:57:54 +03:00 · 2020-05-22 18:41:15 +03:00
69 changed files with 1076 additions and 599 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -1,4 +1,5 @@
 # Copyright 2016, 2017 Peter Dimov
+# 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)

@ -24,13 +25,67 @@ matrix:
    - env: BOGUS_JOB=true

  include:
+# gcc, Linux
+# Note: gcc-4.4 in C++0x mode fails zip_iterator tests with std::tuple
    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc CXXSTD=03,11
+      dist: trusty
+      compiler: gcc-4.4
+      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test

    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc-5 CXXSTD=03,11,14,1z
+      dist: trusty
+      compiler: gcc-4.6
+      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: gcc-4.7
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      compiler: gcc-4.8
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      compiler: gcc-4.9
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      compiler: gcc-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
      addons:
        apt:
          packages:
@ -39,8 +94,9 @@ matrix:
            - ubuntu-toolchain-r-test

    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc-6 CXXSTD=03,11,14,1z
+      dist: xenial
+      compiler: gcc-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
      addons:
        apt:
          packages:
@ -49,8 +105,9 @@ matrix:
            - ubuntu-toolchain-r-test

    - os: linux
-      compiler: g++-7
-      env: TOOLSET=gcc-7 CXXSTD=03,11,14,17
+      dist: xenial
+      compiler: gcc-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
      addons:
        apt:
          packages:
@ -59,28 +116,299 @@ matrix:
            - ubuntu-toolchain-r-test

    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang CXXSTD=03,11,14,1z
+      dist: xenial
+      compiler: gcc-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: bionic
+      compiler: gcc-9
+      env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - g++-9
+          sources:
+            - sourceline: "ppa:ubuntu-toolchain-r/test"
+
+    - os: linux
+      dist: bionic
+      compiler: gcc-10
+      env: TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,17,20
+      addons:
+        apt:
+          packages:
+            - g++-10
+          sources:
+            - sourceline: "ppa:ubuntu-toolchain-r/test"
+
+    - os: linux
+      dist: bionic
+      compiler: gcc-UBSAN
+      env: UBSAN=1 TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,17,20 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
+      addons:
+        apt:
+          packages:
+            - g++-10
+          sources:
+            - sourceline: "ppa:ubuntu-toolchain-r/test"
+
+# clang, Linux
+    - os: linux
+      dist: trusty
+      compiler: clang-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.5 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: trusty
+      compiler: clang-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+            - libstdc++-5-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.6 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: trusty
+      compiler: clang-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+            - libstdc++-5-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.7 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+            - libstdc++-6-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-3.8 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+            - libstdc++-6-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-3.9 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-4
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+            - libstdc++-6-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-4.0 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-5
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+            - libstdc++-7-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-5.0 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-6
+      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+            - libstdc++-8-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-6.0 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-7
+      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-7
+            - libstdc++-8-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-7 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-8
+      env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-8
+            - libstdc++-8-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-8 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-9
+      env: TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-9
+            - libstdc++-9-dev
+          sources:
+            - sourceline: "ppa:ubuntu-toolchain-r/test"
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-10
+      env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20
+      addons:
+        apt:
+          packages:
+            - clang-10
+            - libstdc++-9-dev
+          sources:
+            - sourceline: "ppa:ubuntu-toolchain-r/test"
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-UBSAN
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20 UBSAN_OPTIONS=print_stacktrace=1
+      addons:
+        apt:
+          packages:
+            - clang-10
+            - libstdc++-9-dev
+          sources:
+            - sourceline: "ppa:ubuntu-toolchain-r/test"
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-libc++
+      env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20 CXXFLAGS="-stdlib=libc++" LINKFLAGS="-stdlib=libc++"
+      addons:
+        apt:
+          packages:
+            - clang-10
+            - libc++-10-dev
+            - libc++abi-10-dev
+          sources:
+            - sourceline: "ppa:ubuntu-toolchain-r/test"
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-libc++-UBSAN
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20 UBSAN_OPTIONS=print_stacktrace=1 CXXFLAGS="-stdlib=libc++" LINKFLAGS="-stdlib=libc++"
+      addons:
+        apt:
+          packages:
+            - clang-10
+            - libc++-10-dev
+            - libc++abi-10-dev
+          sources:
+            - sourceline: "ppa:ubuntu-toolchain-r/test"
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+# clang, OS X
+# OS X builds are slow on Travis CI
+#    - os: osx
+#      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+#      osx_image: xcode9.4
+#
+#    - os: osx
+#      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+#      osx_image: xcode10.3

    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,17
+      osx_image: xcode11.2

 install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - GIT_FETCH_JOBS=8
+  - BOOST_BRANCH=develop
+  - if [ "$TRAVIS_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
  - cd ..
  - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
+  - 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
  - cp -r $TRAVIS_BUILD_DIR/* libs/iterator
-  - python tools/boostdep/depinst/depinst.py iterator
+  - python tools/boostdep/depinst/depinst.py --git_args "--jobs $GIT_FETCH_JOBS" iterator
  - ./bootstrap.sh
  - ./b2 headers

 script:
-  - ./b2 -j3 libs/iterator/test toolset=$TOOLSET cxxstd=$CXXSTD
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - BUILD_JOBS=`(nproc || sysctl -n hw.ncpu) 2> /dev/null`
+  - ./b2 -j $BUILD_JOBS libs/iterator/test toolset=$TOOLSET cxxstd=$CXXSTD ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on visibility=global} ${CXXFLAGS:+cxxflags="$CXXFLAGS"} ${LINKFLAGS:+linkflags="$LINKFLAGS"}

 notifications:
  email:
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -0,0 +1,34 @@
+# 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
+
+# Partial (add_subdirectory only) and experimental CMake support
+# Subject to change; please do not rely on the contents of this file yet.
+
+cmake_minimum_required(VERSION 3.5)
+
+project(BoostIterator 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::conversion
+        Boost::core
+        Boost::detail
+        Boost::function_types
+        Boost::fusion
+        Boost::mpl
+        Boost::optional
+        Boost::smart_ptr
+        Boost::static_assert
+        Boost::type_traits
+        Boost::utility
+)
--- a/appveyor.yml
+++ b/appveyor.yml
@ -1,4 +1,5 @@
 # Copyright 2017 Edward Diener
+# Copyright 2019 Andrey Semashev
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)

@ -14,30 +15,66 @@ branches:

 environment:
  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-14.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
+    - TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: msvc-14.0
+      ADDRMD: 32,64
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: msvc-14.1
      CXXSTD: 14,17
+      ADDRMD: 32,64
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    - TOOLSET: msvc-14.2
+      ADDRMD: 32,64
+      CXXSTD: 14,17
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+    - TOOLSET: clang-win
+      ADDRMD: 32,64
+      CXXSTD: 14,17
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    - TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+      ADDPATH: C:\cygwin\bin;
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+      ADDPATH: C:\cygwin64\bin;
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+      ADDPATH: C:\mingw\bin;
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: gcc
+      CXXSTD: 03,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: 03,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

 install:
+  - set GIT_FETCH_JOBS=8
  - set BOOST_BRANCH=develop
  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
  - cd ..
  - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
+  - 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 iterator
+  - python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" iterator
  - cmd /c bootstrap
  - b2 -d0 headers

 build: off

 test_script:
+  - PATH=%ADDPATH%%PATH%
  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - b2 -j3 libs/iterator/test toolset=%TOOLSET% %CXXSTD%
+  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+  - b2 -j %NUMBER_OF_PROCESSORS% libs/iterator/test toolset=%TOOLSET% %CXXSTD% %ADDRMD%
--- a/doc/quickbook/adaptor.qbk
+++ b/doc/quickbook/adaptor.qbk
@ -1,4 +1,3 @@
-
 [section:adaptor Iterator Adaptor]

 The `iterator_adaptor` class template adapts some `Base` [#base]_
@ -47,7 +46,7 @@ that assumption.
    , class Reference           = use_default
    , class Difference = use_default
  >
-  class iterator_adaptor 
+  class iterator_adaptor
    : public iterator_facade<Derived, *V'*, *C'*, *R'*, *D'*> // see details
  {
      friend class iterator_core_access;
@ -60,21 +59,21 @@ that assumption.
      typedef iterator_adaptor iterator_adaptor\_;
      Base const& base_reference() const;
      Base& base_reference();
-   private: // Core iterator interface for iterator_facade.  
+   private: // Core iterator interface for iterator_facade.
      typename iterator_adaptor::reference dereference() const;

      template <
-      class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >   
+          class OtherDerived, class OtherIterator, class V, class C, class R, class D
+      >
      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const;
-  
+
      void advance(typename iterator_adaptor::difference_type n);
      void increment();
      void decrement();

      template <
          class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >   
+      >
      typename iterator_adaptor::difference_type distance_to(
          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const;

@ -133,7 +132,7 @@ above are defined as follows:
  iterator_adaptor();

 [*Requires:] The `Base` type must be Default Constructible.[br]
-[*Returns:] An instance of `iterator_adaptor` with 
+[*Returns:] An instance of `iterator_adaptor` with
    `m_iterator` default constructed.


@ -167,7 +166,7 @@ above are defined as follows:

  template <
  class OtherDerived, class OtherIterator, class V, class C, class R, class D
-  >   
+  >
  bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const;

 [*Returns:] `m_iterator == x.base()`
@ -188,7 +187,7 @@ above are defined as follows:

  template <
      class OtherDerived, class OtherIterator, class V, class C, class R, class D
-  >   
+  >
  typename iterator_adaptor::difference_type distance_to(
      iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const;

@ -229,7 +228,7 @@ operations on the underlying pointer, via the `node_iterator`\ 's
 |dereference_and_equal|_).  The only real behavioral difference
 between `node_base*` and `node_iterator` can be observed when
 they are incremented: `node_iterator` follows the
-`m_next` pointer, while `node_base*` just applies an address offset.   
+`m_next` pointer, while `node_base*` just applies an address offset.

 .. |dereference_and_equal| replace:: `dereference` and `equal` member functions
 .. _dereference_and_equal: iterator_facade.html#implementing-the-core-operations
@ -287,8 +286,8 @@ this technique is known not to work with Borland C++ 5.6.4 and
 Metrowerks CodeWarrior versions prior to 9.0]

 You can see an example program that exercises this version of the
-node iterators 
-[@../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]
--- a/doc/quickbook/archetypes.qbk
+++ b/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]
--- a/doc/quickbook/concepts.qbk
+++ b/doc/quickbook/concepts.qbk
@ -1,4 +1,3 @@
-
 [section:concepts Iterator Concepts]

 [section:access Access]
@ -326,13 +325,13 @@ constant object of type `Distance`.
    [pre: there exists a value `n` of `Distance` such that `a + n == b`. `b == a + (b - a)`.]
  ]
  [
-    [`a\[n\]`]
+    [`a[n]`]
    [convertible to T]
    [`*(a + n)`]
    [pre: a is a *Readable Iterator*]
  ]
  [
-    [`a\[n\] = v`]
+    [`a[n] = v`]
    [convertible to T]
    [`*(a + n) = v`]
    [pre: a is a *Writable iterator*]
--- a/doc/quickbook/counting_iterator.qbk
+++ b/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`
@ -181,7 +182,7 @@ operations.
  counting_iterator& operator--();

 [*Effects: ] `--m_inc`[br]
-[*Returns: ] `*this`  
+[*Returns: ] `*this`


  Incrementable const& base() const;
@ -189,4 +190,4 @@ operations.
 [*Returns: ] `m_inc`


-[endsect]
+[endsect]
--- a/doc/quickbook/facade.qbk
+++ b/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
--- a/doc/quickbook/facade_tutorial.qbk
+++ b/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,10 +253,10 @@ make them private and grant friendship to
  };

 Voila; a complete and conforming readable, forward-traversal
-iterator!  For a working example of its use, see 
-[@../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`]

@ -265,7 +264,7 @@ __ ../example/node_iterator1.cpp
 The term **mutable iterator** means an iterator through which
 the object it references (its "referent") can be modified.  A
 **constant iterator** is one which doesn't allow modification of
-its referent.[br][br]  
+its referent.[br][br]
 The words *constant* and *mutable* don't refer to the ability to
 modify the iterator itself.  For example, an `int const*` is a
 non-\ `const` *constant iterator*, which can be incremented
@ -402,7 +401,7 @@ adding a templatized converting constructor [#broken]_ [#random]_:

      template <class OtherValue>
      bool equal(node_iter<OtherValue> const& other) const
-      { 
+      {
          return this->m_node == other.m_node;
      }

@ -428,11 +427,11 @@ adding a templatized converting constructor [#broken]_ [#random]_:
   `distance_to` function as well.


-__ ../example/node_iterator2.hpp
+__ ../../example/node_iterator2.hpp

 You can see an example program which exercises our interoperable
-iterators 
-[@../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:
--- a/doc/quickbook/filter_iterator.qbk
+++ b/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`.


@ -179,14 +178,14 @@ operations.
  filter_iterator();

 [*Requires: ]`Predicate` and `Iterator` must be Default Constructible.[br]
-[*Effects: ] Constructs a `filter_iterator` whose`m_pred`,  `m_iter`, and `m_end` 
+[*Effects: ] Constructs a `filter_iterator` whose`m_pred`,  `m_iter`, and `m_end`
  members are a default constructed.


  filter_iterator(Predicate f, Iterator x, Iterator end = Iterator());

 [*Effects: ] Constructs a `filter_iterator` where `m_iter` is either
-    the first position in the range `[x,end)` such that `f(*m_iter) == true` 
+    the first position in the range `[x,end)` such that `f(*m_iter) == true`
    or else`m_iter == end`. The member `m_pred` is constructed from
    `f` and `m_end` from `end`.

@ -197,7 +196,7 @@ operations.
 [*Requires: ] `Predicate` must be Default Constructible and
  `Predicate` is a class type (not a function pointer).[br]
 [*Effects: ] Constructs a `filter_iterator` where `m_iter` is either
-    the first position in the range `[x,end)` such that `m_pred(*m_iter) == true` 
+    the first position in the range `[x,end)` such that `m_pred(*m_iter) == true`
    or else`m_iter == end`. The member `m_pred` is default constructed.


@ -236,7 +235,6 @@ operations.
 [*Effects: ] Increments `m_iter` and then continues to
  increment `m_iter` until either `m_iter == m_end`
  or `m_pred(*m_iter) == true`.[br]
-[*Returns: ] `*this`  
+[*Returns: ] `*this`

-
-[endsect]
+[endsect]
--- a/doc/quickbook/function_output_iterator.qbk
+++ b/doc/quickbook/function_output_iterator.qbk
@ -1,4 +1,3 @@
-
 [section:function_output Function Output Iterator]

 The function output iterator adaptor makes it easier to create custom
@ -34,7 +33,7 @@ proxy object.
      x.push_back("!");

      std::string s = "";
-      std::copy(x.begin(), x.end(), 
+      std::copy(x.begin(), x.end(),
          boost::make_function_output_iterator(string_appender(s)));

      std::cout << s << std::endl;
@ -68,7 +67,7 @@ proxy object.

 [h3 Requirements]

-`UnaryFunction` must be Assignable and Copy Constructible.  
+`UnaryFunction` must be Assignable and Copy Constructible.

 [h3 Concepts]

@ -79,14 +78,14 @@ Incrementable Iterator concepts.

  explicit function_output_iterator(const UnaryFunction& f = UnaryFunction());

-[*Effects: ] Constructs an instance of `function_output_iterator` 
+[*Effects: ] Constructs an instance of `function_output_iterator`
  with `m_f` constructed from `f`.

  unspecified_type operator*();

 [*Returns: ] An object `r` of unspecified type such that `r = t`
  is equivalent to `m_f(t)` for all `t`.
-  
+

  function_output_iterator& operator++();

--- a/doc/quickbook/indirect_iterator.qbk
+++ b/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)
@ -204,7 +204,7 @@ following operations:
  indirect_iterator();

 [*Requires: ] `Iterator` must be Default Constructible.[br]
-[*Effects: ] Constructs an instance of `indirect_iterator` with 
+[*Effects: ] Constructs an instance of `indirect_iterator` with
   a default-constructed `m_iterator`.


@ -226,7 +226,7 @@ following operations:
  );

 [*Requires: ] `Iterator2` is implicitly convertible to `Iterator`.[br]
-[*Effects: ] Constructs an instance of `indirect_iterator` whose 
+[*Effects: ] Constructs an instance of `indirect_iterator` whose
    `m_iterator` subobject is constructed from `y.base()`.


@ -251,4 +251,4 @@ following operations:
 [*Effects: ] `--m_iterator`[br]
 [*Returns: ] `*this`

-[endsect]
+[endsect]
--- a/doc/quickbook/iterator.qbk
+++ b/doc/quickbook/iterator.qbk
@ -1,4 +1,3 @@
-
 [library Boost.Iterator
    [/ version 1.0.1]
    [quickbook 1.6]
@ -31,6 +30,7 @@

 [def _iterator_           [@../../../iterator/doc/index.html Boost.Iterator]]
 [def _concept_check_      [@../../../concept_check/index.html Boost.ConceptCheck]]
+[template example_link[name descr]'''<ulink url="../../example/'''[name]'''">'''[descr]'''</ulink>''']

 [template sub[x]'''<subscript>'''[x]'''</subscript>''']

@ -305,4 +305,3 @@ library you see today.
   Patterns, C++ Report, February 1995, pp. 24-27.]

 [endsect]
-
--- a/doc/quickbook/iterator_traits.qbk
+++ b/doc/quickbook/iterator_traits.qbk
@ -1,4 +1,3 @@
-
 [section:iterator_traits Iterator Traits]

 `std::iterator_traits` provides access to five associated types
--- a/doc/quickbook/permutation_iterator.qbk
+++ b/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`.
@ -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]
--- a/doc/quickbook/reverse_iterator.qbk
+++ b/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]

@ -116,7 +115,7 @@ operations.
  reverse_iterator();

 [*Requires: ] `Iterator` must be Default Constructible.[br]
-[*Effects: ] Constructs an instance of `reverse_iterator` with `m_iterator` 
+[*Effects: ] Constructs an instance of `reverse_iterator` with `m_iterator`
  default constructed.

  explicit reverse_iterator(Iterator x);
@ -132,7 +131,7 @@ operations.
    );

 [*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.[br]
-[*Effects: ] Constructs instance of `reverse_iterator` whose 
+[*Effects: ] Constructs instance of `reverse_iterator` whose
    `m_iterator` subobject is constructed from `y.base()`.


@ -157,4 +156,4 @@ operations.
 [*Effects: ] `++m_iterator`[br]
 [*Returns: ] `*this`

-[endsect]
+[endsect]
--- a/doc/quickbook/shared_container_iterator.qbk
+++ b/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.

-[@../../example/shared_iterator_example1.cpp `shared_iterator_example1.cpp`]:
+[example_link shared_iterator_example1.cpp..`shared_iterator_example1.cpp`]:

  #include "shared_container_iterator.hpp"
  #include "boost/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.

-[@../../example/shared_iterator_example2.cpp `shared_iterator_example2.cpp`]:
+[example_link shared_iterator_example2.cpp..`shared_iterator_example2.cpp`]:

  #include "shared_container_iterator.hpp"
  #include "boost/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.

-[@../../example/shared_iterator_example3.cpp `shared_iterator_example3.cpp`]:
+[example_link shared_iterator_example3.cpp..`shared_iterator_example3.cpp`]:

  #include "shared_container_iterator.hpp"
  #include "boost/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]
--- a/doc/quickbook/specialized_adaptors.qbk
+++ b/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]
--- a/doc/quickbook/transform_iterator.qbk
+++ b/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
  {
@ -116,7 +116,7 @@ where the type of `f(*i)` must be
 `result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type`.


-The argument `Iterator` shall model Readable Iterator.  
+The argument `Iterator` shall model Readable Iterator.


 [h3 Concepts]
@ -126,11 +126,11 @@ The resulting `transform_iterator` models the most refined of the
 following that is also modeled by `Iterator`.


-* Writable Lvalue Iterator if `transform_iterator::reference` is a non-const reference. 
+* Writable Lvalue Iterator if `transform_iterator::reference` is a non-const reference.

 * Readable Lvalue Iterator if `transform_iterator::reference` is a const reference.

-* Readable Iterator otherwise. 
+* Readable Iterator otherwise.


 The `transform_iterator` models the most refined standard traversal
@ -143,11 +143,11 @@ the `Iterator` argument models.


 [table Category
-	[[If `Iterator` models][then `transform_iterator` models]]
-	[[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
@ -177,7 +177,7 @@ operations:
  template<class F2, class I2, class R2, class V2>
  transform_iterator(
        transform_iterator<F2, I2, R2, V2> const& t
-      , typename enable_if_convertible<I2, Iterator>::type* = 0	   // exposition only
+      , typename enable_if_convertible<I2, Iterator>::type* = 0      // exposition only
      , typename enable_if_convertible<F2, UnaryFunction>::type* = 0 // exposition only
  );

--- a/doc/quickbook/zip_iterator.qbk
+++ b/doc/quickbook/zip_iterator.qbk
@ -1,17 +1,16 @@
-
 [section:zip Zip Iterator]

 The zip iterator provides the ability to parallel-iterate
-over several controlled sequences simultaneously. A zip 
+over several controlled sequences simultaneously. A zip
 iterator is constructed from a tuple of iterators. Moving
 the zip iterator moves all the iterators in parallel.
 Dereferencing the zip iterator returns a tuple that contains
-the results of dereferencing the individual iterators. 
+the results of dereferencing the individual iterators.

-The tuple of iterators is now implemented in terms of a Boost fusion sequence. 
+The tuple of iterators is now implemented in terms of a Boost fusion sequence.
 Because of this the 'tuple' may be any Boost fusion sequence and, for backwards
-compatibility through a Boost fusion sequence adapter, a Boost tuple. Because the 
-'tuple' may be any boost::fusion sequence the 'tuple' may also be any type for which a 
+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
@ -22,9 +21,9 @@ to use a Boost tuple as your 'tuple'.

 There are two main types of applications of the `zip_iterator`. The first
 one concerns runtime efficiency: If one has several controlled sequences
-of the same length that must be somehow processed, e.g., with the 
+of the same length that must be somehow processed, e.g., with the
 `for_each` algorithm, then it is more efficient to perform just
-one parallel-iteration rather than several individual iterations. For an 
+one parallel-iteration rather than several individual iterations. For an
 example, assume that `vect_of_doubles` and `vect_of_ints`
 are two vectors of equal length containing doubles and ints, respectively,
 and consider the following two iterations:
@ -53,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
@ -72,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`:
@ -128,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;
@ -154,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
@ -168,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
@ -195,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
@ -254,8 +253,8 @@ operations.
 [*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`
@ -263,4 +262,4 @@ operations.

 [endsect]

-[endsect]
+[endsect]
--- a/example/counting_iterator_example.cpp
+++ b/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;
 }
--- a/example/filter_iterator_example.cpp
+++ b/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;
 }
--- a/example/func_output_iter_example.cpp
+++ b/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;
--- a/example/indirect_iterator_example.cpp
+++ b/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;
 }
--- a/example/node_iterator1.cpp
+++ b/example/node_iterator1.cpp
@ -15,11 +15,11 @@ int main()
 #if defined(BOOST_NO_CXX11_SMART_PTR)

    std::auto_ptr<node<int> > nodes(new node<int>(42));
-    
+
 #else

    std::unique_ptr<node<int> > nodes(new node<int>(42));
-    
+
 #endif

    nodes->append(new node<std::string>(" is greater than "));
@ -30,7 +30,7 @@ int main()
      , std::ostream_iterator<node_base>(std::cout, " ")
    );
    std::cout << std::endl;
-    
+
    std::for_each(
        node_iterator(nodes.get()), node_iterator()
      , std::mem_fun_ref(&node_base::double_me)
--- a/example/node_iterator2.cpp
+++ b/example/node_iterator2.cpp
@ -16,11 +16,11 @@ int main()
 #if defined(BOOST_NO_CXX11_SMART_PTR)

    std::auto_ptr<node<int> > nodes(new node<int>(42));
-    
+
 #else

    std::unique_ptr<node<int> > nodes(new node<int>(42));
-    
+
 #endif

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

    std::auto_ptr<node<int> > nodes(new node<int>(42));
-    
+
 #else

    std::unique_ptr<node<int> > nodes(new node<int>(42));
-    
+
 #endif

    nodes->append(new node<std::string>(" is greater than "));
@ -29,16 +29,16 @@ int main()
    // Check interoperability
    assert(node_iterator(nodes.get()) == node_const_iterator(nodes.get()));
    assert(node_const_iterator(nodes.get()) == node_iterator(nodes.get()));
-    
+
    assert(node_iterator(nodes.get()) != node_const_iterator());
    assert(node_const_iterator(nodes.get()) != node_iterator());
-    
+
    std::copy(
        node_iterator(nodes.get()), node_iterator()
      , std::ostream_iterator<node_base>(std::cout, " ")
    );
    std::cout << std::endl;
-    
+
    std::for_each(
        node_iterator(nodes.get()), node_iterator()
      , boost::mem_fn(&node_base::double_me)
--- a/example/permutation_iter_example.cpp
+++ b/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() );

--- a/example/reverse_iterator_example.cpp
+++ b/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);
--- a/example/shared_iterator_example1.cpp
+++ b/example/shared_iterator_example1.cpp
@ -1,6 +1,6 @@
 // Copyright 2003 The Trustees of Indiana University.

-// Use, modification and distribution is subject to the Boost Software 
+// Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

@ -16,14 +16,14 @@ typedef boost::shared_container_iterator< std::vector<int> > iterator;
 void set_range(iterator& i, iterator& end)  {

  boost::shared_ptr< std::vector<int> > ints(new std::vector<int>());
-  
+
  ints->push_back(0);
  ints->push_back(1);
  ints->push_back(2);
  ints->push_back(3);
  ints->push_back(4);
  ints->push_back(5);
-  
+
  i = iterator(ints->begin(),ints);
  end = iterator(ints->end(),ints);
 }
--- a/example/shared_iterator_example2.cpp
+++ b/example/shared_iterator_example2.cpp
@ -1,6 +1,6 @@
 // Copyright 2003 The Trustees of Indiana University.

-// Use, modification and distribution is subject to the Boost Software 
+// Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

@ -36,7 +36,7 @@ int main() {
    print_range_nl(boost::make_shared_container_iterator(ints->begin(),ints),
                   boost::make_shared_container_iterator(ints->end(),ints));
  }
-  
+


  return 0;
--- a/example/shared_iterator_example3.cpp
+++ b/example/shared_iterator_example3.cpp
@ -1,6 +1,6 @@
 // Copyright 2003 The Trustees of Indiana University.

-// Use, modification and distribution is subject to the Boost Software 
+// Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

@ -8,7 +8,7 @@
 #include "boost/shared_ptr.hpp"
 #include "boost/tuple/tuple.hpp" // for boost::tie
 #include <algorithm>              // for std::copy
-#include <iostream>              
+#include <iostream>
 #include <vector>


@ -31,7 +31,7 @@ int main() {


  iterator i,end;
-  
+
  boost::tie(i,end) = return_range();

  std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
--- a/example/transform_iterator_example.cpp
+++ b/example/transform_iterator_example.cpp
@ -1,4 +1,4 @@
-// (C) Copyright Jeremy Siek 2000-2004. 
+// (C) Copyright Jeremy Siek 2000-2004.
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@ -15,7 +15,7 @@

 namespace boost {

-  template <class Operation> 
+  template <class Operation>
  class binder1st {
  public:
    typedef typename Operation::result_type result_type;
@ -70,6 +70,6 @@ main(int, char*[])
            boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
            std::ostream_iterator<int>(std::cout, " "));
  std::cout << std::endl;
-  
+
  return 0;
 }
--- a/include/boost/function_output_iterator.hpp
+++ b/include/boost/function_output_iterator.hpp
@ -9,6 +9,10 @@
 // This is a deprecated header left for backward compatibility.
 // Use boost/iterator/function_output_iterator.hpp instead.

+#include <boost/config/header_deprecated.hpp>
+
+BOOST_HEADER_DEPRECATED("<boost/iterator/function_output_iterator.hpp>")
+
 #include <boost/iterator/function_output_iterator.hpp>

 #endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
--- a/include/boost/iterator/advance.hpp
+++ b/include/boost/iterator/advance.hpp
@ -77,7 +77,7 @@ namespace iterators {

 } // namespace iterators

-using iterators::advance;
+using namespace iterators::advance_adl_barrier;

 } // namespace boost

--- a/include/boost/iterator/counting_iterator.hpp
+++ b/include/boost/iterator/counting_iterator.hpp
@ -38,7 +38,7 @@ 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
--- a/include/boost/iterator/detail/config_def.hpp
+++ b/include/boost/iterator/detail/config_def.hpp
@ -27,7 +27,7 @@
 // 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,7 +46,7 @@

 #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))
@ -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
@ -114,7 +114,7 @@
 # define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
 #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.
--- a/include/boost/iterator/detail/facade_iterator_category.hpp
+++ b/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
@ -33,8 +35,7 @@
 namespace boost {
 namespace iterators {

-// forward declaration
-struct use_default;
+using boost::use_default;

 namespace detail {

--- a/include/boost/iterator/distance.hpp
+++ b/include/boost/iterator/distance.hpp
@ -58,7 +58,7 @@ namespace iterators {

 } // namespace iterators

-using iterators::distance;
+using namespace iterators::distance_adl_barrier;

 } // namespace boost

--- a/include/boost/iterator/indirect_iterator.hpp
+++ b/include/boost/iterator/indirect_iterator.hpp
@ -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();
--- a/include/boost/iterator/iterator_adaptor.hpp
+++ b/include/boost/iterator/iterator_adaptor.hpp
@ -9,6 +9,8 @@

 #include <boost/static_assert.hpp>

+#include <boost/core/use_default.hpp>
+
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/detail/enable_if.hpp>
@ -35,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.
--- a/include/boost/iterator/iterator_archetypes.hpp
+++ b/include/boost/iterator/iterator_archetypes.hpp
@ -426,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;
+      };
  };
 }

--- a/include/boost/iterator/iterator_facade.hpp
+++ b/include/boost/iterator/iterator_facade.hpp
@ -16,7 +16,7 @@
 #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>
--- a/include/boost/pending/iterator_tests.hpp
+++ b/include/boost/pending/iterator_tests.hpp
@ -180,7 +180,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
 }
--- a/include/boost/pointee.hpp
+++ b/include/boost/pointee.hpp
@ -50,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
--- a/include/boost/shared_container_iterator.hpp
+++ b/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
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -59,6 +59,8 @@ test-suite iterator
    [ 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 ]
 ;
--- a/test/adl_test.cpp
+++ b/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;
+}
--- a/test/concept_tests.cpp
+++ b/test/concept_tests.cpp
@ -16,8 +16,13 @@ struct new_random_access
 {};

 struct new_iterator
-  : public std::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; }
@ -36,8 +41,13 @@ struct new_iterator
 new_iterator operator+(std::ptrdiff_t, new_iterator x) { return x; }

 struct old_iterator
-  : public std::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; }
@ -61,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<
--- a/test/counting_iterator_test.cpp
+++ b/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/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
@ -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());
@ -200,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;
@ -283,14 +281,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));
--- a/test/detail/zip_iterator_test.ipp
+++ b/test/detail/zip_iterator_test.ipp
@ -6,7 +6,7 @@
 //
 //  See http://www.boost.org for most recent version including documentation.

-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>

 #include <boost/assign/list_of.hpp>
 #include <boost/fusion/include/at.hpp>
--- a/test/filter_iterator_test.cpp
+++ b/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));
--- a/test/function_input_iterator_test.cpp
+++ b/test/function_input_iterator_test.cpp
@ -55,7 +55,7 @@ int main()
    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),
--- a/test/generator_iterator_test.cpp
+++ b/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
--- a/test/indirect_iter_member_types.cpp
+++ b/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;
 }
--- a/test/indirect_iterator_test.cpp
+++ b/test/indirect_iterator_test.cpp
@ -28,7 +28,7 @@

 #include <boost/mpl/has_xxx.hpp>

-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>

 #include <vector>
 #include <stdlib.h>
@ -44,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;
@ -53,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;
@ -62,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
@ -73,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;

@ -90,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);

@ -125,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()));
@ -145,21 +145,21 @@ 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;
@ -169,7 +169,7 @@ main()
            std::iterator_traits<shared_t::iterator>::value_type
        >::value
        );
-    
+
    typedef boost::indirect_iterator<
        shared_t::iterator
      , boost::iterator_value<shared_t::iterator>::type const
@ -177,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;
@ -202,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();
--- a/test/interoperable.cpp
+++ b/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();
 }
--- a/test/is_lvalue_iterator.cpp
+++ b/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;
 }
--- a/test/is_readable_iterator.cpp
+++ b/test/is_readable_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_readable_iterator.hpp>
-#include <boost/iterator.hpp>

 // Last, for BOOST_NO_LVALUE_RETURN_DETECTION
 #include <boost/iterator/detail/config_def.hpp>
@ -20,52 +20,58 @@ 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;
 };

-struct proxy_iterator : boost::iterator<std::output_iterator_tag,v>
+struct proxy_iterator
 {
-#if BOOST_WORKAROUND(__GNUC__, == 2)
-    typedef boost::iterator<std::input_iterator_tag,v> base;
-    typedef base::iterator_category iterator_category;
-    typedef base::value_type value_type;
-    typedef base::difference_type difference_type;
-    typedef base::pointer pointer;
-    typedef base::reference reference;
-#endif 
-    
+    typedef std::output_iterator_tag iterator_category;
+    typedef v value_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef v* pointer;
+    typedef v& reference;
+
    struct proxy
    {
        operator v&();
        proxy& operator=(v) const;
    };
-        
+
    proxy operator*() const;
 };

-struct proxy_iterator2 : boost::iterator<std::output_iterator_tag,v>
+struct proxy_iterator2
 {
-#if BOOST_WORKAROUND(__GNUC__, == 2)
-    typedef boost::iterator<std::input_iterator_tag,v> base;
-    typedef base::iterator_category iterator_category;
-    typedef base::value_type value_type;
-    typedef base::difference_type difference_type;
-    typedef base::pointer pointer;
-    typedef base::reference reference;
-#endif 
-    
+    typedef std::output_iterator_tag iterator_category;
+    typedef v value_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef v* pointer;
+    typedef v& reference;
+
    struct proxy
    {
        proxy& operator=(v) const;
    };
-        
+
    proxy operator*() const;
 };

@ -81,10 +87,10 @@ int main()
    BOOST_STATIC_ASSERT(boost::is_readable_iterator<proxy_iterator>::value);
    BOOST_STATIC_ASSERT(!boost::is_readable_iterator<proxy_iterator2>::value);
    BOOST_STATIC_ASSERT(boost::is_readable_iterator<value_iterator>::value);
-    
+
    // Make sure inaccessible copy constructor doesn't prevent
    // readability
    BOOST_STATIC_ASSERT(boost::is_readable_iterator<noncopyable_iterator>::value);
-    
+
    return 0;
 }
--- a/test/iterator_adaptor_cc.cpp
+++ b/test/iterator_adaptor_cc.cpp
@ -27,7 +27,7 @@ int main()
 #if defined(__SGI_STL_PORT)                                                             \
    || !BOOST_WORKAROUND(__GNUC__, <= 2)                                                \
    && !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 1))    \
-    && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))                          \
+    && !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))                          \
    && !BOOST_WORKAROUND(__LIBCOMO_VERSION__, BOOST_TESTED_AT(29))                      \
    && !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 1)
  {
@ -41,6 +41,6 @@ int main()
    boost::function_requires< boost_concepts::InteroperableIteratorConcept<rev_iter, c_rev_iter> >();
  }
 #endif
-  
+
  return boost::exit_success;
 }
--- a/test/iterator_adaptor_test.cpp
+++ b/test/iterator_adaptor_test.cpp
@ -16,10 +16,10 @@
 #if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
 # include <boost/iterator/is_readable_iterator.hpp>
 # include <boost/iterator/is_lvalue_iterator.hpp>
-#endif 
+#endif
 #include <boost/pending/iterator_tests.hpp>

-# include <boost/detail/lightweight_test.hpp>
+# include <boost/core/lightweight_test.hpp>

 #include <stdlib.h>
 #include <vector>
@ -56,9 +56,9 @@ struct ptr_iterator
      , V*
      , V
      , boost::random_access_traversal_tag
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
      , V&
-#endif 
+#endif
   >
 {
 private:
@ -67,11 +67,11 @@ private:
      , V*
      , V
      , boost::random_access_traversal_tag
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
      , V&
-#endif 
+#endif
    > super_t;
-    
+
 public:
  ptr_iterator() { }
  ptr_iterator(V* d) : super_t(d) { }
@ -95,7 +95,7 @@ struct modify_traversal
       , Traversal
     >
 {};
-  
+
 template <class T>
 struct fwd_iterator
  : boost::iterator_adaptor<
@ -108,7 +108,7 @@ private:
        fwd_iterator<T>
      , boost::forward_iterator_archetype<T>
  > super_t;
-    
+
 public:
  fwd_iterator() { }
  fwd_iterator(boost::forward_iterator_archetype<T> d) : super_t(d) { }
@ -126,7 +126,7 @@ private:
        in_iterator<T>
      , boost::input_iterator_archetype_no_proxy<T>
  > super_t;
-    
+
 public:
  in_iterator() { }
  in_iterator(boost::input_iterator_archetype_no_proxy<T> d) : super_t(d) { }
@ -145,7 +145,7 @@ struct constant_iterator
      , Iter
      , typename std::iterator_traits<Iter>::value_type const
    > base_t;
-    
+
  constant_iterator() {}
  constant_iterator(Iter it)
    : base_t(it) {}
@ -181,7 +181,7 @@ int static_assert_traversal(Iter* = 0, Trav* = 0)
 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);

@ -192,7 +192,7 @@ main()
  {
    ptr_iterator<dummyT> i(array);
    boost::random_access_iterator_test(i, N, array);
-    
+
    ptr_iterator<const dummyT> j(array);
    boost::random_access_iterator_test(j, N, array);
    boost::const_nonconst_iterator_test(i, ++j);
@ -210,25 +210,25 @@ main()
    test = static_assert_same<Iter1::difference_type, std::ptrdiff_t>::value;
 #if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
    BOOST_STATIC_ASSERT((boost::is_convertible<Iter1::iterator_category, std::random_access_iterator_tag>::value));
-#endif 
+#endif
  }
-  
-  {  
+
+  {
    // Test computation of default when the Value is const
    typedef ptr_iterator<int const> Iter1;
    test = static_assert_same<Iter1::value_type, int>::value;
    test = static_assert_same<Iter1::reference, const int&>::value;
-    
+
 #if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
    BOOST_STATIC_ASSERT(boost::is_readable_iterator<Iter1>::value);
 # ifndef BOOST_NO_LVALUE_RETURN_DETECTION
    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<Iter1>::value);
-# endif 
+# endif
 #endif

-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) // borland drops constness
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) // borland drops constness
    test = static_assert_same<Iter1::pointer, int const*>::value;
-#endif 
+#endif
  }

  {
@ -238,26 +238,26 @@ main()

    test = static_assert_same<Iter::value_type, int>::value;
    test = static_assert_same<Iter::reference, int const&>::value;
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) // borland drops constness
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) // borland drops constness
    test = static_assert_same<Iter::pointer, int const*>::value;
-#endif 
+#endif

 #ifndef BOOST_NO_LVALUE_RETURN_DETECTION
    BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<BaseIter>::value);
    BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<Iter>::value);
-#endif 
-    
+#endif
+
    typedef modify_traversal<BaseIter, boost::incrementable_traversal_tag> IncrementableIter;

    static_assert_traversal<BaseIter,boost::random_access_traversal_tag>();
    static_assert_traversal<IncrementableIter,boost::incrementable_traversal_tag>();
  }
-  
+
  // Test the iterator_adaptor
  {
    ptr_iterator<dummyT> i(array);
    boost::random_access_iterator_test(i, N, array);
-    
+
    ptr_iterator<const dummyT> j(array);
    boost::random_access_iterator_test(j, N, array);
    boost::const_nonconst_iterator_test(i, ++j);
@ -272,9 +272,9 @@ main()
    adaptor_type i(forward_iter);
    int zero = 0;
    if (zero) // don't do this, just make sure it compiles
-      BOOST_TEST((*i).m_x == i->foo());      
+      BOOST_TEST((*i).m_x == i->foo());
  }
-  
+
  // check operator-> with an input iterator
  {
    boost::input_iterator_archetype_no_proxy<dummyT> input_iter;
@ -282,7 +282,7 @@ main()
    adaptor_type i(input_iter);
    int zero = 0;
    if (zero) // don't do this, just make sure it compiles
-      BOOST_TEST((*i).m_x == i->foo());      
+      BOOST_TEST((*i).m_x == i->foo());
  }

  // check that base_type is correct
--- a/test/iterator_archetype_cc.cpp
+++ b/test/iterator_archetype_cc.cpp
@ -21,7 +21,7 @@ int main()

    boost::function_requires< boost_concepts::ReadableIteratorConcept<iter> >();
    boost::function_requires< boost_concepts::RandomAccessTraversalConcept<iter> >();
-  } 
+  }
  {
    typedef boost::iterator_archetype<
        int
@ -32,7 +32,7 @@ int main()
    boost::function_requires< boost_concepts::ReadableIteratorConcept<iter> >();
    boost::function_requires< boost_concepts::WritableIteratorConcept<iter> >();
    boost::function_requires< boost_concepts::RandomAccessTraversalConcept<iter> >();
-  } 
+  }
  {
    typedef boost::iterator_archetype<
        const int // I don't like adding const to Value. It is redundant. -JGS
@ -43,7 +43,7 @@ int main()
    boost::function_requires< boost_concepts::ReadableIteratorConcept<iter> >();
    boost::function_requires< boost_concepts::LvalueIteratorConcept<iter> >();
    boost::function_requires< boost_concepts::RandomAccessTraversalConcept<iter> >();
-  } 
+  }
  {
    typedef boost::iterator_archetype<
        int
@ -54,7 +54,7 @@ int main()
    boost::function_requires< boost_concepts::WritableIteratorConcept<iter> >();
    boost::function_requires< boost_concepts::LvalueIteratorConcept<iter> >();
    boost::function_requires< boost_concepts::RandomAccessTraversalConcept<iter> >();
-  } 
+  }

  return boost::exit_success;
 }
--- a/test/iterator_traits_test.cpp
+++ b/test/iterator_traits_test.cpp
@ -20,14 +20,14 @@
 //              reference type from operator* (David Abrahams)
 //  19 Jan 2001 Initial version with iterator operators (David Abrahams)

-#include <boost/detail/iterator.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/operators.hpp>
 #include <boost/static_assert.hpp>
+#include <boost/config.hpp>
 #include <iterator>
 #include <vector>
 #include <list>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <iostream>

 // A UDT for which we can specialize std::iterator_traits<element*> on
@ -40,7 +40,7 @@ struct my_iterator1
    : boost::forward_iterator_helper<my_iterator1, char, long, const char*, const char&>
 {
    my_iterator1(const char* p) : m_p(p) {}
-    
+
    bool operator==(const my_iterator1& rhs) const
        { return this->m_p == rhs.m_p; }

@ -63,9 +63,9 @@ struct my_iterator2
    typedef const char* pointer;
    typedef const char& reference;
    typedef std::forward_iterator_tag iterator_category;
-    
+
    my_iterator2(const char* p) : m_p(p) {}
-    
+
    bool operator==(const my_iterator2& rhs) const
        { return this->m_p == rhs.m_p; }

@ -77,7 +77,7 @@ struct my_iterator2

 // Used to prove that we're not overly confused by the existence of
 // std::iterator<> in the hierarchy under MSVC6 - we should find that
-// boost::detail::iterator_traits<my_iterator3>::difference_type is int.
+// std::iterator_traits<my_iterator3>::difference_type is int.
 struct my_iterator3 : my_iterator1
 {
    typedef int difference_type;
@ -108,8 +108,8 @@ template <class Iterator,
    class value_type, class difference_type, class pointer, class reference, class category>
 struct non_portable_tests
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::pointer test_pt;
-    typedef typename boost::detail::iterator_traits<Iterator>::reference test_rt;
+    typedef typename std::iterator_traits<Iterator>::pointer test_pt;
+    typedef typename std::iterator_traits<Iterator>::reference test_rt;
    typedef typename assert_same<test_pt, pointer>::type a1;
    typedef typename assert_same<test_rt, reference>::type a2;
 };
@ -118,8 +118,8 @@ template <class Iterator,
    class value_type, class difference_type, class pointer, class reference, class category>
 struct portable_tests
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::difference_type test_dt;
-    typedef typename boost::detail::iterator_traits<Iterator>::iterator_category test_cat;
+    typedef typename std::iterator_traits<Iterator>::difference_type test_dt;
+    typedef typename std::iterator_traits<Iterator>::iterator_category test_cat;
    typedef typename assert_same<test_dt, difference_type>::type a1;
    typedef typename assert_same<test_cat, category>::type a2;
 };
@ -130,7 +130,7 @@ template <class Iterator,
 struct input_iterator_test
    : portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::value_type test_vt;
+    typedef typename std::iterator_traits<Iterator>::value_type test_vt;
    typedef typename assert_same<test_vt, value_type>::type a1;
 };

@ -153,7 +153,16 @@ struct maybe_pointer_test
 input_iterator_test<std::istream_iterator<int>, int, std::ptrdiff_t, int*, int&, std::input_iterator_tag>
        istream_iterator_test;

-#if BOOST_WORKAROUND(__BORLANDC__, <= 0x564) && !defined(__SGI_STL_PORT)
+// C++20 changed ostream_iterator::difference_type to ptrdiff_t.
+// Note: gcc 10.1 defines __cplusplus to a value less than 202002L, but greater than 201703L in C++20 mode.
+#if __cplusplus > 201703L && (\
+    (defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION >= 100100) \
+    ) || \
+    defined(_MSVC_LANG) && _MSVC_LANG > 201703L && _MSVC_STL_UPDATE >= 202010L
+#define BOOST_ITERATOR_CXX20_OSTREAM_ITERATOR
+#endif
+
+#if BOOST_WORKAROUND(BOOST_BORLANDC, <= 0x564) && !defined(__SGI_STL_PORT)
 typedef ::std::char_traits<char>::off_type distance;
 non_pointer_test<std::ostream_iterator<int>,int,
    distance,int*,int&,std::output_iterator_tag> ostream_iterator_test;
@ -165,6 +174,10 @@ non_pointer_test<std::ostream_iterator<int>,
 non_pointer_test<std::ostream_iterator<int>,
    int, long, int*, int&, std::output_iterator_tag>
        ostream_iterator_test;
+#elif defined(BOOST_ITERATOR_CXX20_OSTREAM_ITERATOR)
+non_pointer_test<std::ostream_iterator<int>,
+    void, std::ptrdiff_t, void, void, std::output_iterator_tag>
+        ostream_iterator_test;
 #else
 non_pointer_test<std::ostream_iterator<int>,
    void, void, void, void, std::output_iterator_tag>
@ -189,7 +202,7 @@ maybe_pointer_test<int*, int, std::ptrdiff_t, int*, int&, std::random_access_ite

 non_pointer_test<my_iterator1, char, long, const char*, const char&, std::forward_iterator_tag>
       my_iterator1_test;
-                    
+
 non_pointer_test<my_iterator2, char, long, const char*, const char&, std::forward_iterator_tag>
       my_iterator2_test;

@ -204,15 +217,15 @@ int main()
    for (int length = 3; length < 100; length += length / 3)
    {
        std::list<int> l(length);
-        BOOST_TEST(boost::detail::distance(l.begin(), l.end()) == length);
-        
-        std::vector<int> v(length);
-        BOOST_TEST(boost::detail::distance(v.begin(), v.end()) == length);
+        BOOST_TEST(std::distance(l.begin(), l.end()) == length);

-        BOOST_TEST(boost::detail::distance(&ints[0], ints + length) == length);
-        BOOST_TEST(boost::detail::distance(my_iterator1(chars), my_iterator1(chars + length)) == length);
-        BOOST_TEST(boost::detail::distance(my_iterator2(chars), my_iterator2(chars + length)) == length);
-        BOOST_TEST(boost::detail::distance(my_iterator3(chars), my_iterator3(chars + length)) == length);
+        std::vector<int> v(length);
+        BOOST_TEST(std::distance(v.begin(), v.end()) == length);
+
+        BOOST_TEST(std::distance(&ints[0], ints + length) == length);
+        BOOST_TEST(std::distance(my_iterator1(chars), my_iterator1(chars + length)) == length);
+        BOOST_TEST(std::distance(my_iterator2(chars), my_iterator2(chars + length)) == length);
+        BOOST_TEST(std::distance(my_iterator3(chars), my_iterator3(chars + length)) == length);
    }
    return boost::report_errors();
 }
--- a/test/permutation_iterator_test.cpp
+++ b/test/permutation_iterator_test.cpp
@ -27,7 +27,7 @@ void iterop_test()
 {
    typedef boost::permutation_iterator< double*, int const* > permutation_type;
    typedef boost::permutation_iterator< double const*, int const* > permutation_const_type;
-  
+
    BOOST_CONCEPT_ASSERT((
      boost_concepts::InteroperableIteratorConcept<
           permutation_type
@ -58,7 +58,7 @@ void permutation_test()
  permutation_type begin = boost::make_permutation_iterator( elements.begin(), indices.begin() );
  permutation_type it = begin;
  permutation_type end = boost::make_permutation_iterator( elements.begin(), indices.end() );
-  
+
  BOOST_CHECK( it == begin );
  BOOST_CHECK( it != end );

@ -70,7 +70,7 @@ void permutation_test()
  }

  it = begin;
-  for( int i1 = 0; i1 < index_size - 1 ; ++++i1, ++++it ) 
+  for( int i1 = 0; i1 < index_size - 1 ; ++++i1, ++++it )
  {
    index_type::iterator i_it2 = indices.begin();
    std::advance( i_it2, i1 );
@ -79,14 +79,14 @@ void permutation_test()

  it = begin;
  std::advance(it, index_size);
-  for( index_type::iterator i_it3 = indices.end(); it != begin; ) 
+  for( index_type::iterator i_it3 = indices.end(); it != begin; )
  {
    BOOST_CHECK( *--it == elements[ *--i_it3 ] );
  }
-  
+
  it = begin;
  std::advance(it, index_size);
-  for( int i2 = 0; i2 < index_size - 1; i2+=2, --it ) 
+  for( int i2 = 0; i2 < index_size - 1; i2+=2, --it )
  {
    index_type::iterator i_it4 = --indices.end();
    std::advance( i_it4, -i2 );
--- a/test/pointee.cpp
+++ b/test/pointee.cpp
@ -35,7 +35,7 @@ struct X {
    template <class T> operator T&() const;
 };

-    
+
 int main()
 {
    STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<int> >::type, int);
@ -43,16 +43,16 @@ int main()

    STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<int const> >::type, int const);
    STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<X const> >::type, X const);
-    
+
    STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<int> >::type, int const);
    STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<X> >::type, X const);
-    
+
    STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<int const> >::type, int const);
    STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<X const> >::type, X const);

    STATIC_ASSERT_SAME(boost::pointee<int*>::type, int);
    STATIC_ASSERT_SAME(boost::pointee<int const*>::type, int const);
-    
+
    STATIC_ASSERT_SAME(boost::pointee<X*>::type, X);
    STATIC_ASSERT_SAME(boost::pointee<X const*>::type, X const);

@ -60,7 +60,7 @@ int main()

    STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<int> >::type, int);
    STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<X> >::type, X);
-    
+
    STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<int const> >::type, int const);
    STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<X const> >::type, X const);

@ -68,7 +68,7 @@ int main()

    STATIC_ASSERT_SAME(boost::pointee<std::unique_ptr<int> >::type, int);
    STATIC_ASSERT_SAME(boost::pointee<std::unique_ptr<X> >::type, X);
-    
+
    STATIC_ASSERT_SAME(boost::pointee<std::unique_ptr<int const> >::type, int const);
    STATIC_ASSERT_SAME(boost::pointee<std::unique_ptr<X const> >::type, X const);

@ -76,7 +76,7 @@ int main()

    STATIC_ASSERT_SAME(boost::pointee<std::list<int>::iterator >::type, int);
    STATIC_ASSERT_SAME(boost::pointee<std::list<X>::iterator >::type, X);
-    
+
    STATIC_ASSERT_SAME(boost::pointee<std::list<int>::const_iterator >::type, int const);
    STATIC_ASSERT_SAME(boost::pointee<std::list<X>::const_iterator >::type, X const);
    return 0;
--- a/test/range_distance_compat_test.cpp
+++ b/test/range_distance_compat_test.cpp
@ -0,0 +1,22 @@
+// Copyright (C) 2018 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/range/distance.hpp>
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/iterator/distance.hpp>
+
+int main()
+{
+    // Test that boost::distance from Boost.Range works with boost::distance from Boost.Iterator
+    // (https://github.com/boostorg/iterator/commit/b844c8df530c474ec1856870b9b0de5f487b84d4#commitcomment-30603668)
+
+    typedef boost::iterator_range<const char*> range_type;
+    range_type range;
+
+    (void)boost::distance(range);
+
+    return 0;
+}
--- a/test/reverse_iterator_test.cpp
+++ b/test/reverse_iterator_test.cpp
@ -20,7 +20,7 @@ using boost::dummyT;
 // Test reverse iterator
 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);

@ -104,29 +104,29 @@ int main()
    boost::function_requires< boost_concepts::BidirectionalTraversalConcept<Iter> >();
  }
 #endif
-  
+
  // Test reverse_iterator
  {
    dummyT reversed[N];
    std::copy(array, array + N, reversed);
    std::reverse(reversed, reversed + N);
-    
+
    typedef boost::reverse_iterator<dummyT*> reverse_iterator;
-    
+
    reverse_iterator i(reversed + N);
    boost::random_access_iterator_test(i, N, array);

    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);

    typedef boost::reverse_iterator<const dummyT*> const_reverse_iterator;
-    
+
    const_reverse_iterator j(reversed + N);
    boost::random_access_iterator_test(j, N, array);

    const dummyT* const_reversed = reversed;
-    
+
    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
-    
+
    boost::const_nonconst_iterator_test(i, ++j);
  }

@ -146,7 +146,7 @@ int main()
    // (e.g. "reversed + N") is used in the constructor below.
    const std::deque<dummyT>::iterator finish = reversed_container.end();
    reverse_iterator i(finish);
-    
+
    boost::random_access_iterator_test(i, N, array);
    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);

@ -155,18 +155,18 @@ int main()

    const std::deque<dummyT>::const_iterator const_reversed = reversed;
    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
-    
+
    // Many compilers' builtin deque iterators don't interoperate well, though
    // STLport fixes that problem.
 #if defined(__SGI_STL_PORT)                                                             \
    || !BOOST_WORKAROUND(__GNUC__, <= 2)                                                \
    && !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 1))    \
-    && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))                          \
+    && !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))                          \
    && !BOOST_WORKAROUND(__LIBCOMO_VERSION__, BOOST_TESTED_AT(29))                      \
    && !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 1)
-    
+
    boost::const_nonconst_iterator_test(i, ++j);
-    
+
 #endif
  }

--- a/test/shared_iterator_test.cpp
+++ b/test/shared_iterator_test.cpp
@ -1,13 +1,13 @@
 // Copyright 2003 The Trustees of Indiana University.

-// Use, modification and distribution is subject to the Boost Software 
+// Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-//  Shared container iterator adaptor 
+//  Shared container iterator adaptor
 //  Author: Ronald Garcia
-//  See http://boost.org/libs/utility/shared_container_iterator.html 
-//  for documentation. 
+//  See http://boost.org/libs/utility/shared_container_iterator.html
+//  for documentation.

 //
 // shared_iterator_test.cpp - Regression tests for shared_container_iterator.
@ -38,7 +38,7 @@ void set_range(iterator& i, iterator& end)  {

  for (int j = 0; j != 6; ++j)
    objs->push_back(resource());
-  
+
  i = iterator(objs->begin(),objs);
  end = iterator(objs->end(),objs);
  BOOST_TEST_EQ(resource::count, 6);
@ -48,7 +48,7 @@ void set_range(iterator& i, iterator& end)  {
 int main() {

  BOOST_TEST_EQ(resource::count, 0);
-  
+
  {
    iterator i;
    {
@ -59,6 +59,6 @@ int main() {
    BOOST_TEST_EQ(resource::count, 6);
  }
  BOOST_TEST_EQ(resource::count, 0);
-  
+
  return boost::report_errors();
 }
--- a/test/transform_iterator_test.cpp
+++ b/test/transform_iterator_test.cpp
@ -19,7 +19,6 @@
 #include <boost/iterator/iterator_concepts.hpp>
 #include <boost/iterator/new_iterator_tests.hpp>
 #include <boost/pending/iterator_tests.hpp>
-#include <boost/bind.hpp>
 #include <boost/concept_check.hpp>

 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@ -43,7 +42,7 @@ struct mult_functor {
  int a;
 };

-struct adaptable_mult_functor 
+struct adaptable_mult_functor
 : mult_functor
 {
  typedef int result_type;
@ -114,9 +113,9 @@ struct polymorphic_mult_functor
    template <class F, class T> struct result<F(T&      )> {typedef void type;};
    template <class F, class T> struct result<F(const T&)> {typedef void type;};

-    template <class T> 
+    template <class T>
    T operator()(const T& _arg) const {return _arg*2;}
-    template <class T> 
+    template <class T>
    void operator()(const T& _arg) { BOOST_ASSERT(0); }
 };

@ -139,15 +138,15 @@ main()
    for (int k = 0; k < N; ++k)
      x[k] = k;
    std::copy(x, x + N, y);
-    
+
    for (int k2 = 0; k2 < N; ++k2)
      x[k2] = x[k2] * 2;
-    
+
    typedef boost::transform_iterator<adaptable_mult_functor, int*> iter_t;
    iter_t i(y, adaptable_mult_functor(2));
    boost::input_iterator_test(i, x[0], x[1]);
    boost::input_iterator_test(iter_t(&y[0], adaptable_mult_functor(2)), x[0], x[1]);
-    
+
    boost::random_access_readable_iterator_test(i, N, x);
  }

@ -157,15 +156,15 @@ main()
    for (int k = 0; k < N; ++k)
      x[k] = k;
    std::copy(x, x + N, y);
-    
+
    for (int k2 = 0; k2 < N; ++k2)
      x[k2] = x[k2] * 2;
-    
+
    typedef boost::transform_iterator<mult_functor, int*, int> iter_t;
    iter_t i(y, mult_functor(2));
    boost::input_iterator_test(i, x[0], x[1]);
    boost::input_iterator_test(iter_t(&y[0], mult_functor(2)), x[0], x[1]);
-    
+
    boost::random_access_readable_iterator_test(i, N, x);
  }

@ -196,16 +195,16 @@ main()
    for (int k = 0; k < N; ++k)
      x[k] = k;
    std::copy(x, x + N, y);
-    
+
    for (int k2 = 0; k2 < N; ++k2)
      x[k2] = x[k2] * 2;
-    
+
    boost::input_iterator_test(
        boost::make_transform_iterator(y, mult_2), x[0], x[1]);

    boost::input_iterator_test(
        boost::make_transform_iterator(&y[0], mult_2), x[0], x[1]);
- 
+
    boost::random_access_readable_iterator_test(
        boost::make_transform_iterator(y, mult_2), N, x);

@ -250,7 +249,7 @@ main()
    );

    boost::constant_lvalue_iterator_test(
-        boost::make_transform_iterator((pair_t*)values, const_select_first()), x[0]); 
+        boost::make_transform_iterator((pair_t*)values, const_select_first()), x[0]);

    boost::non_const_lvalue_iterator_test(
        boost::make_transform_iterator((pair_t*)values, select_first()), x[0], 17);
@ -267,16 +266,16 @@ main()
    for (int k = 0; k < N; ++k)
      x[k] = k;
    std::copy(x, x + N, y);
-    
+
    for (int k2 = 0; k2 < N; ++k2)
      x[k2] = x[k2] * 2;
-    
+
    boost::input_iterator_test(
        boost::make_transform_iterator(y, polymorphic_mult_functor()), x[0], x[1]);

    boost::input_iterator_test(
        boost::make_transform_iterator(&y[0], polymorphic_mult_functor()), x[0], x[1]);
- 
+
    boost::random_access_readable_iterator_test(
        boost::make_transform_iterator(y, polymorphic_mult_functor()), N, x);
  }
Author	SHA1	Message	Date
Andrey Semashev	8e457e716b	Merge pull request #60 from CaseyCarter/patch-1 MSVC also has C++20 ostream_iterator	2020-10-14 12:15:55 +03:00
Casey Carter	32f4f4d086	MSVC also has C++20 output_iterator Tell iterator_traits_test not to fail on MSVC when `std::output_iterator` has `difference_type` of `std::ptrdiff_t`.	2020-10-13 19:23:49 -07:00
Andrey Semashev	72f0ebe8d0	Adjusted the check for C++20 on gcc 10. The compiler defines __cplusplus to a non-standard value less than 202002 in C++20 mode.	2020-05-24 00:29:51 +03:00
Andrey Semashev	d7ad43a925	Updated to support C++20 ostream_iterator::difference_type on gcc 10.	2020-05-23 19:57:54 +03:00
Andrey Semashev	733c0fb9cb	Added gcc 10 build jobs to Travis CI.	2020-05-22 18:41:15 +03:00
Andrey Semashev	5b18ae976e	Updated code to use distance and iterator_traits from std.	2020-05-10 23:08:14 +03:00
Andrey Semashev	da8604615e	Removed the use of deprecated header boost/detail/iterator.hpp	2020-05-10 23:02:42 +03:00
Andrey Semashev	8fc94469da	Added clang-10 jobs to Travis CI.	2020-05-05 23:20:14 +03:00
Andrey Semashev	b86c817481	Updated function_output_iterator example to use up-to-date header location.	2020-05-02 02:03:16 +03:00
Andrey Semashev	9649d42392	Merge pull request #51 from Kojoley/add-deprecation-warning-for-boost-function_output_iterator Add deprecation warning in `boost/function_output_iterator.hpp`	2020-05-02 02:01:07 +03:00
Andrey Semashev	0c5f0b822a	Merge pull request #55 from eldiener/develop Changes for Embarcadero C++ clang-based compilers, targeting Boost 1.74. Change __BORLANDC__ to BOOST_BORLANDC, which is defined in Boost conf…	2020-05-02 01:58:01 +03:00
Edward Diener	dc7bf5cc05	Change __BORLANDC__ to BOOST_BORLANDC, which is defined in Boost config for the Embarcadero non-clang-based compilers.	2020-03-31 11:21:59 -04:00
Andrey Semashev	80ec58bb3b	Trim trailing spaces.	2020-03-04 01:06:45 +03:00
Andrey Semashev	c2929ea6c6	Updated to use boost/bind/bind.hpp to avoid warnings and compliance with C++20. boost/bind.hpp emits warnings about deprecating global placeholder argument keywords. C++20 removes std::bind1st/bind2nd, so replaced their usage with boost::bind.	2020-03-04 01:02:52 +03:00
Andrey Semashev	4fe679bb0d	Updated lightweight_test.hpp includes to the new location.	2020-03-04 00:52:58 +03:00
Glen Fernandes	fdcd8439c0	BOOST_ prefix include guard macro	2019-12-18 08:40:35 -05:00
Andrey Semashev	3a8728a595	Whitespace cleanup and formatting fixes in docs.	2019-12-12 12:40:53 +03:00
Andrey Semashev	897ff65fdc	Fixed example links in docs. Fixes https://github.com/boostorg/iterator/issues/52.	2019-12-12 12:16:01 +03:00
Nikita Kniazev	bfe2a004d2	Add deprecation warning in `boost/function_output_iterator.hpp`	2019-11-23 16:47:06 +03:00
Andrey Semashev	d528fc0b11	Disabled C++0x mode for gcc-4.4 because it fails zip_iterator tests with std::tuple.	2019-10-23 12:09:29 +03:00
Andrey Semashev	540f999d0b	Disabled all but one OS X jobs because they are slow on Travis CI.	2019-10-22 15:07:04 +03:00
Andrey Semashev	54dee0db96	Updated CI configs, added compilers.	2019-10-22 01:00:51 +03:00
Glen Fernandes	814965402e	Merge pull request #49 from glenfe/develop Use use_default from Boost.Core	2019-02-22 20:44:56 -05:00
Glen Fernandes	2af5a16539	Use use_default from Boost.Core boost::use_default is now defined in Core for multiple Boost libraries.	2019-02-22 17:17:52 -05:00
Andrey Semashev	171c716d03	Enabled multiple git fetch jobs while executing depinst in CI. Increased the number of jobs to 8.	2019-01-15 13:54:52 +03:00
Andrey Semashev	398fe907d0	Use the actual number of logical CPUs for the number of CI build/test jobs.	2019-01-03 23:19:41 +03:00
Andrey Semashev	e31ae13df5	Re-added manual checkout of libs/config in CI as Boost.Build depends on it.	2018-12-20 20:46:10 +03:00
Andrey Semashev	02e74bf26a	Use multiple jobs to checkout submodules in parallel in CI.	2018-12-18 22:34:58 +03:00
Andrey Semashev	20b5a9c11a	Added tools/boost_install and libs/headers manual checkout to CI jobs.	2018-12-18 22:05:56 +03:00
Andrey Semashev	73918b8616	Added an experimental partial CMakeLists.txt for dependency tracking in CMake projects.	2018-12-18 19:49:23 +03:00
Andrey Semashev	bb1efd3370	Updated addressof.hpp include path.	2018-11-14 12:42:24 +03:00
Andrey Semashev	3cc4107d01	Added a test for compatibility of boost::distance between Range and Iterator. This functionality is used in core Boost components, so it is preferable to test it in Boost.Iterator, even if it's already tested in Boost.Range, to discover problems as early as possible. The test verifies that boost::distance implemented in Boost.Range can invoke boost::distance in Boost.Iterator (i.e. the function lookup succeeds).	2018-09-23 12:37:21 +03:00
Andrey Semashev	6ab148be01	Revert "Revert "Replace using-declarations with using-directives to avoid ADL issues."" This reverts commit `06875a754d`. The suggested fix for build failures need to be applied to Boost.Range: https://github.com/boostorg/range/pull/75	2018-09-23 12:28:03 +03:00
Andrey Semashev	06875a754d	Revert "Replace using-declarations with using-directives to avoid ADL issues." This reverts commit `44cee00831`. The commit reportedly broke building Boost and quickbook. `b844c8df53 (commitcomment-30603668)`	2018-09-22 18:46:36 +03:00
Andrey Semashev	b844c8df53	Merge pull request #44 from morinmorin/fix/unwanted_adl Fix #43 (unwanted ADL issues)	2018-09-22 16:05:22 +03:00
morinmorin	194087e8ca	Merge branch 'develop' into fix/unwanted_adl	2018-09-22 20:47:10 +09:00
morinmorin	b5edc8b64f	Add test for ADL issues.	2018-09-22 20:44:29 +09:00
morinmorin	44cee00831	Replace using-declarations with using-directives to avoid ADL issues.	2018-09-22 20:20:59 +09:00
Edward Diener	b2adecb951	Merge pull request #40 from DanielaE/fix/no-iterator-inheritance Inheriting std::iterator is deprecated in c++17.	2017-12-28 18:43:47 -05:00
Daniela Engert	e16f2de233	Inheriting std::iterator is deprecated in c++17. Boost's iterator.hpp is deprecated, too. Therefore get rid of all of that and replace inheritance by lifting std::iterator's members into the derived class. Signed-off-by: Daniela Engert <dani@ngrt.de>	2017-12-27 09:32:51 +01:00
Peter Dimov	218dc4baf1	Merge branch 'feature/move-shared-iterator' into develop	2017-12-24 14:23:54 +02:00