Merge branch 'feature/use_invoke_swap' of https://github.com/Lastique/tuple into feature/pr-25

boost::swap is deprecated and will be removed. Use boost::core::invoke_swap
as a replacement.

.github/workflows/ci.yml

@@ -0,0 +1,609 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+      - feature/**
+
+env:
+  UBSAN_OPTIONS: print_stacktrace=1
+
+jobs:
+  posix:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: gcc-4.8
+            cxxstd: "03,11"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: g++-4.8-multilib
+            address-model: 32,64
+          - toolset: gcc-5
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: g++-5-multilib
+            address-model: 32,64
+          - toolset: gcc-6
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: g++-6-multilib
+            address-model: 32,64
+          - toolset: gcc-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: g++-7-multilib
+            address-model: 32,64
+          - toolset: gcc-8
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-8-multilib
+            address-model: 32,64
+          - toolset: gcc-9
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-9-multilib
+            address-model: 32,64
+          - toolset: gcc-10
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-10-multilib
+            address-model: 32,64
+          - toolset: gcc-11
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: g++-11-multilib
+            address-model: 32,64
+          - toolset: gcc-12
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: g++-12-multilib
+            address-model: 32,64
+          - toolset: gcc-13
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-latest
+            container: ubuntu:23.04
+            install: g++-13-multilib
+            address-model: 32,64
+          - toolset: clang
+            compiler: clang++-3.9
+            cxxstd: "03,11,14"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: clang-3.9
+          - toolset: clang
+            compiler: clang++-4.0
+            cxxstd: "03,11,14"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: clang-4.0
+          - toolset: clang
+            compiler: clang++-5.0
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: clang-5.0
+          - toolset: clang
+            compiler: clang++-6.0
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-6.0
+          - toolset: clang
+            compiler: clang++-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-7
+          - toolset: clang
+            compiler: clang++-8
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-8
+          - toolset: clang
+            compiler: clang++-9
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-9
+          - toolset: clang
+            compiler: clang++-10
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-11
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-12
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-13
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-22.04
+            install: clang-13
+          - toolset: clang
+            compiler: clang++-14
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: clang-14
+          - toolset: clang
+            compiler: clang++-15
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: clang-15
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-latest
+            container: ubuntu:23.04
+            install: clang-16
+          - toolset: clang
+            cxxstd: "03,11,14,17,2a"
+            os: macos-11
+          - toolset: clang
+            cxxstd: "03,11,14,17,20,2b"
+            os: macos-12
+          - toolset: clang
+            cxxstd: "03,11,14,17,20,2b"
+            os: macos-13
+
+    runs-on: ${{matrix.os}}
+    container: ${{matrix.container}}
+
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup container environment
+        if: matrix.container
+        run: |
+          apt-get update
+          apt-get -y install sudo python3 git g++
+
+      - name: Install packages
+        if: matrix.install
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python3 tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+          ./bootstrap.sh
+          ./b2 -d0 headers
+
+      - name: Create user-config.jam
+        if: matrix.compiler
+        run: |
+          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
+
+      - name: Run tests
+        run: |
+          cd ../boost-root
+          export ADDRMD=${{matrix.address-model}}
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} variant=debug,release
+
+  windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: msvc-14.0
+            cxxstd: 14,latest
+            addrmd: 32,64
+            os: windows-2019
+          - toolset: msvc-14.2
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2019
+          - toolset: msvc-14.3
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: clang-win
+            cxxstd: "14,17,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: gcc
+            cxxstd: "03,11,14,17,2a"
+            addrmd: 64
+            os: windows-2019
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+          cmd /c bootstrap
+          b2 -d0 headers
+
+      - name: Run tests
+        shell: cmd
+        run: |
+          cd ../boost-root
+          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release embed-manifest-via=linker
+
+  posix-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-11
+          - os: macos-12
+          - os: macos-13
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Use library with add_subdirectory
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-11
+          - os: macos-12
+          - os: macos-13
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
+
+      - name: Install
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-11
+          - os: macos-12
+          - os: macos-13
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
+
+      - name: Build tests
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests
+
+      - name: Run tests
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error
+
+  windows-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Use library with add_subdirectory (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use library with add_subdirectory (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+
+      - name: Install (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Debug
+
+      - name: Install (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Release
+
+      - name: Use the installed library (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use the installed library (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DBUILD_TESTING=ON ..
+
+      - name: Build tests (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests --config Debug
+
+      - name: Run tests (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Build tests (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests --config Release
+
+      - name: Run tests (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Release

.travis.yml

@@ -0,0 +1,111 @@
+# Copyright 2016, 2017 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - cp -r $TRAVIS_BUILD_DIR/* libs/tuple
+  - python tools/boostdep/depinst/depinst.py tuple
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 -j 3 libs/tuple/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always

CMakeLists.txt

@@ -0,0 +1,27 @@
+# Generated by `boostdep --cmake tuple`
+# Copyright 2020, 2021 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.20)
+
+project(boost_tuple VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_tuple INTERFACE)
+add_library(Boost::tuple ALIAS boost_tuple)
+
+target_include_directories(boost_tuple INTERFACE include)
+
+target_link_libraries(boost_tuple
+  INTERFACE
+    Boost::config
+    Boost::core
+    Boost::static_assert
+    Boost::type_traits
+)
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()

doc/Jamfile.v2

@@ -0,0 +1,37 @@
+#   Copyright (c) 2001 Jaakko J<>rvi
+
+#   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)
+
+project doc/tuple ;
+
+import boostbook ;
+import quickbook ;
+
+xml tuple : tuple_users_guide.qbk ;
+
+boostbook standalone_tuple
+    :
+        tuple
+    :
+        <xsl:param>boost.root=../../../..
+        # File name of HTML output:
+        <xsl:param>root.filename=tuple_users_guide
+        # How far down we chunk nested sections, basically all of them:
+        <xsl:param>chunk.section.depth=0
+        # Don't put the first section on the same page as the TOC:
+        <xsl:param>chunk.first.sections=0
+        # How far down sections get TOC's
+        <xsl:param>toc.section.depth=1
+        # Max depth in each TOC:
+        <xsl:param>toc.max.depth=1
+        # How far down we go with TOC's
+        <xsl:param>generate.section.toc.level=0
+     ;
+
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : standalone_tuple ;
+explicit boostrelease ;

doc/design_decisions_rationale.html

@@ -1,153 +0,0 @@
-<html>
-
-<title>Design decisions rationale for Boost Tuple Library</title>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86">
-
-<h1>Tuple Library : design decisions rationale</h1>
-
-<h2>About namespaces</h2>
-
-<p>
-There was a discussion about whether tuples should be in a separate namespace or directly in the <code>boost</code> namespace.
-The common principle is that domain libraries (like <i>graph</i>, <i>python</i>) should be on a separate
-subnamespace, while utility like libraries directly in the <code>boost</code> namespace.
-Tuples are somewhere in between, as the tuple template is clearly a general utility, but the library introduces quite a lot of names in addition to just the tuple template. 
-Tuples were originally under a subnamespace.
-As a result of the discussion, tuple definitions were moved directly under the <code>boost</code> namespace.
-As a result of a continued discussion, the subnamespace was reintroduced.
-The final (I truly hope so) solution is now to have all definitions in namespace <code>::boost::tuples</code>, and the most common names in the <code>::boost</code> namespace as well. 
-This is accomplished with using declarations (suggested by Dave Abrahams):
-<code><pre>namespace boost {
-  namespace tuples {
-      ...      
-    // All library code
-      ...
-  }
-  using tuples::tuple; 
-  using tuples::make_tuple;
-  using tuples::tie;
-  using tuples::get;
-}
-</pre></code>
-With this arrangement, tuple creation with direct constructor calls, <code>make_tuple</code> or <code>tie</code> functions do not need the namespace qualifier.
-Further, all functions that manipulate tuples are found with Koenig-lookup.
-The only exceptions are the <code>get&lt;N&gt;</code> functions, which are always called with an explicitly qualified template argument, and thus Koenig-lookup does not apply.
-Therefore, get is lifted to <code>::boost</code> namespace with a using declaration.
-Hence, the interface for an application programmer is in practice under the namespace <code>::boost</code>.
-</p>
-<p>
-The other names, forming an interface for library writers (cons lists, metafunctions manipulating cons lists, ...) remain in the subnamespace <code>::boost::tuples</code>.
-Note, that the names <code>ignore</code>, <code>set_open</code>, <code>set_close</code> and <code>set_delimiter</code> are considered to be part of the application programmer's interface, but are still not under <code>boost</code> namespace. 
-The reason being the danger for name clashes for these common names.
-Further, the usage of these features is probably not very frequent.
-</p>
-
-<h4>For those who are really interested in namespaces</h4>
-
-<p>
-The subnamespace name <i>tuples</i> raised some discussion.
-The rationale for not using the most natural name 'tuple' is to avoid having an identical name with the tuple template. 
-Namespace names are, however, not generally in plural form in boost libraries. 
-First, no real trouble was reported for using the same name for a namespace and a class and we considered changing the name 'tuples' to 'tuple'.
-But we found some trouble after all.
-Both gcc and edg compilers reject using declarations where the namespace and class names are identical:
-
-<code><pre>namespace boost {
-  namespace tuple {
-    ... tie(...);
-    class tuple; 
-&nbsp;     ...
-  }
-  using tuple::tie; // ok
-  using tuple::tuple; // error
-    ...
-}
-</pre></code>
-
-Note, however, that a corresponding using declaration in the global namespace seems to be ok: 
-
-<code><pre>
-using boost::tuple::tuple; // ok;
-</pre></code>
-
-
-<h2>The end mark of the cons list (nil, null_type, ...)</h2>
-
-<p>
-Tuples are internally represented as <code>cons</code> lists:
-
-<code><pre>tuple&lt;int, int&gt;
-</pre></code> 
-inherits from 
-<code><pre>cons&lt;int, cons&lt;int, null_type&gt; &gt;
-</code></pre>
-
-<code>null_type</code> is the end mark of the list. Original proposition was <code>nil</code>, but the name is used in MacOS, and might have caused problems, so <code>null_type</code> was chosen instead.
-Other names considered were <i>null_t</i> and <i>unit</i> (the empty tuple type in SML).
-<p>
-Note that <code>null_type</code> is the internal representation of an empty tuple: <code>tuple&lt;&gt;</code> inherits from <code>null_type</code>.
-</p>
-
-<h2>Element indexing</h2>
-
-<p>
-Whether to use 0- or 1-based indexing was discussed more than thoroughly, and the following observations were made:
-
-<ul>
-<li> 0-based indexing is 'the C++ way' and used with arrays etc.</li>
-<li> 1-based 'name like' indexing exists as well, eg. <code>bind1st</code>, <code>bind2nd</code>, <code>pair::first</code>, etc.</li>
-</ul>
-Tuple access with the syntax <code>get&lt;N&gt;(a)</code>, or <code>a.get&lt;N&gt;()</code> (where <code>a</code> is a tuple and <code>N</code> an index), was considered to be of the first category, hence, the index of the first element in a tuple is 0.
-
-<p>
-A suggestion to provide 1-based 'name like' indexing with constants like <code>_1st</code>, <code>_2nd</code>, <code>_3rd</code>, ... was made.
-By suitably chosen constant types, this would allow alternative syntaxes:
-
-<code><pre>a.get&lt;0&gt;() == a.get(_1st) == a[_1st] == a(_1st);
-</pre></code>
-
-We chose not to provide more than one indexing method for the following reasons:
-<ul>
-<li>0-based indexing might not please everyone, but once its fixed, it is less confusing than having two different methods (would anyone want such constants for arrays?).</li>
-<li>Adding the other indexing scheme doesn't really provide anything new (like a new feature) to the user of the library.</li>
-<li>C++ variable and constant naming rules don't give many possibilities for defining short and nice index constants (like <code>_1st</code>, ...). 
-Let the binding and lambda libraries use these for a better purpose.</li>
-<li>The access syntax <code>a[_1st]</code> (or <code>a(_1st)</code>) is appealing, and almost made us add the index constants after all. However, 0-based subscripting is so deep in C++, that we had a fear for confusion.</li>
-<li>
-Such constants are easy to add.
-</li>
-</ul>
-
-
-<h2>Tuple comparison</h2>
-
-The comparison operator implements lexicographical order. 
-Other orderings were considered, mainly dominance (<i>a &lt; b iff for each i a(i) < b(i)</i>). 
-Our belief is, that lexicographical ordering, though not mathematically the most natural one, is the most frequently needed ordering in everyday programming.
-
-<h2>Streaming</h2>
-
-<p>
-The characters specified with tuple stream manipulators are stored within the space allocated by <code>ios_base::xalloc</code>, which allocates storage for <code>long</code> type objects.
-<code>static_cast</code> is used in casting between <code>long</code> and the stream's character type. 
-Streams that have character types not convertible back and forth to long thus fail to compile.
-
-This may be revisited at some point. The two possible solutions are:
-<ul>
-<li>Allow only plain <code>char</code> types as the tuple delimiters and use <code>widen</code> and <code>narrow</code> to convert between the real character type of the stream. 
-This would always compile, but some calls to set manipulators might result in a different
-  character than expected (some default character).</li>
-<li>Allocate enough space to hold the real character type of the stream. 
-This means memory for holding the delimiter characters must be allocated separately, and that pointers to this memory are stored in the space allocated with <code>ios_base::xalloc</code>.
-Any volunteers?</li>
-</ul>
-
-<A href="tuple_users_guide.html">Back to the user's guide</A>
-<hr><p>&copy; Copyright Jaakko J&auml;rvi 2001. 
-</body>
-</html>
-

doc/design_decisions_rationale.qbk

@@ -0,0 +1,190 @@
+[/
+ /  Copyright (c) 2001 Jaakko J<>rvi
+ /
+ / 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)
+ /]
+
+[article Design decisions rationale
+  [quickbook 1.6]
+  [id design_decisions_rationale]
+  [copyright 2001 Jaakko J\u00E4rvi]
+  [license Distributed under the
+    [@http://boost.org/LICENSE_1_0.txt Boost Software License,
+      Version 1.0].
+  ]
+]
+
+[template simplesect[title]
+[block '''<simplesect><title>'''[title]'''</title>''']]
+
+[template endsimplesect[]
+[block '''</simplesect>''']]
+
+[section About namespaces]
+
+There was a discussion about whether tuples should be in a separate namespace
+or directly in the `boost` namespace. The common principle is that domain
+libraries (like /graph/, /python/) should be on a separate subnamespace, while
+utility like libraries directly in the boost namespace. Tuples are somewhere
+in between, as the tuple template is clearly a general utility, but the
+library introduces quite a lot of names in addition to just the tuple template.
+Tuples were originally under a subnamespace. As a result of the discussion,
+tuple definitions were moved directly under the `boost` namespace. As a result
+of a continued discussion, the subnamespace was reintroduced. The final (I
+truly hope so) solution is now to have all definitions in namespace
+`::boost::tuples`, and the most common names in the `::boost` namespace as well.
+This is accomplished with using declarations (suggested by Dave Abrahams):
+
+    namespace boost {
+      namespace tuples {
+          ...
+        // All library code
+          ...
+      }
+      using tuples::tuple;
+      using tuples::make_tuple;
+      using tuples::tie;
+      using tuples::get;
+    }
+
+With this arrangement, tuple creation with direct constructor calls,
+`make_tuple` or `tie` functions do not need the namespace qualifier. Further,
+all functions that manipulate tuples are found with Koenig-lookup. The only
+exceptions are the `get<N>` functions, which are always called with an
+explicitly qualified template argument, and thus Koenig-lookup does not apply.
+Therefore, `get` is lifted to `::boost` namespace with a using declaration.
+Hence, the interface for an application programmer is in practice under the
+namespace `::boost`.
+
+The other names, forming an interface for library writers (cons lists,
+metafunctions manipulating cons lists, ...) remain in the subnamespace
+`::boost::tuples`. Note, that the names `ignore`, `set_open`, `set_close` and
+`set_delimiter` are considered to be part of the application programmer's
+interface, but are still not under `boost` namespace. The reason being the
+danger for name clashes for these common names. Further, the usage of these
+features is probably not very frequent.
+
+[section For those who are really interested in namespaces]
+
+The subnamespace name /tuples/ raised some discussion. The rationale for not
+using the most natural name 'tuple' is to avoid having an identical name with
+the tuple template. Namespace names are, however, not generally in plural form
+in Boost libraries. First, no real trouble was reported for using the same
+name for a namespace and a class and we considered changing the name 'tuples'
+to 'tuple'. But we found some trouble after all. Both gcc and edg compilers
+reject using declarations where the namespace and class names are identical:
+
+    namespace boost {
+      namespace tuple {
+        ... tie(...);
+        class tuple;
+          ...
+      }
+      using tuple::tie; // ok
+      using tuple::tuple; // error
+        ...
+    }
+
+Note, however, that a corresponding using declaration in the global namespace
+seems to be ok:
+
+    using boost::tuple::tuple; // ok;
+
+[endsect]
+
+[endsect]
+
+[section The end mark of the cons list (`nil`, `null_type`, ...)]
+
+Tuples are internally represented as cons lists:
+
+    tuple<int, int>
+
+inherits from
+
+    cons<int, cons<int, null_type> >
+
+`null_type` is the end mark of the list. Original proposition was `nil`, but
+the name is used in MacOS, and might have caused problems, so `null_type` was
+chosen instead. Other names considered were /null_t/ and /unit/ (the empty
+tuple type in SML).
+
+Note that `null_type` is the internal representation of an empty tuple:
+`tuple<>` inherits from `null_type`.
+
+[endsect]
+
+[section Element indexing]
+
+Whether to use `0`- or `1`-based indexing was discussed more than thoroughly,
+and the following observations were made:
+
+* `0`-based indexing is 'the C++ way' and used with arrays etc.
+
+* `1`-based 'name like' indexing exists as well, eg. `bind1st`, `bind2nd`,
+  `pair::first`, etc.
+
+Tuple access with the syntax `get<N>(a)`, or `a.get<N>()` (where `a` is a
+tuple and `N` an index), was considered to be of the first category, hence,
+the index of the first element in a tuple is `0`.
+
+A suggestion to provide `1`-based 'name like' indexing with constants like
+`_1st`, `_2nd`, `_3rd`, ... was made. By suitably chosen constant types, this
+would allow alternative syntaxes:
+
+    a.get<0>() == a.get(_1st) == a[_1st] == a(_1st);
+
+We chose not to provide more than one indexing method for the following
+reasons:
+
+* `0`-based indexing might not please everyone, but once its fixed, it is less
+  confusing than having two different methods (would anyone want such
+  constants for arrays?).
+
+* Adding the other indexing scheme doesn't really provide anything new (like a
+  new feature) to the user of the library.
+
+* C++ variable and constant naming rules don't give many possibilities for
+  defining short and nice index constants (like `_1st`, ...). Let the binding
+  and lambda libraries use these for a better purpose.
+
+* The access syntax a[_1st] (or a(_1st)) is appealing, and almost made us add
+  the index constants after all. However, `0`-based subscripting is so deep in
+  C++, that we had a fear for confusion.
+
+* Such constants are easy to add.
+
+[endsect]
+
+[section Tuple comparison]
+
+The comparison operator implements lexicographical order. Other orderings were
+considered, mainly dominance /(a < b iff for each i a(i) < b(i))/. Our belief
+is, that lexicographical ordering, though not mathematically the most natural
+one, is the most frequently needed ordering in everyday programming.
+
+[endsect]
+
+[section Streaming]
+
+The characters specified with tuple stream manipulators are stored within the
+space allocated by `ios_base::xalloc`, which allocates storage for `long` type
+objects. `static_cast` is used in casting between `long` and the stream's
+character type. Streams that have character types not convertible back and
+forth to long thus fail to compile.
+
+This may be revisited at some point. The two possible solutions are:
+
+* Allow only plain `char` types as the tuple delimiters and use `widen` and
+  `narrow` to convert between the real character type of the stream. This
+  would always compile, but some calls to set manipulators might result in a
+  different character than expected (some default character).
+
+* Allocate enough space to hold the real character type of the stream. This
+  means memory for holding the delimiter characters must be allocated
+  separately, and that pointers to this memory are stored in the space
+  allocated with `ios_base::xalloc`. Any volunteers?
+
+[endsect]

doc/tuple_advanced_interface.html

@@ -1,133 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>Tuple library advanced features</title>
-<body bgcolor="#FFFFFF" text="#000000">
-
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86">
-
-  </head>
-
-  <body>
-    <h1>Tuple library advanced features</h1>
-
-The advanced features described in this document are all under namespace <code>::boost::tuples</code>
-
-<h2>Metafunctions for tuple types</h2>
-<p>
-Suppose <code>T</code> is a tuple type, and <code>N</code> is a constant integral expression. 
-
-<code><pre>element&lt;N, T&gt;::type</pre></code>
-
-gives the type of the <code>N</code>th element in the tuple type <code>T</code>.
-</p>
-
-<code><pre>length&lt;T&gt;::value</pre></code>
-
-gives the length of the tuple type <code>T</code>.
-</p>
-
-<h2>Cons lists</h2>
-
-<p>
-Tuples are internally represented as <i>cons lists</i>.
-For example, the tuple 
-
-<code><pre>tuple&lt;A, B, C, D&gt;</pre></code>
-
- inherits from the type
-<code><pre>cons&lt;A, cons&lt;B, cons&lt;C, cons&lt;D, null_type&gt; &gt; &gt; &gt;
-</pre></code>
-
-The tuple template provides the typedef <code>inherited</code> to access the cons list representation. E.g.:
-<code>tuple&lt;A&gt;::inherited</code> is the type <code>cons&lt;A, null_type&gt;</code>.
-</p>
-
-<h4>Empty tuple</h4>
-<p>
-The internal representation of the empty tuple <code>tuple&lt;&gt</code> is <code>null_type</code>.
-</p>
-
-<h4>Head and tail</h4>
-<p>
-Both tuple template and the cons templates provide the typedefs <code>head_type</code> and <code>tail_type</code>.
-The <code>head_type</code> typedef gives the type of the first element of the tuple (or the cons list).
-The 
-<code>tail_type</code> typedef gives the remaining cons list after removing the first element.
-The head element is stored in the member variable <code>head</code> and the tail list in the member variable <code>tail</code>.
-Cons lists provide the member function <code>get_head()</code> for getting a reference to the head of a cons list, and <code>get_tail()</code> for getting a reference to the tail.
-There are const and non-const versions of both functions.
-</p>
-<p>
-Note that in a one element tuple, <code>tail_type</code> equals <code>null_type</code> and the <code>get_tail()</code> function returns an object of type <code>null_type</code>.
-</p>
-<p>
-The empty tuple (<code>null_type</code>) has no head or tail, hence the <code>get_head</code> and <code>get_tail</code> functions are not provided.
-</p>
-
-<p>
-Treating tuples as cons lists gives a convenient means to define generic functions to manipulate tuples. For example, the following pair of function templates assign 0 to each element of a tuple (obviously, the assignments must be valid operations for the element types):
-
-<pre><code>inline void set_to_zero(const null_type&amp;) {};
-
-template &lt;class H, class T&gt;
-inline void set_to_zero(cons&lt;H, T&gt;&amp; x) { x.get_head() = 0; set_to_zero(x.get_tail()); }
-</code></pre>
-<p>
-
-<h4>Constructing cons lists</h4>
-
-<p>
-A cons list can be default constructed provided that all its elements can be default constructed.
-</p>
-<p>
-A cons list can be constructed from its head and tail. The prototype of the constructor is:
-<pre><code>cons(typename access_traits&lt;head_type&gt;::parameter_type h,
-     const tail_type&amp; t)
-</code></pre>
-The traits template for the head parameter selects correct parameter types for different kinds of element types (for reference elements the parameter type equals the element type, for non-reference types the parameter type is a reference to const non-volatile element type).
-</p>
-<p>
-For a one-element cons list the tail argument (<code>null_type</code>) can be omitted.
-</p>
-
-
-<h2>Traits classes for tuple element types</h2>
-
-<h4><code>access_traits</code></h4>
-<p>
-The template <code>access_traits</code> defines three type functions. Let <code>T</code> be a type of an element in a tuple:
-<ol>
-<li><code>access_traits&lt;T&gt;::type</code> maps <code>T</code> to the return type of the non-const access functions (nonmeber and member <code>get</code> functions, and the <code>get_head</code> function).</li>
-<li><code>access_traits&lt;T&gt;::const_type</code> maps <code>T</code> to the return type of the const access functions.</li>
-<li><code>access_traits&lt;T&gt;::parameter_type</code> maps <code>T</code> to the parameter type of the tuple constructor.</li>
-</ol>
-<h4><code>make_tuple_traits</code></h4>
-
-The element types of the tuples that are created with the <code>make_tuple</code> functions are computed with the type function <code>make_tuple_traits</code>. 
-The type function call <code>make_tuple_traits&lt;T&gt;::type</code> implements the following type mapping:
-<ul>
-<li><i>any reference type</i> -&gt; <i>compile time error</i>
-</li>
-<li><i>any array type</i> -&gt; <i>constant reference to the array type</i>
-</li>
-<li><code>reference_wrapper&lt;T&gt;</code> -&gt; <code>T&amp;</code>
-</li>
-<li><code>T</code> -&gt; <code>T</code>
-</li>
-</ul>
-
-Objects of type <code>reference_wrapper</code> are created with the <code>ref</code> and <code>cref</code> functions (see <A href="tuple_users_guide.html#make_tuple">The <code>make_tuple</code> function</A>.)
-</p>
-
-<p>Reference wrappers were originally part of the tuple library, but they are now a general utility of boost. 
-The <code>reference_wrapper</code> template and the <code>ref</code> and <code>cref</code> functions are defined in a separate file <code>ref.hpp</code> in the main boost include directory; and directly in the <code>boost</code> namespace.
-</p>
-
-<A href="tuple_users_guide.html">Back to the user's guide</A>
-<hr>
-
-<p>&copy; Copyright Jaakko J&auml;rvi 2001.</p>
-  </body>
-</html>

doc/tuple_advanced_interface.qbk

@@ -0,0 +1,159 @@
+[/
+ /  Copyright (c) 2001 Jaakko J<>rvi
+ /
+ / 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)
+ /]
+
+[article Tuple library advanced features
+  [quickbook 1.6]
+  [id tuple_advanced_interface]
+  [copyright 2001 Jaakko J\u00E4rvi]
+  [license Distributed under the
+    [@http://boost.org/LICENSE_1_0.txt Boost Software License,
+      Version 1.0].
+  ]
+]
+
+[template simplesect[title]
+[block '''<simplesect><title>'''[title]'''</title>''']]
+
+[template endsimplesect[]
+[block '''</simplesect>''']]
+
+The advanced features described in this document are all under namespace
+`::boost::tuples`
+
+[section Metafunctions for tuple types]
+
+Suppose `T` is a tuple type, and `N` is a constant integral expression.
+
+    element<N, T>::type
+
+gives the type of the `N`-th element in the tuple type `T`. If `T` is `const`,
+the resulting type is `const` qualified as well. Note that the constness of `T`
+does not affect reference type elements.
+
+    length<T>::value
+
+gives the length of the tuple type `T`.
+
+[endsect]
+
+[section Cons lists]
+
+Tuples are internally represented as /cons lists/. For example, the tuple
+
+    tuple<A, B, C, D>
+
+inherits from the type
+
+    cons<A, cons<B, cons<C, cons<D, null_type> > > >
+
+The tuple template provides the typedef inherited to access the cons list
+representation. E.g.: `tuple<A>::inherited` is the type `cons<A, null_type>`.
+
+[section Empty tuple]
+
+The internal representation of the empty tuple `tuple<>` is `null_type`.
+
+[endsect]
+
+[section Head and tail]
+
+Both tuple template and the cons templates provide the typedefs `head_type`
+and `tail_type`. The `head_type` typedef gives the type of the first element
+of the tuple (or the cons list). The `tail_type` typedef gives the remaining
+cons list after removing the first element. The head element is stored in the
+member variable `head` and the tail list in the member variable `tail`. Cons
+lists provide the member function `get_head()` for getting a reference to the
+head of a cons list, and `get_tail()` for getting a reference to the tail.
+There are const and non-const versions of both functions.
+
+Note that in a one element tuple, `tail_type` equals `null_type` and the
+`get_tail()` function returns an object of type `null_type`.
+
+The empty tuple (`null_type`) has no head or tail, hence the `get_head` and
+`get_tail` functions are not provided.
+
+Treating tuples as cons lists gives a convenient means to define generic
+functions to manipulate tuples. For example, the following pair of function
+templates assign `0` to each element of a tuple (obviously, the assignments
+must be valid operations for the element types):
+
+    inline void set_to_zero(const null_type&) {};
+
+    template <class H, class T>
+    inline void set_to_zero(cons<H, T>& x) { x.get_head() = 0; set_to_zero(x.get_tail()); }
+
+[endsect]
+
+[section Constructing cons lists]
+
+A cons list can be default constructed provided that all its elements can be
+default constructed.
+
+A cons list can be constructed from its head and tail. The prototype of the
+constructor is:
+
+    cons(typename access_traits<head_type>::parameter_type h, const tail_type& t)
+
+The traits template for the head parameter selects correct parameter types for
+different kinds of element types (for reference elements the parameter type
+equals the element type, for non-reference types the parameter type is a
+reference to const non-volatile element type).
+
+For a one-element cons list the tail argument (`null_type`) can be omitted.
+
+[endsect]
+
+[endsect]
+
+[section Traits classes for tuple element types]
+
+[section access_traits]
+
+The template `access_traits` defines three type functions. Let `T` be a type
+of an element in a tuple:
+
+* `access_traits<T>::non_const_type` maps `T` to the return type of the no
+  n-const access functions (nonmember and member `get` functions, and the
+  `get_head` function).
+
+* `access_traits<T>::const_type` maps `T` to the return type of the const
+  access functions.
+
+* `access_traits<T>::parameter_type` maps `T` to the parameter type of the
+  tuple constructor.
+
+[endsect]
+
+[section make_tuple_traits]
+
+The element types of the tuples that are created with the `make_tuple`
+functions are computed with the type function `make_tuple_traits`. The type
+function call `make_tuple_traits<T>::type` implements the following type
+mapping:
+
+* /any reference type/ -> /compile time error/
+
+* /any array type/ -> /constant reference to the array type/
+
+* `reference_wrapper<T>` -> `T&`
+
+* `T` -> `T`
+
+Objects of type `reference_wrapper` are created with the `ref` and `cref`
+functions (see [link tuple.constructing_tuples.make_tuple The `make_tuple`
+function]).
+
+Reference wrappers were originally part of the tuple library, but they are now
+a general utility of boost. The `reference_wrapper` template and the `ref` and
+`cref` functions are defined in a separate file
+[@boost:/libs/core/doc/html/core/ref.html `ref.hpp`] in the main boost include
+directory; and directly in the `boost` namespace.
+
+[endsect]
+
+[endsect]

doc/tuple_users_guide.html

@@ -1,529 +0,0 @@
-<html>
-<head>
-<title>The Boost Tuple Library</title>
-</head>
-<body bgcolor="#FFFFFF" text="#000000">
-
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86">
-
-<h1>The Boost Tuple Library</h1>
-
-<p>
-A tuple (or <i>n</i>-tuple) is a fixed size collection of elements. 
-Pairs, triples, quadruples etc. are tuples. 
-In a programming language, a tuple is a data object containing other objects as elements. 
-These element objects may be of different types.
-</p>
-
-<p>Tuples are convenient in many circumstances. 
-For instance, tuples make it easy to define functions that return more than one value.
-</p>
-
-<p>
-Some programming languages, such as ML, Python and Haskell, have built-in tuple constructs. 
-Unfortunately C++ does not.
-To compensate for this &quot;deficiency&quot;, the Boost Tuple Library implements a tuple construct using templates.
-</p>
-
-<h2>Table of Contents</h2>
-
-<ol>
-<li><a href = "#using_library">Using the library</a></li>
-<li><a href = "#tuple_types">Tuple types</a></li>
-<li><a href = "#constructing_tuples">Constructing tuples</a></li>
-<li><a href = "#accessing_elements">Accessing tuple elements</a></li>
-<li><a href = "#construction_and_assignment">Copy construction and tuple assignment</a></li>
-<li><a href = "#relational_operators">Relational operators</a></li>
-<li><a href = "#tiers">Tiers</a></li>
-<li><a href = "#streaming">Streaming</a></li>
-<li><a href = "#performance">Performance</a></li>
-<li><a href = "#portability">Portability</a></li>
-<li><a href = "#thanks">Acknowledgements</a></li>
-<li><a href = "#references">References</a></li>
-</ol>
-
-<h4>More details</h4>
-
-<p>
-<a href = "tuple_advanced_interface.html">Advanced features</a> (describes some metafunctions etc.).</p>
-<p>
-<a href = "design_decisions_rationale.html">Rationale behind some design/implementation decisions.</a></p>
-
-
-<h2><a name="using_library">Using the library</a></h2>
-
-<p>To use the library, just include:
-
-<pre><code>#include &quot;boost/tuple/tuple.hpp&quot;</code></pre>
-
-<p>Comparison operators can be included with:
-<pre><code>#include &quot;boost/tuple/tuple_comparison.hpp&quot;</code></pre>
-
-<p>To use tuple input and output operators,
-
-<pre><code>#include &quot;boost/tuple/tuple_io.hpp&quot;</code></pre>
-
-Both <code>tuple_io.hpp</code> and <code>tuple_comparison.hpp</code> include <code>tuple.hpp</code>.
-
-<p>All definitions are in namespace <code>::boost::tuples</code>, but the most common names are lifted to namespace <code>::boost</code> with using declarations. These names are: <code>tuple</code>, <code>make_tuple</code>, <code>tie</code> and <code>get</code>. Further, <code>ref</code> and <code>cref</code> are defined directly under the <code>::boost</code> namespace.
-
-<h2><a name = "tuple_types">Tuple types</a></h2>
-
-<p>A tuple type is an instantiation of the <code>tuple</code> template. 
-The template parameters specify the types of the tuple elements.
-The current version supports tuples with 0-10 elements. 
-If necessary, the upper limit can be increased up to, say, a few dozen elements.
-The data element can be any C++ type.
-Note that <code>void</code> and plain function types are valid 
-C++ types, but objects of such types cannot exist. 
-Hence, if a tuple type contains such types as elements, the tuple type
-can exist, but not an object of that type.
-There are natural limitations for element types that cannot
-be be copied, or that are not default constructible (see 'Constructing tuples'
- below). 
-
-<p>
-For example, the following definitions are valid tuple instantiations (<code>A</code>, <code>B</code> and <code>C</code> are some user defined classes):
-
-<pre><code>tuple&lt;int&gt;
-tuple&lt;double&amp;, const double&amp;, const double, double*, const double*&gt;
-tuple&lt;A, int(*)(char, int), B(A::*)(C&amp;), C&gt;
-tuple&lt;std::string, std::pair&lt;A, B&gt; &gt;
-tuple&lt;A*, tuple&lt;const A*, const B&amp;, C&gt;, bool, void*&gt;
-</code></pre>
-
-<h2><a name = "constructing_tuples">Constructing tuples</a></h2>
-
-<p>
-The tuple constructor takes the tuple elements as arguments. 
-For an <i>n</i>-element tuple, the constructor can be invoked with <i>k</i> arguments, where 0 &lt; <i>k</i> &lt;= <i>n</i>.
-For example:
-<pre><code>tuple&lt;int, double&gt;() 
-tuple&lt;int, double&gt;(1) 
-tuple&lt;int, double&gt;(1, 3.14)
-</code></pre>
-
-<p>
-If no initial value for an element is provided, it is default initialized (and hence must be default initializable).
-For example.
-
-<pre><code>class X {
-  X(); 
-public:
-  X(std::string);
-};
-
-tuple&lt;X,X,X&gt;()                                              // error: no default constructor for X
-tuple&lt;X,X,X&gt;(string(&quot;Jaba&quot;), string(&quot;Daba&quot;), string(&quot;Duu&quot;)) // ok
-</code></pre>
-
-In particular, reference types do not have a default initialization: 
-
-<pre><code>tuple&lt;double&amp;&gt;()                // error: reference must be 
-                                // initialized explicitly
-
-double d = 5; 
-tuple&lt;double&amp;&gt;(d)               // ok
-
-tuple&lt;double&amp;&gt;(d+3.14)          // error: cannot initialize 
-                                // non-const reference with a temporary
-
-tuple&lt;const double&amp;&gt;(d+3.14)    // ok, but dangerous: 
-                                // the element becomes a dangling reference 
-</code></pre>
-
-<p>Using an initial value for an element that cannot be copied, is a compile
-time error:
-
-<pre><code>class Y { 
-  Y(const Y&amp;); 
-public:
-  Y();
-};
-
-char a[10];
-
-tuple&lt;char[10], Y&gt;(a, Y()); // error, neither arrays nor Y can be copied
-tuple&lt;char[10], Y&gt;();       // ok
-</code></pre>
-
-Note particularly that the following is perfectly ok:
-<code><pre>Y y;
-tuple&lt;char(&amp;)[10], Y&amp;&gt;(a, y); 
-</code></pre>
-
-It is possible to come up with a tuple type that cannot be constructed.
-This occurs if an element that cannot be initialized has a lower
-index than an element that requires initialization. 
-For example: <code>tuple&lt;char[10], int&amp;&gt;</code>.
-
-<p>In sum, the tuple construction is semantically just a group of individual elementary constructions.
-</p>
-
-<h4><a name="make_tuple">The <code>make_tuple</code> function</a></h4>
-
-<p>
-Tuples can also be constructed using the <code>make_tuple</code> (cf. <code>std::make_pair</code>) helper functions.
-This makes the construction more convenient, saving the programmer from explicitly specifying the element types: 
-<pre><code>tuple&lt;int, int, double&gt; add_multiply_divide(int a, int b) {
-  return make_tuple(a+b, a*b, double(a)/double(b));
-}
-</code></pre>
-
-<p>
-By default, the element types are deduced to the plain non-reference types. E.g: 
-<pre><code>void foo(const A&amp; a, B&amp; b) { 
-  ...
-  make_tuple(a, b);
-</code></pre>
-The <code>make_tuple</code> invocation results in a tuple of type <code>tuple&lt;A, B&gt;</code>.
-
-<p>
-Sometimes the plain non-reference type is not desired, e.g. if the element type cannot be copied. 
-Therefore, the programmer can control the type deduction and state that a reference to const or reference to
-non-const type should be used as the element type instead.
-This is accomplished with two helper template functions: <code>ref</code> and <code>cref</code>. 
-Any argument can be wrapped with these functions to get the desired type. 
-The mechanism does not compromise const correctness since a const object wrapped with <code>ref</code> results in a tuple element with const reference type (see the fifth code line below).
-For example:
-
-<pre><code>A a; B b; const A ca = a;
-make_tuple(cref(a), b);      // creates tuple&lt;const A&amp;, B&gt;
-make_tuple(ref(a), b);       // creates tuple&lt;A&amp;, B&gt;
-make_tuple(ref(a), cref(b)); // creates tuple&lt;A&amp;, const B&amp;&gt;
-make_tuple(cref(ca));        // creates tuple&lt;const A&amp;&gt;
-make_tuple(ref(ca));         // creates tuple&lt;const A&amp;&gt;
-</code></pre>
-
-
-<p>
-Array arguments to <code>make_tuple</code> functions are deduced to reference to const types by default; there is no need to wrap them with <code>cref</code>. For example:
-<pre><code>make_tuple(&quot;Donald&quot;, &quot;Daisy&quot;);
-</code></pre>
-
-This creates an object of type <code>tuple&lt;const char (&amp;)[5], const char (&amp;)[6]&gt;</code> 
-(note that the type of a string literal is an array of const characters, not <code>const char*</code>). 
-However, to get <code>make_tuple</code> to create a tuple with an element of a
-non-const array type one must use the <code>ref</code> wrapper.
-
-<p>
-Function pointers are deduced to the plain non-reference type, that is, to plain function pointer. 
-A tuple can also hold a reference to a function, 
-but such a tuple cannot be constructed with <code>make_tuple</code> (a const qualified function type would result, which is illegal):
-<pre><code>void f(int i);
-  ...
-make_tuple(&amp;f); // tuple&lt;void (*)(int)&gt;
-  ...
-tuple&lt;tuple&lt;void (&amp;)(int)&gt; &gt; a(f) // ok
-make_tuple(f);                    // not ok
-</code></pre>
-
-<h2><a name = "accessing_elements">Accessing tuple elements</a></h2>
-
-<p>
-Tuple elements are accessed with the expression:
-
-<pre><code>t.get&lt;N&gt;()
-</code></pre>
-or
-<pre><code>get&lt;N&gt;(t)
-</code></pre>
-where <code>t</code> is a tuple object and <code>N</code> is a constant integral expression specifying the index of the element to be accessed.
-Depending on whether <code>t</code> is const or not, <code>get</code> returns the <code>N</code>th element as a reference to const or
-non-const type.
-The index of the first element is 0 and thus<code>
-N</code> must be between 0 and <code>k-1</code>, where <code>k</code> is the number of elements in the tuple. 
-Violations of  these constrains are detected at compile time. Examples:
-
-<pre><code>double d = 2.7; A a;
-tuple&lt;int, double&amp;, const A&amp;&gt; t(1, d, a);
-const tuple&lt;int, double&amp;, const A&amp;&gt; ct = t;
-  ...
-int i = get&lt;0&gt;(t); i = t.get&lt;0&gt;();        // ok
-int j = get&lt;0&gt;(ct);                       // ok
-get&lt;0&gt;(t) = 5;                            // ok 
-get&lt;0&gt;(ct) = 5;                           // error, can't assign to const 
-  ...
-double e = get&lt;1&gt;(t); // ok   
-get&lt;1&gt;(t) = 3.14;     // ok 
-get&lt;2&gt;(t) = A();      // error, can't assign to const 
-A aa = get&lt;3&gt;(t);     // error: index out of bounds 
-  ...
-++get&lt;0&gt;(t);  // ok, can be used as any variable
-</code></pre>
-
-Note! The member get functions are not supported with MS Visual C++ compiler.
-Further, the compiler has trouble with finding the non-member get functions without an explicit namespace qualifier. 
-Hence, all <code>get</code> calls should be qualified as: <code>tuples::get&lt;N&gt;(a_tuple)</code> when writing code that shoud compile with MSVC++ 6.0.
-
-<h2><a name = "construction_and_assignment">Copy construction and tuple assignment</a></h2>
-
-<p>
-A tuple can be copy constructed from another tuple, provided that the element types are element-wise copy constructible.
-Analogously, a tuple can be assigned to another tuple, provided that the element types are element-wise assignable.
-For example:
-
-<pre><code>class A;
-class B : public A {};
-struct C { C(); C(const B&amp;); }
-struct D { operator C() const; }
-tuple&lt;char, B*, B, D&gt; t;
-  ...
-tuple&lt;int, A*, C, C&gt; a(t); // ok 
-a = t;                     // ok 
-</code></pre>
-
-In both cases, the conversions performed are: <code>char -> int</code>, <code>B* -> A*</code> (derived class pointer to base class pointer),  <code>B -> C</code> (a user defined conversion) and <code>D -> C</code> (a user defined conversion).
-
-<p>
-Note that assignment is also defined from <code>std::pair</code> types:
-
-<pre><code>tuple&lt;float, int&gt; a = std::make_pair(1, 'a');
-</code></pre>
-
-<h2><a name = "relational_operators">Relational operators</a></h2>
-<p>
-Tuples reduce the operators <code>==, !=, &lt;, >, &lt;=</code> and <code>>=</code> to the corresponding elementary operators. 
-This means, that if any of these operators is defined between all elements of two tuples, then the same operator is defined between the tuples as well.
-
-The equality operators for two tuples <code>a</code> and <code>b</code> are defined as:
-<ul>
-<li><code>a == b</code> iff for each <code>i</code>: <code>a<sub>i</sub> == b<sub>i</sub></code></li>
-<li><code>a != b</code> iff exists <code>i</code>: <code>a<sub>i</sub> != b<sub>i</sub></code></li>
-</ul>
-
-The operators <code>&lt;, >, &lt;=</code> and <code>>=</code> implement a lexicographical ordering.
-
-<p>
-Note that an attempt to compare two tuples of different lengths results in a compile time error.</p>
-Also, the comparison operators are <i>"short-circuited"</i>: elementary comparisons start from the first elements and are performed only until the result is clear.
-
-<p>Examples:
-
-<pre><code>tuple&lt;std::string, int, A&gt; t1(std::string(&quot;same?&quot;), 2, A());
-tuple&lt;std::string, long, A&gt; t2(std::string(&quot;same?&quot;), 2, A());
-tuple&lt;std::string, long, A&gt; t3(std::string(&quot;different&quot;), 3, A());
-
-bool operator==(A, A) { std::cout &lt;&lt; &quot;All the same to me...&quot;; return true; }
-
-t1 == t2; 		// true
-t1 == t3;               // false, does not print &quot;All the...&quot;
-</code></pre>
-
-
-<h2><a name = "tiers">Tiers</a></h2>
-
-<p>
-<i>Tiers</i> are tuples, where all elements are of non-const reference types.
-They are constructed with a call to the <code>tie</code> function template (cf. <code>make_tuple</code>):
-
-<pre><code>int i; char c; double d; 
-  ...
-tie(i, c, a);
-</code></pre>
-
-<p>
-The above <code>tie</code> function creates a tuple of type <code>tuple&lt;int&amp;, char&amp;, double&amp;&gt;</code>. 
-The same result could be achieved with the call <code>make_tuple(ref(i), ref(c), ref(a))</code>.
-</p>
-
-<p>
-A tuple that contains non-const references as elements can be used to 'unpack' another tuple into variables. E.g.:
-
-<pre><code>int i; char c; double d; 
-tie(i, c, d) = make_tuple(1,'a', 5.5);
-std::cout &lt;&lt; i &lt;&lt; &quot; &quot; &lt;&lt;  c &lt;&lt; &quot; &quot; &lt;&lt; d;
-</code></pre>
-This code prints <code>1 a 5.5</code> to the standard output stream.
-
-A tuple unpacking operation like this is found for example in ML and Python. 
-It is convenient when calling functions which return tuples.
-
-<p>
-The tying mechanism works with <code>std::pair</code> templates as well:
-
-<pre><code>int i; char c;
-tie(i, c) = std::make_pair(1, 'a');
-</code></pre>
-<h4>Ignore</h4>
-There is also an object called <code>ignore</code> which allows you to ignore an element assigned by a tuple.
-The idea is that a function may return a tuple, only part of which you are interested in. For example (note, that <code>ignore</code> is under the <code>tuples</code> subnamespace):
-
-<pre><code>char c;
-tie(tuples::ignore, c) = std::make_pair(1, 'a');
-</code></pre>
-
-<h2><a name = "streaming">Streaming</a></h2>
-
-<p>
-The global <code>operator&lt;&lt;</code> has been overloaded for <code>std::ostream</code> such that tuples are 
-output by recursively calling <code>operator&lt;&lt;</code> for each element. 
-</p>
-
-<p>
-Analogously, the global <code>operator&gt;&gt;</code> has been overloaded to extract tuples from <code>std::istream</code>  by recursively calling <code>operator&gt;&gt;</code> for each element. 
-</p>
-
-<p>
-The default delimiter between the elements is space, and the tuple is enclosed
-in parenthesis.
-For Example:
-
-<pre><code>tuple&lt;float, int, std::string&gt; a(1.0f,  2, std::string(&quot;Howdy folks!&quot;);
-
-cout &lt;&lt; a; 
-</code></pre>
-outputs the tuple as: <code>(1.0 2 Howdy folks!)</code>
-
-<p>
-The library defines three <i>manipulators</i> for changing the default behavior:
-<ul>
-<li><code>set_open(char)</code> defines the character that is output before the first
-element.</li>
-<li><code>set_close(char)</code> defines the character that is output after the
-last element.</li>
-<li><code>set_delimiter(char)</code> defines the delimiter character between
-elements.</li>
-</ul>
-
-Note, that these manipulators are defined in the <code>tuples</code> subnamespace. 
-For example:
-<code><pre>cout &lt;&lt; tuples::set_open('[') &lt;&lt; tuples::set_close(']') &lt;&lt; tuples::set_delimiter(',') &lt;&lt; a; 
-</code></pre>
-outputs the same tuple <code>a</code> as: <code>[1.0,2,Howdy folks!]</code>
-
-<p>The same manipulators work with <code>operator&gt;&gt;</code> and <code>istream</code> as well. Suppose the <code>cin</code> stream contains the following data:
-
-<pre><code>(1 2 3) [4:5]</code></pre>
-
-The code:
-
-<code><pre>tuple&lt;int, int, int&gt; i;
-tuple&lt;int, int&gt; j;
-
-cin &gt;&gt; i;
-cin &gt;&gt; tuples::set_open('[') &gt;&gt; tuples::set_close(']') &gt;&gt; tules::set_delimiter(':');
-cin &gt;&gt; j;
-</code></pre>
-
-reads the data into the tuples <code>i</code> and <code>j</code>.
-
-<p>
-Note that extracting tuples with <code>std::string</code> or C-style string
-elements does not generally work, since the streamed tuple representation may not be unambiguously
-parseable.
-</p>
-
-<h2><a name = "performance">Performance</a></h2>
-
-All tuple access and construction functions are small inlined one-liners. 
-Therefore, a decent compiler can eliminate any extra cost of using tuples compared to using hand written tuple like classes. 
-Particularly, with a decent compiler there is no performance difference between this code:
-
-<pre><code>class hand_made_tuple { 
-  A a; B b; C c;
-public:
-  hand_made_tuple(const A&amp; aa, const B&amp; bb, const C&amp; cc) 
-    : a(aa), b(bb), c(cc) {};
-  A&amp; getA() { return a; };
-  B&amp; getB() { return b; };
-  C&amp; getC() { return c; };
-};
-
-hand_made_tuple hmt(A(), B(), C()); 
-hmt.getA(); hmt.getB(); hmt.getC();
-</code></pre>
-
-and this code:
-
-<pre><code>tuple&lt;A, B, C&gt; t(A(), B(), C());
-t.get&lt;0&gt;(); t.get&lt;1&gt;(); t.get&lt;2&gt;(); 
-</code></pre>
-
-<p>Note, that there are widely used compilers (e.g. bcc 5.5.1) which fail to optimize this kind of tuple usage.
-</p>  
-<p>
-Depending on the optimizing ability of the compiler, the tier mechanism may have a small performance penalty compared to using
-non-const reference parameters as a mechanism for returning multiple values from a function. 
-For example, suppose that the following functions <code>f1</code> and <code>f2</code> have equivalent functionalities:
-
-<pre><code>void f1(int&amp;, double&amp;);
-tuple&lt;int, double&gt; f2();
-</code></pre>
-
-Then, the call #1 may be slightly faster than #2 in the code below:
-
-<pre><code>int i; double d;
-  ...
-f1(i,d);         // #1
-tie(i,d) = f2(); // #2
-</code></pre>
-See 
-[<a href=#publ_1>1</a>,
-<a href=#publ_2>2</a>]
- for more in-depth discussions about efficiency.
-
-<h4>Effect on Compile Time</h4>
-
-<p>
-Compiling tuples can be slow due to the excessive amount of template instantiations.
-Depending on the compiler and the tuple length, it may be more than 10 times slower to compile a tuple construct, compared to compiling an equivalent explicitly written class, such as the <code>hand_made_tuple</code> class above.
-However, as a realistic program is likely to contain a lot of code in addition to tuple definitions, the difference is probably unnoticeable.
-Compile time increases between 5 to 10 percentages were measured for programs which used tuples very frequently.
-With the same test programs, memory consumption of compiling increased between 22% to 27%. See  
-[<a href=#publ_1>1</a>,
-<a href=#publ_2>2</a>]
-for details.
-</p>
-
-<h2><a name = "portability">Portability</a></h2>
-
-<p>The library code is(?) standard C++ and thus the library works with a standard conforming compiler. 
-Below is a list of compilers and known problems with each compiler:
-</p>
-<table>
-<tr><td><u>Compiler</u></td><td><u>Problems</u></td></tr>
-<tr><td>gcc 2.95</td><td>-</td></tr>
-<tr><td>edg 2.44</td><td>-</td></tr>
-<tr><td>Borland 5.5</td><td>Can't use function  pointers or member pointers as tuple elements</td></tr>
-<tr><td>Metrowerks 6.2</td><td>Can't use <code>ref</code> and <code>cref</code> wrappers</td></tr>
-<tr><td>MS Visual C++</td><td>No reference elements (<code>tie</code> still works). Can't use <code>ref</code> and <code>cref</code> wrappers</td></tr>
-</table>
-
-<h2><a name = "thanks">Acknowledgements</a></h2>
-Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. 
-The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David Abrahams and Hartmut Kaiser helped to improve the
-library.
-The idea for the tie mechanism came from an old usenet article by Ian McCulloch, where he proposed something similar for std::pairs.
-<h2><a name = "references">References</a></h2>
-
-<p>
-<a name="publ_1"></a>[1]
-J&auml;rvi J.: <i>Tuples and multiple return values in C++</i>, TUCS Technical Report No 249, 1999 (<a href="http://www.tucs.fi/publications">http://www.tucs.fi/publications</a>).
-</p>
-
-<p>
-<a name="publ_2"></a>[2]
-J&auml;rvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism</i>, TUCS Technical Report No 267, 1999 (<a href="http://www.tucs.fi/publications">http://www.tucs.fi/publications</a>).
-</p>
-
-<p>
-[3] J&auml;rvi J.:<i>Tuple Types and Multiple Return Values</i>, C/C++ Users Journal, August 2001.
-</p>
-
-<hr>
-
-<p>Last modified 2001-09-13</p>
-
-<p>&copy; Copyright <a href="../../../people/jaakko_jarvi.htm"> Jaakko J&auml;rvi</a> 2001. 
-
-Permission to copy, use, modify, sell and distribute this software and its documentation is granted provided this copyright notice appears in all copies. 
-This software and its documentation is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose.
-</p>
-</body>
-</html>
-
-
-
-

doc/tuple_users_guide.qbk

@@ -0,0 +1,525 @@
+[/
+ /  Copyright (c) 2001 Jaakko J<>rvi
+ /
+ / 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)
+ /]
+
+[library Boost.Tuple
+  [quickbook 1.6]
+  [id tuple]
+  [copyright 2001 Jaakko J\u00E4rvi]
+  [dirname tuple]
+  [license Distributed under the
+    [@http://boost.org/LICENSE_1_0.txt Boost Software License,
+      Version 1.0].
+  ]
+]
+
+[include tuple_advanced_interface.qbk]
+[include design_decisions_rationale.qbk]
+
+[template simplesect[title]
+[block '''<simplesect><title>'''[title]'''</title>''']]
+
+[template endsimplesect[]
+[block '''</simplesect>''']]
+
+A tuple (or n-tuple) is a fixed size collection of elements. Pairs, triples,
+quadruples etc. are tuples. In a programming language, a tuple is a data
+object containing other objects as elements. These element objects may be of
+different types.
+
+Tuples are convenient in many circumstances. For instance, tuples make it easy
+to define functions that return more than one value.
+
+Some programming languages, such as ML, Python and Haskell, have built-in
+tuple constructs. Unfortunately C++ does not. To compensate for this
+"deficiency", the Boost Tuple Library implements a tuple construct using
+templates.
+
+[section:using_library Using the Library]
+
+To use the library, just include:
+
+    #include "boost/tuple/tuple.hpp"
+
+Comparison operators can be included with:
+
+    #include "boost/tuple/tuple_comparison.hpp"
+
+To use tuple input and output operators,
+
+    #include "boost/tuple/tuple_io.hpp"
+
+Both `tuple_io.hpp` and `tuple_comparison.hpp` include `tuple.hpp`.
+
+All definitions are in namespace `::boost::tuples`, but the most common names
+are lifted to namespace `::boost` with using declarations. These names are:
+`tuple`, `make_tuple`, `tie` and `get`. Further, `ref` and `cref` are defined
+directly under the `::boost` namespace.
+
+[endsect]
+
+[section:tuple_types Tuple Types]
+
+A tuple type is an instantiation of the `tuple` template. The template
+parameters specify the types of the tuple elements. The current version
+supports tuples with 0-10 elements. If necessary, the upper limit can be
+increased up to, say, a few dozen elements. The data element can be any C++
+type. Note that `void` and plain function types are valid C++ types, but
+objects of such types cannot exist. Hence, if a tuple type contains such types
+as elements, the tuple type can exist, but not an object of that type. There
+are natural limitations for element types that cannot be copied, or that are
+not default constructible (see [link tuple.constructing_tuples 'Constructing tuples']
+below).
+
+For example, the following definitions are valid tuple instantiations (`A`,
+`B` and `C` are some user defined classes):
+
+    tuple<int>
+    tuple<double&, const double&, const double, double*, const double*>
+    tuple<A, int(*)(char, int), B(A::*)(C&), C>
+    tuple<std::string, std::pair<A, B> >
+    tuple<A*, tuple<const A*, const B&, C>, bool, void*>
+
+[endsect]
+
+[section:constructing_tuples Constructing Tuples]
+
+The tuple constructor takes the tuple elements as arguments. For an /n/-
+element tuple, the constructor can be invoked with /k/ arguments, where
+`0` <= /k/ <= /n/. For example:
+
+    tuple<int, double>()
+    tuple<int, double>(1)
+    tuple<int, double>(1, 3.14)
+
+If no initial value for an element is provided, it is default initialized
+(and hence must be default initializable). For example:
+
+    class X {
+      X();
+    public:
+      X(std::string);
+    };
+
+    tuple<X,X,X>()                                              // error: no default constructor for X
+    tuple<X,X,X>(string("Jaba"), string("Daba"), string("Duu")) // ok
+
+In particular, reference types do not have a default initialization:
+
+    tuple<double&>()                // error: reference must be
+                                    // initialized explicitly
+
+    double d = 5;
+    tuple<double&>(d)               // ok
+
+    tuple<double&>(d+3.14)          // error: cannot initialize
+                                    // non-const reference with a temporary
+
+    tuple<const double&>(d+3.14)    // ok, but dangerous:
+                                    // the element becomes a dangling reference
+
+Using an initial value for an element that cannot be copied, is a compile time
+error:
+
+    class Y {
+      Y(const Y&);
+    public:
+      Y();
+    };
+
+    char a[10];
+
+    tuple<char[10], Y>(a, Y()); // error, neither arrays nor Y can be copied
+    tuple<char[10], Y>();       // ok
+
+Note particularly that the following is perfectly ok:
+
+    Y y;
+    tuple<char(&)[10], Y&>(a, y);
+
+It is possible to come up with a tuple type that cannot be constructed. This
+occurs if an element that cannot be initialized has a lower index than an
+element that requires initialization. For example: `tuple<char[10], int&>`.
+
+In sum, the tuple construction is semantically just a group of individual
+elementary constructions.
+
+[section:make_tuple The `make_tuple` function]
+
+Tuples can also be constructed using the `make_tuple` (cf. `std::make_pair`)
+helper functions. This makes the construction more convenient, saving the
+programmer from explicitly specifying the element types:
+
+    tuple<int, int, double> add_multiply_divide(int a, int b) {
+      return make_tuple(a+b, a*b, double(a)/double(b));
+    }
+
+By default, the element types are deduced to the plain non-reference types.
+E.g.:
+
+    void foo(const A& a, B& b) {
+      ...
+      make_tuple(a, b);
+
+The `make_tuple` invocation results in a tuple of type `tuple<A, B>`.
+
+Sometimes the plain non-reference type is not desired, e.g. if the element
+type cannot be copied. Therefore, the programmer can control the type
+deduction and state that a reference to const or reference to non-const type
+should be used as the element type instead. This is accomplished with two
+helper template functions: [@boost:/libs/core/doc/html/core/ref.html `boost::ref`]
+and [@boost:/libs/core/doc/html/core/ref.html `boost::cref`]. Any argument can
+be wrapped with these functions to get the desired type. The mechanism does
+not compromise const correctness since a const object wrapped with ref results
+in a tuple element with const reference type (see the fifth example below).
+For example:
+
+    A a; B b; const A ca = a;
+    make_tuple(cref(a), b);      // creates tuple<const A&, B>
+    make_tuple(ref(a), b);       // creates tuple<A&, B>
+    make_tuple(ref(a), cref(b)); // creates tuple<A&, const B&>
+    make_tuple(cref(ca));        // creates tuple<const A&>
+    make_tuple(ref(ca));         // creates tuple<const A&>
+
+Array arguments to `make_tuple` functions are deduced to reference to const
+types by default; there is no need to wrap them with `cref`. For example:
+
+    make_tuple("Donald", "Daisy");
+
+This creates an object of type `tuple<const char (&)[7], const char (&)[6]>`
+(note that the type of a string literal is an array of const characters, not
+`const char*`). However, to get `make_tuple` to create a tuple with an element
+of a non-const array type one must use the `ref` wrapper.
+
+Function pointers are deduced to the plain non-reference type, that is, to
+plain function pointer. A tuple can also hold a reference to a function, but
+such a tuple cannot be constructed with `make_tuple` (a const qualified
+function type would result, which is illegal):
+
+    void f(int i);
+      ...
+    make_tuple(&f); // tuple<void (*)(int)>
+      ...
+    tuple<tuple<void (&)(int)> > a(f) // ok
+    make_tuple(f);                    // not ok
+
+[endsect]
+
+[endsect]
+
+[section:accessing_elements Accessing Tuple Elements]
+
+Tuple elements are accessed with the expression:
+
+    t.get<N>()
+
+or
+
+    get<N>(t)
+
+where `t`  is a tuple object and `N` is a constant integral expression
+specifying the index of the element to be accessed. Depending on whether `t`
+is const or not, `get` returns the `N`-th element as a reference to const or
+non-const type. The index of the first element is `0` and thus `N` must be
+between `0` and /k/`-1`, where /k/ is the number of elements in the tuple.
+Violations of these constraints are detected at compile time. Examples:
+
+    double d = 2.7; A a;
+    tuple<int, double&, const A&> t(1, d, a);
+    const tuple<int, double&, const A&> ct = t;
+      ...
+    int i = get<0>(t); i = t.get<0>();        // ok
+    int j = get<0>(ct);                       // ok
+    get<0>(t) = 5;                            // ok
+    get<0>(ct) = 5;                           // error, can't assign to const
+      ...
+    double e = get<1>(t); // ok
+    get<1>(t) = 3.14;     // ok
+    get<2>(t) = A();      // error, can't assign to const
+    A aa = get<3>(t);     // error: index out of bounds
+      ...
+    ++get<0>(t);  // ok, can be used as any variable
+
+/[Note:/ The member `get` functions are not supported with MS Visual C++
+compiler. Further, the compiler has trouble with finding the non-member `get`
+functions without an explicit namespace qualifier. Hence, all `get` calls
+should be qualified as `tuples::get<N>(a_tuple)` when writing code that should
+compile with MSVC++ 6.0./]/
+
+[endsect]
+
+[section:construction_and_assignment Copy Construction and Tuple Assignment]
+
+A tuple can be copy constructed from another tuple, provided that the element
+types are element-wise copy constructible. Analogously, a tuple can be
+assigned to another tuple, provided that the element types are element-wise
+assignable. For example:
+
+    class A {};
+    class B : public A {};
+    struct C { C(); C(const B&); };
+    struct D { operator C() const; };
+    tuple<char, B*, B, D> t;
+      ...
+    tuple<int, A*, C, C> a(t); // ok
+    a = t;                     // ok
+
+In both cases, the conversions performed are:
+
+* `char -> int`,
+* `B* -> A*` (derived class pointer to base class pointer),
+* `B -> C` (a user defined conversion), and
+* `D -> C` (a user defined conversion).
+
+Note that assignment is also defined from `std::pair` types:
+
+    tuple<float, int> a = std::make_pair(1, 'a');
+
+[endsect]
+
+[section:relational_operators Relational Operators]
+
+Tuples reduce the operators `==`, `!=`, `<`, `>`, `<=` and `>=` to the
+corresponding elementary operators. This means, that if any of these operators
+is defined between all elements of two tuples, then the same operator is
+defined between the tuples as well. The equality operators for two tuples `a`
+and `b` are defined as:
+
+* `a == b` iff for each `i`: `a`'''<subscript>i</subscript>'''` == b`'''<subscript>i</subscript>'''
+* `a != b` iff exists `i`: `a`'''<subscript>i</subscript>'''` != b`'''<subscript>i</subscript>'''
+
+The operators `<`, `>`, `<=` and `>=` implement a lexicographical ordering.
+
+Note that an attempt to compare two tuples of different lengths results in a
+compile time error. Also, the comparison operators are /"short-circuited"/:
+elementary comparisons start from the first elements and are performed only
+until the result is clear.
+
+Examples:
+
+    tuple<std::string, int, A> t1(std::string("same?"), 2, A());
+    tuple<std::string, long, A> t2(std::string("same?"), 2, A());
+    tuple<std::string, long, A> t3(std::string("different"), 3, A());
+
+    bool operator==(A, A) { std::cout << "All the same to me..."; return true; }
+
+    t1 == t2;               // true
+    t1 == t3;               // false, does not print "All the..."
+
+[endsect]
+
+[section:tiers Tiers]
+
+/Tiers/ are tuples, where all elements are of non-const reference types. They
+are constructed with a call to the `tie` function template (cf. `make_tuple`):
+
+    int i; char c; double d;
+      ...
+    tie(i, c, a);
+
+The above `tie` function creates a tuple of type `tuple<int&, char&, double&>`.
+The same result could be achieved with the call `make_tuple(ref(i), ref(c), ref(a))`.
+
+A tuple that contains non-const references as elements can be used to 'unpack'
+another tuple into variables. E.g.:
+
+    int i; char c; double d;
+    tie(i, c, d) = make_tuple(1,'a', 5.5);
+    std::cout << i << " " <<  c << " " << d;
+
+This code prints `1 a 5.5` to the standard output stream. A tuple unpacking
+operation like this is found for example in ML and Python. It is convenient
+when calling functions which return tuples.
+
+The tying mechanism works with `std::pair` templates as well:
+
+    int i; char c;
+    tie(i, c) = std::make_pair(1, 'a');
+
+[section Ignore]
+
+There is also an object called `ignore` which allows you to ignore an element
+assigned by a tuple. The idea is that a function may return a tuple, only part
+of which you are interested in. For example (note, that ignore is under the
+`tuples` subnamespace):
+
+    char c;
+    tie(tuples::ignore, c) = std::make_pair(1, 'a');
+
+[endsect]
+
+[endsect]
+
+[section:streaming Streaming]
+
+The global `operator<<` has been overloaded for `std::ostream` such that
+tuples are output by recursively calling `operator<<` for each element.
+
+Analogously, the global `operator>>` has been overloaded to extract tuples
+from `std::istream` by recursively calling `operator>>` for each element.
+
+The default delimiter between the elements is space, and the tuple is enclosed
+in parenthesis. For Example:
+
+    tuple<float, int, std::string> a(1.0f,  2, std::string("Howdy folks!");
+
+    cout << a;
+
+outputs the tuple as: `(1.0 2 Howdy folks!)`
+
+The library defines three manipulators for changing the default behavior:
+
+* `set_open(char)` defines the character that is output before the first element.
+* `set_close(char)` defines the character that is output after the last element.
+* `set_delimiter(char)` defines the delimiter character between elements.
+
+Note, that these manipulators are defined in the tuples subnamespace. For
+example:
+
+    cout << tuples::set_open('[') << tuples::set_close(']') << tuples::set_delimiter(',') << a;
+
+outputs the same tuple `a` as: `[1.0,2,Howdy folks!]`
+
+The same manipulators work with `operator>>` and `istream` as well. Suppose
+the `cin` stream contains the following data:
+
+    (1 2 3) [4:5]
+
+The code:
+
+    tuple<int, int, int> i;
+    tuple<int, int> j;
+
+    cin >> i;
+    cin >> tuples::set_open('[') >> tuples::set_close(']') >> tuples::set_delimiter(':');
+    cin >> j;
+
+reads the data into the tuples `i` and `j`.
+
+Note that extracting tuples with `std::string` or C-style string elements does
+not generally work, since the streamed tuple representation may not be
+unambiguously parseable.
+
+[endsect]
+
+[section:performance Performance]
+
+All tuple access and construction functions are small inlined one-liners.
+Therefore, a decent compiler can eliminate any extra cost of using tuples
+compared to using hand-written tuple like classes. Particularly, with a decent
+compiler there is no performance difference between this code:
+
+    class hand_made_tuple {
+      A a; B b; C c;
+    public:
+      hand_made_tuple(const A& aa, const B& bb, const C& cc)
+        : a(aa), b(bb), c(cc) {};
+      A& getA() { return a; };
+      B& getB() { return b; };
+      C& getC() { return c; };
+    };
+
+    hand_made_tuple hmt(A(), B(), C());
+    hmt.getA(); hmt.getB(); hmt.getC();
+
+and this code:
+
+    tuple<A, B, C> t(A(), B(), C());
+    t.get<0>(); t.get<1>(); t.get<2>();
+
+Note, that there are widely used compilers (e.g. bcc 5.5.1) which fail to
+optimize this kind of tuple usage.
+
+Depending on the optimizing ability of the compiler, the tier mechanism may
+have a small performance penalty compared to using non-const reference
+parameters as a mechanism for returning multiple values from a function. For
+example, suppose that the following functions `f1` and `f2` have equivalent
+functionalities:
+
+    void f1(int&, double&);
+    tuple<int, double> f2();
+
+Then, the call #1 may be slightly faster than #2 in the code below:
+
+    int i; double d;
+      ...
+    f1(i,d);         // #1
+    tie(i,d) = f2(); // #2
+
+See [[link publ_1 1], [link publ_2 2]] for more in-depth discussions about 
+efficiency.
+
+[section Effect on Compile Time]
+
+Compiling tuples can be slow due to the excessive amount of template
+instantiations. Depending on the compiler and the tuple length, it may be more
+than 10 times slower to compile a tuple construct, compared to compiling an
+equivalent explicitly written class, such as the `hand_made_tuple` class above.
+However, as a realistic program is likely to contain a lot of code in addition
+to tuple definitions, the difference is probably unnoticeable. Compile time
+increases between 5 and 10 percent were measured for programs which used tuples
+very frequently. With the same test programs, memory consumption of compiling
+increased between 22% to 27%. See [[link publ_1 1], [link publ_2 2]] for
+details.
+
+[endsect]
+
+[endsect]
+
+[section:portability Portability]
+
+The library code is(?) standard C++ and thus the library works with a standard
+conforming compiler. Below is a list of compilers and known problems with each
+compiler:
+
+[table
+    [[Compiler]        [Problems]]
+    [[gcc 2.95]        [-]]
+    [[edg 2.44]        [-]]
+    [[Borland 5.5]     [Can't use function pointers or member pointers as
+                       tuple elements]]
+    [[Metrowerks 6.2]  [Can't use `ref` and `cref` wrappers]]
+    [[MS Visual C++]   [No reference elements (`tie` still works). Can't use
+                       `ref` and `cref` wrappers]]
+]
+
+[endsect]
+
+[section:more_details More Details]
+
+[link tuple_advanced_interface Advanced features] (describes some metafunctions etc.).
+
+[link design_decisions_rationale Rationale behind some design/implementation decisions].
+
+[endsect]
+
+[section:thanks Acknowledgements]
+
+Gary Powell has been an indispensable helping hand. In particular, stream
+manipulators for tuples were his idea. Doug Gregor came up with a working
+version for MSVC, David Abrahams found a way to get rid of most of the
+restrictions for compilers not supporting partial specialization. Thanks to
+Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. The
+comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David
+Abrahams and Hartmut Kaiser helped to improve the library. The idea for the
+`tie` mechanism came from an old usenet article by Ian McCulloch, where he
+proposed something similar for `std::pair`s.
+
+[endsect]
+
+[section:references References]
+
+[#publ_1]
+[1] J\u00E4rvi J.: /Tuples and multiple return values in C++/, TUCS Technical Report No 249, 1999.
+
+[#publ_2]
+[2] J\u00E4rvi J.: /ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism/, TUCS Technical Report No 267, 1999.
+
+[#publ_3]
+[3] J\u00E4rvi J.: /Tuple Types and Multiple Return Values/, C/C++ Users Journal, August 2001.
+
+[endsect]

include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp

@@ -1,756 +0,0 @@
-// - tuple_basic_no_partial_spec.hpp -----------------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2001 Doug Gregor (gregod@rpi.edu)
-// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies. 
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org or http://lambda.cs.utu.fi 
-
-// Revision History 
-//  14 02 01    Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG)
-//  10 02 01    Fixed "null_type" constructors.
-//              Implemented comparison operators globally.
-//              Hide element_type_ref and element_type_const_ref.
-//              (DG).
-//  09 02 01    Extended to tuples of length 10. Changed comparison for 
-//              operator<()
-//              to the same used by std::pair<>, added cnull_type() (GP)
-//  03 02 01    Initial Version from original tuple.hpp code by JJ. (DG)
-
-// ----------------------------------------------------------------- 
-
-#ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
-#define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
-
-#include "boost/type_traits.hpp"
-#include <utility>
-
-#if defined BOOST_MSVC
-#pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored
-#pragma warning(disable:4181) // qualifier applied to reference type ignored
-#pragma warning(disable:4227) // qualifier applied to reference type ignored
-#endif
-
-namespace boost {
-namespace tuples {
-
-    // null_type denotes the end of a list built with "cons"
-    struct null_type 
-    {
-      null_type() {}
-      null_type(const null_type&, const null_type&) {}
-    };
-     
-    // a helper function to provide a const null_type type temporary
-    inline const null_type cnull_type() { return null_type(); }
-
-// forward declaration of tuple
-    template<
-      typename T1 = null_type, 
-      typename T2 = null_type, 
-      typename T3 = null_type, 
-      typename T4 = null_type,
-      typename T5 = null_type,
-      typename T6 = null_type,
-      typename T7 = null_type,
-      typename T8 = null_type,
-      typename T9 = null_type,
-      typename T10 = null_type
-    >
-    class tuple;
-
-    namespace detail {
-
-      // Takes a pointer and routes all assignments to whatever it points to
-      template<typename T>
-      struct assign_to_pointee
-      {
-      public:
-        explicit assign_to_pointee(T* p) : ptr(p) {}
-
-        template<typename Other>
-        assign_to_pointee& operator=(const Other& other)
-        {
-          *ptr = other;
-          return *this;
-        }
-
-      private:
-        T* ptr;
-      };
-
-      // Swallows any assignment
-      struct swallow_assign
-      {
-        template<typename T>
-        swallow_assign& operator=(const T&)
-        {
-          return *this;
-        }
-      };
-
-  } // end of namespace detail
-
-    // cons builds a heterogenous list of types
-   template<typename Head, typename Tail = null_type>
-   struct cons
-   {
-     typedef cons self_type;
-     typedef Head head_type;
-     typedef Tail tail_type;
-
-     head_type head;
-     tail_type tail;
-
-     typename boost::add_reference<head_type>::type get_head() { return head; }
-     typename boost::add_reference<tail_type>::type get_tail() { return tail; }  
-
-     typename boost::add_reference<const head_type>::type get_head() const { return head; }
-     typename boost::add_reference<const tail_type>::type get_tail() const { return tail; }
-  
-#if defined BOOST_MSVC
-      template<typename Tail>
-      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
-                    const Tail& t) : head(h), tail(t.head, t.tail)
-      {
-      }
-
-      explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
-                    const null_type& t) : head(h), tail(t)
-      {
-      }
-
-#else
-      template<typename T>
-      explicit cons(const head_type& h, const T& t) : 
-        head(h), tail(t.head, t.tail)
-      {
-      }
-
-      explicit cons(const head_type& h = head_type(),
-                    const tail_type& t = tail_type()) :
-        head(h), tail(t)
-      {
-      }
-#endif
-
-
-      template<typename Other>
-      cons& operator=(const Other& other)
-      {
-        head = other.head;
-        tail = other.tail;
-        return *this;
-      }
-    };
-  
-    namespace detail {
-
-      // Determines if the parameter is null_type
-      template<typename T> struct is_null_type { enum { RET = 0 }; };
-      template<> struct is_null_type<null_type> { enum { RET = 1 }; };
-      
-      /* Build a cons structure from the given Head and Tail. If both are null_type,
-      return null_type. */
-      template<typename Head, typename Tail>
-      struct build_cons
-      {
-      private:
-        enum { tail_is_null_type = is_null_type<Tail>::RET };
-      public:
-        typedef cons<Head, Tail> RET;
-      };
-
-      template<>
-      struct build_cons<null_type, null_type>
-      {
-        typedef null_type RET;
-      };
-
-      // Map the N elements of a tuple into a cons list
-      template<
-        typename T1, 
-        typename T2 = null_type, 
-        typename T3 = null_type, 
-        typename T4 = null_type, 
-        typename T5 = null_type, 
-        typename T6 = null_type, 
-        typename T7 = null_type, 
-        typename T8 = null_type, 
-        typename T9 = null_type, 
-        typename T10 = null_type
-      >
-      struct map_tuple_to_cons
-      {
-        typedef typename detail::build_cons<T10, null_type  >::RET cons10;
-        typedef typename detail::build_cons<T9, cons10>::RET cons9;
-        typedef typename detail::build_cons<T8, cons9>::RET cons8;
-        typedef typename detail::build_cons<T7, cons8>::RET cons7;
-        typedef typename detail::build_cons<T6, cons7>::RET cons6;
-        typedef typename detail::build_cons<T5, cons6>::RET cons5;
-        typedef typename detail::build_cons<T4, cons5>::RET cons4;
-        typedef typename detail::build_cons<T3, cons4>::RET cons3;
-        typedef typename detail::build_cons<T2, cons3>::RET cons2;
-        typedef typename detail::build_cons<T1, cons2>::RET cons1;
-      };
-
-      // Workaround the lack of partial specialization in some compilers
-      template<int N>
-      struct _element_type
-      {
-        template<typename Tuple>
-        struct inner
-        {
-        private:
-          typedef typename Tuple::tail_type tail_type;
-          typedef _element_type<N-1> next_elt_type;
-
-        public:
-          typedef typename _element_type<N-1>::template inner<tail_type>::RET RET;
-        };
-      };
-
-      template<>
-      struct _element_type<0>
-      {
-        template<typename Tuple>
-        struct inner
-        {
-          typedef typename Tuple::head_type RET;
-        };
-      };
-
-    } // namespace detail
-
-
-    // Return the Nth type of the given Tuple
-    template<int N, typename Tuple>
-    struct element
-    {
-    private:
-      typedef detail::_element_type<N> nth_type;
-
-    public:
-      typedef typename nth_type::template inner<Tuple>::RET RET;
-      typedef RET type;
-    };
-
-    namespace detail {
-
-#if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
-      // special workaround for vc7:
-
-      template <bool x>
-      struct reference_adder
-      {
-         template <class T>
-         struct rebind
-         {
-            typedef T& type;
-         };
-      };
-
-      template <>
-      struct reference_adder<true>
-      {
-         template <class T>
-         struct rebind
-         {
-            typedef T type;
-         };
-      };
-
-
-      // Return a reference to the Nth type of the given Tuple
-      template<int N, typename Tuple>
-      struct element_ref
-      {
-      private:
-         typedef typename element<N, Tuple>::RET elt_type;
-         enum { is_ref = is_reference<elt_type>::value };
-
-      public:
-         typedef reference_adder<is_ref>::rebind<elt_type>::type RET;
-         typedef RET type;
-      };
-
-      // Return a const reference to the Nth type of the given Tuple
-      template<int N, typename Tuple>
-      struct element_const_ref
-      {
-      private:
-         typedef typename element<N, Tuple>::RET elt_type;
-         enum { is_ref = is_reference<elt_type>::value };
-
-      public:
-         typedef reference_adder<is_ref>::rebind<const elt_type>::type RET;
-         typedef RET type;
-      };
-
-#else // vc7
-
-      // Return a reference to the Nth type of the given Tuple
-      template<int N, typename Tuple>
-      struct element_ref
-      {
-      private:
-        typedef typename element<N, Tuple>::RET elt_type;
-
-      public:
-        typedef typename add_reference<elt_type>::type RET;
-        typedef RET type;
-      };
-
-      // Return a const reference to the Nth type of the given Tuple
-      template<int N, typename Tuple>
-      struct element_const_ref
-      {
-      private:
-        typedef typename element<N, Tuple>::RET elt_type;
-
-      public:
-        typedef typename add_reference<const elt_type>::type RET;
-        typedef RET type;
-      };
-#endif // vc7
-
-    } // namespace detail
-
-    // Get length of this tuple
-    template<typename Tuple>
-    struct length
-    {
-      BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
-    };
-    
-    template<> struct length<tuple<> > {
-      BOOST_STATIC_CONSTANT(int, value = 0);
-    };
-
-    template<>
-    struct length<null_type>
-    {
-      BOOST_STATIC_CONSTANT(int, value = 0);
-    };
-
-    namespace detail {
-
-    // Reference the Nth element in a tuple and retrieve it with "get"
-    template<int N>
-    struct get_class
-    {
-      template<typename Head, typename Tail>
-      static inline
-      typename detail::element_ref<N, cons<Head, Tail> >::RET
-      get(cons<Head, Tail>& t)
-      {
-        return get_class<N-1>::get(t.tail);
-      }
-
-      template<typename Head, typename Tail>
-      static inline
-      typename detail::element_const_ref<N, cons<Head, Tail> >::RET
-      get(const cons<Head, Tail>& t)
-      {
-        return get_class<N-1>::get(t.tail);
-      }
-    };
-
-    template<>
-    struct get_class<0>
-    {
-      template<typename Head, typename Tail>
-      static inline
-      typename add_reference<Head>::type
-      get(cons<Head, Tail>& t)
-      {
-        return t.head;
-      }
-
-      template<typename Head, typename Tail>
-      static inline
-      typename add_reference<const Head>::type
-      get(const cons<Head, Tail>& t)
-      {
-        return t.head;
-      }
-    };
-
-    } // namespace detail
-
-    // tuple class
-    template<
-      typename T1, 
-      typename T2, 
-      typename T3, 
-      typename T4,
-      typename T5,
-      typename T6,
-      typename T7,
-      typename T8,
-      typename T9,
-      typename T10
-    >
-    class tuple : 
-      public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
-    {
-    private:
-      typedef detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mapped_tuple;
-      typedef typename mapped_tuple::cons10 cons10;
-      typedef typename mapped_tuple::cons9 cons9;
-      typedef typename mapped_tuple::cons8 cons8;
-      typedef typename mapped_tuple::cons7 cons7;
-      typedef typename mapped_tuple::cons6 cons6;
-      typedef typename mapped_tuple::cons5 cons5;
-      typedef typename mapped_tuple::cons4 cons4;
-      typedef typename mapped_tuple::cons3 cons3;
-      typedef typename mapped_tuple::cons2 cons2;
-      typedef typename mapped_tuple::cons1 cons1;
-
-    public:
-      typedef cons1 inherited;
-      typedef tuple self_type;
-
-      explicit tuple(const T1& t1 = T1(), 
-                     const T2& t2 = T2(),
-                     const T3& t3 = T3(),
-                     const T4& t4 = T4(),
-                     const T5& t5 = T5(),
-                     const T6& t6 = T6(),
-                     const T7& t7 = T7(),
-                     const T8& t8 = T8(),
-                     const T9& t9 = T9(),
-                     const T10& t10 = T10()) :
-        cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
-      {
-      }
-
-      template<typename Head, typename Tail>
-      explicit tuple(const cons<Head, Tail>& other) : 
-        cons1(other.head, other.tail)
-      {
-      }
-
-      template<typename First, typename Second>
-      self_type& operator=(const std::pair<First, Second>& other)
-      {
-        this->head = other.first;
-        this->tail.head = other.second;
-        return *this;
-      }
-
-      template<typename Head, typename Tail>
-      self_type& operator=(const cons<Head, Tail>& other)
-      {
-        this->head = other.head;
-        this->tail = other.tail;
-
-        return *this;
-      }
-    };
-
-    namespace detail {
-
-      template<int N> struct workaround_holder {};
-
-    } // namespace detail
-
-    template<int N, typename Head, typename Tail>
-    typename detail::element_ref<N, cons<Head, Tail> >::RET
-    get(cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
-    {
-      return detail::get_class<N>::get(t);
-    }
-
-    template<int N, typename Head, typename Tail>
-    typename detail::element_const_ref<N, cons<Head, Tail> >::RET
-    get(const cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
-    {
-      return detail::get_class<N>::get(t);
-    }
-
-    // Make a tuple
-    template<typename T1>
-    inline
-    tuple<T1>
-    make_tuple(const T1& t1)
-    {
-      return tuple<T1>(t1);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2>
-    inline
-    tuple<T1, T2>
-    make_tuple(const T1& t1, const T2& t2)
-    {
-      return tuple<T1, T2>(t1, t2);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3>
-    inline
-    tuple<T1, T2, T3>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3)
-    {
-      return tuple<T1, T2, T3>(t1, t2, t3);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4>
-    inline
-    tuple<T1, T2, T3, T4>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
-    {
-      return tuple<T1, T2, T3, T4>(t1, t2, t3, t4);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5>
-    inline
-    tuple<T1, T2, T3, T4, T5>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5)
-    {
-      return tuple<T1, T2, T3, T4, T5>(t1, t2, t3, t4, t5);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-    inline
-    tuple<T1, T2, T3, T4, T5, T6>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6)
-    {
-      return tuple<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6);
-    }
-  
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-    inline
-    tuple<T1, T2, T3, T4, T5, T6, T7>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7)
-    {
-      return tuple<T1, T2, T3, T4, T5, T6, T7>(t1, t2, t3, t4, t5, t6, t7);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-    inline
-    tuple<T1, T2, T3, T4, T5, T6, T7, T8>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8)
-    {
-      return tuple<T1, T2, T3, T4, T5, T6, T7, T8>(t1, t2, t3, t4, t5, t6, t7, t8);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
-    inline
-    tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9)
-    {
-      return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(t1, t2, t3, t4, t5, t6, t7, t8, t9);
-    }
-
-    // Make a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
-    inline
-    tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
-    make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10)
-    {
-      return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
-    }
-
-    // Tie variables into a tuple
-    template<typename T1>
-    inline
-    tuple<detail::assign_to_pointee<T1> >
-    tie(T1& t1)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2> >
-    tie(T1& t1, T2& t2)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3> >
-    tie(T1& t1, T2& t2, T3& t3)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5),
-                        detail::assign_to_pointee<T6>(&t6));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6>, 
-      detail::assign_to_pointee<T7> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5),
-                        detail::assign_to_pointee<T6>(&t6),
-                        detail::assign_to_pointee<T7>(&t7));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6>, 
-      detail::assign_to_pointee<T7>, 
-      detail::assign_to_pointee<T8> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5),
-                        detail::assign_to_pointee<T6>(&t6),
-                        detail::assign_to_pointee<T7>(&t7),
-                        detail::assign_to_pointee<T8>(&t8));
-    }
-
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6>, 
-      detail::assign_to_pointee<T7>, 
-      detail::assign_to_pointee<T8>, 
-      detail::assign_to_pointee<T9> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5),
-                        detail::assign_to_pointee<T6>(&t6),
-                        detail::assign_to_pointee<T7>(&t7),
-                        detail::assign_to_pointee<T8>(&t8),
-                        detail::assign_to_pointee<T9>(&t9));
-    }
-    // Tie variables into a tuple
-    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
-    inline
-    tuple<detail::assign_to_pointee<T1>, 
-      detail::assign_to_pointee<T2>, 
-      detail::assign_to_pointee<T3>, 
-      detail::assign_to_pointee<T4>, 
-      detail::assign_to_pointee<T5>, 
-      detail::assign_to_pointee<T6>, 
-      detail::assign_to_pointee<T7>, 
-      detail::assign_to_pointee<T8>, 
-      detail::assign_to_pointee<T9>, 
-      detail::assign_to_pointee<T10> >
-    tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10)
-    {
-      return make_tuple(detail::assign_to_pointee<T1>(&t1),
-                        detail::assign_to_pointee<T2>(&t2),
-                        detail::assign_to_pointee<T3>(&t3),
-                        detail::assign_to_pointee<T4>(&t4),
-                        detail::assign_to_pointee<T5>(&t5),
-                        detail::assign_to_pointee<T6>(&t6),
-                        detail::assign_to_pointee<T7>(&t7),
-                        detail::assign_to_pointee<T8>(&t8),
-                        detail::assign_to_pointee<T9>(&t9),
-                        detail::assign_to_pointee<T10>(&t10));
-    }
-    // "ignore" allows tuple positions to be ignored when using "tie". 
-    namespace {
-      detail::swallow_assign ignore;
-    }
-
-} // namespace tuples
-} // namespace boost
-#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP

