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,155 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-
-<title>Design decisions rationale for Boost Tuple Library</title>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<IMG SRC="../../../boost.png" 
-     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):</p>
-<pre><code>namespace boost {
-  namespace tuples {
-      ...      
-    // All library code
-      ...
-  }
-  using tuples::tuple; 
-  using tuples::make_tuple;
-  using tuples::tie;
-  using tuples::get;
-}
-</code></pre>
-<p>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:</p>
-
-<pre><code>namespace boost {
-  namespace tuple {
-    ... tie(...);
-    class tuple; 
-&nbsp;     ...
-  }
-  using tuple::tie; // ok
-  using tuple::tuple; // error
-    ...
-}
-</code></pre>
-
-<p>Note, however, that a corresponding using declaration in the global namespace seems to be ok:</p>
-
-<pre><code>
-using boost::tuple::tuple; // ok;
-</code></pre>
-
-
-<h2>The end mark of the cons list (nil, null_type, ...)</h2>
-
-<p>
-Tuples are internally represented as <code>cons</code> lists:
-
-<pre><code>tuple&lt;int, int&gt;
-</code></pre> 
-<p>inherits from</p>
-<pre><code>cons&lt;int, cons&lt;int, null_type&gt; &gt;
-</code></pre>
-
-<p>
-<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>
-<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:</p>
-
-<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>
-<p>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>
-
-<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:
-
-<pre><code>a.get&lt;0&gt;() == a.get(_1st) == a[_1st] == a(_1st);
-</code></pre>
-
-<p>We chose not to provide more than one indexing method for the following reasons:</p>
-<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>
-
-<p>The comparison operator implements lexicographical order. 
-Other orderings were considered, mainly dominance (<i>a &lt; b iff for each i a(i) &lt; 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.</p>
-
-<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.</p>
-
-<p>This may be revisited at some point. The two possible solutions are:</p>
-<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,134 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <title>Tuple library advanced features</title>
-  </head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<IMG SRC="../../../boost.png" 
-     ALT="C++ Boost" width="277" height="86">
-
-    <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.</p>
-
-<pre><code>element&lt;N, T&gt;::type</code></pre>
-
-<p>gives the type of the <code>N</code>th element in the tuple type <code>T</code>. If <code>T</code> is const, the resulting type is const qualified as well. 
-Note that the constness of <code>T</code> does not affect reference type
-elements.
-</p>
-
-<pre><code>length&lt;T&gt;::value</code></pre>
-
-<p>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 </p>
-
-<pre><code>tuple&lt;A, B, C, D&gt;</code></pre>
-
-<p>inherits from the type</p>
-<pre><code>cons&lt;A, cons&lt;B, cons&lt;C, cons&lt;D, null_type&gt; &gt; &gt; &gt;
-</code></pre>
-
-<p>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:</p>
-<pre><code>cons(typename access_traits&lt;head_type&gt;::parameter_type h,
-     const tail_type&amp; t)
-</code></pre>
-<p>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:</p>
-<ol>
-<li><code>access_traits&lt;T&gt;::non_const_type</code> maps <code>T</code> to the return type of the non-const access functions (nonmember 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>
-
-<p>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:</p>
-<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>
-
-<p>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,535 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<title>The Boost Tuple Library</title>
-</head>
-<body bgcolor="#FFFFFF" text="#000000">
-
-<IMG SRC="../../../boost.png" 
-     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:</p>
-
-<pre><code>#include &quot;boost/tuple/tuple.hpp&quot;</code></pre>
-
-<p>Comparison operators can be included with:</p>
-<pre><code>#include &quot;boost/tuple/tuple_comparison.hpp&quot;</code></pre>
-
-<p>To use tuple input and output operators,</p>
-
-<pre><code>#include &quot;boost/tuple/tuple_io.hpp&quot;</code></pre>
-
-<p>Both <code>tuple_io.hpp</code> and <code>tuple_comparison.hpp</code> include <code>tuple.hpp</code>.</p>
-
-<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.</p>
-
-<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 copied, or that are not default constructible (see 'Constructing tuples'
- below). </p>
-
-<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):</p>
-
-<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:</p>
-<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.</p>
-
-<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>
-
-<p>In particular, reference types do not have a default initialization: </p>
-
-<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:</p>
-
-<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>
-
-<p>Note particularly that the following is perfectly ok:</p>
-<pre><code>Y y;
-tuple&lt;char(&amp;)[10], Y&amp;&gt;(a, y); 
-</code></pre>
-
-<p>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>
-
-<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:</p>
-<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.: </p>
-<pre><code>void foo(const A&amp; a, B&amp; b) { 
-  ...
-  make_tuple(a, b);
-</code></pre>
-<p>The <code>make_tuple</code> invocation results in a tuple of type <code>tuple&lt;A, B&gt;</code>.</p>
-
-<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 example below).
-For example:</p>
-
-<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:</p>
-<pre><code>make_tuple(&quot;Donald&quot;, &quot;Daisy&quot;);
-</code></pre>
-
-<p>This creates an object of type <code>tuple&lt;const char (&amp;)[7], 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>
-
-<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):</p>
-<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:</p>
-
-<pre><code>t.get&lt;N&gt;()
-</code></pre>
-<p>or</p>
-<pre><code>get&lt;N&gt;(t)
-</code></pre>
-<p>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 constraints are detected at compile time. Examples:</p>
-
-<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>
-
-<p>
-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 should compile with MSVC++ 6.0.
-</p>
-
-<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:</p>
-
-<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>
-
-<p>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>
-
-<p>
-Note that assignment is also defined from <code>std::pair</code> types:</p>
-
-<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;, &gt;, &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:</p>
-<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>
-
-<p>The operators <code>&lt;, &gt;, &lt;=</code> and <code>&gt;=</code> implement a lexicographical ordering.</p>
-
-<p>
-Note that an attempt to compare two tuples of different lengths results in a compile time error.
-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>
-
-<p>Examples:</p>
-
-<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>):</p>
-
-<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.:</p>
-
-<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>
-<p>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>
-
-<p>
-The tying mechanism works with <code>std::pair</code> templates as well:</p>
-
-<pre><code>int i; char c;
-tie(i, c) = std::make_pair(1, 'a');
-</code></pre>
-<h4>Ignore</h4>
-<p>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):</p>
-
-<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>
-<p>outputs the tuple as: <code>(1.0 2 Howdy folks!)</code></p>
-
-<p>
-The library defines three <i>manipulators</i> for changing the default behavior:</p>
-<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>
-
-<p>Note, that these manipulators are defined in the <code>tuples</code> subnamespace.
-For example:</p>
-<pre><code>cout &lt;&lt; tuples::set_open('[') &lt;&lt; tuples::set_close(']') &lt;&lt; tuples::set_delimiter(',') &lt;&lt; a; 
-</code></pre>
-<p>outputs the same tuple <code>a</code> as: <code>[1.0,2,Howdy folks!]</code></p>
-
-<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>
-
-<p>The code:</p>
-
-<pre><code>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; tuples::set_delimiter(':');
-cin &gt;&gt; j;
-</code></pre>
-
-<p>reads the data into the tuples <code>i</code> and <code>j</code>.</p>
-
-<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>
-
-<p>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:</p>
-
-<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>
-
-<p>and this code:</p>
-
-<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:</p>
-
-<pre><code>void f1(int&amp;, double&amp;);
-tuple&lt;int, double&gt; f2();
-</code></pre>
-
-<p>Then, the call #1 may be slightly faster than #2 in the code below:</p>
-
-<pre><code>int i; double d;
-  ...
-f1(i,d);         // #1
-tie(i,d) = f2(); // #2
-</code></pre>
-<p>See 
-[<a href="#publ_1">1</a>,
-<a href="#publ_2">2</a>]
- for more in-depth discussions about efficiency.</p>
-
-<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 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  
-[<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>
-<p>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::pairs.</p>
-<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 2003-09-07</p>
-
-<p>&copy; Copyright <a href="http://www.boost.org/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.hpp

@@ -34,14 +34,16 @@
 
 
 #include <utility> // needed for the assignment from pair to tuple
+#include <cstddef> // for std::size_t
 
-#include "boost/type_traits/cv_traits.hpp"
-#include "boost/type_traits/function_traits.hpp"
-#include "boost/utility/swap.hpp"
+#include <boost/core/invoke_swap.hpp>
+#include <boost/type_traits/cv_traits.hpp>
+#include <boost/type_traits/function_traits.hpp>
+#include <boost/type_traits/integral_constant.hpp>
 
-#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
+#include <boost/detail/workaround.hpp> // needed for BOOST_WORKAROUND
 
-#if BOOST_GCC >= 40700
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 #endif
@@ -92,7 +94,7 @@ namespace detail {
 template<class T>
 class generate_error;
 
-template<int N>
+template<std::size_t N>
 struct drop_front {
     template<class Tuple>
     struct apply {
@@ -126,21 +128,21 @@ struct drop_front<0> {
 
 #ifndef BOOST_NO_CV_SPECIALIZATIONS
 
-template<int N, class T>
+template<std::size_t N, class T>
 struct element
 {
   typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
       apply<T>::type::head_type type;
 };
 
-template<int N, class T>
+template<std::size_t N, class T>
 struct element<N, const T>
 {
 private:
   typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
       apply<T>::type::head_type unqualified_type;
 public:
-#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
+#if BOOST_WORKAROUND(BOOST_BORLANDC,<0x600)
   typedef const unqualified_type type;
 #else
   typedef BOOST_DEDUCED_TYPENAME boost::add_const<unqualified_type>::type type;
@@ -150,14 +152,14 @@ public:
 
 namespace detail {
 
-template<int N, class T, bool IsConst>
+template<std::size_t N, class T, bool IsConst>
 struct element_impl
 {
   typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
       apply<T>::type::head_type type;
 };
 
-template<int N, class T>
+template<std::size_t N, class T>
 struct element_impl<N, T, true /* IsConst */>
 {
   typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
@@ -168,7 +170,7 @@ struct element_impl<N, T, true /* IsConst */>
 } // end of namespace detail
 
 
-template<int N, class T>
+template<std::size_t N, class T>
 struct element:
   public detail::element_impl<N, T, ::boost::is_const<T>::value>
 {
@@ -209,7 +211,7 @@ template <class T> struct access_traits<T&> {
 
 // get function for non-const cons-lists, returns a reference to the element
 
-template<int N, class HT, class TT>
+template<std::size_t N, class HT, class TT>
 inline typename access_traits<
                   typename element<N, cons<HT, TT> >::type
                 >::non_const_type
@@ -223,7 +225,7 @@ get(cons<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)
-template<int N, class HT, class TT>
+template<std::size_t N, class HT, class TT>
 inline typename access_traits<
                   typename element<N, cons<HT, TT> >::type
                 >::const_type
@@ -309,6 +311,7 @@ struct cons {
       tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
       {}
 
+  cons( const cons& u ) : head(u.head), tail(u.tail) {}
 
   template <class HT2, class TT2>
   cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
@@ -331,7 +334,7 @@ struct cons {
   }
 
   // get member functions (non-const and const)
-  template <int N>
+  template <std::size_t N>
   typename access_traits<
              typename element<N, cons<HT, TT> >::type
            >::non_const_type
@@ -339,7 +342,7 @@ struct cons {
     return boost::tuples::get<N>(*this); // delegate to non-member get
   }
 
-  template <int N>
+  template <std::size_t N>
   typename access_traits<
              typename element<N, cons<HT, TT> >::type
            >::const_type
@@ -388,6 +391,8 @@ struct cons<HT, null_type> {
        const null_type&, const null_type&, const null_type&)
   : head () {}
 
+  cons( const cons& u ) : head(u.head) {}
+
   template <class HT2>
   cons( const cons<HT2, null_type>& u ) : head(u.head) {}
 
@@ -399,7 +404,7 @@ struct cons<HT, null_type> {
   // is illformed if HT is a reference
   cons& operator=(const cons& u) { head = u.head; return *this; }
 
-  template <int N>
+  template <std::size_t N>
   typename access_traits<
              typename element<N, self_type>::type
             >::non_const_type
@@ -407,7 +412,7 @@ struct cons<HT, null_type> {
     return boost::tuples::get<N>(*this);
   }
 
-  template <int N>
+  template <std::size_t N>
   typename access_traits<
              typename element<N, self_type>::type
            >::const_type
@@ -420,28 +425,28 @@ struct cons<HT, null_type> {
 // templates for finding out the length of the tuple -------------------
 
 template<class T>
-struct length  {
-  BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
+struct length: boost::integral_constant<std::size_t, 1 + length<typename T::tail_type>::value>
+{
 };
 
 template<>
-struct length<tuple<> > {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+struct length<tuple<> >: boost::integral_constant<std::size_t, 0>
+{
 };
 
 template<>
-struct length<tuple<> const> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+struct length<tuple<> const>: boost::integral_constant<std::size_t, 0>
+{
 };
 
 template<>
-struct length<null_type> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+struct length<null_type>: boost::integral_constant<std::size_t, 0>
+{
 };
 
 template<>
-struct length<null_type const> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+struct length<null_type const>: boost::integral_constant<std::size_t, 0>
+{
 };
 
 namespace detail {
@@ -484,7 +489,7 @@ public:
 // access_traits<T>::parameter_type takes non-reference types as const T&
   tuple() {}
 
-  tuple(typename access_traits<T0>::parameter_type t0)
+  explicit tuple(typename access_traits<T0>::parameter_type t0)
     : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
                 detail::cnull(), detail::cnull(), detail::cnull(),
                 detail::cnull(), detail::cnull(), detail::cnull()) {}
@@ -672,20 +677,20 @@ struct make_tuple_traits<T&> {
 // All arrays are converted to const. This is because make_tuple takes its
 // parameters as const T& and thus the knowledge of the potential
 // non-constness of actual argument is lost.
-template<class T, int n>  struct make_tuple_traits <T[n]> {
+template<class T, std::size_t n>  struct make_tuple_traits <T[n]> {
   typedef const T (&type)[n];
 };
 
-template<class T, int n>
+template<class T, std::size_t n>
 struct make_tuple_traits<const T[n]> {
   typedef const T (&type)[n];
 };
 
-template<class T, int n>  struct make_tuple_traits<volatile T[n]> {
+template<class T, std::size_t n>  struct make_tuple_traits<volatile T[n]> {
   typedef const volatile T (&type)[n];
 };
 
-template<class T, int n>
+template<class T, std::size_t n>
 struct make_tuple_traits<const volatile T[n]> {
   typedef const volatile T (&type)[n];
 };
@@ -959,11 +964,11 @@ void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
 inline void swap(null_type&, null_type&) {}
 template<class HH>
 inline void swap(cons<HH, null_type>& lhs, cons<HH, null_type>& rhs) {
-  ::boost::swap(lhs.head, rhs.head);
+  ::boost::core::invoke_swap(lhs.head, rhs.head);
 }
 template<class HH, class TT>
 inline void swap(cons<HH, TT>& lhs, cons<HH, TT>& rhs) {
-  ::boost::swap(lhs.head, rhs.head);
+  ::boost::core::invoke_swap(lhs.head, rhs.head);
   ::boost::tuples::swap(lhs.tail, rhs.tail);
 }
 template <class T0, class T1, class T2, class T3, class T4,
@@ -979,11 +984,9 @@ inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
 } // end of namespace boost
 
 
-#if BOOST_GCC >= 40700
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
 #pragma GCC diagnostic pop
 #endif
 
 
 #endif // BOOST_TUPLE_BASIC_HPP
-
-

include/boost/tuple/tuple.hpp

@@ -8,7 +8,7 @@
 
 // For more information, see http://www.boost.org
 
-// ----------------------------------------------------------------- 
+// -----------------------------------------------------------------
 
 #ifndef BOOST_TUPLE_HPP
 #define BOOST_TUPLE_HPP
@@ -20,15 +20,15 @@
 namespace boost { namespace python { class tuple; }}
 #endif
 
-#include "boost/config.hpp"
-#include "boost/static_assert.hpp"
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
 
 // other compilers
-#include "boost/ref.hpp"
-#include "boost/tuple/detail/tuple_basic.hpp"
+#include <boost/core/ref.hpp>
+#include <boost/tuple/detail/tuple_basic.hpp>
 
 
-namespace boost {    
+namespace boost {
 
 using tuples::tuple;
 using tuples::make_tuple;
@@ -47,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)
@@ -60,8 +60,59 @@ get(const tuples::cons<HT, TT>& c) {
 }
 
 #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,31 +1,31 @@
 // tuple_comparison.hpp -----------------------------------------------------
-//  
+//
 // Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
 //
 // 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
-// 
+//
 // (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).
 //
@@ -46,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.
 
 

include/boost/tuple/tuple_io.hpp

@@ -6,7 +6,7 @@
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
-// For more information, see http://www.boost.org 
+// For more information, see http://www.boost.org
 
 // ----------------------------------------------------------------------------
 
@@ -18,11 +18,11 @@
 
 #include <sstream>
 
-#include "boost/tuple/tuple.hpp"
+#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 
+// 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.
 
@@ -30,9 +30,9 @@
 
 #include <locale> // for two-arg isspace
 
-#else 
+#else
 
-#include <cctype> // for one-arg (old) isspace 
+#include <cctype> // for one-arg (old) isspace
 #include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
 
 #endif
@@ -43,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]
@@ -58,19 +58,19 @@ private:
    }
 
    format_info(const format_info&);
-   format_info();   
+   format_info();
 
 
 public:
 
    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) {
@@ -84,27 +84,27 @@ 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);
    }
 };
 
 } // 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, 
-                             const char c = 0)
+  explicit tuple_manipulator(detail::format_info::manipulator_type m,
+                             CharType c = CharType())
      : mt(m), f_c(c) {}
-  
+
    template<class CharTrait>
   void set(std::basic_ios<CharType, CharTrait> &io) const {
      detail::format_info::set_manipulator(io, mt, f_c);
@@ -126,7 +126,7 @@ operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<C
   return i;
 }
 
-   
+
 template<class CharType>
 inline tuple_manipulator<CharType> set_open(const CharType c) {
    return tuple_manipulator<CharType>(detail::format_info::open, c);
@@ -144,38 +144,38 @@ 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.
 
 
 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;
 }
 
- 
+
 template<class CharType, class CharTrait>
-inline std::basic_ostream<CharType, CharTrait>& 
-print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) { 
-  return o; 
+inline std::basic_ostream<CharType, CharTrait>&
+print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) {
+  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;
 
   o << d;
@@ -205,17 +205,17 @@ inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) {
 
 
 template<class CharType, class CharTrait>
-inline std::basic_ostream<CharType, CharTrait>& 
-operator<<(std::basic_ostream<CharType, CharTrait>& o, 
+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 = 
+
+  const CharType l =
     detail::format_info::get_manipulator(o, detail::format_info::open);
-  const CharType r = 
+  const CharType r =
     detail::format_info::get_manipulator(o, detail::format_info::close);
-   
+
   o << l;
   o << r;
 
@@ -223,27 +223,27 @@ operator<<(std::basic_ostream<CharType, CharTrait>& o,
 }
 
 template<class CharType, class CharTrait, class T1, class T2>
-inline std::basic_ostream<CharType, CharTrait>& 
-operator<<(std::basic_ostream<CharType, CharTrait>& o, 
+inline std::basic_ostream<CharType, CharTrait>&
+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;
 }
 
-   
+
 // -------------------------------------------------------------
 // input stream operators
 
@@ -251,7 +251,7 @@ namespace detail {
 
 
 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)
 {
@@ -259,17 +259,17 @@ extract_and_check_delimiter(
 
 #if defined (BOOST_NO_STD_LOCALE)
   const bool is_delimiter = !isspace(d);
-#elif defined ( __BORLANDC__ )
+#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()) );            
+  const bool is_delimiter = (!std::isspace(d, is.getloc()) );
 #endif
 
   CharType c;
-  if (is_delimiter) { 
+  if (is_delimiter) {
     is >> c;
-    if (is.good() && c!=d) { 
+    if (is.good() && c!=d) {
       is.setstate(std::ios::failbit);
     }
   } else {
@@ -278,22 +278,22 @@ extract_and_check_delimiter(
   return is;
 }
 
-   
+
 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;   
-   
-  return is >> t1.head; 
+  if (!is.good()) return is;
+
+  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;
 
 
@@ -306,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;
@@ -318,15 +318,15 @@ 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;
@@ -337,5 +337,3 @@ operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
 } // end of namespace boost
 
 #endif // BOOST_TUPLE_IO_HPP
-
-

index.html

@@ -1,9 +1,9 @@
 <html>
 <head>
-<meta http-equiv="refresh" content="0; URL=doc/tuple_users_guide.html">
+<meta http-equiv="refresh" content="0; URL=doc/html/tuple_users_guide.html">
 </head>
 <body>
-Automatic redirection failed, please go to <a href="doc/tuple_users_guide.html">doc/tuple_users_guide.html</a> 
+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 

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

@@ -1,8 +1,12 @@
+# Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+# Distributed under the Boost Software License, Version 1.0.
 
-project : requirements <library>/boost/test//boost_test_exec_monitor ;
+import testing ;
 
-test-suite tuple : 
-    [ run tuple_test_bench.cpp ]
-    [ run io_test.cpp ]
-    [ run another_tuple_test_bench.cpp ]
-    ;
+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

@@ -15,11 +15,10 @@
 // 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>
 
@@ -149,7 +148,7 @@ void foo7() {
 
 // --------------------------------
 // ----------------------------
-int test_main(int, char *[]) {
+int main() {
 
   foo1();
   foo2();
@@ -159,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

@@ -10,17 +10,19 @@
 //
 // Testing the I/O facilities of tuples
 
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
-#include "boost/test/test_tools.hpp"    // see "Header Implementation Option"
+#define _CRT_SECURE_NO_WARNINGS // std::tmpnam
 
 #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>
@@ -28,6 +30,8 @@
 #include <sstream>
 #endif
 
+#define BOOST_CHECK BOOST_TEST
+
 using namespace boost;
 
 #if defined BOOST_NO_STRINGSTREAM
@@ -38,9 +42,7 @@ typedef std::ostringstream useThisOStringStream;
 typedef std::istringstream useThisIStringStream;
 #endif
 
-int test_main(int argc, char * argv[] ) {
-   (void)argc;
-   (void)argv;
+int main() {
    using boost::tuples::set_close;
    using boost::tuples::set_open;
    using boost::tuples::set_delimiter;
@@ -84,7 +86,9 @@ int test_main(int argc, char * argv[] ) {
   os4 << std::setw(10) << make_tuple(1, 2, 3);
   BOOST_CHECK (os4.str() == std::string("   (1 2 3)") );
 
-  std::ofstream tmp("temp.tmp");
+  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);
@@ -95,7 +99,7 @@ int test_main(int argc, char * argv[] ) {
   tmp.close();
   
   // When teading tuples from a stream, manipulators must be set correctly:
-  std::ifstream tmp3("temp.tmp");
+  std::ifstream tmp3( fn.c_str() );
   tuple<std::string, std::string, int> j;
 
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
@@ -110,6 +114,7 @@ int test_main(int argc, char * argv[] ) {
    
   tmp3.close(); 
 
+  std::remove( fn.c_str() );
 
   // reading tuple<int, int, int> in format (a b c); 
   useThisIStringStream is1("(100 200 300)"); 
@@ -138,6 +143,5 @@ int test_main(int argc, char * argv[] ) {
   // 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

@@ -8,19 +8,18 @@
 
 //  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>
 
+#define BOOST_CHECK BOOST_TEST
+
 using namespace boost;
 
 // ----------------------------------------------------------------------------
@@ -82,7 +81,7 @@ 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
 
@@ -307,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
       
@@ -422,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_CHECK(get<0>(t1) == 5);
-  BOOST_CHECK(get<1>(t1) == 3.3f);
+  BOOST_CHECK(get<1>(t1) == 3.25f);
 }
 
 // ----------------------------------------------------------------------------
@@ -472,7 +471,7 @@ void tuple_swap_test()
 // - main ---------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 
-int test_main(int, char *[]) {
+int main() {
 
   construction_test();
   element_access_test();
@@ -486,12 +485,6 @@ int test_main(int, char *[]) {
   const_tuple_test();
   tuple_length_test();
   tuple_swap_test();
-  return 0;
+
+  return boost::report_errors();
 }
-
-
-
-
-
-
-