include/boost/tuple/tuple.hpp

@@ -1,45 +1,41 @@
 //  tuple.hpp - Boost Tuple Library --------------------------------------
 
-// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //
-// Permission to copy, use, sell and distribute this software is granted
+// Distributed under the Boost Software License, Version 1.0. (See
-// provided this copyright notice appears in all copies. 
+// accompanying file LICENSE_1_0.txt or copy at
-// Permission to modify the code and to distribute modified code is granted
+// http://www.boost.org/LICENSE_1_0.txt)
-// provided this copyright notice appears in all copies, and a notice 
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
 
 // For more information, see http://www.boost.org
 
-// ----------------------------------------------------------------- 
+// -----------------------------------------------------------------
 
 #ifndef BOOST_TUPLE_HPP
 #define BOOST_TUPLE_HPP
 
-#include "boost/config.hpp"
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
-#include "boost/static_assert.hpp"
+// Work around a compiler bug.
+// boost::python::tuple has to be seen by the compiler before the
+// boost::tuple class template.
+namespace boost { namespace python { class tuple; }}
+#endif
 
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#include <boost/config.hpp>
-// The MSVC version
+#include <boost/static_assert.hpp>
-#include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp"
 
-#else
 // other compilers
-#include "boost/ref.hpp"
+#include <boost/core/ref.hpp>
-#include "boost/tuple/detail/tuple_basic.hpp"
+#include <boost/tuple/detail/tuple_basic.hpp>
 
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
-namespace boost {    
+namespace boost {
 
 using tuples::tuple;
 using tuples::make_tuple;
 using tuples::tie;
 #if !defined(BOOST_NO_USING_TEMPLATE)
 using tuples::get;
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else
 //
 // The "using tuples::get" statement causes the
 // Borland compiler to ICE, use forwarding
@@ -51,7 +47,7 @@ inline typename tuples::access_traits<
                 >::non_const_type
 get(tuples::cons<HT, TT>& c) {
   return tuples::get<N,HT,TT>(c);
-} 
+}
 // get function for const cons-lists, returns a const reference to
 // the element. If the element is a reference, returns the reference
 // as such (that is, can return a non-const reference)
@@ -62,27 +58,61 @@ inline typename tuples::access_traits<
 get(const tuples::cons<HT, TT>& c) {
   return tuples::get<N,HT,TT>(c);
 }
-#else  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//
-// MSVC, using declarations don't mix with templates well,
-// so use forwarding functions instead:
-//
-template<int N, typename Head, typename Tail>
-typename tuples::detail::element_ref<N, tuples::cons<Head, Tail> >::RET
-get(tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
-{
-   return tuples::detail::get_class<N>::get(t);
-}
 
-template<int N, typename Head, typename Tail>
-typename tuples::detail::element_const_ref<N, tuples::cons<Head, Tail> >::RET
-get(const tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
-{
-   return tuples::detail::get_class<N>::get(t);
-}
 #endif // BOOST_NO_USING_TEMPLATE
-   
+
 } // end namespace boost
 
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+
+#include <tuple>
+#include <cstddef>
+
+namespace std
+{
+
+#if defined(BOOST_CLANG)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+
+// std::tuple_size
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
+    class tuple_size< boost::tuples::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >:
+        public boost::tuples::length< boost::tuples::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >
+{
+};
+
+template<class H, class T> class tuple_size< boost::tuples::cons<H, T> >:
+    public boost::tuples::length< boost::tuples::cons<H, T> >
+{
+};
+
+template<> class tuple_size< boost::tuples::null_type >:
+    public boost::tuples::length< boost::tuples::null_type >
+{
+};
+
+// std::tuple_element
+
+template<std::size_t I, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
+    class tuple_element< I, boost::tuples::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >:
+        public boost::tuples::element< I, boost::tuples::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >
+{
+};
+
+template<std::size_t I, class H, class T> class tuple_element< I, boost::tuples::cons<H, T> >:
+    public boost::tuples::element< I, boost::tuples::cons<H, T> >
+{
+};
+
+#if defined(BOOST_CLANG)
+# pragma clang diagnostic pop
+#endif
+
+} // namespace std
+
+#endif // !defined(BOOST_NO_CXX11_HDR_TUPLE)
 
 #endif // BOOST_TUPLE_HPP

include/boost/tuple/tuple_comparison.hpp

@@ -1,36 +1,31 @@
 // tuple_comparison.hpp -----------------------------------------------------
-//  
+//
-// Copyright (C) 2001 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute this software is granted
+// Distributed under the Boost Software License, Version 1.0. (See
-// provided this copyright notice appears in all copies. 
+// accompanying file LICENSE_1_0.txt or copy at
-// Permission to modify the code and to distribute modified code is granted
+// http://www.boost.org/LICENSE_1_0.txt)
-// provided this copyright notice appears in all copies, and a notice 
+//
-// that the code was modified is included with the copyright notice.
-// 
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-// 
 // For more information, see http://www.boost.org
-// 
+//
 // (The idea and first impl. of comparison operators was from Doug Gregor)
 
-// ----------------------------------------------------------------- 
+// -----------------------------------------------------------------
 
 #ifndef BOOST_TUPLE_COMPARISON_HPP
 #define BOOST_TUPLE_COMPARISON_HPP
 
-#include "boost/tuple/tuple.hpp"
+#include <boost/tuple/tuple.hpp>
 
 // -------------------------------------------------------------
-// equality and comparison operators 
+// equality and comparison operators
 //
 // == and != compare tuples elementwise
 // <, >, <= and >= use lexicographical ordering
 //
 // Any operator between tuples of different length fails at compile time
-// No dependencies between operators are assumed 
+// No dependencies between operators are assumed
 // (i.e. !(a<b)  does not imply a>=b, a!=b does not imply a==b etc.
 // so any weirdnesses of elementary operators are respected).
 //
@@ -51,7 +46,7 @@ inline bool operator>(const null_type&, const null_type&) { return false; }
 namespace detail {
   // comparison operators check statically the length of its operands and
   // delegate the comparing task to the following functions. Hence
-  // the static check is only made once (should help the compiler).  
+  // the static check is only made once (should help the compiler).
   // These functions assume tuples to be of the same length.
 
 
@@ -74,8 +69,8 @@ inline bool neq<null_type,null_type>(const null_type&, const null_type&) { retur
 template<class T1, class T2>
 inline bool lt(const T1& lhs, const T2& rhs) {
   return lhs.get_head() < rhs.get_head()  ||
-            !(rhs.get_head() < lhs.get_head()) &&
+          ( !(rhs.get_head() < lhs.get_head()) &&
-            lt(lhs.get_tail(), rhs.get_tail());
+            lt(lhs.get_tail(), rhs.get_tail()));
 }
 template<>
 inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; }
@@ -83,8 +78,8 @@ inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return
 template<class T1, class T2>
 inline bool gt(const T1& lhs, const T2& rhs) {
   return lhs.get_head() > rhs.get_head()  ||
-            !(rhs.get_head() > lhs.get_head()) &&
+          ( !(rhs.get_head() > lhs.get_head()) &&
-            gt(lhs.get_tail(), rhs.get_tail());
+            gt(lhs.get_tail(), rhs.get_tail()));
 }
 template<>
 inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; }

include/boost/tuple/tuple_io.hpp

@@ -1,40 +1,41 @@
 // tuple_io.hpp --------------------------------------------------------------
 
-// Copyright (C) 2001 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //               2001 Gary Powell (gary.powell@sierra.com)
 //
-// Permission to copy, use, sell and distribute this software is granted
+// Distributed under the Boost Software License, Version 1.0. (See
-// provided this copyright notice appears in all copies. 
+// accompanying file LICENSE_1_0.txt or copy at
-// Permission to modify the code and to distribute modified code is granted
+// http://www.boost.org/LICENSE_1_0.txt)
-// provided this copyright notice appears in all copies, and a notice 
+// For more information, see http://www.boost.org
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty, 
-// and with no claim as to its suitability for any purpose.
-// For more information, see http://www.boost.org 
 
 // ----------------------------------------------------------------------------
 
 #ifndef BOOST_TUPLE_IO_HPP
 #define BOOST_TUPLE_IO_HPP
 
-
-// add to boost/config.hpp
-// for now
-# if defined __GNUC__
-#   if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) 
-#define BOOST_NO_TEMPLATED_STREAMS
-#endif
-#endif // __GNUC__
-
-#if defined BOOST_NO_TEMPLATED_STREAMS
-#include <iostream>
-#else 
 #include <istream>
 #include <ostream>
-#endif  
 
-#include "boost/tuple/tuple.hpp"
+#include <sstream>
+
+#include <boost/tuple/tuple.hpp>
+
+// This is ugly: one should be using twoargument isspace since whitspace can
+// be locale dependent, in theory at least.
+// not all libraries implement have the two-arg version, so we need to
+// use the one-arg one, which one should get with <cctype> but there seem
+// to be exceptions to this.
+
+#if !defined (BOOST_NO_STD_LOCALE)
+
+#include <locale> // for two-arg isspace
+
+#else
+
+#include <cctype> // for one-arg (old) isspace
+#include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
+
+#endif
 
 namespace boost {
 namespace tuples {
@@ -42,12 +43,12 @@ namespace tuples {
 namespace detail {
 
 class format_info {
-public:   
+public:
 
    enum manipulator_type { open, close, delimiter };
    BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1);
 private:
-   
+
    static int get_stream_index (int m)
    {
      static const int stream_index[number_of_manipulators]
@@ -57,44 +58,25 @@ private:
    }
 
    format_info(const format_info&);
-   format_info();   
+   format_info();
 
 
 public:
 
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-   static char get_manipulator(std::ios& i, manipulator_type m) {
-     char c = static_cast<char>(i.iword(get_stream_index(m))); 
-     
-     // parentheses and space are the default manipulators
-     if (!c) {
-       switch(m) {
-         case open : c = '('; break;
-         case close : c = ')'; break;
-         case delimiter : c = ' '; break;
-       }
-     }
-     return c;
-   }
-
-   static void set_manipulator(std::ios& i, manipulator_type m, char c) {
-      i.iword(get_stream_index(m)) = static_cast<long>(c);
-   }
-#else
    template<class CharType, class CharTrait>
-   static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& i, 
+   static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& i,
                                    manipulator_type m) {
      // The manipulators are stored as long.
      // A valid instanitation of basic_stream allows CharType to be any POD,
-     // hence, the static_cast may fail (it fails if long is not convertible 
+     // hence, the static_cast may fail (it fails if long is not convertible
      // to CharType
-     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); 
+     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) );
      // parentheses and space are the default manipulators
      if (!c) {
        switch(m) {
-         case open :  c = i.widen('('); break;
+         case detail::format_info::open :  c = i.widen('('); break;
-         case close : c = i.widen(')'); break;
+         case detail::format_info::close : c = i.widen(')'); break;
-         case delimiter : c = i.widen(' '); break;
+         case detail::format_info::delimiter : c = i.widen(' '); break;
        }
      }
      return c;
@@ -102,61 +84,33 @@ public:
 
 
    template<class CharType, class CharTrait>
-   static void set_manipulator(std::basic_ios<CharType, CharTrait>& i, 
+   static void set_manipulator(std::basic_ios<CharType, CharTrait>& i,
                                manipulator_type m, CharType c) {
      // The manipulators are stored as long.
      // A valid instanitation of basic_stream allows CharType to be any POD,
-     // hence, the static_cast may fail (it fails if CharType is not 
+     // hence, the static_cast may fail (it fails if CharType is not
      // convertible long.
       i.iword(get_stream_index(m)) = static_cast<long>(c);
    }
-#endif // BOOST_NO_TEMPLATED_STREAMS
 };
 
 } // end of namespace detail
- 
+
-template<class CharType>    
+template<class CharType>
 class tuple_manipulator {
   const detail::format_info::manipulator_type mt;
   CharType f_c;
 public:
-  explicit tuple_manipulator(detail::format_info::manipulator_type m, 
+  explicit tuple_manipulator(detail::format_info::manipulator_type m,
-                             const char c = 0)
+                             CharType c = CharType())
      : mt(m), f_c(c) {}
-  
+
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-  void set(std::ios &io) const {
-     detail::format_info::set_manipulator(io, mt, f_c);
-  }
-#else
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-   template<class CharType2, class CharTrait>
-  void set(std::basic_ios<CharType2, CharTrait> &io) const {
-     detail::format_info::set_manipulator(io, mt, f_c);
-  }
-#else
    template<class CharTrait>
   void set(std::basic_ios<CharType, CharTrait> &io) const {
      detail::format_info::set_manipulator(io, mt, f_c);
   }
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#endif // BOOST_NO_TEMPLATED_STREAMS
 };
 
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-inline std::ostream&
-operator<<(std::ostream& o, const tuple_manipulator<char>& m) {
-  m.set(o);
-  return o;
-}
-
-inline std::istream&
-operator>>(std::istream& i, const tuple_manipulator<char>& m) {
-  m.set(i);
-  return i;
-}
-
-#else
 
 template<class CharType, class CharTrait>
 inline std::basic_ostream<CharType, CharTrait>&
@@ -172,8 +126,7 @@ operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<C
   return i;
 }
 
-#endif   // BOOST_NO_TEMPLATED_STREAMS
+
-   
 template<class CharType>
 inline tuple_manipulator<CharType> set_open(const CharType c) {
    return tuple_manipulator<CharType>(detail::format_info::open, c);
@@ -191,271 +144,158 @@ inline tuple_manipulator<CharType> set_delimiter(const CharType c) {
 
 
 
-   
+
-   
+
 // -------------------------------------------------------------
 // printing tuples to ostream in format (a b c)
 // parentheses and space are defaults, but can be overriden with manipulators
 // set_open, set_close and set_delimiter
-   
+
 namespace detail {
 
-// Note: The order of the print functions is critical 
+// Note: The order of the print functions is critical
 // to let a conforming compiler  find and select the correct one.
 
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-template<class T1>
-inline std::ostream& print(std::ostream& o, const cons<T1, null_type>& t) {
-  return o << t.head;
-}
-#endif // BOOST_NO_TEMPLATED_STREAMS
- 
-inline std::ostream& print(std::ostream& o, const null_type&) { return o; }
-
-template<class T1, class T2>
-inline std::ostream& 
-print(std::ostream& o, const cons<T1, T2>& t) {
-  
-  const char d = format_info::get_manipulator(o, format_info::delimiter);
-   
-  o << t.head;
-
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuples::length<T2>::value == 0)
-    return o;
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  o << d;
-  
-  return print(o, t.tail );
-
-}
-
-
-
-#else
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 template<class CharType, class CharTrait, class T1>
-inline std::basic_ostream<CharType, CharTrait>& 
+inline std::basic_ostream<CharType, CharTrait>&
 print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, null_type>& t) {
   return o << t.head;
 }
-#endif  // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
- 
+
 template<class CharType, class CharTrait>
-inline std::basic_ostream<CharType, CharTrait>& 
+inline std::basic_ostream<CharType, CharTrait>&
-print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) { 
+print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) {
-  return o; 
+  return o;
 }
 
 template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_ostream<CharType, CharTrait>& 
+inline std::basic_ostream<CharType, CharTrait>&
 print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
-  
+
   const CharType d = format_info::get_manipulator(o, format_info::delimiter);
-   
+
   o << t.head;
 
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuples::length<T2>::value == 0)
-    return o;
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   o << d;
 
   return print(o, t.tail);
 }
 
-#endif  // BOOST_NO_TEMPLATED_STREAMS
+template<class CharT, class Traits, class T>
+inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) {
+    std::streamsize width = o.width();
+    if(width == 0) return false;
+
+    std::basic_ostringstream<CharT, Traits> ss;
+
+    ss.copyfmt(o);
+    ss.tie(0);
+    ss.width(0);
+
+    ss << t;
+    o << ss.str();
+
+    return true;
+}
+
 
 } // namespace detail
 
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-template<class T1, class T2>
-inline std::ostream& operator<<(std::ostream& o, const cons<T1, T2>& t) {
-  if (!o.good() ) return o;
- 
-  const char l = 
-    detail::format_info::get_manipulator(o, detail::format_info::open);
-  const char r = 
-    detail::format_info::get_manipulator(o, detail::format_info::close);
-   
-  o << l;
-  
-  detail::print(o, t);  
 
+template<class CharType, class CharTrait>
+inline std::basic_ostream<CharType, CharTrait>&
+operator<<(std::basic_ostream<CharType, CharTrait>& o,
+           const null_type& t) {
+  if (!o.good() ) return o;
+  if (detail::handle_width(o, t)) return o;
+
+  const CharType l =
+    detail::format_info::get_manipulator(o, detail::format_info::open);
+  const CharType r =
+    detail::format_info::get_manipulator(o, detail::format_info::close);
+
+  o << l;
   o << r;
 
   return o;
 }
 
-#else
-
 template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_ostream<CharType, CharTrait>& 
+inline std::basic_ostream<CharType, CharTrait>&
-operator<<(std::basic_ostream<CharType, CharTrait>& o, 
+operator<<(std::basic_ostream<CharType, CharTrait>& o,
            const cons<T1, T2>& t) {
   if (!o.good() ) return o;
- 
+  if (detail::handle_width(o, t)) return o;
-  const CharType l = 
-    detail::format_info::get_manipulator(o, detail::format_info::open);
-  const CharType r = 
-    detail::format_info::get_manipulator(o, detail::format_info::close);
-   
-  o << l;   
 
-  detail::print(o, t);  
+  const CharType l =
+    detail::format_info::get_manipulator(o, detail::format_info::open);
+  const CharType r =
+    detail::format_info::get_manipulator(o, detail::format_info::close);
+
+  o << l;
+
+  detail::print(o, t);
 
   o << r;
 
   return o;
 }
-#endif // BOOST_NO_TEMPLATED_STREAMS
 
-   
+
 // -------------------------------------------------------------
 // input stream operators
 
 namespace detail {
 
-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-
-inline std::istream& 
-extract_and_check_delimiter(
-  std::istream& is, format_info::manipulator_type del)
-{
-  const char d = format_info::get_manipulator(is, del);
-
-  const bool is_delimiter = (!isspace(d) );      
-
-  char c;
-  if (is_delimiter) { 
-    is >> c; 
-    if (c!=d) {
-      is.setstate(std::ios::failbit);
-    } 
-  }
-  return is;
-}
-
-
-// Note: The order of the read functions is critical to let a 
-// (conforming?) compiler find and select the correct one.
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-template<class T1>
-inline  std::istream & 
-read (std::istream &is, cons<T1, null_type>& t1) {
-
-  if (!is.good()) return is;   
-   
-  return is >> t1.head ;
-}
-#else
-inline std::istream& read(std::istream& i, const null_type&) { return i; }
-#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   
-template<class T1, class T2>
-inline std::istream& 
-read(std::istream &is, cons<T1, T2>& t1) {
-
-  if (!is.good()) return is;
-   
-  is >> t1.head;
-
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuples::length<T2>::value == 0)
-    return is;
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-  extract_and_check_delimiter(is, format_info::delimiter);
-
-  return read(is, t1.tail);
-}
-
-} // end namespace detail
-
-inline std::istream& 
-operator>>(std::istream &is, null_type&) {
-
-  if (!is.good() ) return is;
-
-  detail::extract_and_check_delimiter(is, detail::format_info::open);
-  detail::extract_and_check_delimiter(is, detail::format_info::close);
-
-  return is;
-}
-
-
-template<class T1, class T2>
-inline std::istream& 
-operator>>(std::istream& is, cons<T1, T2>& t1) {
-
-  if (!is.good() ) return is;
-
-  detail::extract_and_check_delimiter(is, detail::format_info::open);
-                      
-  detail::read(is, t1);
-   
-  detail::extract_and_check_delimiter(is, detail::format_info::close);
-
-  return is;
-}
-
-
-
-#else
 
 template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>& 
+inline std::basic_istream<CharType, CharTrait>&
 extract_and_check_delimiter(
   std::basic_istream<CharType, CharTrait> &is, format_info::manipulator_type del)
 {
   const CharType d = format_info::get_manipulator(is, del);
 
-  const bool is_delimiter = (!isspace(d) );      
+#if defined (BOOST_NO_STD_LOCALE)
+  const bool is_delimiter = !isspace(d);
+#elif defined ( BOOST_BORLANDC )
+  const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
+    (is.getloc() ).is( std::ctype_base::space, d);
+#else
+  const bool is_delimiter = (!std::isspace(d, is.getloc()) );
+#endif
 
   CharType c;
-  if (is_delimiter) { 
+  if (is_delimiter) {
     is >> c;
-    if (c!=d) { 
+    if (is.good() && c!=d) {
       is.setstate(std::ios::failbit);
     }
+  } else {
+    is >> std::ws;
   }
   return is;
 }
 
-   
+
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 template<class CharType, class CharTrait, class T1>
-inline  std::basic_istream<CharType, CharTrait> & 
+inline  std::basic_istream<CharType, CharTrait> &
 read (std::basic_istream<CharType, CharTrait> &is, cons<T1, null_type>& t1) {
 
-  if (!is.good()) return is;   
+  if (!is.good()) return is;
-   
-  return is >> t1.head; 
-}
-#else
-template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>& 
-read(std::basic_istream<CharType, CharTrait>& i, const null_type&) { return i; }
 
-#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  return is >> t1.head;
+}
 
 template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_istream<CharType, CharTrait>& 
+inline std::basic_istream<CharType, CharTrait>&
 read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
 
   if (!is.good()) return is;
-   
+
   is >> t1.head;
 
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  if (tuples::length<T2>::value == 0)
-    return is;
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
   extract_and_check_delimiter(is, format_info::delimiter);
 
@@ -466,7 +306,7 @@ read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
 
 
 template<class CharType, class CharTrait>
-inline std::basic_istream<CharType, CharTrait>& 
+inline std::basic_istream<CharType, CharTrait>&
 operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {
 
   if (!is.good() ) return is;
@@ -478,25 +318,22 @@ operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {
 }
 
 template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_istream<CharType, CharTrait>& 
+inline std::basic_istream<CharType, CharTrait>&
 operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
 
   if (!is.good() ) return is;
 
   detail::extract_and_check_delimiter(is, detail::format_info::open);
-                      
+
   detail::read(is, t1);
-   
+
   detail::extract_and_check_delimiter(is, detail::format_info::close);
 
   return is;
 }
 
-#endif // BOOST_NO_TEMPLATED_STREAMS
 
 } // end of namespace tuples
 } // end of namespace boost
 
 #endif // BOOST_TUPLE_IO_HPP
-
-

index.html

@@ -0,0 +1,13 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=doc/html/tuple_users_guide.html">
+</head>
+<body>
+Automatic redirection failed, please go to <a href="doc/html/tuple_users_guide.html">doc/html/tuple_users_guide.html</a> 
+&nbsp;<hr>
+<p><EFBFBD> Copyright Beman Dawes, 2001</p>
+<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
+file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
+at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
+</html>

meta/libraries.json

@@ -0,0 +1,18 @@
+{
+    "key": "tuple",
+    "name": "Tuple",
+    "authors": [
+        "Jaakko Järvi"
+    ],
+    "description": "Ease definition of functions returning multiple values, and more.",
+    "std": [
+        "tr1"
+    ],
+    "category": [
+        "Data"
+    ],
+    "maintainers": [
+        "Jaakko Jarvi <jarvi -at- cs.tamu.edu>"
+    ],
+    "cxxstd": "03"
+}

test/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright 2018, 2019 Peter Dimov
+# 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(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
+
+if(HAVE_BOOST_TEST)
+
+boost_test_jamfile(FILE Jamfile LINK_LIBRARIES Boost::tuple Boost::core)
+
+endif()

test/Jamfile

@@ -0,0 +1,12 @@
+# Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+# Distributed under the Boost Software License, Version 1.0.
+
+import testing ;
+
+run tuple_test_bench.cpp ;
+run io_test.cpp ;
+run another_tuple_test_bench.cpp ;
+run std_tuple_size.cpp ;
+run std_tuple_element.cpp ;
+run structured_bindings.cpp ;
+run quick.cpp ;

test/another_tuple_test_bench.cpp

@@ -1,3 +1,12 @@
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+// 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)
+
+// For more information, see http://www.boost.org
+
+
 //  another_test_bench.cpp  --------------------------------
 
 // This file has various tests to see that things that shouldn't
@@ -6,15 +15,13 @@
 // Defining any of E1 to E5 or E7 to E11 opens some illegal code that 
 // should cause the compliation to fail.
 
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
-#include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
-
 #include "boost/tuple/tuple.hpp"
 
+#include "boost/core/lightweight_test.hpp"
+
 #include <string>
 #include <utility>
 
-using namespace std;
 using namespace boost;
 using namespace boost::tuples;
 
@@ -89,12 +96,11 @@ void foo2() {
 
 void foo4() 
 {
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   double d = 2.7; 
   A a;
   tuple<int, double&, const A&> t(1, d, a);
   const tuple<int, double&, const A> ct = t;
-
+  (void)ct;
 #ifdef E8
   get<0>(ct) = 5; // can't assign to const
 #endif
@@ -105,8 +111,6 @@ void foo4()
 #ifdef E10
   dummy(get<5>(ct)); // illegal index
 #endif
-
-#endif
 }
 
 // testing copy and assignment with implicit conversions between elements
@@ -119,9 +123,10 @@ void foo4()
 
   void foo5() {
     tuple<char, BB*, BB, DD> t;
-
+    (void)t;
     tuple<char, char> aaa;
     tuple<int, int> bbb(aaa);
+    (void)bbb;
     //    tuple<int, AA*, CC, CC> a = t;
     //    a = t;
   }
@@ -143,7 +148,7 @@ void foo7() {
 
 // --------------------------------
 // ----------------------------
-int test_main(int, char *[]) {
+int main() {
 
   foo1();
   foo2();
@@ -153,5 +158,5 @@ int test_main(int, char *[]) {
 
   foo7();
 
-  return 0;
+  return boost::report_errors();
 }

test/cmake_install_test/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Copyright 2018, 2019 Peter Dimov
+# 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
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(cmake_install_test LANGUAGES CXX)
+
+find_package(boost_tuple REQUIRED)
+
+add_executable(main main.cpp)
+target_link_libraries(main Boost::tuple)
+
+enable_testing()
+add_test(main main)
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/cmake_install_test/main.cpp

@@ -0,0 +1,18 @@
+// Copyright 2017, 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/tuple/tuple.hpp>
+#include <cassert>
+
+#define BOOST_TEST(expr) assert(expr)
+#define BOOST_TEST_EQ(x1, x2) assert((x1)==(x2))
+
+int main()
+{
+    boost::tuple<int, int, int> tp( 1, 2, 3 );
+
+    BOOST_TEST_EQ( boost::get<0>(tp), 1 );
+    BOOST_TEST_EQ( boost::get<1>(tp), 2 );
+    BOOST_TEST_EQ( boost::get<2>(tp), 3 );
+}

test/cmake_subdir_test/CMakeLists.txt

@@ -0,0 +1,40 @@
+# Copyright 2018, 2019 Peter Dimov
+# 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
+
+cmake_minimum_required(VERSION 3.5...3.20)
+
+project(cmake_subdir_test LANGUAGES CXX)
+
+add_subdirectory(../.. boostorg/tuple)
+
+set(deps
+
+# Primary dependencies
+
+config
+core
+static_assert
+type_traits
+
+# Secondary dependencies
+
+assert
+throw_exception
+)
+
+foreach(dep IN LISTS deps)
+
+  add_subdirectory(../../../${dep} boostorg/${dep})
+
+endforeach()
+
+# --target check
+
+add_executable(quick ../quick.cpp)
+target_link_libraries(quick Boost::tuple Boost::core)
+
+enable_testing()
+add_test(quick quick)
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/io_test.cpp

@@ -1,17 +1,28 @@
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+// 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)
+
+// For more information, see http://www.boost.org
+
 // -- io_test.cpp -----------------------------------------------
 //
 // Testing the I/O facilities of tuples
 
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
+#define _CRT_SECURE_NO_WARNINGS // std::tmpnam
-#include "boost/test/test_tools.hpp"    // see "Header Implementation Option"
 
 #include "boost/tuple/tuple_io.hpp"
 #include "boost/tuple/tuple_comparison.hpp"
 
+#include "boost/core/lightweight_test.hpp"
+
 #include <fstream>
 #include <iterator>
 #include <algorithm>
 #include <string>
+#include <iomanip>
+#include <cstdio>
 
 #if defined BOOST_NO_STRINGSTREAM
 #include <strstream>
@@ -19,21 +30,19 @@
 #include <sstream>
 #endif
 
-#include "boost/config.hpp"
+#define BOOST_CHECK BOOST_TEST
 
-using namespace std;
 using namespace boost;
 
 #if defined BOOST_NO_STRINGSTREAM
-typedef ostrstream useThisOStringStream;
+typedef std::ostrstream useThisOStringStream;
-typedef istrstream useThisIStringStream;
+typedef std::istrstream useThisIStringStream;
 #else
-typedef ostringstream useThisOStringStream;
+typedef std::ostringstream useThisOStringStream;
-typedef istringstream useThisIStringStream;
+typedef std::istringstream useThisIStringStream;
 #endif
 
-int test_main(int argc, char * argv[] ) {
+int main() {
-
    using boost::tuples::set_close;
    using boost::tuples::set_open;
    using boost::tuples::set_delimiter;
@@ -45,7 +54,7 @@ int test_main(int argc, char * argv[] ) {
   os1 << set_close(']');
   os1 << set_delimiter(',');
   os1 << make_tuple(1, 2, 3);
-  BOOST_TEST (os1.str() == std::string("[1,2,3]") );
+  BOOST_CHECK (os1.str() == std::string("[1,2,3]") );
 
   {
   useThisOStringStream os2;
@@ -55,54 +64,84 @@ int test_main(int argc, char * argv[] ) {
   os2 << set_delimiter(':');
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   os2 << make_tuple("TUPU", "HUPU", "LUPU", 4.5);
-  BOOST_TEST (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
+  BOOST_CHECK (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
 #endif
   }
 
   // The format is still [a, b, c] for os1
   os1 << make_tuple(1, 2, 3);
-  BOOST_TEST (os1.str() == std::string("[1,2,3][1,2,3]") );
+  BOOST_CHECK (os1.str() == std::string("[1,2,3][1,2,3]") );
 
-  ofstream tmp("temp.tmp");
+  // check empty tuple.
+  useThisOStringStream os3;
+  os3 << make_tuple();
+  BOOST_CHECK (os3.str() == std::string("()") );
+  os3 << set_open('[');
+  os3 << set_close(']');
+  os3 << make_tuple();
+  BOOST_CHECK (os3.str() == std::string("()[]") );
+  
+  // check width
+  useThisOStringStream os4;
+  os4 << std::setw(10) << make_tuple(1, 2, 3);
+  BOOST_CHECK (os4.str() == std::string("   (1 2 3)") );
+
+  std::string fn = std::tmpnam( 0 );
+
+  std::ofstream tmp( fn.c_str() );
 
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   tmp << make_tuple("One", "Two", 3);
 #endif   
   tmp << set_delimiter(':');
-  tmp << make_tuple(1000, 2000, 3000) << endl;
+  tmp << make_tuple(1000, 2000, 3000) << std::endl;
 
   tmp.close();
   
   // When teading tuples from a stream, manipulators must be set correctly:
-  ifstream tmp3("temp.tmp");
+  std::ifstream tmp3( fn.c_str() );
-  tuple<string, string, int> j;
+  tuple<std::string, std::string, int> j;
 
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   tmp3 >> j; 
-  BOOST_TEST (tmp3.good() ); 
+  BOOST_CHECK (tmp3.good() ); 
 #endif
    
   tmp3 >> set_delimiter(':');
   tuple<int, int, int> i;
   tmp3 >> i; 
-  BOOST_TEST (tmp3.good() ); 
+  BOOST_CHECK (tmp3.good() ); 
    
   tmp3.close(); 
 
+  std::remove( fn.c_str() );
 
   // reading tuple<int, int, int> in format (a b c); 
-  useThisIStringStream is("(100 200 300)"); 
+  useThisIStringStream is1("(100 200 300)"); 
    
-  tuple<int, int, int> ti; 
+  tuple<int, int, int> ti1; 
-  BOOST_TEST(is >> ti);
+  BOOST_CHECK(bool(is1 >> ti1));
-  BOOST_TEST(ti == make_tuple(100, 200, 300));
+  BOOST_CHECK(ti1 == make_tuple(100, 200, 300));
+
+  useThisIStringStream is2("()");
+  tuple<> ti2;
+  BOOST_CHECK(bool(is2 >> ti2));
+  useThisIStringStream is3("[]");
+  is3 >> set_open('[');
+  is3 >> set_close(']');
+  BOOST_CHECK(bool(is3 >> ti2));
+
+  // Make sure that whitespace between elements
+  // is skipped.
+  useThisIStringStream is4("(100 200 300)"); 
    
+  BOOST_CHECK(bool(is4 >> std::noskipws >> ti1));
+  BOOST_CHECK(ti1 == make_tuple(100, 200, 300));
 
   // Note that strings are problematic:
   // writing a tuple on a stream and reading it back doesn't work in
   // general. If this is wanted, some kind of a parseable string class
   // should be used.
   
-  return 0;
+  return boost::report_errors();
 }
-

test/quick.cpp

@@ -0,0 +1,16 @@
+// Copyright 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    boost::tuple<int, int, int> tp( 1, 2, 3 );
+
+    BOOST_TEST_EQ( boost::get<0>(tp), 1 );
+    BOOST_TEST_EQ( boost::get<1>(tp), 2 );
+    BOOST_TEST_EQ( boost::get<2>(tp), 3 );
+
+    return boost::report_errors();
+}

test/std_tuple_element.cpp

@@ -0,0 +1,56 @@
+// Copyright 2017 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX11_HDR_TUPLE)
+
+BOOST_PRAGMA_MESSAGE("Skipping std::tuple_element tests for lack of <tuple>")
+int main() {}
+
+#else
+
+#include <tuple>
+
+template<class Tp, std::size_t I, class E> void test()
+{
+    BOOST_TEST_TRAIT_TRUE((boost::is_same<typename std::tuple_element<I, Tp>::type, E>));
+
+    typedef typename Tp::inherited Tp2;
+    BOOST_TEST_TRAIT_TRUE((boost::is_same<typename std::tuple_element<I, Tp2>::type, E>));
+}
+
+template<int> struct X
+{
+};
+
+int main()
+{
+    test<boost::tuple<X<0> const>, 0, X<0> const>();
+
+    test<boost::tuple<X<0> const, X<1> const>, 0, X<0> const>();
+    test<boost::tuple<X<0> const, X<1> const>, 1, X<1> const>();
+
+    test<boost::tuple<X<0> const, X<1> const, X<2> const>, 0, X<0> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const>, 1, X<1> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const>, 2, X<2> const>();
+
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const>, 0, X<0> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const>, 1, X<1> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const>, 2, X<2> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const>, 3, X<3> const>();
+
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 0, X<0> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 1, X<1> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 2, X<2> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 3, X<3> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 4, X<4> const>();
+
+    return boost::report_errors();
+}
+
+#endif

test/std_tuple_size.cpp

@@ -0,0 +1,61 @@
+// Copyright 2017 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX11_HDR_TUPLE)
+
+BOOST_PRAGMA_MESSAGE("Skipping std::tuple_size tests for lack of <tuple>")
+int main() {}
+
+#else
+
+#include <tuple>
+
+template<class Tp> void test( std::size_t x )
+{
+    BOOST_TEST_EQ( std::tuple_size< Tp >::value, x );
+    BOOST_TEST_EQ( std::tuple_size< typename Tp::inherited >::value, x );
+}
+
+struct V
+{
+};
+
+int main()
+{
+    test< boost::tuple<> >( 0 );
+    test< boost::tuple<V> >( 1 );
+    test< boost::tuple<V, V> >( 2 );
+    test< boost::tuple<V, V, V> >( 3 );
+    test< boost::tuple<V, V, V, V> >( 4 );
+    test< boost::tuple<V, V, V, V, V> >( 5 );
+    test< boost::tuple<V, V, V, V, V, V> >( 6 );
+    test< boost::tuple<V, V, V, V, V, V, V> >( 7 );
+    test< boost::tuple<V, V, V, V, V, V, V, V> >( 8 );
+    test< boost::tuple<V, V, V, V, V, V, V, V, V> >( 9 );
+    test< boost::tuple<V, V, V, V, V, V, V, V, V, V> >( 10 );
+
+#if !defined(BOOST_NO_CXX11_DECLTYPE)
+
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple())>::value, 0 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1))>::value, 1 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2))>::value, 2 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3))>::value, 3 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4))>::value, 4 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5))>::value, 5 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6))>::value, 6 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6, 7))>::value, 7 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6, 7, 8))>::value, 8 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6, 7, 8, 9))>::value, 9 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))>::value, 10 );
+
+#endif
+
+    return boost::report_errors();
+}
+
+#endif

test/structured_bindings.cpp

@@ -0,0 +1,77 @@
+// Copyright 2017 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX17_STRUCTURED_BINDINGS)
+
+BOOST_PRAGMA_MESSAGE("Skipping structured bindings test, not supported")
+int main() {}
+
+#else
+
+int main()
+{
+    // make_tuple
+
+    {
+        auto [x1] = boost::make_tuple( 1 );
+        BOOST_TEST_EQ( x1, 1 );
+    }
+
+    {
+        auto [x1, x2] = boost::make_tuple( 1, 2 );
+        BOOST_TEST_EQ( x1, 1 );
+        BOOST_TEST_EQ( x2, 2 );
+    }
+
+    {
+        auto [x1, x2, x3] = boost::make_tuple( 1, 2, 3 );
+        BOOST_TEST_EQ( x1, 1 );
+        BOOST_TEST_EQ( x2, 2 );
+        BOOST_TEST_EQ( x3, 3 );
+    }
+
+    {
+        auto [x1, x2, x3, x4] = boost::make_tuple( 1, 2, 3, 4 );
+        BOOST_TEST_EQ( x1, 1 );
+        BOOST_TEST_EQ( x2, 2 );
+        BOOST_TEST_EQ( x3, 3 );
+        BOOST_TEST_EQ( x4, 4 );
+    }
+
+    // tuple
+
+    {
+        auto [x1] = boost::tuple<int>( 1 );
+        BOOST_TEST_EQ( x1, 1 );
+    }
+
+    {
+        auto [x1, x2] = boost::tuple<int, int>( 1, 2 );
+        BOOST_TEST_EQ( x1, 1 );
+        BOOST_TEST_EQ( x2, 2 );
+    }
+
+    {
+        auto [x1, x2, x3] = boost::tuple<int, int, int>( 1, 2, 3 );
+        BOOST_TEST_EQ( x1, 1 );
+        BOOST_TEST_EQ( x2, 2 );
+        BOOST_TEST_EQ( x3, 3 );
+    }
+
+    {
+        auto [x1, x2, x3, x4] = boost::tuple<int, int, int, int>( 1, 2, 3, 4 );
+        BOOST_TEST_EQ( x1, 1 );
+        BOOST_TEST_EQ( x2, 2 );
+        BOOST_TEST_EQ( x3, 3 );
+        BOOST_TEST_EQ( x4, 4 );
+    }
+
+    return boost::report_errors();
+}
+
+#endif

test/tuple_test_bench.cpp

@@ -1,16 +1,25 @@
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+// 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)
+
+// For more information, see http://www.boost.org
+
 //  tuple_test_bench.cpp  --------------------------------
 
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
-#include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
-
 #include "boost/tuple/tuple.hpp"
-
 #include "boost/tuple/tuple_comparison.hpp"
 
+#include "boost/type_traits/is_const.hpp"
+#include "boost/ref.hpp"
+#include "boost/core/lightweight_test.hpp"
+
 #include <string>
 #include <utility>
 
-using namespace std;
+#define BOOST_CHECK BOOST_TEST
+
 using namespace boost;
 
 // ----------------------------------------------------------------------------
@@ -66,33 +75,26 @@ public:
 
 typedef tuple<int> t1;
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 typedef tuple<double&, const double&, const double, double*, const double*> t2;
 typedef tuple<A, int(*)(char, int), C> t3;
 typedef tuple<std::string, std::pair<A, B> > t4;
 typedef tuple<A*, tuple<const A*, const B&, C>, bool, void*> t5;
 typedef tuple<volatile int, const volatile char&, int(&)(float) > t6;
 
-# if !defined(__BORLANDC__) || __BORLAND__ > 0x0551
+# if !defined(BOOST_BORLANDC) || BOOST_BORLANDC > 0x0551
 typedef tuple<B(A::*)(C&), A&> t7;
 #endif
 
-#endif
-
 // -----------------------------------------------------------------------
 // -tuple construction tests ---------------------------------------------
 // -----------------------------------------------------------------------
 
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 no_copy y;
 tuple<no_copy&> x = tuple<no_copy&>(y); // ok
-#endif
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 char cs[10];
 tuple<char(&)[10]> v2(cs);  // ok
-#endif
 
 void
 construction_test()
@@ -103,32 +105,32 @@ construction_test()
   // MSVC 6.0 just cannot find get without the namespace qualifier
 
   tuple<int> t1;
-  BOOST_TEST(get<0>(t1) == int());
+  BOOST_CHECK(get<0>(t1) == int());
 
   tuple<float> t2(5.5f);
-  BOOST_TEST(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
+  BOOST_CHECK(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f);
 
   tuple<foo> t3(foo(12));
-  BOOST_TEST(get<0>(t3) == foo(12));
+  BOOST_CHECK(get<0>(t3) == foo(12));
 
   tuple<double> t4(t2);
-  BOOST_TEST(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
+  BOOST_CHECK(get<0>(t4) > 5.4 && get<0>(t4) < 5.6);
 
   tuple<int, float> t5;
-  BOOST_TEST(get<0>(t5) == int());
+  BOOST_CHECK(get<0>(t5) == int());
-  BOOST_TEST(get<1>(t5) == float());
+  BOOST_CHECK(get<1>(t5) == float());
 
   tuple<int, float> t6(12, 5.5f);
-  BOOST_TEST(get<0>(t6) == 12);
+  BOOST_CHECK(get<0>(t6) == 12);
-  BOOST_TEST(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);
+  BOOST_CHECK(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f);
 
   tuple<int, float> t7(t6);
-  BOOST_TEST(get<0>(t7) == 12);
+  BOOST_CHECK(get<0>(t7) == 12);
-  BOOST_TEST(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);
+  BOOST_CHECK(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f);
 
   tuple<long, double> t8(t6);
-  BOOST_TEST(get<0>(t8) == 12);
+  BOOST_CHECK(get<0>(t8) == 12);
-  BOOST_TEST(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);
+  BOOST_CHECK(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f);
 
   dummy(
     tuple<no_def_constructor, no_def_constructor, no_def_constructor>(
@@ -147,12 +149,10 @@ construction_test()
   //  dummy(tuple<double&>()); // should fail, not defaults for references
   //  dummy(tuple<const double&>()); // likewise
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   double dd = 5;
   dummy(tuple<double&>(dd)); // ok
 
   dummy(tuple<const double&>(dd+3.14)); // ok, but dangerous
-#endif
 
   //  dummy(tuple<double&>(dd+3.14)); // should fail,
   //                                  // temporary to non-const reference
@@ -165,7 +165,6 @@ construction_test()
 
 void element_access_test()
 {
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   double d = 2.7;
   A a;
   tuple<int, double&, const A&, int> t(1, d, a, 2);
@@ -174,58 +173,40 @@ void element_access_test()
   int i  = get<0>(t);
   int i2 = get<3>(t);
 
-  BOOST_TEST(i == 1 && i2 == 2);
+  BOOST_CHECK(i == 1 && i2 == 2);
 
   int j  = get<0>(ct);
-  BOOST_TEST(j == 1);
+  BOOST_CHECK(j == 1);
    
   get<0>(t) = 5;
-  BOOST_TEST(t.head == 5);
+  BOOST_CHECK(t.head == 5);
    
   //  get<0>(ct) = 5; // can't assign to const
 
   double e = get<1>(t);
-  BOOST_TEST(e > 2.69 && e < 2.71);
+  BOOST_CHECK(e > 2.69 && e < 2.71);
      
   get<1>(t) = 3.14+i;
-  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
+  BOOST_CHECK(get<1>(t) > 4.13 && get<1>(t) < 4.15);
 
   //  get<4>(t) = A(); // can't assign to const
   //  dummy(get<5>(ct)); // illegal index
 
   ++get<0>(t);
-  BOOST_TEST(get<0>(t) == 6);
+  BOOST_CHECK(get<0>(t) == 6);
+
+  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, tuple<int, float> >::type>::value != true));
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, const tuple<int, float> >::type>::value));
+#endif 
+
+  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<1, tuple<int, float> >::type>::value != true));
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<1, const tuple<int, float> >::type>::value));
+#endif 
+
 
   dummy(i); dummy(i2); dummy(j); dummy(e); // avoid warns for unused variables
-#else
-  double d = 2.7; 
-  A a;
-  tuple<int, double, const A, int> t(1, d, a, 2);
-
-  int i  = get<0>(t);
-  int i2 = get<3>(t);
-
-  BOOST_TEST(i == 1 && i2 == 2);
-   
-  get<0>(t) = 5;
-  BOOST_TEST(t.head == 5);
-   
-  //  get<0>(ct) = 5; // can't assign to const
-
-  double e = get<1>(t);
-  BOOST_TEST(e > 2.69 && e < 2.71);
-     
-  get<1>(t) = 3.14+i;
-  BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
-
-  //  get<4>(t) = A(); // can't assign to const
-  //  dummy(get<5>(ct)); // illegal index
-
-  ++get<0>(t);
-  BOOST_TEST(get<0>(t) == 6);
-
-  dummy(i); dummy(i2); dummy(e); // avoid warns for unused variables
-#endif
 }
 
 
@@ -241,13 +222,13 @@ copy_test()
   tuple<int, char> t1(4, 'a');
   tuple<int, char> t2(5, 'b');
   t2 = t1;
-  BOOST_TEST(get<0>(t1) == get<0>(t2));
+  BOOST_CHECK(get<0>(t1) == get<0>(t2));
-  BOOST_TEST(get<1>(t1) == get<1>(t2));
+  BOOST_CHECK(get<1>(t1) == get<1>(t2));
 
   tuple<long, std::string> t3(2, "a");
   t3 = t1;
-  BOOST_TEST((double)get<0>(t1) == get<0>(t3));
+  BOOST_CHECK((double)get<0>(t1) == get<0>(t3));
-  BOOST_TEST(get<1>(t1) == get<1>(t3)[0]);
+  BOOST_CHECK(get<1>(t1) == get<1>(t3)[0]);
 
 // testing copy and assignment with implicit conversions between elements
 // testing tie
@@ -259,9 +240,9 @@ copy_test()
   int i; char c; double d;
   tie(i, c, d) = make_tuple(1, 'a', 5.5);
   
-  BOOST_TEST(i==1);
+  BOOST_CHECK(i==1);
-  BOOST_TEST(c=='a');
+  BOOST_CHECK(c=='a');
-  BOOST_TEST(d>5.4 && d<5.6);
+  BOOST_CHECK(d>5.4 && d<5.6);
 }
 
 void
@@ -273,10 +254,10 @@ mutate_test()
   get<2>(t1) = false;
   get<3>(t1) = foo(5);
 
-  BOOST_TEST(get<0>(t1) == 6);
+  BOOST_CHECK(get<0>(t1) == 6);
-  BOOST_TEST(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
+  BOOST_CHECK(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f);
-  BOOST_TEST(get<2>(t1) == false);
+  BOOST_CHECK(get<2>(t1) == false);
-  BOOST_TEST(get<3>(t1) == foo(5));
+  BOOST_CHECK(get<3>(t1) == foo(5));
 }
 
 // ----------------------------------------------------------------------------
@@ -287,40 +268,36 @@ void
 make_tuple_test()
 {
   tuple<int, char> t1 = make_tuple(5, 'a');
-  BOOST_TEST(get<0>(t1) == 5);
+  BOOST_CHECK(get<0>(t1) == 5);
-  BOOST_TEST(get<1>(t1) == 'a');
+  BOOST_CHECK(get<1>(t1) == 'a');
 
   tuple<int, std::string> t2;
-  t2 = make_tuple((short int)2, std::string("Hi"));
+  t2 = boost::make_tuple((short int)2, std::string("Hi"));
-  BOOST_TEST(get<0>(t2) == 2);
+  BOOST_CHECK(get<0>(t2) == 2);
-  BOOST_TEST(get<1>(t2) == "Hi");
+  BOOST_CHECK(get<1>(t2) == "Hi");
 
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+    A a = A(); B b;
-    A a; B b;
     const A ca = a;
-    make_tuple(cref(a), b);
+    make_tuple(boost::cref(a), b);
-    make_tuple(ref(a), b);
+    make_tuple(boost::ref(a), b);
-    make_tuple(ref(a), cref(b));
+    make_tuple(boost::ref(a), boost::cref(b));
 
-    make_tuple(ref(ca));
+    make_tuple(boost::ref(ca));
-#endif
      
 // the result of make_tuple is assignable:
-   BOOST_TEST(make_tuple(2, 4, 6) == 
+   BOOST_CHECK(make_tuple(2, 4, 6) == 
              (make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
     make_tuple("Donald", "Daisy"); // should work;
-#endif
+#endif 
     //    std::make_pair("Doesn't","Work"); // fails
 
 // You can store a reference to a function in a tuple
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
     tuple<void(&)()> adf(make_tuple_test);
 
     dummy(adf); // avoid warning for unused variable
-#endif
  
 // But make_tuple doesn't work 
 // with function references, since it creates a const qualified function type
@@ -329,7 +306,7 @@ make_tuple_test()
   
 // With function pointers, make_tuple works just fine
 
-#if !defined(__BORLANDC__) || __BORLAND__ > 0x0551
+#if !defined(BOOST_BORLANDC) || BOOST_BORLANDC > 0x0551
    make_tuple(&make_tuple_test);
 #endif
       
@@ -357,19 +334,19 @@ tie_test()
   foo c(5);
 
   tie(a, b, c) = make_tuple(2, 'a', foo(3));
-  BOOST_TEST(a == 2);
+  BOOST_CHECK(a == 2);
-  BOOST_TEST(b == 'a');
+  BOOST_CHECK(b == 'a');
-  BOOST_TEST(c == foo(3));
+  BOOST_CHECK(c == foo(3));
 
   tie(a, tuples::ignore, c) = make_tuple((short int)5, false, foo(5));
-  BOOST_TEST(a == 5);
+  BOOST_CHECK(a == 5);
-  BOOST_TEST(b == 'a');
+  BOOST_CHECK(b == 'a');
-  BOOST_TEST(c == foo(5));
+  BOOST_CHECK(c == foo(5));
 
 // testing assignment from std::pair
    int i, j; 
    tie (i, j) = std::make_pair(1, 2);
-   BOOST_TEST(i == 1 && j == 2);
+   BOOST_CHECK(i == 1 && j == 2);
 
    tuple<int, int, float> ta;
 #ifdef E11
@@ -389,13 +366,13 @@ equality_test()
 {
   tuple<int, char> t1(5, 'a');
   tuple<int, char> t2(5, 'a');
-  BOOST_TEST(t1 == t2);
+  BOOST_CHECK(t1 == t2);
 
   tuple<int, char> t3(5, 'b');
   tuple<int, char> t4(2, 'a');
-  BOOST_TEST(t1 != t3);
+  BOOST_CHECK(t1 != t3);
-  BOOST_TEST(t1 != t4);
+  BOOST_CHECK(t1 != t4);
-  BOOST_TEST(!(t1 != t2));
+  BOOST_CHECK(!(t1 != t2));
 }
 
 
@@ -409,14 +386,14 @@ ordering_test()
   tuple<int, float> t1(4, 3.3f);
   tuple<short, float> t2(5, 3.3f);
   tuple<long, double> t3(5, 4.4);
-  BOOST_TEST(t1 < t2);
+  BOOST_CHECK(t1 < t2);
-  BOOST_TEST(t1 <= t2);
+  BOOST_CHECK(t1 <= t2);
-  BOOST_TEST(t2 > t1);
+  BOOST_CHECK(t2 > t1);
-  BOOST_TEST(t2 >= t1);
+  BOOST_CHECK(t2 >= t1);
-  BOOST_TEST(t2 < t3);
+  BOOST_CHECK(t2 < t3);
-  BOOST_TEST(t2 <= t3);
+  BOOST_CHECK(t2 <= t3);
-  BOOST_TEST(t3 > t2);
+  BOOST_CHECK(t3 > t2);
-  BOOST_TEST(t3 >= t2);
+  BOOST_CHECK(t3 >= t2);
 
 }
 
@@ -426,7 +403,6 @@ ordering_test()
 // ----------------------------------------------------------------------------
 void cons_test()
 {
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   using tuples::cons;
   using tuples::null_type;
 
@@ -434,11 +410,10 @@ void cons_test()
   cons<const int, cons<volatile float, null_type> > b(2,a);
   int i = 3;
   cons<int&, cons<const int, cons<volatile float, null_type> > > c(i, b);
-  BOOST_TEST(make_tuple(3,2,1)==c);
+  BOOST_CHECK(make_tuple(3,2,1)==c);
 
   cons<char, cons<int, cons<float, null_type> > > x;
   dummy(x);
-#endif
 }
 
 // ----------------------------------------------------------------------------
@@ -446,9 +421,9 @@ void cons_test()
 // ----------------------------------------------------------------------------
 void const_tuple_test()
 {
-  const tuple<int, float> t1(5, 3.3f);
+  const tuple<int, float> t1(5, 3.25f);
-  BOOST_TEST(get<0>(t1) == 5);
+  BOOST_CHECK(get<0>(t1) == 5);
-  BOOST_TEST(get<1>(t1) == 3.3f);
+  BOOST_CHECK(get<1>(t1) == 3.25f);
 }
 
 // ----------------------------------------------------------------------------
@@ -469,6 +444,26 @@ void tuple_length_test()
 
 }
 
+// ----------------------------------------------------------------------------
+// - testing swap -----------------------------------------------------------
+// ----------------------------------------------------------------------------
+void tuple_swap_test()
+{
+  tuple<int, float, double> t1(1, 2.0f, 3.0), t2(4, 5.0f, 6.0);
+  swap(t1, t2);
+  BOOST_CHECK(get<0>(t1) == 4);
+  BOOST_CHECK(get<1>(t1) == 5.0f);
+  BOOST_CHECK(get<2>(t1) == 6.0);
+  BOOST_CHECK(get<0>(t2) == 1);
+  BOOST_CHECK(get<1>(t2) == 2.0f);
+  BOOST_CHECK(get<2>(t2) == 3.0);
+
+  int i = 1,j = 2;
+  boost::tuple<int&> t3(i), t4(j);
+  swap(t3, t4);
+  BOOST_CHECK(i == 2);
+  BOOST_CHECK(j == 1);
+}
 
 
 
@@ -476,7 +471,7 @@ void tuple_length_test()
 // - main ---------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 
-int test_main(int, char *[]) {
+int main() {
 
   construction_test();
   element_access_test();
@@ -489,12 +484,7 @@ int test_main(int, char *[]) {
   cons_test();
   const_tuple_test();
   tuple_length_test();
-  return 0;
+  tuple_swap_test();
+
+  return boost::report_errors();
 }
-
-
-
-
-
-
-