This commit was manufactured by cvs2svn to create branch

'thread_rewrite'.

[SVN r30953]

.github/workflows/ci.yml

@@ -1,600 +0,0 @@
-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: "11"
-            os: ubuntu-latest
-            container: ubuntu:18.04
-            install: g++-4.8
-          - toolset: gcc-5
-            cxxstd: "11,14,1z"
-            os: ubuntu-latest
-            container: ubuntu:18.04
-            install: g++-5
-          - toolset: gcc-6
-            cxxstd: "11,14,1z"
-            os: ubuntu-latest
-            container: ubuntu:18.04
-            install: g++-6
-          - toolset: gcc-7
-            cxxstd: "11,14,17"
-            os: ubuntu-20.04
-            install: g++-7
-          - toolset: gcc-8
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: g++-8
-          - toolset: gcc-9
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-          - toolset: gcc-10
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: g++-10
-          - toolset: gcc-11
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: g++-11
-          - toolset: gcc-12
-            cxxstd: "11,14,17,20,2b"
-            os: ubuntu-22.04
-            install: g++-12
-          - toolset: gcc-13
-            cxxstd: "11,14,17,20,2b"
-            os: ubuntu-latest
-            container: ubuntu:23.04
-            install: g++-13
-          - toolset: clang
-            compiler: clang++-3.9
-            cxxstd: "11,14"
-            os: ubuntu-latest
-            container: ubuntu:18.04
-            install: clang-3.9
-          - toolset: clang
-            compiler: clang++-4.0
-            cxxstd: "11,14"
-            os: ubuntu-latest
-            container: ubuntu:18.04
-            install: clang-4.0
-          - toolset: clang
-            compiler: clang++-5.0
-            cxxstd: "11,14,1z"
-            os: ubuntu-latest
-            container: ubuntu:18.04
-            install: clang-5.0
-          - toolset: clang
-            compiler: clang++-6.0
-            cxxstd: "11,14,17"
-            os: ubuntu-20.04
-            install: clang-6.0
-          - toolset: clang
-            compiler: clang++-7
-            cxxstd: "11,14,17"
-            os: ubuntu-20.04
-            install: clang-7
-          - toolset: clang
-            compiler: clang++-8
-            cxxstd: "11,14,17"
-            os: ubuntu-20.04
-            install: clang-8
-          - toolset: clang
-            compiler: clang++-9
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: clang-9
-          - toolset: clang
-            compiler: clang++-10
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: clang-10
-          - toolset: clang
-            compiler: clang++-11
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: clang-11
-          - toolset: clang
-            compiler: clang++-12
-            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: clang-12
-          - toolset: clang
-            compiler: clang++-13
-            cxxstd: "11,14,17,20,2b"
-            os: ubuntu-22.04
-            install: clang-13
-          - toolset: clang
-            compiler: clang++-14
-            cxxstd: "11,14,17,20,2b"
-            os: ubuntu-22.04
-            install: clang-14
-          - toolset: clang
-            compiler: clang++-15
-            cxxstd: "11,14,17,20,2b"
-            os: ubuntu-22.04
-            install: clang-15
-          - toolset: clang
-            compiler: clang++-16
-            cxxstd: "11,14,17,20,2b"
-            os: ubuntu-latest
-            container: ubuntu:23.04
-            install: clang-16
-          - toolset: clang
-            cxxstd: "11,14,17,2a"
-            os: macos-11
-          - toolset: clang
-            cxxstd: "11,14,17,20,2b"
-            os: macos-12
-          - toolset: clang
-            cxxstd: "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
-          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} 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: "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

@@ -1,186 +0,0 @@
-# Copyright 2016, 2017 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-language: cpp
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-dist: xenial
-
-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++-4.7
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.8
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources:
-            - ubuntu-toolchain-r-test
-    - os: linux
-      compiler: g++-4.9
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      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++-3.5
-      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.6
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.7
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - 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
-
-    - 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
-
-    - 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 --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - cp -r $TRAVIS_BUILD_DIR/* libs/typeof
-  - python tools/boostdep/depinst/depinst.py typeof
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - |-
-    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - ./b2 libs/typeof/test toolset=$TOOLSET cxxstd=$CXXSTD
-
-notifications:
-  email:
-    on_success: always

CMakeLists.txt

@@ -1,26 +0,0 @@
-# Generated by `boostdep --cmake typeof`
-# 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.8...3.20)
-
-project(boost_typeof VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
-
-add_library(boost_typeof INTERFACE)
-add_library(Boost::typeof ALIAS boost_typeof)
-
-target_include_directories(boost_typeof INTERFACE include)
-
-target_link_libraries(boost_typeof
-  INTERFACE
-    Boost::config
-)
-
-target_compile_features(boost_typeof INTERFACE cxx_std_11)
-
-if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
-
-  add_subdirectory(test)
-
-endif()

appveyor.yml

@@ -1,62 +0,0 @@
-# Copyright 2016 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)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-
-platform:
-  - x64
-
-environment:
-  matrix:
-    - ARGS: --toolset=msvc-9.0  address-model=32
-    - ARGS: --toolset=msvc-10.0 address-model=32
-    - ARGS: --toolset=msvc-11.0 address-model=32
-    - ARGS: --toolset=msvc-12.0 address-model=32
-    - ARGS: --toolset=msvc-14.0 address-model=32
-    - ARGS: --toolset=msvc-12.0 address-model=64
-    - ARGS: --toolset=msvc-14.0 address-model=64
-    - ARGS: --toolset=msvc-14.0 address-model=64 cxxflags=-std:c++latest
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARGS: --toolset=msvc-14.1 address-model=64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARGS: --toolset=msvc-14.1 address-model=32
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARGS: --toolset=msvc-14.1 address-model=64 cxxflags=-std:c++latest
-    - ARGS: --toolset=gcc address-model=64
-      PATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
-    - ARGS: --toolset=gcc address-model=64 cxxflags=-std=gnu++1z
-      PATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
-    - ARGS: --toolset=gcc address-model=32
-      PATH: C:\mingw-w64\i686-5.3.0-posix-dwarf-rt_v4-rev0\mingw32\bin;%PATH%
-    - ARGS: --toolset=gcc address-model=32 linkflags=-Wl,-allow-multiple-definition
-      PATH: C:\MinGW\bin;%PATH%
-
-
-install:
-  - cd ..
-  - git clone -b %APPVEYOR_REPO_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\typeof\
-  - python tools/boostdep/depinst/depinst.py typeof
-  - bootstrap
-  - b2 headers
-
-build: off
-
-test_script:
-  - cd libs\config\test
-  - ..\..\..\b2 config_info_travis_install %ARGS%
-  - config_info_travis
-  - cd ..\..\typeof\test
-  - ..\..\..\b2 -j3 %ARGS% define=CI_SUPPRESS_KNOWN_ISSUES

doc/Jamfile.v2

@@ -1,29 +0,0 @@
-
-# Copyright Peder Holt 2005. Use, modification, and distribution are
-# subject to the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-using quickbook ;
-
-xml typeof : typeof.qbk ;
-boostbook standalone
-    :
-        typeof
-    :
-        <xsl:param>boost.root=../../../..
-        <xsl:param>nav.layout=none
-        <xsl:param>navig.graphics=0
-    ;
-
-install html : ../../../doc/src/boostbook.css ;
-install ../ : ../../../boost.png ;
-
-###############################################################################
-alias boostdoc
-    : typeof
-    :
-    :
-    : ;
-explicit boostdoc ;
-alias boostrelease ;
-explicit boostrelease ;

doc/typeof.qbk

@@ -1,884 +0,0 @@
-[library Boost.Typeof
-    [authors [Vertleyb, Arkadiy], [Holt, Peder]]
-    [copyright 2004 2005 Arkadiy Vertleyb, Peder Holt]
-    [license
-        Distributed under the Boost Software License, Version 1.0.
-        (See accompanying file LICENSE_1_0.txt or copy at
-        <ulink url="http://www.boost.org/LICENSE_1_0.txt">
-            http://www.boost.org/LICENSE_1_0.txt
-        </ulink>)
-    ]
-    [id typeof]
-    [last-revision $Date$]
-]
-
-[section:moti Motivation]
-
-[c++]
-
-Today many template libraries supply object generators to simplify object creation 
-by utilizing the C++ template argument deduction facility.  Consider `std::pair`.  
-In order to instantiate this class template and create a temporary object of this instantiation, 
-one has to supply template parameters, as well as parameters to the constructor:
-
-    std::pair<int, double>(5, 3.14159);
-
-To avoid this duplication, STL supplies the `std::make_pair` object generator.  
-When it is used, the types of template parameters are deduced from supplied function arguments:
-
-    std::make_pair(5, 3.14159);
-
-For the temporary objects it is enough.  However, when a named object needs to be allocated, 
-the problem appears again:
-
-    std::pair<int, double> p(5, 3.14159);
-
-The object generator no longer helps:
-
-    std::pair<int, double> p = std::make_pair(5, 3.14159);
-
-It would be nice to deduce the type of the object (on the left) from the expression 
-it is initialized with (on the right), but the current C++ syntax does not allow for this.
-
-The above example demonstrates the essence of the problem but does not demonstrate its scale.  
-Many libraries, especially expression template libraries, create objects of really complex types, 
-and go a long way to hide this complexity behind object generators.  Consider a nit Boost.Lambda functor:
-
-    _1 > 15 && _2 < 20
-
-If one wanted to allocate a named copy of such an innocently looking functor, 
-she would have to specify something like this:
- 
-    lambda_functor<
-        lambda_functor_base<
-            logical_action<and_action>,
-            tuple<
-                lambda_functor<
-                    lambda_functor_base<
-                        relational_action<greater_action>,
-                        tuple<
-                            lambda_functor<placeholder<1> >,
-                            int const
-                        > 
-                    > 
-                >,
-                lambda_functor<
-                    lambda_functor_base<
-                        relational_action<less_action>,
-                        tuple<
-                            lambda_functor<placeholder<2> >,
-                            int const 
-                        > 
-                    > 
-                >
-            > 
-        > 
-    > 
-    f = _1 > 15 && _2 < 20;
-
-
-Not exactly elegant.  To solve this problem (as well as some other problems), 
-the C++ standard committee is considering 
-a few additions to the standard language, such as `typeof/decltype` and `auto` (see 
-[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1607.pdf
-http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1607.pdf]).
-
-The `typeof` operator (or `decltype`, which is a slightly different flavor of `typeof`) 
-allows one to determine the type of an expression at compile time.  Using `typeof`, 
-the above example can be simplified drastically:
-
-    typeof(_1 > 15 && _2 < 20) f = _1 > 15 && _2 < 20;
-
-Much better, but some duplication still exists.  The `auto` type solves the rest of the problem:
-
-    auto f = _1 > 15 && _2 < 20;
-
-The purpose of the Boost.Typeof library is to provide a library-based solution, 
-which could be used until the language-based facility is added to the Standard
-and becomes widely available.
- 
-[endsect]
-
-[section:tuto Tutorial]
-
-To start using typeof include the typeof header:
-
-    #include <boost/typeof/typeof.hpp>
-
-To deduce the type of an expression at compile time
-use the `BOOST_TYPEOF` macro:
-
-    namespace ex1
-    {
-        typedef BOOST_TYPEOF(1 + 0.5) type;
-
-        BOOST_STATIC_ASSERT((is_same<type, double>::value));
-    }
-
-In the dependent context use `BOOST_TYPEOF_TPL` instead of `BOOST_TYPEOF`:
-
-    namespace ex2
-    {
-        template<class T, class U>
-        BOOST_TYPEOF_TPL(T() + U()) add(const T& t, const U& u)
-        {
-            return t + u;
-        };
-
-        typedef BOOST_TYPEOF(add('a', 1.5)) type; 
-
-        BOOST_STATIC_ASSERT((is_same<type, double>::value));
-    }
-
-The above examples are possible because the Typeof Library knows about 
-primitive types, such as `int`, `double`, `char`, etc.  The Typeof Library also
-knows about most types and templates defined by the 
-Standard C++ Library, but the appropriate headers need to be included
-to take advantage of this:
-
-    #include <boost/typeof/std/utility.hpp>
-
-    namespace ex3
-    {
-        BOOST_AUTO(p, make_pair(1, 2));
-
-        BOOST_STATIC_ASSERT((is_same<BOOST_TYPEOF(p), pair<int, int> >::value));
-    }
-
-Here `<boost/typeof/std/utility.hpp>` includes `<utility>` and contains 
-knowledge about templates defined there.  This naming convention 
-applies in general, for example to let the Typeof Library handle `std::vector`,
-include `<boost/typeof/std/vector.hpp>`, etc.
-
-To deduce the type of a variable from the expression, this variable 
-is initialized with, use the `BOOST_AUTO` macro (or `BOOST_AUTO_TPL` 
-in a dependent context:
-
-    #include <boost/typeof/std/string.hpp>
-
-    namespace ex4
-    {
-        BOOST_AUTO(p, new int[20]);
-
-        BOOST_STATIC_ASSERT((is_same<BOOST_TYPEOF(p), int*>::value));
-    }
-
-Both `BOOST_TYPEOF` and `BOOST_AUTO` strip top-level qualifiers.  
-Therefore, to allocate for example a reference, it has to be specified explicitly: 
-
-    namespace ex5
-    {
-        string& hello()
-        {
-            static string s = "hello";
-            return s;
-        }
-
-        BOOST_AUTO(&s, hello());
-    }
-
-To better understand this syntax, note that this gets expanded into:
-
-    BOOST_TYPEOF(hello()) &s = hello();
-
-If your define your own type, the Typeof Library cannot handle it
-unless you let it know about this type.  You tell the Typeof Library
-about a type (or template) by the means of "registering" this type/template.
-
-Any source or header file where types/templates are registered has to 
-contain the following line before any registration is done:
-
-    #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-After this a type can be registered:
-
-    namespace ex6
-    {
-        struct MyType
-        {};
-    }
-
-    BOOST_TYPEOF_REGISTER_TYPE(ex6::MyType)
-
-The registration must be done from the context of global namespace; 
-fully qualified type name has to be used.
-
-Any number of types can be registered in one file, each on a separate line.
-
-Once your type is registered, the Typeof Library can handle it in any context:
-
-    namespace ex6
-    {
-        typedef BOOST_TYPEOF(make_pair(1, MyType())) type;
-
-        BOOST_STATIC_ASSERT((is_same<type, pair<int, MyType> >::value));
-    }
-
-A template is registered by specifying its fully qualified name,
-and describing its parameters.  In the simplest case, when all parameters
-are type parameters, only their number needs to be specified:
-
-    namespace ex7
-    {
-        template<class T, class U>
-        struct MyTemplate
-        {};
-    }
-
-    BOOST_TYPEOF_REGISTER_TEMPLATE(ex7::MyTemplate, 2)
-
-    namespace ex7
-    {
-        typedef BOOST_TYPEOF(make_pair(1, MyTemplate<int, ex6::MyType>())) type;
-
-        BOOST_STATIC_ASSERT((is_same<type, 
-            pair<int, MyTemplate<int, ex6::MyType> > 
-        >::value));
-    }
-
-When a template has integral template parameters, all parameters need
-to be described in the preprocessor sequence:
-
-    namespace ex8
-    {
-        template<class T, int n>
-        struct MyTemplate
-        {};
-    }
-
-    BOOST_TYPEOF_REGISTER_TEMPLATE(ex8::MyTemplate, (class)(int))
-
-    namespace ex8
-    {
-        typedef BOOST_TYPEOF(make_pair(1, MyTemplate<ex7::MyTemplate<ex6::MyType, int>, 0>())) type;
-
-        BOOST_STATIC_ASSERT((is_same<type, 
-            pair<int, MyTemplate<ex7::MyTemplate<ex6::MyType, int>, 0> > 
-        >::value));
-    }
-
-Please see the reference for more details.
-
-[endsect]
-
-[section:refe Reference]
-
-[section:auto AUTO, AUTO_TPL]
-
-The `BOOST_AUTO` macro emulates the proposed `auto` keyword in C++. 
-
-[h4 Usage]
-
-    BOOST_AUTO(var,expr)
-    BOOST_AUTO_TPL(var,expr)
-    
-[variablelist Arguments
-[[var][a variable to be initialized with the expression]] 
-[[expr][a valid c++ expression]]
-]
-
-[h4 Remarks]
-
-If you want to use `auto` in a template-context, use `BOOST_AUTO_TPL(expr)`,
-which takes care of the `typename` keyword inside the `auto` expression.
-
-[h4 Sample Code]
-
-    int main() 
-    {
-        length::meter a(5);
-        force::newton b(6);
-        BOOST_AUTO(c, a * b);
-    }
-
-[endsect]
-
-[section:compl COMPLIANT]
-
-The `BOOST_TYPEOF_COMPLIANT` macro can be used to force the emulation mode.  
-Define it if your compiler by default uses another mode, such as native `typeof`
-or Microsoft-specific trick, but you want to use the emulation mode, 
-for example for portability reasons.   
-
-[endsect]
-
-[section:incr INCREMENT_REGISTRATION_GROUP]
-
-The `BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP` macro ensures that type registrations 
-in different header files receive unique identifiers.
-
-[h4 Usage]
-
-    #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-    
-[h4 Remarks]
-
-specified once in every cpp/hpp file where any registration is performed, 
-before any registration.
-
-[h4 Sample Code]
-
-    #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-    class X; 
-    BOOST_TYPEOF_REGISTER_TYPE(X)
-    
-[endsect]
-
-[section:inte INTEGRAL]
-
-The `BOOST_TYPEOF_INTEGRAL` macro is used when registering an integral
-template parameter using `BOOST_TYPEOF_REGISTER_TEMPLATE`.
-
-Useful for `enum`s and dependent integral template parameters.
-
-[h4 Usage]
-
-    BOOST_TYPEOF_INTEGRAL(x)
-
-[variablelist Arguments
-[[x][a fully qualified integral type or enum]]
-]
- 
-[h4 Remarks]
-
-A short syntax has been implemented for the built in types 
-(int, bool, long, unsigned long, etc.)
-Other non-type template parameters (e.g. pointer to member) 
-are not supported.
-
-[h4 Sample Code]
-
-    #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-    namespace foo 
-    {
-        enum color {red, green, blue};
-
-        template<color C0,typename T1>
-        class class_with_enum {};
-
-        template<typename T0,T0 I1>
-        class class_with_dependent_non_type {};
-    }
-
-    BOOST_TYPEOF_REGISTER_TEMPLATE(foo::class_with_enum,
-        (BOOST_TYPEOF_INTEGRAL(foo::color))
-        (typename)
-        )
-        
-    BOOST_TYPEOF_REGISTER_TEMPLATE(foo::class_with_dependent_non_type,
-        (typename)
-        (BOOST_TYPEOF_INTEGRAL(P0))
-        )
-
-[endsect]
-
-[section:limit_func LIMIT_FUNCTION_ARITY]
-
-The `BOOST_TYPEOF_LIMIT_FUNCTION_ARITY` macro defines how many parameters
-are supported for functios, and applies to functions, function pointers,
-function references, and member function pointers.  The default value is 10.
-Redefine if you want the Typeof Library to handle functions with more parameters.
-   
-[endsect]
-
-[section:messages MESSAGES]
-
-Define `BOOST_TYPEOF_MESSAGE` before including boost/typeof/typeof.hpp to 
-include messages "using typeof emulation" and "using native typeof".
-By default, these messages will not be displayed.
-
-[endsect]
-
-[section:limit_size LIMIT_SIZE]
-
-The `BOOST_TYPEOF_LIMIT_SIZE` macro defines the size of the compile-time sequence
-used to encode a type.  The default value is 50.  Increase it if you want 
-the Typeof Library to handle very complex types, although this 
-possibility is limited by the maximum number of template parameters supported
-by your compiler.  On the other hand, if you work only with very simple types, 
-decreasing this number may help to boost compile-time performance.
-
-[endsect]
-
-[section:regtype REGISTER_TYPE]
-
-The `BOOST_TYPEOF_REGISTER_TYPE` macro informs the Typeof Library 
-about the existence of a type
-
-[h4 Usage]
-
-    BOOST_TYPEOF_REGISTER_TYPE(x)
-    
-[variablelist Arguments
-[[x][a fully qualified type]]
-]
-  
-[h4 Remarks]
-
-Must be used in the global namespace
-
-[h4 Sample Code]
-
-    #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-    namespace foo 
-    {
-        class bar {};
-        enum color {red, green, blue};
-    }
-
-    BOOST_TYPEOF_REGISTER_TYPE(foo::bar)
-    BOOST_TYPEOF_REGISTER_TYPE(foo::color)
-
-[endsect]
-
-[section:regtemp REGISTER_TEMPLATE]
-
-The `BOOST_TYPEOF_REGISTER_TEMPLATE` macro informs the Typeof Library 
-about the existence of a template and describes its parameters
-
-[h4 Usage]
-
-    BOOST_TYPEOF_REGISTER_TEMPLATE(x, n)
-    BOOST_TYPEOF_REGISTER_TEMPLATE(x, seq)
-    
-[variablelist Arguments
-[[x][a fully qualified template]] 
-[[n][the number of template arguments. Only valid if all template arguments are typenames]]
-[[seq][a sequence of template arguments. Must be used when integral or template template parameters are present]]
-] 
-  
-[h4 Remarks]
-
-Must be used in the global namespace. 
-
-The library allows registration of templates with type, integral, 
-and template template parameters:
- 
-* A type template parameter is described by the `(class)` or `(typename)` sequence element
-* A template parameter of a well-known integral type can be described by 
-simply supplying its type, like `(unsigned int)`.  
-The following well-known integral types are supported: 
-    * `[signed/unsigned] char`
-    * `[unsigned] short`
-    * `[unsigned] int`
-    * `[unsigned] long`
-    * `unsigned`
-    * `bool`
-    * `size_t`
-* Enums and typedefs of integral types, need to be described explicitly 
-with the `BOOST_TYPEOF_INTEGRAL` macro, like `(BOOST_TYPEOF_INTEGRAL(MyEnum))` 
-* Template template parameters are described with the `BOOST_TYPEOF_TEMPLATE` macro, 
-like: `(BOOST_TYPEOF_TEMPLATE((class)(unsigned int)))`.  
-In case of all type parameters this can be shortened to something like `(BOOST_TYPEOF_TEMPLATE(2))`.  
-The nested template template parameters are not supported. 
-
-[h4 Sample Code]
-
-    #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-    namespace foo 
-    {
-        template<typename T0, typename T1>
-        class simple_template {};
-
-        template<typename T0, int I1>
-        class class_with_integral_constant {};
-    }
-
-    BOOST_TYPEOF_REGISTER_TEMPLATE(foo::simple_template, 2)
-    BOOST_TYPEOF_REGISTER_TEMPLATE(foo::class_with_integral_constant, (typename)(int))
-
-[endsect]
-
-[section:temp TEMPLATE]
-
-The `BOOST_TYPEOF_TEMPLATE` macro is used when registering template template parameters 
-using `BOOST_TYPEOF_REGISTER_TEMPLATE`.
- 
-[h4 Usage]
-
-    BOOST_TYPEOF_TEMPLATE(n)
-    BOOST_TYPEOF_TEMPLATE(seq)
-
-[variablelist Arguments
-[[n][the number of template arguments. Only valid if all template arguments are typenames]]
-[[seq][a sequence of template arguments. Must be used when there are integral constants in the nested template]]
-]
- 
-[h4 Remarks]
-
-Can not be used to register nested template template parameters.
-
-[h4 Sample Code]
-
-    #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-    namespace foo 
-    {
-        enum color {red, green, blue};
-
-        template<color C0, template<typename> class T1>
-        class nested_template_class {};
-
-        template<template<typename, unsigned char> class T1>
-        class nested_with_integral {};
-    }
-
-    BOOST_TYPEOF_REGISTER_TEMPLATE(foo::nested_template_class,
-        (foo::color)
-        (BOOST_TYPEOF_TEMPLATE(1)) 
-        )
-        
-    BOOST_TYPEOF_REGISTER_TEMPLATE(foo::nested_with_integral,
-        (BOOST_TYPEOF_TEMPLATE((typename)(unsigned char))) 
-        )
-
-[endsect]
-
-[section:typo TYPEOF, TYPEOF_TPL]
-
-The `BOOST_TYPEOF` macro calculates the type of an expression, 
-but removes the top-level qualifiers, `const&` 
-
-[h4 Usage]
-
-    BOOST_TYPEOF(expr)
-    BOOST_TYPEOF_TPL(expr)
-    
-[variablelist Arguments
-[[expr][a valid c++ expression that can be bound to const T&]]
-]
-
-[h4 Remarks]
-
-If you want to use `typeof` in a template-context, use `BOOST_TYPEOF_TPL(expr)`, 
-which takes care of `typename` inside the `typeof` expression.
-
-[h4 Sample Code]
-
-    template<typename A, typename B>
-    struct result_of_conditional 
-    {
-        typedef BOOST_TYPEOF_TPL(true?A():B()) type;
-    };
-
-    template<typename A, typename B>
-    result_of_conditional<A, B>::type min(const A& a,const B& b) 
-    {
-        return a < b ? a : b;
-    }
-    
-[endsect]
-
-[section:typn TYPEOF_NESTED_TYPEDEF, TYPEOF_NESTED_TYPEDEF_TPL]
-
-The `TYPEOF_NESTED_TYPEDEF` macro works in much the same way as the 'TYPEOF' macro does, but
-workarounds several compiler deficiencies. 
-
-[h4 Usage]
-
-    BOOST_TYPEOF_NESTED_TYPEDEF(name,expr)
-    BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr)
-    
-[variablelist Arguments
-[[name][a valid identifier to nest the typeof operation inside]
-[expr][a valid c++ expression that can be bound to const T&]]
-]
-
-[h4 Remarks]
-
-'typeof_nested_typedef' nests the 'typeof' operation inside a struct. By doing this, the 'typeof' operation
-can be split into two steps, deconfusing several compilers (notably VC7.1 and VC8.0) on the way. 
-This also removes the limitation imposed by `BOOST_TYPEOF_LIMIT_SIZE` and allows you to use 'typeof' on much 
-larger expressions.
-
-If you want to use `typeof_nested_typedef` in a template-context, use `BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr)`, 
-which takes care of `typename` inside the `typeof` expression.
-
-'typeof_nested_typedef' can not be used at function/block scope.
-
-[h4 Sample Code]
-
-    template<typename A, typename B>
-    struct result_of_conditional 
-    {
-        BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested,true?A():B())
-        typedef typename nested::type type;
-    };
-
-    template<typename A, typename B>
-    result_of_conditional<A, B>::type min(const A& a,const B& b) 
-    {
-        return a < b ? a : b;
-    }
-    
-[endsect]
-
-[endsect]
-
-[section:other Other considerations and tips]
-
-[section:natem Native typeof support and emulation]
-
-Many compilers support typeof already, most noticeable GCC and Metrowerks.
- 
-Igor Chesnokov discovered a method that allows to implement `typeof`
-on the VC series of compilers.  It uses a bug in the Microsoft compiler 
-that allows a nested class of base to be defined in a class derived from base:
- 
-    template<int ID> struct typeof_access
-    {
-        struct id2type; //not defined
-    };
-
-    template<class T, int ID> struct typeof_register : typeof_access
-    {
-        // define base's nested class here
-        struct typeof_access::id2type
-        {
-            typedef T type;
-        };
-    };
-
-    //Type registration function 
-    typeof_register<T, compile-time-constant> register_type(const T&);
-
-    //Actually register type by instantiating typeof_register for the correct type
-    sizeof(register_type(some-type)); 
-
-    //Use the base class to access the type.
-    typedef typeof_access::id2type::type type; 
- 
-Peder Holt adapted this method to VC7.0, where the nested class 
-is a template class that is specialized in the derived class. 
-
-In VC8.0, it seemed that all the bug-featire had been fixed, but
-Steven Watanabe managed to implement a more rigorous version of the VC7.0 fix that
-enables 'typeof' to be supported 'natively' here as well.
- 
-For many other compilers neither native `typeof` support 
-nor the trick described above is an option.  For such compilers  
-the emulation method is the only way of implementing `typeof`.
-
-According to a rough estimate, at the time of this writing 
-the introduction of the `typeof`, `auto`, etc., into the C++ standard 
-may not happen soon.  Even after it's done, some time still has to pass 
-before most compilers implement this feature.  But even after that, 
-there always are legacy compilers to support (for example now, in 2005, 
-many people are still using VC6, long after VC7.x, and even VC8.0 beta became available).
- 
-Considering extreme usefulness of the feature right now, 
-it seems to make sense to implement it at the library level.  
-
-The emulation mode seems to be important even if a better option is present
-on some particular compiler.  If a library author wants to develop portable
-code using `typeof`, she needs to use emulation mode and register her types and
-templates.  Those users who have a better option can still take
-advantage of it, since the registration macros are defined as no-op on
-such compilers, while the users for whom emulation is the only option will use it.
-
-The other consideration applies to the users of VC7.1.  Even though the more 
-convenient `typeof` trick is available, the possibility of upgrade to VC8,
-where emulation remains the only option, should be considered.
-
-The emulation mode can be forced on the compilers that don't use it 
-by default by defining the `BOOST_TYPEOF_COMPLIANT` symbol:
-
-    g++ -D BOOST_TYPEOF_COMPLIANT -I \boost\boost_1_32_0 main.cpp
-
-[endsect] 
-
-[section:parties The three participating parties]
-
-The Lambda example from the Motivation section requires the following registration:
- 
-    #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-     
-    BOOST_TYPEOF_REGISTER_TEMPLATE(boost::tuples::tuple, 2);
-    BOOST_TYPEOF_REGISTER_TEMPLATE(boost::lambda::lambda_functor, 1);
-    BOOST_TYPEOF_REGISTER_TEMPLATE(boost::lambda::lambda_functor_base, 2);
-    BOOST_TYPEOF_REGISTER_TEMPLATE(boost::lambda::relational_action, 1);
-    BOOST_TYPEOF_REGISTER_TEMPLATE(boost::lambda::logical_action, 1);
-    BOOST_TYPEOF_REGISTER_TEMPLATE(boost::lambda::other_action, 1);
-    BOOST_TYPEOF_REGISTER_TYPE(boost::lambda::greater_action);
-    BOOST_TYPEOF_REGISTER_TYPE(boost::lambda::less_action);
-    BOOST_TYPEOF_REGISTER_TYPE(boost::lambda::and_action);
-    BOOST_TYPEOF_REGISTER_TEMPLATE(boost::lambda::placeholder, (int));
- 
-It may seem that the price for the ability to discover the expression's type 
-is too high: rather large amount of registration is required.  
-However note that all of the above registration is done only once, 
-and after that, any combination of the registered types and templates 
-would be handled.  Moreover, this registration is typically done 
-not by the end-user, but rather by a layer on top of some library 
-(in this example -- Boost.Lambda). 
- 
-When thinking about this, it's helpful to consider three parties: the typeof facility, 
-the library (probably built on expression templates principle), and the end-user.  
-The typeof facility is responsible for registering fundamental types.  
-The library can register its own types and templates.
- 
-In the best-case scenario, if the expressions always consist of only 
-fundamental types and library-defined types and templates, a library author 
-can achieve the impression that the `typeof` is natively supported for her library.  
-On the other hand, the more often expressions contain user-defined types, 
-the more responsibility is put on the end-user, and therefore the less attractive 
-this approach becomes.  
- 
-Thus, the ratio of user-defined types in the expressions should be the main 
-factor to consider when deciding whether or not to apply the typeof facility. 
-
-[endsect] 
-
-[section:features Supported features]
-
-The Typeof library pre-registers fundamental types.  For these types, 
-and for any other types/templates registered by the user library or end-user, 
-any combination of the following is supported:
- 
-* Pointers;
-* References (except top-level);
-* Consts (except top-level);
-* Volatiles (except top-level);
-* Arrays;
-* Functions, function pointers, and references;
-* Pointers to member functions;
-* Pointers to data members.
- 
-For example the following type:
- 
-    int& (*)(const volatile char*, double[5], void(*)(short))
- 
-is supported right away, and something like:
- 
-    void (MyClass::*)(int MyClass::*, MyClass[10]) const
- 
-is supported provided `MyClass` is registered. 
-
-The Typeof Library also provides registration files for most STL classes/templates.  
-These files are located in the std subdirectory, and named after corresponding STL headers.  
-These files are not included by the typeof system and have to be explicitly included 
-by the user, as needed:
- 
-    #include <boost/typeof/std/functional.hpp>
-    BOOST_AUTO(fun, std::bind2nd(std::less<int>(), 21)); //create named function object for future use.
-
-[endsect] 
-
-[section:what What needs to be registered?]
-
-It is possible to take advantage of the compiler when registering types for the Typeof Library. 
-Even though there is currently no direct support for typeof in the language, 
-the compiler is aware of what the type of an expression is, and gives an error 
-if it encounters an expression that has not been handled correctly. In the `typeof` context, 
-this error message will contain clues to what types needs to be registered with the 
-Typeof Library in order for `BOOST_TYPEOF` to work.
-
-    struct X {};
-     
-    template<typename A,bool B>
-    struct Y {};
-
-    std::pair<X,Y<int,true> > a;
-
-    BOOST_AUTO(a,b);
- 
-We get the following error message from VC7.1
-
-[pre 
-    error C2504: 'boost::type_of::'anonymous-namespace'::encode_type_impl<V,Type_Not_Registered_With_Typeof_System>' : base
-    class undefined
-        with 
-        \[
-            V=boost::type_of::'anonymous-namespace'::encode_type_impl<boost::mpl::vector0<boost::mpl::na>,std::pair<X,Y<int,true>>>::V0,
-            Type_Not_Registered_With_Typeof_System=X
-        \]
-]
- 
-Inspecting this error message, we see that the compiler complains about `X`
- 
-    BOOST_TYPEOF_REGISTER_TYPE(X); //register X with the typeof system
-
-Recompiling, we get a new error message from VC7.1
- 
-[pre 
-    error C2504: 'boost::type_of::'anonymous-namespace'::encode_type_impl<V,Type_Not_Registered_With_Typeof_System>' : base
-    class undefined
-        with
-        \[
-            V=boost::type_of::'anonymous-namespace'::encode_type_impl<boost::mpl::vector0<boost::mpl::na>,std::pair<X,Y<int,true>>>::V1,
-            Type_Not_Registered_With_Typeof_System=Y<int,true>
-        \]
-]
- 
-Inspecting this error message, we see that the compiler complains about `Y<int,true>`.
-Since `Y` is a template, and contains integral constants, we need to take more care when registering:
-
-    BOOST_TYPEOF_REGISTER_TEMPLATE(Y,(typename)(bool)); //register template class Y
- 
-It is a good idea to look up the exact definition of `Y` when it contains integral constants. 
-For simple template classes containing only typenames, you can rely solely on the compiler error.
-
-The above code now compiles.
-
-This technique can be used to get an overview of which types needs to be registered 
-for a given project in order to support `typeof`.
-
-[endsect] 
-
-[section:limi Limitations]
-
-Nested template template parameters are not supported, like:
- 
-    template<template<template<class> class> class Tpl> 
-    class A; // can't register!
- 
-Classes and templates nested inside other templates also can't be registered 
-because of the issue of nondeduced context.  This limitation is most noticeable 
-with regards to standard iterators in Dinkumware STL, which are implemented 
-as nested classes.  Instead, instantiations can be registered:
- 
-    BOOST_TYPEOF_REGISTER_TYPE(std::list<int>::const_iterator)
-    
-[endsect] 
-
-[endsect] 
-
-[section:cont Contributed By:]
-
-* Compliant compilers   --  Arkadiy Vertleyb, Peder Holt
-* MSVC 6.5, 7.0, 7.1    --  Igor Chesnokov, Peder Holt
-
-[endsect]
-
-[section:ackn Acknowledgements]
-
-The idea of representing a type as multiple compile-time integers, 
-and passing these integers across function boundaries using sizeof(), 
-was taken from Steve Dewhurst's article "A Bitwise typeof Operator", CUJ 2002.
-This article can also be viewed online, at [@http://www.semantics.org/localarchive.html
-http://www.semantics.org/localarchive.html].
- 
-Special thank you to Paul Mensonides, Vesa Karvonen, and Aleksey Gurtovoy 
-for the Boost Preprocessor Library and MPL.  Without these two libraries, 
-this typeof implementation would not exist.  
-  
-The following people provided support, gave valuable comments, 
-or in any other way contributed to the library development 
-(in alphabetical order):
- 
-* David Abrahams
-* Andrey Beliakov
-* Joel de Guzman
-* Daniel James
-* Vesa Karvonen
-* Andy Little
-* Paul Mensonides
-* Alexander Nasonov
-* Tobias Schwinger
-* Martin Wille
-
-[endsect]

include/boost/typeof/config.hpp

@@ -0,0 +1,35 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_CONFIG_HPP_INCLUDED
+#define BOOST_TYPEOF_CONFIG_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if !defined(BOOST_TYPEOF_COMPLIANT) &&\
+    !defined(BOOST_TYPEOF_NATIVE)
+
+#   if defined __GNUC__
+#       define BOOST_TYPEOF_NATIVE
+
+#   elif defined  __MWERKS__
+#       define BOOST_TYPEOF_NATIVE
+
+#   elif defined(BOOST_MSVC) && (BOOST_MSVC<1400)
+//Doesn't require registration
+#       define BOOST_TYPEOF_NATIVE
+
+#   else
+#       define BOOST_TYPEOF_COMPLIANT
+
+#   endif
+
+#endif
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
+#   define BOOST_TYPEOF_NO_SIMPLE_TYPE_OPTIMIZATION
+#endif
+
+#endif//BOOST_TYPEOF_CONFIG_HPP_INCLUDED

include/boost/typeof/constant.hpp

@@ -1,26 +0,0 @@
-/*
-Copyright 2018 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_TYPEOF_CONSTANT_HPP
-#define BOOST_TYPEOF_CONSTANT_HPP
-
-#include <boost/config.hpp>
-
-namespace boost {
-namespace type_of {
-
-template<class T, T N>
-struct constant {
-    typedef constant<T, N> type;
-    typedef constant<T, N + 1> next;
-    BOOST_STATIC_CONSTANT(T, value=N);
-};
-
-} /* type_of */
-} /* boost */
-
-#endif

include/boost/typeof/decltype.hpp

@@ -1,33 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Copyright (C) 2017 Daniela Engert
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPEOF_DECLTYPE_HPP_INCLUDED
-# define BOOST_TYPEOF_DECLTYPE_HPP_INCLUDED
-
-#include <type_traits>
-
-namespace boost { namespace type_of {
-    template<typename T>
-    using remove_cv_ref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-}}
-
-#define BOOST_TYPEOF(expr) boost::type_of::remove_cv_ref_t<decltype(expr)>
-#define BOOST_TYPEOF_TPL BOOST_TYPEOF
-
-#define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
-    struct name {\
-        typedef BOOST_TYPEOF_TPL(expr) type;\
-    };
-
-#define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
-    struct name {\
-        typedef BOOST_TYPEOF(expr) type;\
-    };
-
-#define BOOST_TYPEOF_REGISTER_TYPE(x)
-#define BOOST_TYPEOF_REGISTER_TEMPLATE(x, params)
-
-#endif //BOOST_TYPEOF_DECLTYPE_HPP_INCLUDED
-

include/boost/typeof/encode_decode.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
+#define BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
+
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/next.hpp>
+
+namespace boost{namespace type_of{namespace{
+
+    template<class V, class Type_Not_Registered_With_Typeof_System> 
+    struct encode_type_impl;
+    
+    template<class T, class Iter> 
+    struct decode_type_impl
+    {
+        typedef int type;  // MSVC ETI workaround
+    };
+
+    template<class V, class T> 
+    struct encode_type : encode_type_impl<V, T>
+    {};
+
+    template<class Iter> 
+    struct decode_type : decode_type_impl<
+        typename Iter::type,
+        typename Iter::next
+    >
+    {};
+}}}
+
+#endif//BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED

include/boost/typeof/encode_decode_params.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2005 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED
+#define BOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+
+// Assumes iter0 contains initial iterator
+
+#define BOOST_TYPEOF_DECODE_PARAM(z, n, text)   \
+    typedef decode_type<iter##n> decode##n;     \
+    typedef typename decode##n::type p##n;      \
+    typedef typename decode##n::iter BOOST_PP_CAT(iter, BOOST_PP_INC(n));
+
+#define BOOST_TYPEOF_DECODE_PARAMS(n)\
+    BOOST_PP_REPEAT(n, BOOST_TYPEOF_DECODE_PARAM, ~)
+
+// The P0, P1, ... PN are encoded and added to V 
+
+#define BOOST_TYPEOF_ENCODE_PARAMS_BEGIN(z, n, text)\
+    typename encode_type<
+
+#define BOOST_TYPEOF_ENCODE_PARAMS_END(z, n, text)\
+    , BOOST_PP_CAT(P, n)>::type
+
+#define BOOST_TYPEOF_ENCODE_PARAMS(n, ID)                   \
+    BOOST_PP_REPEAT(n, BOOST_TYPEOF_ENCODE_PARAMS_BEGIN, ~) \
+    typename push_back<V, mpl::size_t<ID> >::type      \
+    BOOST_PP_REPEAT(n, BOOST_TYPEOF_ENCODE_PARAMS_END, ~)
+
+#endif//BOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED

include/boost/typeof/incr_registration_group.hpp

@@ -1,5 +0,0 @@
-// Copyright (C) 2004, 2005 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-// This header is no longer useful and is only retained for compatibility

include/boost/typeof/increment_registration_group.hpp

@@ -0,0 +1,21 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+// Inclusion of this file increments BOOST_TYPEOF_REGISTRATION_GROUP 
+// This method was suggested by Paul Mensonides
+
+#ifndef BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP_HPP_INCLUDED
+
+#   define BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP_HPP_INCLUDED
+#   include <boost/preprocessor/slot/slot.hpp>
+#   define BOOST_TYPEOF_REGISTRATION_GROUP 0
+
+#else
+
+#   define BOOST_PP_VALUE BOOST_TYPEOF_REGISTRATION_GROUP + 1
+#   include BOOST_PP_ASSIGN_SLOT(1)
+#   undef BOOST_TYPEOF_REGISTRATION_GROUP
+#   define BOOST_TYPEOF_REGISTRATION_GROUP BOOST_PP_SLOT(1)
+
+#endif//BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP_HPP_INCLUDED

include/boost/typeof/int_encoding.hpp

@@ -0,0 +1,113 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED
+#define BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED
+
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/size_t.hpp>
+
+namespace boost{namespace type_of{
+
+    template<class T> struct get_unsigned
+    {
+        typedef T type;
+    };
+    template<> struct get_unsigned<signed char>
+    {
+        typedef unsigned char type;
+    };
+    template<> struct get_unsigned<char>
+    {
+        typedef unsigned char type;
+    };
+    template<> struct get_unsigned<short>
+    {
+        typedef unsigned short type;
+    };
+    template<> struct get_unsigned<int>
+    {
+        typedef unsigned int type;
+    };
+    template<> struct get_unsigned<long>
+    {
+        typedef unsigned long type;
+    };
+
+    //////////////////////////
+
+    template<size_t n, bool Overflow> 
+    struct pack
+    {
+        enum {value = (n + 1) * 2 + (Overflow ? 1 : 0)};
+    };
+
+    template<size_t m> 
+    struct unpack
+    {
+        enum {value = (m / 2) - 1};
+        enum {overflow = (m % 2 == 1)};
+    };
+
+    ////////////////////////////////
+
+    template<class V, size_t n, bool overflow = (n >= 0x3fffffff)>
+    struct encode_size_t : push_back<
+        V, 
+        boost::mpl::size_t<pack<n, false>::value> 
+    >
+    {};
+
+    template<class V, size_t n>
+    struct encode_size_t<V, n, true> : push_back<typename push_back<
+        V,
+        boost::mpl::size_t<pack<n % 0x3ffffffe, true>::value> >::type,
+        boost::mpl::size_t<n / 0x3ffffffe>
+    >
+    {};
+
+    template<class V, class T, T n>
+    struct encode_integral : encode_size_t< V, (typename get_unsigned<T>::type)n > 
+    {};
+
+    ///////////////////////////
+
+    template<size_t n, class Iter, bool overflow> 
+    struct decode_size_t;
+
+    template<size_t n, class Iter> 
+    struct decode_size_t<n, Iter, false>
+    {
+        enum {value = n};
+        typedef Iter iter;
+    };
+
+    template<size_t n, class Iter> 
+    struct decode_size_t<n, Iter, true>
+    {
+        enum {m = Iter::type::value};
+
+        enum {value = (size_t)m * 0x3ffffffe + n};
+        typedef typename Iter::next iter;
+    };
+
+    template<class T, class Iter>
+    struct decode_integral
+    {
+        enum {m = Iter::type::value};
+
+        enum {n = unpack<m>::value};
+
+        enum {overflow = unpack<m>::overflow};
+
+        typedef typename Iter::next nextpos;
+        
+        static const T value = (T)(size_t)decode_size_t<n, nextpos, overflow>::value;
+
+        typedef typename decode_size_t<n, nextpos, overflow>::iter iter;
+    };
+
+}}//namespace 
+
+#endif//BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED

include/boost/typeof/integral_template_param.hpp

@@ -0,0 +1,80 @@
+// Copyright (C) 2005 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED
+#define BOOST_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED
+
+#define BOOST_TYPEOF_unsigned (unsigned)
+#define BOOST_TYPEOF_signed (signed)
+
+#define char_BOOST_TYPEOF (char)
+#define short_BOOST_TYPEOF (short)
+#define int_BOOST_TYPEOF (int)
+#define long_BOOST_TYPEOF (long)
+
+#define BOOST_TYPEOF_char_BOOST_TYPEOF (char)
+#define BOOST_TYPEOF_short_BOOST_TYPEOF (short)
+#define BOOST_TYPEOF_int_BOOST_TYPEOF (int)
+#define BOOST_TYPEOF_long_BOOST_TYPEOF (long)
+#define BOOST_TYPEOF_bool_BOOST_TYPEOF (bool)
+#define BOOST_TYPEOF_unsigned_BOOST_TYPEOF (unsigned)
+#define BOOST_TYPEOF_size_t_BOOST_TYPEOF (size_t)
+
+#define BOOST_TYPEOF_MAKE_OBJ_char          BOOST_TYPEOF_INTEGRAL_PARAM(char)
+#define BOOST_TYPEOF_MAKE_OBJ_short         BOOST_TYPEOF_INTEGRAL_PARAM(short)
+#define BOOST_TYPEOF_MAKE_OBJ_int           BOOST_TYPEOF_INTEGRAL_PARAM(int)
+#define BOOST_TYPEOF_MAKE_OBJ_long          BOOST_TYPEOF_INTEGRAL_PARAM(long)
+#define BOOST_TYPEOF_MAKE_OBJ_bool          BOOST_TYPEOF_INTEGRAL_PARAM(bool)
+#define BOOST_TYPEOF_MAKE_OBJ_unsigned      BOOST_TYPEOF_INTEGRAL_PARAM(unsigned)
+#define BOOST_TYPEOF_MAKE_OBJ_size_t        BOOST_TYPEOF_INTEGRAL_PARAM(size_t)
+#define BOOST_TYPEOF_MAKE_OBJ_unsignedchar  BOOST_TYPEOF_INTEGRAL_PARAM(unsigned char)
+#define BOOST_TYPEOF_MAKE_OBJ_unsignedshort BOOST_TYPEOF_INTEGRAL_PARAM(unsigned short)
+#define BOOST_TYPEOF_MAKE_OBJ_unsignedint   BOOST_TYPEOF_INTEGRAL_PARAM(unsigned int)
+#define BOOST_TYPEOF_MAKE_OBJ_unsignedlong  BOOST_TYPEOF_INTEGRAL_PARAM(unsigned long)
+#define BOOST_TYPEOF_MAKE_OBJ_signedchar    BOOST_TYPEOF_INTEGRAL_PARAM(signed char)
+#define BOOST_TYPEOF_MAKE_OBJ_signedshort   BOOST_TYPEOF_INTEGRAL_PARAM(signed short)
+#define BOOST_TYPEOF_MAKE_OBJ_signedint     BOOST_TYPEOF_INTEGRAL_PARAM(signed int)
+#define BOOST_TYPEOF_MAKE_OBJ_signedlong    BOOST_TYPEOF_INTEGRAL_PARAM(signed long)
+#define BOOST_TYPEOF_MAKE_OBJ_integral(x)   BOOST_TYPEOF_INTEGRAL_PARAM(x)
+
+#define BOOST_TYPEOF_INTEGRAL(X) integral(X) BOOST_TYPEOF_EAT
+#define BOOST_TYPEOF_EAT_BOOST_TYPEOF
+#define BOOST_TYPEOF_integral(X) (integral(X))
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM(Type)\
+    (INTEGRAL_PARAM)\
+    (Type)
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)\
+    BOOST_PP_SEQ_ELEM(1, Param)
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM_EXPANDTYPE(Param)\
+    BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)
+
+// INTEGRAL_PARAM "virtual functions" implementation
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM_ENCODE(This, n)\
+    typedef typename encode_integral<\
+        BOOST_PP_CAT(V, n),\
+        BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This),\
+        BOOST_PP_CAT(P, n)\
+    >::type BOOST_PP_CAT(V, BOOST_PP_INC(n)); 
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM_DECODE(This, n)\
+    typedef decode_integral<BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This), BOOST_PP_CAT(iter, n)> BOOST_PP_CAT(d, n);\
+    static const BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This) BOOST_PP_CAT(P, n) = BOOST_PP_CAT(d, n)::value;\
+    typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter, BOOST_PP_INC(n));
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM_PLACEHOLDER(Param)\
+    (BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param))0
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM_DECLARATION_TYPE(Param)\
+    BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM_PLACEHOLDER_TYPES(Param, n)\
+    BOOST_PP_CAT(T,n)
+
+#define BOOST_TYPEOF_INTEGRAL_PARAM_ISTEMPLATE 0
+
+#endif//BOOST_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED

include/boost/typeof/limit_size.hpp

@@ -0,0 +1,35 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_LIMIT_SIZE_HPP_INCLUDED
+#define BOOST_TYPEOF_LIMIT_SIZE_HPP_INCLUDED
+
+#include "boost/mpl/vector.hpp"
+#include "boost/mpl/aux_/config/ctps.hpp"
+#include "boost/preprocessor/iterate.hpp"
+#include "boost/preprocessor/if.hpp"
+#include "boost/config.hpp"
+
+#ifndef BOOST_TYPEOF_LIMIT_SIZE
+#define BOOST_TYPEOF_LIMIT_SIZE 50
+#endif//BOOST_TYPEOF_LIMIT_SIZE
+
+#if (BOOST_TYPEOF_LIMIT_SIZE > BOOST_MPL_LIMIT_VECTOR_SIZE)
+
+namespace boost
+{ 
+    namespace mpl 
+    {
+        #define BOOST_PP_ITERATION_PARAMS_1 (3,(        \
+            BOOST_PP_INC(BOOST_MPL_LIMIT_VECTOR_SIZE),  \
+            BOOST_TYPEOF_LIMIT_SIZE,                    \
+            "boost/mpl/vector/aux_/numbered.hpp"))
+
+        #include BOOST_PP_ITERATE()
+    }
+}
+
+#endif//BOOST_TYPEOF_LIMIT_SIZE > BOOST_MPL_LIMIT_VECTOR_SIZE
+
+#endif//BOOST_TYPEOF_LIMIT_SIZE_HPP_INCLUDED

include/boost/typeof/lvalue_typeof.hpp

@@ -0,0 +1,111 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Copyright (C) 2004 Peder Holt
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_LVALUE_TYPEOF_HPP_INCLUDED
+#define BOOST_TYPEOF_LVALUE_TYPEOF_HPP_INCLUDED
+
+#include <boost/type_traits/is_const.hpp>
+
+namespace boost
+{
+    namespace type_of
+    {
+        enum
+        {
+            RVALUE = 1,
+            LVALUE,
+            CONST_LVALUE
+        };
+
+        char(*classify_expression(...))[
+            RVALUE
+        ];
+
+        template<class T>
+        char(*classify_expression(T&))[
+            is_const<T>::value ? CONST_LVALUE : LVALUE
+        ];
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+        template<class T, int n> struct decorate_type
+        {
+            typedef T type;
+        };
+        template<class T> struct decorate_type<T, LVALUE>
+        {
+            typedef T& type;
+        };
+        template<class T> struct decorate_type<T, CONST_LVALUE>
+        {
+            typedef const T& type;
+        };
+#else 
+        template<int n> 
+        struct decorate_type_impl {
+            template<typename T>
+            struct inner {
+                typedef T type;
+            };
+        };
+        template<> 
+        struct decorate_type_impl<LVALUE> {
+            template<typename T>
+            struct inner {
+                typedef T& type;
+            };
+        };
+
+        template<>
+        struct decorate_type_impl<CONST_LVALUE> {
+            template<typename T>
+            struct inner {
+                typedef T const& type;
+            };
+        };
+
+        template<class T, int n> struct decorate_type
+        {
+            typedef decorate_type_impl<n>::inner<T>::type type;
+        };
+#endif
+    }
+}
+
+
+// Since this is always a type, 
+// just add "typename" when using in templates
+
+#ifndef BOOST_TYPEOF_COMPLIANT
+
+#define BOOST_LVALUE_TYPEOF(expr)                           \
+    boost::type_of::decorate_type<                          \
+        BOOST_TYPEOF(expr),                                 \
+        sizeof(*boost::type_of::classify_expression(expr))  \
+    >::type
+
+#else //BOOST_TYPEOF_COMPLIANT
+
+#include <boost/typeof/typeof_impl.hpp>
+
+namespace boost { namespace type_of {
+
+    template<class V, int n>
+    struct decorate_decode_begin
+    {
+        typedef typename decorate_type<
+            typename decode_begin<V>::type,
+            n
+        >::type type;
+    };
+}}
+
+#define BOOST_LVALUE_TYPEOF(expr)                           \
+    boost::type_of::decorate_decode_begin<                  \
+        BOOST_TYPEOF_ENCODED_VECTOR(expr),                  \
+        sizeof(*boost::type_of::classify_expression(expr))  \
+    >::type
+
+#endif
+
+#endif//BOOST_TYPEOF_LVALUE_TYPEOF_HPP_INCLUDED

include/boost/typeof/message.hpp

@@ -0,0 +1,8 @@
+// Copyright (C) 2005 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#if defined(_MSC_VER) && !defined BOOST_TYPEOF_SILENT 
+#    pragma message(BOOST_TYPEOF_TEXT)
+#endif
+#undef BOOST_TYPEOF_TEXT

include/boost/typeof/modifiers.hpp

@@ -0,0 +1,91 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_MODIFIERS_HPP_INCLUDED
+#define BOOST_TYPEOF_MODIFIERS_HPP_INCLUDED
+
+#include <boost/typeof/encode_decode.hpp>
+
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+// modifiers
+
+#define BOOST_TYPEOF_modifier_support(ID, Fun)\
+    template<class V, class T> struct encode_type_impl<V, Fun(T)>\
+    {\
+        typedef\
+            typename encode_type<\
+            typename push_back<\
+            V\
+            , mpl::size_t<ID> >::type\
+            , T>::type\
+            type;\
+    };\
+    template<class Iter> struct decode_type_impl<mpl::size_t<ID>, Iter>\
+    {\
+        typedef decode_type<Iter> d1;\
+        typedef Fun(typename d1::type) type;\
+        typedef typename d1::iter iter;\
+    }
+
+#define BOOST_TYPEOF_const_fun(T) const T
+#define BOOST_TYPEOF_volatile_fun(T) volatile T
+#define BOOST_TYPEOF_volatile_const_fun(T) volatile const T
+#define BOOST_TYPEOF_pointer_fun(T) T*
+#define BOOST_TYPEOF_reference_fun(T) T&
+
+namespace boost{namespace type_of{namespace{
+
+    BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_const_fun);
+    BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_volatile_fun);
+    BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_volatile_const_fun);
+    BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_pointer_fun);
+    BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_reference_fun);
+
+}}}
+
+#undef BOOST_TYPEOF_modifier_support
+#undef BOOST_TYPEOF_const_fun
+#undef BOOST_TYPEOF_volatile_fun
+#undef BOOST_TYPEOF_volatile_const_fun
+#undef BOOST_TYPEOF_pointer_fun
+#undef BOOST_TYPEOF_reference_fun
+
+// arrays
+
+#define BOOST_TYPEOF_array_support(ID, Qualifier)\
+    template<class V, class T, int N>\
+    struct encode_type_impl<V, Qualifier T[N]>\
+    {\
+        typedef\
+            typename encode_type<\
+            typename push_back<\
+            typename push_back<\
+            V\
+            , mpl::size_t<ID> >::type\
+            , mpl::size_t<N> >::type\
+            , T>::type\
+        type;\
+    };\
+    template<class Iter>\
+    struct decode_type_impl<mpl::size_t<ID>, Iter>\
+    {\
+        enum{n = Iter::type::value};\
+        typedef decode_type<typename Iter::next> d;\
+        typedef typename d::type Qualifier type[n];\
+        typedef typename d::iter iter;\
+    }
+
+namespace boost{namespace type_of{namespace{
+
+    BOOST_TYPEOF_array_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_PP_EMPTY());
+    BOOST_TYPEOF_array_support(BOOST_TYPEOF_UNIQUE_ID(), const);
+    BOOST_TYPEOF_array_support(BOOST_TYPEOF_UNIQUE_ID(), volatile);
+    BOOST_TYPEOF_array_support(BOOST_TYPEOF_UNIQUE_ID(), volatile const);
+
+}}}
+
+#undef BOOST_TYPEOF_array_support
+
+#endif//BOOST_TYPEOF_MODIFIERS_HPP_INCLUDED

include/boost/typeof/msvc/typeof_impl.hpp

@@ -1,7 +1,6 @@
-
-// Copyright (C) 2005 Igor Chesnokov, mailto:ichesnokov@gmail.com (VC 6.5,VC 7.1 + counter code)
-// Copyright (C) 2005-2007 Peder Holt (VC 7.0 + framework)
-// Copyright (C) 2006 Steven Watanabe (VC 8.0)
+                                                                                                                                                                                                                                                               
+// Copyright (C) 2005 Igor Chesnokov, mailto:ichesnokov@gmail.com
+// Copyright (C) 2005 Peder Holt
 
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
@@ -10,11 +9,7 @@
 # define BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
 
 # include <boost/config.hpp>
-# include <boost/config/workaround.hpp>
-# include <boost/typeof/constant.hpp>
-# include <type_traits>
-
-# include <typeinfo>
+# include <boost/detail/workaround.hpp>
 
 namespace boost
 {
@@ -22,9 +17,9 @@ namespace boost
     {
 
         //Compile time constant code
-# if defined(_MSC_EXTENSIONS)
+# if BOOST_WORKAROUND(BOOST_MSVC,>=1300) && defined(_MSC_EXTENSIONS)
         template<int N> struct the_counter;
-
+        
         template<typename T,int N = 5/*for similarity*/>
         struct encode_counter
         {
@@ -41,7 +36,7 @@ namespace boost
                 __if_not_exists(the_counter<N + 64>)
                 {
                     __if_exists(the_counter<N + 16>)
-                    {
+                    { 
                         BOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 17>::count));
                     }
                     __if_not_exists(the_counter<N + 16>)
@@ -72,7 +67,7 @@ namespace boost
 # else
         template<int N> struct encode_counter : encode_counter<N - 1> {};
         template<> struct encode_counter<0> {};
-
+        
         //Need to default to a larger value than 4, as due to MSVC's ETI errors. (sizeof(int)==4)
         char (*encode_index(...))[5];
 
@@ -82,59 +77,45 @@ namespace boost
 
         //Typeof code
 
-# if BOOST_WORKAROUND(BOOST_MSVC,>=1400)
-        struct msvc_extract_type_default_param {};
-
-        template<typename ID, typename T = msvc_extract_type_default_param>
-        struct msvc_extract_type;
-
-        template<typename ID>
-        struct msvc_extract_type<ID, msvc_extract_type_default_param> {
+# if BOOST_WORKAROUND(BOOST_MSVC,==1300)
+        template<int ID>
+        struct msvc_typeof_base
+        {
             template<bool>
             struct id2type_impl;
 
             typedef id2type_impl<true> id2type;
         };
 
-        template<typename ID, typename T>
-        struct msvc_extract_type : msvc_extract_type<ID,msvc_extract_type_default_param>
+        template<typename T, int ID>
+        struct msvc_typeof : msvc_typeof_base<ID>
         {
             template<>
-            struct id2type_impl<true>  //VC8.0 specific bugfeature
+            struct id2type_impl<true> 
             {
                 typedef T type;
             };
-            template<bool>
-            struct id2type_impl;
-
-            typedef id2type_impl<true> id2type;
         };
+# else 
+        template<int ID>
+        struct msvc_typeof_base
+        {
 
-        template<typename T, typename ID>
-        struct msvc_register_type : msvc_extract_type<ID, T>
-        {
-        };
-# else
-        template<typename ID>
-        struct msvc_extract_type
-        {
             struct id2type;
         };
 
-        template<typename T, typename ID>
-        struct msvc_register_type : msvc_extract_type<ID>
+        template<typename T, int ID>
+        struct msvc_typeof : msvc_typeof_base<ID>
         {
-            typedef msvc_extract_type<ID> base_type;
-            struct base_type::id2type // This uses nice VC6.5 and VC7.1 bugfeature
+            struct msvc_typeof_base<ID>::id2type // This uses nice VC6-VC7 bugfeature
             {
                 typedef T type;
             };
         };
 # endif
-
         template<int ID>
         struct msvc_typeid_wrapper {
-            typedef typename msvc_extract_type<constant<int,ID> >::id2type id2type;
+            typedef typename msvc_typeof_base<ID>::id2type id2type;
             typedef typename id2type::type type;
         };
         //Workaround for ETI-bug for VC6 and VC7
@@ -155,48 +136,21 @@ namespace boost
             //Get the next available compile time constants index
             BOOST_STATIC_CONSTANT(unsigned,value=BOOST_TYPEOF_INDEX(T));
             //Instantiate the template
-            typedef typename msvc_register_type<T,constant<int,value> >::id2type type;
+            typedef typename msvc_typeof<T,value>::id2type type;
             //Set the next compile time constants index
             BOOST_STATIC_CONSTANT(unsigned,next=value+1);
             //Increment the compile time constant (only needed when extensions are not active
-            BOOST_TYPEOF_NEXT_INDEX(next);
+            BOOST_TYPEOF_NEXT_INDEX(next);     
         };
 
-        template<class T>
-        struct sizer
-        {
-            typedef char(*type)[encode_type<T>::value];
-        };
-        template<typename T> typename std::enable_if<
-            !std::is_function<T>::value,
-            typename sizer<T>::type>::type encode_start(T const&);
-
-        template<typename T> typename std::enable_if<
-            std::is_function<T>::value,
-            typename sizer<T>::type>::type encode_start(T&);
-        template<typename Organizer, typename T>
-        msvc_register_type<T,Organizer> typeof_register_type(const T&,Organizer* =0);
+        template<typename T>
+        char (*encode_start(T const&))[encode_type<T>::value];
+    }
+}
 
 # define BOOST_TYPEOF(expr) \
     boost::type_of::msvc_typeid_wrapper<sizeof(*boost::type_of::encode_start(expr))>::type
 
 # define BOOST_TYPEOF_TPL(expr) typename BOOST_TYPEOF(expr)
 
-# define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
-    struct name {\
-        enum {_typeof_register_value=sizeof(boost::type_of::typeof_register_type<name>(expr))};\
-        typedef typename boost::type_of::msvc_extract_type<name>::id2type id2type;\
-        typedef typename id2type::type type;\
-    };
-
-# define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
-    struct name {\
-        enum {_typeof_register_value=sizeof(boost::type_of::typeof_register_type<name>(expr))};\
-        typedef boost::type_of::msvc_extract_type<name>::id2type id2type;\
-        typedef id2type::type type;\
-    };
-
-    }
-}
-
 #endif//BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED

include/boost/typeof/pointers_data_members.hpp

@@ -0,0 +1,44 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_POINTERS_DATA_MEMBERS_HPP_INCLUDED
+#define BOOST_TYPEOF_POINTERS_DATA_MEMBERS_HPP_INCLUDED
+
+#include <boost/typeof/encode_decode_params.hpp>
+#include <boost/typeof/encode_decode.hpp>
+
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+namespace boost
+{
+    namespace type_of
+    {
+        namespace
+        {
+            enum {PTR_DATA_MEM_ID = BOOST_TYPEOF_UNIQUE_ID()};
+
+            template<class V, class P0, class P1> 
+            struct encode_type_impl<V, P0 P1::*>
+            {
+                typedef BOOST_TYPEOF_ENCODE_PARAMS(2, PTR_DATA_MEM_ID) type;
+            };
+
+            template<class Iter> 
+            struct decode_type_impl<mpl::size_t<PTR_DATA_MEM_ID>, Iter>
+            {
+                typedef Iter iter0;
+                BOOST_TYPEOF_DECODE_PARAMS(2)
+
+                template<class T> struct workaround{
+                    typedef p0 T::* type;
+                };
+
+                typedef typename workaround<p1>::type type;
+                typedef iter2 iter;
+            };
+        }
+    }
+}
+
+#endif//BOOST_TYPEOF_POINTERS_DATA_MEMBERS_HPP_INCLUDED

include/boost/typeof/register_functions.hpp

@@ -0,0 +1,45 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_REGISTER_FUNCTIONS_HPP_INCLUDED
+#define BOOST_TYPEOF_REGISTER_FUNCTIONS_HPP_INCLUDED
+
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/preprocessor/dec.hpp>
+#include <boost/preprocessor/if.hpp>
+#include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifndef BOOST_TYPEOF_LIMIT_FUNCTION_ARITY
+#define BOOST_TYPEOF_LIMIT_FUNCTION_ARITY 10
+#endif
+
+enum 
+{
+    FUN_ID                          = BOOST_TYPEOF_UNIQUE_ID(),
+    FUN_PTR_ID                      = FUN_ID + 1 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    FUN_REF_ID                      = FUN_ID + 2 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    MEM_FUN_ID                      = FUN_ID + 3 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    CONST_MEM_FUN_ID                = FUN_ID + 4 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    VOLATILE_MEM_FUN_ID             = FUN_ID + 5 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    VOLATILE_CONST_MEM_FUN_ID       = FUN_ID + 6 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY)
+};
+
+namespace boost
+{
+    namespace type_of
+    {   
+        # define BOOST_PP_ITERATION_LIMITS (0, BOOST_TYPEOF_LIMIT_FUNCTION_ARITY)
+        # define BOOST_PP_FILENAME_1 <boost/typeof/register_functions_iterate.hpp>
+        # include BOOST_PP_ITERATE()
+    }
+}
+
+#endif//BOOST_TYPEOF_REGISTER_FUNCTIONS_HPP_INCLUDED

include/boost/typeof/register_functions_iterate.hpp

@@ -0,0 +1,84 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/typeof/encode_decode_params.hpp>
+
+#define n BOOST_PP_ITERATION()
+
+namespace
+{
+    // function pointers
+
+    template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)> 
+    struct encode_type_impl<V, R(*)(BOOST_PP_ENUM_PARAMS(n, P))>
+    {
+        typedef R BOOST_PP_CAT(P, n);
+        typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_PTR_ID + n) type;
+    };
+
+    template<class Iter>
+    struct decode_type_impl<mpl::size_t<FUN_PTR_ID + n>, Iter>
+    {
+        typedef Iter iter0;
+        BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
+        typedef BOOST_PP_CAT(p, n)(*type)(BOOST_PP_ENUM_PARAMS(n, p));
+        typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
+    };
+
+    // function references
+
+    template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)> 
+    struct encode_type_impl<V, R(&)(BOOST_PP_ENUM_PARAMS(n, P))>
+    {
+        typedef R BOOST_PP_CAT(P, n);
+        typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_REF_ID + n) type;
+    };
+
+    template<class Iter>
+    struct decode_type_impl<mpl::size_t<FUN_REF_ID + n>, Iter>
+    {
+        typedef Iter iter0;
+        BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
+        typedef BOOST_PP_CAT(p, n)(&type)(BOOST_PP_ENUM_PARAMS(n, p));
+        typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
+    };
+
+    // functions
+
+    template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)> 
+    struct encode_type_impl<V, R(BOOST_PP_ENUM_PARAMS(n, P))>
+    {
+        typedef R BOOST_PP_CAT(P, n);
+        typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_ID + n) type;
+    };
+
+    template<class Iter>
+    struct decode_type_impl<mpl::size_t<FUN_ID + n>, Iter>
+    {
+        typedef Iter iter0;
+        BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
+        typedef BOOST_PP_CAT(p, n)(type)(BOOST_PP_ENUM_PARAMS(n, p));
+        typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
+    };
+
+    // member functions
+
+    #define BOOST_TYPEOF_qualifier 
+    #define BOOST_TYPEOF_id MEM_FUN_ID
+    #include <boost/typeof/register_mem_functions.hpp>
+
+    #define BOOST_TYPEOF_qualifier const
+    #define BOOST_TYPEOF_id CONST_MEM_FUN_ID
+    #include <boost/typeof/register_mem_functions.hpp>
+
+    #define BOOST_TYPEOF_qualifier volatile 
+    #define BOOST_TYPEOF_id VOLATILE_MEM_FUN_ID
+    #include <boost/typeof/register_mem_functions.hpp>
+
+    #define BOOST_TYPEOF_qualifier volatile const
+    #define BOOST_TYPEOF_id VOLATILE_CONST_MEM_FUN_ID
+    #include <boost/typeof/register_mem_functions.hpp>
+}
+
+#undef n

include/boost/typeof/register_fundamental.hpp

@@ -0,0 +1,64 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Copyright (C) 2004 Peder Holt
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_REGISTER_FUNDAMENTAL_HPP_INCLUDED
+#define BOOST_TYPEOF_REGISTER_FUNDAMENTAL_HPP_INCLUDED
+
+#include <boost/typeof/typeof.hpp>
+
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TYPE(unsigned char)
+BOOST_TYPEOF_REGISTER_TYPE(unsigned short)
+BOOST_TYPEOF_REGISTER_TYPE(unsigned int)
+BOOST_TYPEOF_REGISTER_TYPE(unsigned long)
+
+BOOST_TYPEOF_REGISTER_TYPE(signed char)
+BOOST_TYPEOF_REGISTER_TYPE(signed short)
+BOOST_TYPEOF_REGISTER_TYPE(signed int)
+BOOST_TYPEOF_REGISTER_TYPE(signed long)
+
+BOOST_TYPEOF_REGISTER_TYPE(bool)
+BOOST_TYPEOF_REGISTER_TYPE(char)
+
+BOOST_TYPEOF_REGISTER_TYPE(float)
+BOOST_TYPEOF_REGISTER_TYPE(double)
+BOOST_TYPEOF_REGISTER_TYPE(long double)
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+// If the following line fails to compile and you're using the Intel
+// compiler, see http://lists.boost.org/MailArchives/boost-users/msg06567.php,
+// and define BOOST_NO_INTRINSIC_WCHAR_T on the command line.
+BOOST_TYPEOF_REGISTER_TYPE(wchar_t)
+#endif
+
+#if (defined(BOOST_MSVC) && (BOOST_MSVC == 1200)) \
+    || (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
+    || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER == 1200))
+BOOST_TYPEOF_REGISTER_TYPE(unsigned __int8)
+BOOST_TYPEOF_REGISTER_TYPE(__int8)
+BOOST_TYPEOF_REGISTER_TYPE(unsigned __int16)
+BOOST_TYPEOF_REGISTER_TYPE(__int16)
+BOOST_TYPEOF_REGISTER_TYPE(unsigned __int32)
+BOOST_TYPEOF_REGISTER_TYPE(__int32)
+#ifdef __BORLANDC__
+BOOST_TYPEOF_REGISTER_TYPE(unsigned __int64)
+BOOST_TYPEOF_REGISTER_TYPE(__int64)
+#endif
+#endif
+
+# if defined(BOOST_HAS_LONG_LONG)
+BOOST_TYPEOF_REGISTER_TYPE(::boost::ulong_long_type)
+BOOST_TYPEOF_REGISTER_TYPE(::boost::long_long_type)
+#elif defined(BOOST_HAS_MS_INT64)
+BOOST_TYPEOF_REGISTER_TYPE(unsigned __int64)
+BOOST_TYPEOF_REGISTER_TYPE(__int64)
+#endif
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TYPE(void)
+#endif
+
+#endif//BOOST_TYPEOF_REGISTER_FUNDAMENTAL_HPP_INCLUDED

include/boost/typeof/register_mem_functions.hpp

@@ -0,0 +1,32 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/typeof/encode_decode_params.hpp>
+
+// member functions
+
+template<class V, class T, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)> 
+struct encode_type_impl<V, R(T::*)(BOOST_PP_ENUM_PARAMS(n, P)) BOOST_TYPEOF_qualifier>
+{
+    typedef R BOOST_PP_CAT(P, n);
+    typedef T BOOST_PP_CAT(P, BOOST_PP_INC(n));
+    typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_ADD(n, 2), BOOST_TYPEOF_id + n) type;
+};
+
+template<class Iter>
+struct decode_type_impl<mpl::size_t<BOOST_TYPEOF_id + n>, Iter>
+{
+    typedef Iter iter0;
+    BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_ADD(n, 2))
+    template<class T> struct workaround{
+        typedef BOOST_PP_CAT(p, n)(T::*type)(BOOST_PP_ENUM_PARAMS(n, p)) BOOST_TYPEOF_qualifier;
+    };
+    typedef typename workaround<BOOST_PP_CAT(p, BOOST_PP_INC(n))>::type type;
+    typedef BOOST_PP_CAT(iter, BOOST_PP_ADD(n, 2)) iter;
+};
+
+// undef parameters
+
+#undef BOOST_TYPEOF_id
+#undef BOOST_TYPEOF_qualifier

include/boost/typeof/std/bitset.hpp

@@ -2,12 +2,16 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_bitset_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_bitset_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <bitset>
 #include <boost/typeof/typeof.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::bitset, (size_t))
+
 #endif//BOOST_TYPEOF_STD_bitset_hpp_INCLUDED

include/boost/typeof/std/complex.hpp

@@ -2,12 +2,16 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_complex_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_complex_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <complex>
 #include <boost/typeof/typeof.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::complex, 1)
+
 #endif//BOOST_TYPEOF_STD_complex_hpp_INCLUDED

include/boost/typeof/std/deque.hpp

@@ -2,13 +2,20 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_deque_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_deque_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <deque>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/memory.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::deque, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::deque, 2)
+
 #endif//BOOST_TYPEOF_STD_deque_hpp_INCLUDED

include/boost/typeof/std/fstream.hpp

@@ -2,13 +2,38 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_fstream_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_fstream_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <fstream>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/string.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_filebuf, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_filebuf, 2)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ifstream, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ifstream, 2)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ofstream, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ofstream, 2)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_fstream, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_fstream, 2)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TYPE(std::filebuf)
+BOOST_TYPEOF_REGISTER_TYPE(std::ifstream)
+BOOST_TYPEOF_REGISTER_TYPE(std::ofstream)
+BOOST_TYPEOF_REGISTER_TYPE(std::fstream)
+#endif//BOOST_TYPEOF_COMPLIANT
+
 #endif//BOOST_TYPEOF_STD_fstream_hpp_INCLUDED

include/boost/typeof/std/functional.hpp

@@ -2,13 +2,48 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_functional_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_functional_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
-#include <boost/typeof/typeof.hpp>
-#include <boost/config.hpp>
 #include <functional>
+#include <boost/typeof/typeof.hpp>
+
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::unary_function, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::binary_function, 3)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::plus, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::minus, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::multiplies, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::divides, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::modulus, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::negate, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::equal_to, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::not_equal_to, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::greater, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::less, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::greater_equal, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::less_equal, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::logical_and, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::logical_or, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::logical_not, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::unary_negate, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::binary_negate, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::binder1st, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::binder2nd, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::pointer_to_unary_function, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::pointer_to_binary_function, 3)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::mem_fun_t, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::mem_fun1_t, 3)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::mem_fun_ref_t, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::mem_fun1_ref_t, 3)
+#if !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::const_mem_fun_t, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::const_mem_fun1_t, 3)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::const_mem_fun_ref_t, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::const_mem_fun1_ref_t, 3)
+#endif//BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
 
 #endif//BOOST_TYPEOF_STD_functional_hpp_INCLUDED

include/boost/typeof/std/iostream.hpp

@@ -2,13 +2,21 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_iostream_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_iostream_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <iostream>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/string.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::fpos, 1)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ios, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ios, 2)
+
 #endif//BOOST_TYPEOF_STD_iostream_hpp_INCLUDED

include/boost/typeof/std/istream.hpp

@@ -2,13 +2,28 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_istream_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_istream_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <istream>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/string.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_istream, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_istream, 2)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_iostream, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_iostream, 2)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TYPE(std::istream)
+BOOST_TYPEOF_REGISTER_TYPE(std::iostream)
+#endif//BOOST_TYPEOF_COMPLIANT
+
 #endif//BOOST_TYPEOF_STD_istream_hpp_INCLUDED

include/boost/typeof/std/iterator.hpp

@@ -2,13 +2,75 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_iterator_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_iterator_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <iterator>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/string.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator_traits, 1)
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator, 2)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator, 3)
+#else
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator, 3)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator, 4)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::iterator, 5)
+#endif//BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+BOOST_TYPEOF_REGISTER_TYPE(std::input_iterator_tag)
+BOOST_TYPEOF_REGISTER_TYPE(std::output_iterator_tag)
+BOOST_TYPEOF_REGISTER_TYPE(std::forward_iterator_tag)
+BOOST_TYPEOF_REGISTER_TYPE(std::bidirectional_iterator_tag)
+BOOST_TYPEOF_REGISTER_TYPE(std::random_access_iterator_tag)
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::reverse_iterator, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::reverse_iterator, 3)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::reverse_iterator, 4)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::reverse_iterator, 5)
+#else
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::reverse_iterator, 1)
+#endif//BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::back_insert_iterator, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::front_insert_iterator, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::insert_iterator, 1)
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 2)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 3)
+#else
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 3)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::istream_iterator, 4)
+#endif//BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::ostream_iterator, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::ostream_iterator, 2)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::ostream_iterator, 3)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::istreambuf_iterator, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::istreambuf_iterator, 2)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::ostreambuf_iterator, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::ostreambuf_iterator, 2)
+
 #endif//BOOST_TYPEOF_STD_iterator_hpp_INCLUDED

include/boost/typeof/std/list.hpp

@@ -2,13 +2,20 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_list_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_list_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <list>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/memory.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::list, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::list, 2)
+
 #endif//BOOST_TYPEOF_STD_list_hpp_INCLUDED

include/boost/typeof/std/locale.hpp

@@ -2,12 +2,41 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_locale_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_locale_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <locale>
 #include <boost/typeof/typeof.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TYPE(std::locale)
+BOOST_TYPEOF_REGISTER_TYPE(std::ctype_base)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::ctype, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::ctype_byname, 1)
+BOOST_TYPEOF_REGISTER_TYPE(std::codecvt_base)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::codecvt, 3)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::codecvt_byname, 3)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::num_get, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::num_put, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::numpunct, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::numpunct_byname, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::collate, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::collate_byname, 1)
+BOOST_TYPEOF_REGISTER_TYPE(std::time_base)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::time_get, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::time_get_byname, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::time_put, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::time_put_byname, 2)
+BOOST_TYPEOF_REGISTER_TYPE(std::money_base)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::money_get, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::money_put, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::moneypunct, (class)(bool))
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::moneypunct_byname, (class)(bool))
+BOOST_TYPEOF_REGISTER_TYPE(std::messages_base)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::messages, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::messages_byname, 1)
+
 #endif//BOOST_TYPEOF_STD_locale_hpp_INCLUDED

include/boost/typeof/std/map.hpp

@@ -2,15 +2,28 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_map_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_map_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <map>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/memory.hpp>
 #include <boost/typeof/std/functional.hpp>
 #include <boost/typeof/std/utility.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::map, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::map, 3)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::map, 4)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::multimap, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::multimap, 3)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::multimap, 4)
+
 #endif//BOOST_TYPEOF_STD_map_hpp_INCLUDED

include/boost/typeof/std/memory.hpp

@@ -2,13 +2,18 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_memory_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_memory_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
-#include <boost/typeof/typeof.hpp>
-#include <boost/config.hpp>
 #include <memory>
+#include <boost/typeof/typeof.hpp>
+
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::allocator, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::raw_storage_iterator, 2)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::auto_ptr, 1)
 
 #endif//BOOST_TYPEOF_STD_memory_hpp_INCLUDED

include/boost/typeof/std/ostream.hpp

@@ -2,13 +2,23 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_ostream_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_ostream_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <ostream>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/string.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ostream, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ostream, 2)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TYPE(std::ostream)
+#endif//BOOST_TYPEOF_COMPLIANT
+
 #endif//BOOST_TYPEOF_STD_ostream_hpp_INCLUDED

include/boost/typeof/std/queue.hpp

@@ -2,13 +2,20 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_queue_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_queue_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <queue>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/memory.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::queue, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::queue, 2)
+
 #endif//BOOST_TYPEOF_STD_queue_hpp_INCLUDED

include/boost/typeof/std/set.hpp

@@ -2,14 +2,27 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_set_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_set_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <set>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/memory.hpp>
 #include <boost/typeof/std/functional.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::set, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::set, 2)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::set, 3)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::multiset, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::multiset, 2)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::multiset, 3)
+
 #endif//BOOST_TYPEOF_STD_set_hpp_INCLUDED

include/boost/typeof/std/sstream.hpp

@@ -2,14 +2,43 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_sstream_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_sstream_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <sstream>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/string.hpp>
 #include <boost/typeof/std/memory.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_stringbuf, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_stringbuf, 2)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_stringbuf, 3)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_istringstream, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_istringstream, 2)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_istringstream, 3)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ostringstream, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ostringstream, 2)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_ostringstream, 3)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_stringstream, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_stringstream, 2)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_stringstream, 3)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TYPE(std::stringbuf)
+BOOST_TYPEOF_REGISTER_TYPE(std::istringstream)
+BOOST_TYPEOF_REGISTER_TYPE(std::ostringstream)
+BOOST_TYPEOF_REGISTER_TYPE(std::stringstream)
+#endif//BOOST_TYPEOF_COMPLIANT
+
 #endif//BOOST_TYPEOF_STD_sstream_hpp_INCLUDED

include/boost/typeof/std/stack.hpp

@@ -2,13 +2,20 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_stack_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_stack_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <stack>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/memory.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::stack, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::stack, 2)
+
 #endif//BOOST_TYPEOF_STD_stack_hpp_INCLUDED

include/boost/typeof/std/streambuf.hpp

@@ -2,13 +2,20 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_streambuf_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_streambuf_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <streambuf>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/string.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_streambuf, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_streambuf, 2)
+
 #endif//BOOST_TYPEOF_STD_streambuf_hpp_INCLUDED

include/boost/typeof/std/string.hpp

@@ -2,13 +2,25 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_string_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_string_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <string>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/memory.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::char_traits, 1)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_string, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_string, 2)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::basic_string, 3)
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TYPE(std::string)
+#endif//BOOST_TYPEOF_COMPLIANT
+
 #endif//BOOST_TYPEOF_STD_string_hpp_INCLUDED

include/boost/typeof/std/utility.hpp

@@ -2,12 +2,16 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_utility_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_utility_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <utility>
 #include <boost/typeof/typeof.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::pair, 2)
+
 #endif//BOOST_TYPEOF_STD_utility_hpp_INCLUDED

include/boost/typeof/std/valarray.hpp

@@ -2,12 +2,22 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_valarray_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_valarray_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <valarray>
 #include <boost/typeof/typeof.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::valarray, 1)
+BOOST_TYPEOF_REGISTER_TYPE(std::slice)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::slice_array, 1)
+BOOST_TYPEOF_REGISTER_TYPE(std::gslice)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::gslice_array, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::mask_array, 1)
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::indirect_array, 1)
+
 #endif//BOOST_TYPEOF_STD_valarray_hpp_INCLUDED

include/boost/typeof/std/vector.hpp

@@ -2,13 +2,20 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
+// This is a generated file -- please do not modify by hand.
+
 #ifndef BOOST_TYPEOF_STD_vector_hpp_INCLUDED
 #define BOOST_TYPEOF_STD_vector_hpp_INCLUDED
 
-// This header is no longer useful and is only retained for compatibility
-
 #include <vector>
 #include <boost/typeof/typeof.hpp>
 #include <boost/typeof/std/memory.hpp>
 
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+#ifdef BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::vector, 1)
+#endif//BOOST_TYPEOF_COMPLIANT
+BOOST_TYPEOF_REGISTER_TEMPLATE(std::vector, 2)
+
 #endif//BOOST_TYPEOF_STD_vector_hpp_INCLUDED

include/boost/typeof/template_encoding.hpp

@@ -0,0 +1,148 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Copyright (C) 2005 Peder Holt
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_TEMPLATE_ENCODING_HPP_INCLUDED
+#define BOOST_TYPEOF_TEMPLATE_ENCODING_HPP_INCLUDED
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repetition/enum_trailing.hpp>
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/detail/is_unary.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/tuple/eat.hpp>
+#include <boost/preprocessor/seq/transform.hpp>
+#include <boost/preprocessor/seq/for_each_i.hpp>
+
+#include <boost/typeof/encode_decode.hpp>
+#include <boost/typeof/int_encoding.hpp>
+
+#include <boost/typeof/type_template_param.hpp>
+#include <boost/typeof/integral_template_param.hpp>
+#include <boost/typeof/template_template_param.hpp>
+
+// The template parameter description, entered by the user,
+// is converted into a polymorphic "object" 
+// that is used to generate the code responsible for
+// encoding/decoding the parameter, etc.
+
+// make sure to cat the sequence first, and only then add the prefix.
+#define BOOST_TYPEOF_MAKE_OBJ(elem) BOOST_PP_CAT(\
+    BOOST_TYPEOF_MAKE_OBJ,\
+    BOOST_PP_SEQ_CAT((_) BOOST_TYPEOF_TO_SEQ(elem))\
+    )
+
+#define BOOST_TYPEOF_TO_SEQ(tokens) BOOST_TYPEOF_ ## tokens ## _BOOST_TYPEOF 
+
+// BOOST_TYPEOF_REGISTER_TEMPLATE
+
+#define BOOST_TYPEOF_REGISTER_TEMPLATE(Name, Params)\
+    BOOST_TYPEOF_REGISTER_TEMPLATE_IMPL(\
+        Name,\
+        BOOST_TYPEOF_MAKE_OBJS(BOOST_TYPEOF_TOSEQ(Params)),\
+        BOOST_PP_SEQ_SIZE(BOOST_TYPEOF_TOSEQ(Params)),\
+        BOOST_TYPEOF_UNIQUE_ID())\
+
+#define BOOST_TYPEOF_OBJECT_MAKER(s, data, elem)\
+    BOOST_TYPEOF_MAKE_OBJ(elem)
+
+#define BOOST_TYPEOF_MAKE_OBJS(Params)\
+    BOOST_PP_SEQ_TRANSFORM(BOOST_TYPEOF_OBJECT_MAKER, ~, Params)
+
+// As suggested by Paul Mensonides:
+
+#define BOOST_TYPEOF_TOSEQ(x)\
+    BOOST_PP_IIF(\
+        BOOST_PP_IS_UNARY(x),\
+        x BOOST_PP_TUPLE_EAT(3), BOOST_PP_REPEAT\
+    )(x, BOOST_TYPEOF_TOSEQ_2, ~)
+
+#define BOOST_TYPEOF_TOSEQ_2(z, n, _) (class)
+
+// BOOST_TYPEOF_VIRTUAL
+
+#define BOOST_TYPEOF_CAT_4(a, b, c, d) BOOST_TYPEOF_CAT_4_I(a, b, c, d)
+#define BOOST_TYPEOF_CAT_4_I(a, b, c, d) a ## b ## c ## d
+
+#define BOOST_TYPEOF_VIRTUAL(Fun, Obj)\
+    BOOST_TYPEOF_CAT_4(BOOST_TYPEOF_, BOOST_PP_SEQ_HEAD(Obj), _, Fun)
+
+// BOOST_TYPEOF_SEQ_ENUM[_TRAILING][_1]
+// Two versions provided due to reentrancy issue
+
+#define BOOST_TYPEOF_SEQ_EXPAND_ELEMENT(z,n,seq)\
+   BOOST_PP_SEQ_ELEM(0,seq) (z,n,BOOST_PP_SEQ_ELEM(n,BOOST_PP_SEQ_ELEM(1,seq)))
+
+#define BOOST_TYPEOF_SEQ_ENUM(seq,macro)\
+    BOOST_PP_ENUM(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT,(macro)(seq))
+
+#define BOOST_TYPEOF_SEQ_ENUM_TRAILING(seq,macro)\
+    BOOST_PP_ENUM_TRAILING(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT,(macro)(seq))
+
+#define BOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1(z,n,seq)\
+    BOOST_PP_SEQ_ELEM(0,seq) (z,n,BOOST_PP_SEQ_ELEM(n,BOOST_PP_SEQ_ELEM(1,seq)))
+
+#define BOOST_TYPEOF_SEQ_ENUM_1(seq,macro)\
+    BOOST_PP_ENUM(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1,(macro)(seq))
+
+#define BOOST_TYPEOF_SEQ_ENUM_TRAILING_1(seq,macro)\
+    BOOST_PP_ENUM_TRAILING(BOOST_PP_SEQ_SIZE(seq),BOOST_TYPEOF_SEQ_EXPAND_ELEMENT_1,(macro)(seq))
+
+//
+
+#define BOOST_TYPEOF_PLACEHOLDER(z, n, elem)\
+    BOOST_TYPEOF_VIRTUAL(PLACEHOLDER, elem)(elem)
+
+#define BOOST_TYPEOF_PLACEHOLDER_TYPES(z, n, elem)\
+    BOOST_TYPEOF_VIRTUAL(PLACEHOLDER_TYPES, elem)(elem, n)
+
+#define BOOST_TYPEOF_REGISTER_TEMPLATE_ENCODE_PARAM(r, data, n, elem)\
+    BOOST_TYPEOF_VIRTUAL(ENCODE, elem)(elem, n)
+
+#define BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM(r, data, n, elem)\
+    BOOST_TYPEOF_VIRTUAL(DECODE, elem)(elem, n)
+
+#define BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR(z, n, elem) \
+    BOOST_TYPEOF_VIRTUAL(EXPANDTYPE, elem)(elem) BOOST_PP_CAT(P, n)
+
+#define BOOST_TYPEOF_REGISTER_DEFAULT_TEMPLATE_TYPE(Name,Params,ID)\
+    Name< BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params), P) >
+
+//Since we are creating an internal decode struct, we need to use different template names, T instead of P.
+#define BOOST_TYPEOF_REGISTER_DECODER_TYPE_PARAM_PAIR(z,n,elem) \
+    BOOST_TYPEOF_VIRTUAL(EXPANDTYPE, elem)(elem) BOOST_PP_CAT(T, n)
+
+//Default template param decoding
+#define BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TYPE(Name,Params)\
+    typedef Name<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),P)> type;        
+
+//Branch the decoding
+#define BOOST_TYPEOF_TYPEDEF_DECODED_TYPE(Name,Params)\
+    BOOST_PP_IF(BOOST_TYPEOF_HAS_TEMPLATES(Params),\
+        BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TEMPLATE_TYPE,\
+        BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TYPE)(Name,Params)
+
+#define BOOST_TYPEOF_REGISTER_TEMPLATE_IMPL(Name, Params, Size, ID)\
+    namespace boost{namespace type_of{namespace{\
+    BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_IMPL(Name, Params, ID)\
+    template<class V\
+        BOOST_TYPEOF_SEQ_ENUM_TRAILING(Params, BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR)\
+    >\
+    struct encode_type_impl<V, Name<BOOST_PP_ENUM_PARAMS(Size, P)> >\
+    {\
+        typedef typename push_back<V, boost::mpl::size_t<ID> >::type V0;\
+        BOOST_PP_SEQ_FOR_EACH_I(BOOST_TYPEOF_REGISTER_TEMPLATE_ENCODE_PARAM, ~, Params)\
+        typedef BOOST_PP_CAT(V, Size) type;\
+    };\
+    template<class Iter>\
+    struct decode_type_impl<boost::mpl::size_t<ID>, Iter>\
+    {\
+        typedef Iter iter0;\
+        BOOST_PP_SEQ_FOR_EACH_I(BOOST_TYPEOF_REGISTER_TEMPLATE_DECODE_PARAM, ~, Params)\
+        BOOST_TYPEOF_TYPEDEF_DECODED_TYPE(Name, Params)\
+        typedef BOOST_PP_CAT(iter, Size) iter;\
+    };\
+    }}}
+
+#endif//BOOST_TYPEOF_TEMPLATE_ENCODING_HPP_INCLUDED

include/boost/typeof/template_template_param.hpp

@@ -0,0 +1,126 @@
+// Copyright (C) 2005 Peder Holt
+// Copyright (C) 2005 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_TEMPLATE_TEMPLATE_PARAM_HPP_INCLUDED
+#define BOOST_TYPEOF_TEMPLATE_TEMPLATE_PARAM_HPP_INCLUDED
+
+#include <boost/preprocessor/logical/or.hpp>
+#include <boost/preprocessor/seq/fold_left.hpp>
+#include <boost/preprocessor/seq/enum.hpp>
+
+#define BOOST_TYPEOF_MAKE_OBJ_template(x)   BOOST_TYPEOF_TEMPLATE_PARAM(x)
+#define BOOST_TYPEOF_TEMPLATE(X) template(X) BOOST_TYPEOF_EAT
+#define BOOST_TYPEOF_template(X) (template(X))
+
+#define BOOST_TYPEOF_TEMPLATE_PARAM(Params)\
+    (TEMPLATE_PARAM)\
+    (Params)
+
+#define BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)\
+    BOOST_TYPEOF_TOSEQ(BOOST_PP_SEQ_ELEM(1, This))
+
+//Encode / decode this
+#define BOOST_TYPEOF_TEMPLATE_PARAM_ENCODE(This, n)\
+   typedef typename encode_template<BOOST_PP_CAT(V, n),\
+       BOOST_PP_CAT(P, n)<BOOST_TYPEOF_SEQ_ENUM(BOOST_TYPEOF_MAKE_OBJS(BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This)),BOOST_TYPEOF_PLACEHOLDER)>\
+   >::type BOOST_PP_CAT(V, BOOST_PP_INC(n));
+
+#define BOOST_TYPEOF_TEMPLATE_PARAM_DECODE(This, n)\
+   typedef decode_template< BOOST_PP_CAT(iter, n) > BOOST_PP_CAT(d, n);\
+   typedef typename BOOST_PP_CAT(d, n)::type BOOST_PP_CAT(P, n);\
+   typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter,BOOST_PP_INC(n));
+
+// template<class, unsigned int, ...> class
+#define BOOST_TYPEOF_TEMPLATE_PARAM_EXPANDTYPE(This) \
+    template <BOOST_PP_SEQ_ENUM(BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(This))> class
+
+#define BOOST_TYPEOF_TEMPLATE_PARAM_PLACEHOLDER(Param)\
+    Nested_Template_Template_Arguments_Not_Supported
+
+//'template<class,int> class' is reduced to 'class'
+#define BOOST_TYPEOF_TEMPLATE_PARAM_DECLARATION_TYPE(Param) class
+
+// T3<int, (unsigned int)0, ...>
+#define BOOST_TYPEOF_TEMPLATE_PARAM_PLACEHOLDER_TYPES(Param, n)\
+    BOOST_PP_CAT(T,n)<BOOST_TYPEOF_SEQ_ENUM_1(BOOST_TYPEOF_MAKE_OBJS(BOOST_TYPEOF_TEMPLATE_PARAM_GETPARAMS(Param)),BOOST_TYPEOF_PLACEHOLDER)>
+
+#define BOOST_TYPEOF_TEMPLATE_PARAM_ISTEMPLATE 1
+
+////////////////////////////
+// move to encode_decode?
+
+namespace boost
+{
+    namespace type_of 
+    {
+        namespace 
+        {
+            template<class V, class Type_Not_Registered_With_Typeof_System> struct encode_template_impl;
+            template<class T, class Iter> struct decode_template_impl;
+        }
+        template<class V, class T> struct encode_template
+            : encode_template_impl<V, T>
+        {};
+
+        template<class Iter> struct decode_template 
+            :   decode_template_impl<typename Iter::type, typename Iter::next>
+        {};
+    }
+}
+
+////////////////////////////
+// move to template_encoding.hpp?
+
+//Template template registration
+#define BOOST_TYPEOF_REGISTER_TYPE_FOR_TEMPLATE_TEMPLATE(Name,Params,ID)\
+    template<class V\
+        BOOST_TYPEOF_SEQ_ENUM_TRAILING(Params,BOOST_TYPEOF_REGISTER_TEMPLATE_PARAM_PAIR)\
+    >\
+    struct encode_template_impl<V,Name<\
+        BOOST_PP_ENUM_PARAMS(\
+        BOOST_PP_SEQ_SIZE(Params),\
+        P)> >\
+    :   push_back<V, mpl::size_t<ID> >\
+    {\
+    };\
+    template<class Iter> struct decode_template_impl<mpl::size_t<ID>, Iter>\
+    {\
+        BOOST_PP_REPEAT(BOOST_PP_SEQ_SIZE(Params),BOOST_TYPEOF_TYPEDEF_INT_PN,_)\
+        typedef Name<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_PLACEHOLDER)> type;\
+        typedef Iter iter;\
+    };
+
+#define BOOST_TYPEOF_TYPEDEF_INT_PN(z,n,Params) typedef int BOOST_PP_CAT(P,n);
+
+#define BOOST_TYPEOF_REGISTER_NOTHING(Name,Params,ID)
+
+//Template template param decoding
+#define BOOST_TYPEOF_TYPEDEF_DECODED_TEMPLATE_TEMPLATE_TYPE(Name,Params)\
+    template<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_REGISTER_DECLARE_DECODER_TYPE_PARAM_PAIR)>\
+    struct decode_params;\
+    template<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_REGISTER_DECODER_TYPE_PARAM_PAIR)>\
+    struct decode_params<BOOST_TYPEOF_SEQ_ENUM(Params,BOOST_TYPEOF_PLACEHOLDER_TYPES) >\
+    {\
+        typedef Name<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),T)> type;\
+    };\
+    typedef typename decode_params<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(Params),P)>::type type;
+
+#define BOOST_TYPEOF_REGISTER_DECLARE_DECODER_TYPE_PARAM_PAIR(z,n,elem) \
+    BOOST_TYPEOF_VIRTUAL(DECLARATION_TYPE, elem)(elem) BOOST_PP_CAT(T, n)
+
+// BOOST_TYPEOF_HAS_TEMPLATES
+#define BOOST_TYPEOF_HAS_TEMPLATES(Params)\
+    BOOST_PP_SEQ_FOLD_LEFT(BOOST_TYPEOF_HAS_TEMPLATES_OP, 0, Params)
+
+#define BOOST_TYPEOF_HAS_TEMPLATES_OP(s, state, elem)\
+    BOOST_PP_OR(state, BOOST_TYPEOF_VIRTUAL(ISTEMPLATE, elem))
+
+//Define template template arguments
+#define BOOST_TYPEOF_REGISTER_TEMPLATE_TEMPLATE_IMPL(Name,Params,ID)\
+    BOOST_PP_IF(BOOST_TYPEOF_HAS_TEMPLATES(Params),\
+        BOOST_TYPEOF_REGISTER_NOTHING,\
+        BOOST_TYPEOF_REGISTER_TYPE_FOR_TEMPLATE_TEMPLATE)(Name,Params,ID)
+
+#endif //BOOST_TYPEOF_TEMPLATE_TEMPLATE_PARAM_HPP_INCLUDED

include/boost/typeof/type_encoding.hpp

@@ -0,0 +1,24 @@
+// Copyright (C) 2004 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_TYPE_ENCODING_HPP_INCLUDED
+#define BOOST_TYPEOF_TYPE_ENCODING_HPP_INCLUDED
+
+#define BOOST_TYPEOF_REGISTER_TYPE_IMPL(T, Id)                          \
+                                                                        \
+    template<class V> struct encode_type_impl<V, T >                    \
+        : push_back<V, mpl::size_t<Id> >                   \
+    {};                                                                 \
+    template<class Iter> struct decode_type_impl<mpl::size_t<Id>, Iter> \
+    {                                                                   \
+        typedef T type;                                                 \
+        typedef Iter iter;                                              \
+    };
+
+#define BOOST_TYPEOF_REGISTER_TYPE(Type)                                \
+    namespace boost{namespace type_of{namespace{                        \
+        BOOST_TYPEOF_REGISTER_TYPE_IMPL(Type, BOOST_TYPEOF_UNIQUE_ID()) \
+    }}}
+
+#endif//BOOST_TYPEOF_TYPE_ENCODING_HPP_INCLUDED

include/boost/typeof/type_template_param.hpp

@@ -0,0 +1,37 @@
+// Copyright (C) 2005 Arkadiy Vertleyb
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED
+#define BOOST_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED
+
+#define BOOST_TYPEOF_class_BOOST_TYPEOF (class)
+#define BOOST_TYPEOF_typename_BOOST_TYPEOF (typename)
+
+#define BOOST_TYPEOF_MAKE_OBJ_class BOOST_TYPEOF_TYPE_PARAM
+#define BOOST_TYPEOF_MAKE_OBJ_typename BOOST_TYPEOF_TYPE_PARAM
+
+#define BOOST_TYPEOF_TYPE_PARAM\
+    (TYPE_PARAM)
+
+#define BOOST_TYPEOF_TYPE_PARAM_EXPANDTYPE(Param) class
+
+// TYPE_PARAM "virtual functions" implementation
+
+#define BOOST_TYPEOF_TYPE_PARAM_ENCODE(This, n)\
+    typedef typename encode_type<\
+        BOOST_PP_CAT(V, n),\
+        BOOST_PP_CAT(P, n)\
+    >::type BOOST_PP_CAT(V, BOOST_PP_INC(n)); 
+
+#define BOOST_TYPEOF_TYPE_PARAM_DECODE(This, n)\
+    typedef decode_type< BOOST_PP_CAT(iter, n) > BOOST_PP_CAT(d, n);\
+    typedef typename BOOST_PP_CAT(d, n)::type BOOST_PP_CAT(P, n);\
+    typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter, BOOST_PP_INC(n));
+
+#define BOOST_TYPEOF_TYPE_PARAM_PLACEHOLDER(Param) int
+#define BOOST_TYPEOF_TYPE_PARAM_DECLARATION_TYPE(Param) class
+#define BOOST_TYPEOF_TYPE_PARAM_PLACEHOLDER_TYPES(Param, n) BOOST_PP_CAT(T,n)
+#define BOOST_TYPEOF_TYPE_PARAM_ISTEMPLATE 0
+
+#endif//BOOST_TYPEOF_TYPE_TEMPLATE_PARAM_HPP_INCLUDED

include/boost/typeof/typeof.hpp

@@ -1,34 +1,89 @@
 // Copyright (C) 2004 Arkadiy Vertleyb
-// 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)
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
 #ifndef BOOST_TYPEOF_TYPEOF_HPP_INCLUDED
 #define BOOST_TYPEOF_TYPEOF_HPP_INCLUDED
 
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/seq/cat.hpp>
+#include <boost/preprocessor/expand.hpp>
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1900)
+// implementation
 
-# include <boost/typeof/msvc/typeof_impl.hpp>
+#include <boost/typeof/config.hpp>
 
-# define BOOST_TYPEOF_REGISTER_TYPE(x)
-# define BOOST_TYPEOF_REGISTER_TEMPLATE(x, params)
+// BOOST_TYPEOF, BOOST_TYPEOF_TPL
 
-#else
+#if defined(BOOST_TYPEOF_NATIVE) && defined(BOOST_MSVC)
+#   define BOOST_TYPEOF_TEXT "using msvc 'native' imlementation"
+#   include <boost/typeof/message.hpp>
+#	include <boost/typeof/msvc/typeof_impl.hpp>
 
-# include <boost/typeof/decltype.hpp>
+#elif defined(BOOST_TYPEOF_COMPLIANT)
+#   define BOOST_TYPEOF_TEXT "using compliant imlementation"
+#   include <boost/typeof/message.hpp>
+#   include <boost/typeof/typeof_impl.hpp>
+
+#else//BOOST_TYPEOF_NATIVE
+
+#   define BOOST_TYPEOF_TEXT "using native imlementation"
+#   include <boost/typeof/message.hpp>
+
+#	if !defined BOOST_TYPEOF_KEYWORD
+#		define BOOST_TYPEOF_KEYWORD __typeof__
+#	endif
+
+    /* Native __typeof__ can accept either type or value.
+    Something like "int()" can be viewed either way, but 
+    __typeof__ consideres it a type.  We force it otherwise
+    to ensure consistensy with emulation */
+
+    namespace boost { namespace type_of {
+        template<class T> T& ensure_obj(const T&);
+    }}
+
+#   define BOOST_TYPEOF(expr) BOOST_TYPEOF_KEYWORD(boost::type_of::ensure_obj(expr))
+
+#	define BOOST_TYPEOF_TPL BOOST_TYPEOF
 
 #endif
 
+// auto
+#define BOOST_AUTO(Var, Expr) BOOST_TYPEOF(Expr) Var = Expr
+#define BOOST_AUTO_TPL(Var, Expr) BOOST_TYPEOF_TPL(Expr) Var = Expr
+
+// lvalue typeof
+
+#	include <boost/typeof/lvalue_typeof.hpp>
+
+// type/template encoding
+
+#if defined(BOOST_TYPEOF_COMPLIANT)
+#	include <boost/typeof/type_encoding.hpp>
+#	include <boost/typeof/template_encoding.hpp>
+#else   //BOOST_TYPEOF_NATIVE
+#	define BOOST_TYPEOF_REGISTER_TYPE(x)
+#	define BOOST_TYPEOF_REGISTER_TEMPLATE(x, params)
+#endif
+
 #define BOOST_TYPEOF_UNIQUE_ID()\
-     BOOST_TYPEOF_REGISTRATION_GROUP * 0x10000 + __LINE__
+    BOOST_TYPEOF_REGISTRATION_GROUP * 0x10000 + __LINE__
 
 #define BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()\
-     <boost/typeof/incr_registration_group.hpp>
+    <boost/typeof/increment_registration_group.hpp>
 
-// auto
-#define BOOST_AUTO(Var, Expr) auto Var = Expr
-#define BOOST_AUTO_TPL(Var, Expr) auto Var = Expr
+// register stuff
+#include <boost/typeof/register_fundamental.hpp>
+
+#if defined(BOOST_TYPEOF_COMPLIANT)
+
+#	include <boost/typeof/modifiers.hpp>
+#	include <boost/typeof/pointers_data_members.hpp>
+#	include <boost/typeof/register_functions.hpp>
+
+#else //BOOST_TYPEOF_NATIVE
+
+#endif
 
 #endif//BOOST_TYPEOF_TYPEOF_HPP_INCLUDED

include/boost/typeof/typeof_impl.hpp

@@ -0,0 +1,59 @@
+// Copyright (C) 2004, 2005 Arkadiy Vertleyb
+// Copyright (C) 2005 Peder Holt
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_TYPEOF_IMPL_HPP_INCLUDED
+#define BOOST_TYPEOF_TYPEOF_IMPL_HPP_INCLUDED
+
+#include <boost/mpl/size_t.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/typeof/encode_decode.hpp>
+#include <boost/typeof/vector.hpp>
+
+#define BOOST_TYPEOF_VECTOR(n) BOOST_PP_CAT(boost::type_of::vector, n)
+
+#define BOOST_TYPEOF_sizer_item(z, n, _)\
+    char item ## n[V::item ## n ::value];
+
+namespace boost { namespace type_of {
+    
+    template<class V> 
+    struct sizer
+    {
+        // char item0[V::item0::value];
+        // char item1[V::item1::value];
+        // ...
+
+        BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE, BOOST_TYPEOF_sizer_item, ~)
+    };
+
+    template<class T> 
+    sizer<typename encode_type<BOOST_TYPEOF_VECTOR(0)<>, T>::type> encode(const T&);
+}}
+
+#undef BOOST_TYPEOF_sizer_item
+
+namespace boost { namespace type_of {
+
+    template<class V>
+    struct decode_begin
+    {
+        typedef typename decode_type<typename V::begin>::type type;
+    };
+}}
+
+#define BOOST_TYPEOF_TYPEITEM(z, n, expr)\
+    boost::mpl::size_t<sizeof(boost::type_of::encode(expr).item ## n)>
+
+#define BOOST_TYPEOF_ENCODED_VECTOR(Expr)                                   \
+    BOOST_TYPEOF_VECTOR(BOOST_TYPEOF_LIMIT_SIZE)<                           \
+        BOOST_PP_ENUM(BOOST_TYPEOF_LIMIT_SIZE, BOOST_TYPEOF_TYPEITEM, Expr) \
+    >
+
+#define BOOST_TYPEOF(Expr)\
+    boost::type_of::decode_begin<BOOST_TYPEOF_ENCODED_VECTOR(Expr) >::type
+
+#define BOOST_TYPEOF_TPL typename BOOST_TYPEOF
+
+#endif//BOOST_TYPEOF_COMPLIANT_TYPEOF_IMPL_HPP_INCLUDED

include/boost/typeof/vector.hpp

@@ -0,0 +1,87 @@
+// Copyright (C) 2005 Arkadiy Vertleyb
+// Copyright (C) 2005 Peder Holt
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_TYPEOF_VECTOR_HPP_INCLUDED
+#define BOOST_TYPEOF_VECTOR_HPP_INCLUDED
+
+#include <boost/mpl/int.hpp>
+#include <boost/preprocessor/enum_params.hpp>
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/preprocessor/repeat_from_to.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/preprocessor/comma_if.hpp>
+
+#ifndef BOOST_TYPEOF_LIMIT_SIZE
+#   define BOOST_TYPEOF_LIMIT_SIZE 50
+#endif
+
+// iterator
+
+#define BOOST_TYPEOF_spec_iter(z, n, _)\
+    template<class V>\
+    struct v_iter<V, mpl::int_<n> >\
+    {\
+        typedef typename V::item ## n type;\
+        typedef v_iter<V, mpl::int_<n + 1> > next;\
+    };
+
+namespace boost{ namespace type_of{
+
+    template<class V, class Pos> struct v_iter; // not defined
+    BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE, BOOST_TYPEOF_spec_iter, ~)
+}}
+
+#undef BOOST_TYPEOF_spec_iter
+
+// vector
+
+#define BOOST_TYPEOF_typedef_item(z, n, _)\
+    typedef P ## n item ## n;
+
+#define BOOST_TYPEOF_typedef_fake_item(z, n, _)\
+    typedef mpl::int_<1> item ## n;
+
+#define BOOST_TYPEOF_define_vector(z, n, _)\
+    template<BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_COMMA_IF(n) class T = void>\
+    struct vector ## n\
+    {\
+        typedef v_iter<vector ## n, boost::mpl::int_<0> > begin;\
+        BOOST_PP_REPEAT(n, BOOST_TYPEOF_typedef_item, ~)\
+        BOOST_PP_REPEAT_FROM_TO(n, BOOST_TYPEOF_LIMIT_SIZE, BOOST_TYPEOF_typedef_fake_item, ~)\
+    };
+
+namespace boost{ namespace type_of{
+
+    BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_TYPEOF_LIMIT_SIZE), BOOST_TYPEOF_define_vector, ~)
+}}
+
+#undef BOOST_TYPEOF_typedef_item
+#undef BOOST_TYPEOF_typedef_fake_item
+#undef BOOST_TYPEOF_define_vector
+
+// push_back
+
+#define BOOST_TYPEOF_spec_push_back(z, n, _)\
+    template<BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_COMMA_IF(n) class T>\
+    struct push_back<BOOST_PP_CAT(boost::type_of::vector, n)<BOOST_PP_ENUM_PARAMS(n, P)>, T>\
+    {\
+        typedef BOOST_PP_CAT(boost::type_of::vector, BOOST_PP_INC(n))<\
+            BOOST_PP_ENUM_PARAMS(n, P) BOOST_PP_COMMA_IF(n) T\
+        > type;\
+    };
+
+namespace boost{ namespace type_of{
+
+    template<class V, class T> struct push_back; // not defined
+    BOOST_PP_REPEAT(BOOST_TYPEOF_LIMIT_SIZE, BOOST_TYPEOF_spec_push_back, ~)
+}}
+
+#undef BOOST_TYPEOF_spec_push_back
+
+#endif//BOOST_TYPEOF_COMPLIANT_VECTOR_HPP_INCLUDED
+
+
+

index.html

@@ -1,16 +0,0 @@
-<!--
-Copyright (C) 2006 Arkadiy Vertleyb
-Use, modification and distribution is subject to the Boost Software
-License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
--->
-
-<html>
-<head>
-<meta http-equiv="refresh" content="0; URL=../../doc/html/typeof.html">
-</head>
-<body>
-Automatic redirection failed, please go to
-<a href="../../doc/html/typeof.html">../../doc/html/typeof.html</a>
-</body>
-</html>
-

meta/libraries.json

@@ -1,17 +0,0 @@
-{
-    "key": "typeof",
-    "name": "Typeof",
-    "authors": [
-        "Arkadiy Vertleyb",
-        "Peder Holt"
-    ],
-    "description": "Typeof operator emulation.",
-    "category": [
-        "Emulation"
-    ],
-    "maintainers": [
-        "Arkadiy Vertleyb <vertleyb -at- hotmail.com>",
-        "Peder Holt <peder.holt -at- gmail.com>"
-    ],
-    "cxxstd": "11"
-}

test/CMakeLists.txt

@@ -1,54 +0,0 @@
-# Copyright 2018-2020 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(BoostTest OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
-
-if(NOT HAVE_BOOST_TEST)
-  return()
-endif()
-
-macro(typeof_test s1)
-
-  string(MAKE_C_IDENTIFIER ${s1} n1)
-
-  boost_test(TYPE compile SOURCES ${s1} ${ARGN} COMPILE_DEFINITIONS BOOST_TYPEOF_NATIVE NAME ${n1}_native)
-  boost_test(TYPE compile SOURCES ${s1} ${ARGN} COMPILE_DEFINITIONS BOOST_TYPEOF_EMULATION NAME ${n1}_emulation)
-
-endmacro()
-
-set(BOOST_TEST_LINK_LIBRARIES Boost::typeof Boost::core Boost::type_traits Boost::static_assert)
-
-set(tests
-
-data_member.cpp
-function.cpp
-function_binding.cpp
-function_ptr.cpp
-function_ptr_from_tpl.cpp
-function_ref.cpp
-member_function.cpp
-modifiers.cpp
-msvc_typeof_in_lambda.cpp
-nested_typedef.cpp
-noncopyable.cpp
-std.cpp
-template_dependent.cpp
-template_enum.cpp
-template_int.cpp
-template_multiword.cpp
-template_tpl.cpp
-template_type.cpp
-type.cpp
-)
-
-foreach(test IN LISTS tests)
-
-  typeof_test(${test})
-
-endforeach()
-
-boost_test(TYPE run SOURCES odr1.cpp odr2.cpp COMPILE_DEFINITIONS BOOST_TYPEOF_NATIVE NAME odr_native)
-boost_test(TYPE run SOURCES odr1.cpp odr2.cpp COMPILE_DEFINITIONS BOOST_TYPEOF_EMULATED NAME odr_emulated)
-
-boost_test(TYPE run SOURCES odr_no_uns1.cpp odr_no_uns2.cpp COMPILE_DEFINITIONS BOOST_TYPEOF_EMULATED NAME odr_no_uns)

test/Jamfile.v2

@@ -1,57 +0,0 @@
-# Copyright (C) 2006 Vladimir Prus
-# Copyright (C) 2006 Arkadiy Vertleyb
-# Use, modification and distribution is subject to the Boost Software
-# License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-# Boost Typeof Library test Jamfile
-
-import testing ;
-import set ;
-
-# The special requirement is not ported yet.
-#
-#local rule special-requirements ( toolset variant : properties * )
-#{
-#    # Tru64/CXX6.5 hangs on most tests, so just turn it off completely.
-#
-#    if $(UNIX) && $(OS) = OSF
-#    {
-#        switch $(toolset)
-#        {
-#            case tru64cxx65* : properties =
-#                [ replace-properties $(properties) : <build>no ] ;
-#        }
-#    }
-#    
-#    return $(properties) ;
-#}
-
-rule typeof-test ( source )
-{
-   return [ compile $(source) : <define>BOOST_TYPEOF_NATIVE :
-                $(source:B)_native ]
-          [ compile $(source) : <define>BOOST_TYPEOF_EMULATION :
-                $(source:B)_emulation ] 
-          ;        
-}
-
-rule all-tests ( )
-{
-    local all ;
-#    for local t in [ set.difference [ glob *.cpp ] : odr1.cpp odr2.cpp ]
-    for local t in [ set.difference [ glob *.cpp ] : [ glob odr*.cpp ] ]
-    {
-        all += [ typeof-test $(t) ] ;
-    }
-    all += [ run odr1.cpp odr2.cpp : : : <define>BOOST_TYPEOF_NATIVE :
-                odr_native ] ;
-    all += [ run odr1.cpp odr2.cpp : : : <define>BOOST_TYPEOF_EMULATION :
-                odr_emulation ] ;		
-    all += [ run odr_no_uns1.cpp odr_no_uns2.cpp : : : <define>BOOST_TYPEOF_EMULATION : 
-                odr_no_uns ] ;		
-    return $(all) ;    
-}
-
-test-suite "typeof" 
-	:  [ all-tests ]
-    ;

test/cmake_install_test/CMakeLists.txt

@@ -1,17 +0,0 @@
-# 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_typeof REQUIRED)
-
-add_executable(main main.cpp)
-target_link_libraries(main Boost::typeof)
-
-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

@@ -1,11 +0,0 @@
-// Copyright 2017, 2021 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/typeof/typeof.hpp>
-
-int main()
-{
-    BOOST_AUTO(x, 5);
-    return x == 5? 0: 1;
-}

test/cmake_subdir_test/CMakeLists.txt

@@ -1,34 +0,0 @@
-# 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/typeof)
-
-set(deps
-
-# Primary dependencies
-
-config
-
-# Secondary dependencies
-)
-
-foreach(dep IN LISTS deps)
-
-  add_subdirectory(../../../${dep} boostorg/${dep})
-
-endforeach()
-
-# --target check
-
-add_executable(main main.cpp)
-target_link_libraries(main Boost::typeof)
-
-enable_testing()
-add_test(main main)
-
-add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/cmake_subdir_test/main.cpp

@@ -1,11 +0,0 @@
-// Copyright 2017, 2021 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/typeof/typeof.hpp>
-
-int main()
-{
-    BOOST_AUTO(x, 5);
-    return x == 5? 0: 1;
-}

test/data_member.cpp

@@ -1,11 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-struct x;
-BOOST_TYPEOF_REGISTER_TYPE(x)
-
-BOOST_STATIC_ASSERT(boost::type_of::test<double x::*>::value);

test/function.cpp

@@ -1,10 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-
-BOOST_STATIC_ASSERT(boost::type_of::test<void()>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<double(bool)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<void(...)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<float(int, ...)>::value);

test/function_binding.cpp

@@ -1,22 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/typeof/typeof.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/static_assert.hpp>
-
-int foo1(double);
-int foo2(...);
-int foo3(int, ...);
-typedef int(&FREF1)(double);
-typedef int(&FREF2)(...);
-typedef int(&FREF3)(int, ...);
-FREF1 fref1 = *foo1;
-FREF2 fref2 = *foo2;
-FREF3 fref3 = *foo3;
-
-BOOST_STATIC_ASSERT((boost::is_same<BOOST_TYPEOF(fref1), int(double)>::value));
-BOOST_STATIC_ASSERT((boost::is_same<BOOST_TYPEOF(fref2), int(...)>::value));
-BOOST_STATIC_ASSERT((boost::is_same<BOOST_TYPEOF(fref3), int(int,...)>::value));

test/function_ptr.cpp

@@ -1,26 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-
-BOOST_STATIC_ASSERT(boost::type_of::test<double(*)()>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<double(*)(int, double, short, char*, bool, char, float, long, unsigned short)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<void(*)()>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<void(*)(int, double, short, char*, bool, char, float, long, unsigned short)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<void(*)(...)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<void(*)(int, double, short, char*, bool, char, float, long, unsigned short, ...)>::value);
-
-// check that const gets stripped from function pointer
-
-int foo1(double);
-int foo2(...);
-typedef int(*PTR1)(double);
-typedef int(*PTR2)(...);
-typedef const PTR1 CPTR1;
-typedef const PTR2 CPTR2;
-CPTR1 cptr1 = foo1;
-CPTR2 cptr2 = foo2;
-
-BOOST_STATIC_ASSERT((boost::is_same<BOOST_TYPEOF(cptr1), PTR1>::value));
-BOOST_STATIC_ASSERT((boost::is_same<BOOST_TYPEOF(cptr2), PTR2>::value));

test/function_ptr_from_tpl.cpp

@@ -1,28 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/typeof/typeof.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/static_assert.hpp>
-
-void f1() {}
-void f2(...) {}
-
-template<class T> 
-struct tpl1
-{
-    typedef BOOST_TYPEOF_TPL(&f1) type;
-};
-
-template<class T> 
-struct tpl2
-{
-    typedef BOOST_TYPEOF_TPL(&f2) type;
-};
-
-typedef void(*fun1_type)();
-typedef void(*fun2_type)(...);
- 
-BOOST_STATIC_ASSERT((boost::is_same<tpl1<void>::type, fun1_type>::value));
-BOOST_STATIC_ASSERT((boost::is_same<tpl2<void>::type, fun2_type>::value));

test/function_ref.cpp

@@ -1,10 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-
-BOOST_STATIC_ASSERT(boost::type_of::test<void(&)()>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<int(&)(int, short)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<int(&)(...)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<int(&)(int,...)>::value);

test/member_function.cpp

@@ -1,10 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-
-BOOST_STATIC_ASSERT(boost::type_of::test<double(*)()>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<double(*)(int, double, short, char*, bool, char, float, long, unsigned short)>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<void(*)()>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<void(*)(int, double, short, char*, bool, char, float, long, unsigned short)>::value);

test/modifiers.cpp

@@ -1,19 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-struct x{};
-BOOST_TYPEOF_REGISTER_TYPE(x)
-
-BOOST_STATIC_ASSERT(boost::type_of::test<x*>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<x&>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<x[20]>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<const x>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<volatile x>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<volatile const x>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<const x&>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<const x*>::value);
-

test/msvc_typeof_in_lambda.cpp

@@ -1,74 +0,0 @@
-// Copyright (C) 2018 Tobias Loew
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/config.hpp>
-#include <boost/config/pragma_message.hpp>
-
-#if defined(BOOST_NO_CXX11_LAMBDAS)
-
-BOOST_PRAGMA_MESSAGE("Skipping test due to BOOST_NO_CXX11_LAMBDAS")
-int main() {}
-
-#elif defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
-
-BOOST_PRAGMA_MESSAGE("Skipping test due to BOOST_NO_CXX11_AUTO_DECLARATIONS")
-int main() {}
-
-#else
-
-#include <boost/typeof/typeof.hpp>
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-namespace detail {
-    template<class T> inline T& deref(T& r) {
-        return  r;
-    }
-    template<class T>
-    struct wrapper {
-        typedef T type;
-    };
-
-    template<class T> wrapper<T> wrap(T&);
-};
-
-BOOST_TYPEOF_REGISTER_TEMPLATE(::detail::wrapper, 1)
-
-void test_typeof_in_lambda() {
-    // Visual Studio 2015 (BOOST_MSVC == 1900) had an internal compiler error with Boost 1.65 and 1.66 when using BOOST_SCOPE_EXIT inside a lambda
-    // the error was due to a change of include in boost/typeof/typeof.hpp  (<boost/typeof/decltype.hpp> instead of <boost/typeof/native.hpp>)
-    // This test is an more or less minimal extract from the BOOST_SCOPE_EXIT macro expansions
-    
-    // worked also with VS 2015 in version 1.65/1.66
-    int n;
-    typedef BOOST_TYPEOF(::detail::wrap(::detail::deref(n))) n_type_wrapped;
-    typedef  n_type_wrapped::type n_type;
-
-    int test;
-
-    auto check_property = [&n,&test]() {
-        // internal compiler error with VS 2015 in version 1.65/1.66
-        // minimal extract from
-        //BOOST_SCOPE_EXIT(test) {
-        //    test = 42;
-        //}BOOST_SCOPE_EXIT_END
-
-        // this compiles always (as long as the one before outside the lambda has the same name)
-        typedef BOOST_TYPEOF(::detail::wrap(::detail::deref(n))) n_type_wrapped;
-        typedef  n_type_wrapped::type n_type;
-
-        // this fails with internal compiler error with VS 2015 in version 1.65/1.66
-        typedef BOOST_TYPEOF(::detail::wrap(::detail::deref(test))) test_type_wrapped;
-        typedef  test_type_wrapped::type test_type;
-
-    };
-
-}
-
-int main() {
-    test_typeof_in_lambda();
-
-    return 0;
-}
-
-#endif

test/nested_typedef.cpp

@@ -1,37 +0,0 @@
-// Copyright (C) 2006 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/typeof/typeof.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/static_assert.hpp>
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-
-void do_int(int) {}
-
-struct {
-    template<typename T>
-    T operator[](const T& n) {return n;}
-} int_p;
-
-
-template<typename T> struct wrap
-{
-    BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested,int_p[& do_int])
-    typedef typename nested::type type;
-};
-
-BOOST_TYPEOF_REGISTER_TEMPLATE(wrap,1)
-
-template<typename T> struct parser
-{
-    struct __rule {
-        static T & a_placeholder;
-        BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested,int_p[a_placeholder])
-        typedef typename nested::type type;
-    };
-};
-
-BOOST_STATIC_ASSERT((boost::is_same<wrap<double>::type,void(*)(int)>::value));
-BOOST_STATIC_ASSERT((boost::is_same<parser<wrap<double> >::__rule::type,wrap<double> >::value));

test/noncopyable.cpp

@@ -1,36 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-#include <boost/noncopyable.hpp>
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-struct x : boost::noncopyable
-{
-    void foo() {}
-    void bar() const {}
-};
-
-BOOST_TYPEOF_REGISTER_TYPE(x)
-
-x& make_ref()
-{
-    static x result;
-    return result;
-}
-
-const x& make_const_ref()
-{
-    static x result;
-    return result;
-}
-
-void foo()
-{
-    BOOST_AUTO(& v1, make_ref());
-    v1.foo();
-
-    BOOST_AUTO(const& v2, make_const_ref());
-    v2.bar();
-}

test/odr.hpp

@@ -1,17 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-// boostinspect:nounnamed
-
-#include <boost/typeof/typeof.hpp>
-
-struct foo
-{
-    typedef BOOST_TYPEOF(1 + 2.5) type;
-};
-
-namespace
-{
-    typedef foo::type type;
-}

test/odr1.cpp

@@ -1,12 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "odr.hpp"
-#include <iostream>
-
-int main()
-{
-    std::cout << "No ODR violation detected" << std::endl; 
-    return 0;
-}

test/odr2.cpp

@@ -1,5 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "odr.hpp"

test/odr_no_uns1.cpp

@@ -1,20 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Copyright (C) 2006 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "odr_no_uns1.hpp"
-#include "odr_no_uns2.hpp"
-
-void odr_no_uns1()
-{
-    odr_test_1 t1;
-    odr_test_2 t2;
-    BOOST_AUTO(v1, t1);
-    BOOST_AUTO(v2, t2);
-}
-
-int main()
-{
-    return 0;
-}

test/odr_no_uns1.hpp

@@ -1,19 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Copyright (C) 2006 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPEOF_ODR_NO_UNS1_HPP_INCLUDED
-#define BOOST_TYPEOF_ODR_NO_UNS1_HPP_INCLUDED
-
-#define BOOST_TYPEOF_SUPPRESS_UNNAMED_NAMESPACE
-#include <boost/typeof/typeof.hpp>
-
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-struct odr_test_1
-{};
-
-BOOST_TYPEOF_REGISTER_TYPE(odr_test_1)
-
-#endif//BOOST_TYPEOF_ODR_NO_UNS1_HPP_INCLUDED

test/odr_no_uns2.cpp

@@ -1,15 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Copyright (C) 2006 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "odr_no_uns2.hpp"
-#include "odr_no_uns1.hpp"
-
-void odr_no_uns2()
-{
-    odr_test_1 t1;
-    odr_test_2 t2;
-    BOOST_AUTO(v1, t1);
-    BOOST_AUTO(v2, t2);
-}

test/odr_no_uns2.hpp

@@ -1,19 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Copyright (C) 2006 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPEOF_ODR_NO_UNS2_HPP_INCLUDED
-#define BOOST_TYPEOF_ODR_NO_UNS2_HPP_INCLUDED
-
-#define BOOST_TYPEOF_SUPPRESS_UNNAMED_NAMESPACE
-#include <boost/typeof/typeof.hpp>
-
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-struct odr_test_2
-{};
-
-BOOST_TYPEOF_REGISTER_TYPE(odr_test_2)
-
-#endif//BOOST_TYPEOF_ODR_NO_UNS2_HPP_INCLUDED

test/std.cpp

@@ -1,78 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-
-#include <boost/typeof/std/string.hpp>
-#include <boost/typeof/std/deque.hpp>
-#include <boost/typeof/std/list.hpp>
-#include <boost/typeof/std/queue.hpp>
-#include <boost/typeof/std/stack.hpp>
-#include <boost/typeof/std/vector.hpp>
-#include <boost/typeof/std/map.hpp>
-#include <boost/typeof/std/set.hpp>
-#include <boost/typeof/std/bitset.hpp>
-#include <boost/typeof/std/functional.hpp>
-#include <boost/typeof/std/valarray.hpp>
-#include <boost/typeof/std/locale.hpp>
-#include <boost/typeof/std/iostream.hpp>
-#include <boost/typeof/std/streambuf.hpp>
-#include <boost/typeof/std/istream.hpp>
-#include <boost/typeof/std/ostream.hpp>
-#include <boost/typeof/std/sstream.hpp>
-#include <boost/typeof/std/fstream.hpp>
-#include <boost/typeof/std/iterator.hpp>
-
-using namespace std;
-
-// STL containers
-
-BOOST_STATIC_ASSERT(boost::type_of::test<string>::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<deque<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<list<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<queue<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<stack<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<vector<int> >::value);
-BOOST_STATIC_ASSERT((boost::type_of::test<map<int, int> >::value));
-BOOST_STATIC_ASSERT((boost::type_of::test<multimap<int, int> >::value));
-BOOST_STATIC_ASSERT(boost::type_of::test<set<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<multiset<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<bitset<10> >::value);
-
-// function objects
-
-#ifndef BOOST_NO_CXX98_FUNCTION_BASE
-BOOST_STATIC_ASSERT((boost::type_of::test<unary_function<int, int> >::value));
-BOOST_STATIC_ASSERT((boost::type_of::test<binary_function<int, int, int> >::value));
-#endif//BOOST_NO_CXX98_FUNCTION_BASE
-
-BOOST_STATIC_ASSERT(boost::type_of::test<plus<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<minus<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<multiplies<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<divides<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<modulus<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<negate<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<equal_to<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<not_equal_to<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<greater<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<less<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<greater_equal<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<less_equal<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<logical_and<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<logical_or<int> >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<logical_not<int> >::value);
-
-#if BOOST_CXX_VERSION < 202000L
-BOOST_STATIC_ASSERT(boost::type_of::test<unary_negate<negate<int> > >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<binary_negate<less<int> > >::value);
-#endif
-
-#ifndef BOOST_NO_CXX98_BINDERS
-BOOST_STATIC_ASSERT(boost::type_of::test<binder1st<less<int> > >::value);
-BOOST_STATIC_ASSERT(boost::type_of::test<binder2nd<less<int> > >::value);
-#endif//BOOST_NO_CXX98_BINDERS
-
-// valarray
-
-BOOST_STATIC_ASSERT(boost::type_of::test<valarray<int> >::value);

test/template_dependent.cpp

@@ -1,15 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-template<class T, T n> struct t{};
-
-BOOST_TYPEOF_REGISTER_TEMPLATE(t,
-                               (class)
-                               (BOOST_TYPEOF_INTEGRAL(P0))
-                               )
-
-BOOST_STATIC_ASSERT((boost::type_of::test<t<int, 5> >::value));

test/template_enum.cpp

@@ -1,15 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-enum E{ONE, TWO, THREE};
-template<E e> struct t{};
-
-BOOST_TYPEOF_REGISTER_TEMPLATE(t, 
-                               (BOOST_TYPEOF_INTEGRAL(E))
-                               )
-
-BOOST_STATIC_ASSERT(boost::type_of::test<t<TWO> >::value);

test/template_int.cpp

@@ -1,32 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-#include <climits>
-
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-struct x;
-BOOST_TYPEOF_REGISTER_TYPE(x)
-
-template<
-    class T, char c, unsigned short us, int i, unsigned long ul, 
-    bool b1, bool b2, signed char sc, unsigned u> 
-    struct Tpl
-{};
-
-BOOST_TYPEOF_REGISTER_TEMPLATE(Tpl, 
-    (class)
-    (char)
-    (unsigned short)
-    (int)
-    (unsigned long)
-    (bool)
-    (bool)
-    (signed char)
-    (unsigned)
-    )
-
-BOOST_STATIC_ASSERT((boost::type_of::test<Tpl<int, 5, 4, -3, 2, true, false, -1, 5> >::value));
-BOOST_STATIC_ASSERT((boost::type_of::test<Tpl<int, 1, 1, 0, ULONG_MAX, false, true, -1, 0> >::value));

test/template_multiword.cpp

@@ -1,14 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-template<unsigned long int n> struct t{};
-
-BOOST_TYPEOF_REGISTER_TEMPLATE(t,
-                               (BOOST_TYPEOF_INTEGRAL(unsigned long int))
-                               )
-
-BOOST_STATIC_ASSERT((boost::type_of::test<t<5> >::value));

test/template_tpl.cpp

@@ -1,26 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-template<class T, class U> 
-struct t0;
-
-template<class T, int n> 
-struct t1;
-
-template<template<class, class> class T, template<class, int> class U> 
-struct t2;
-
-BOOST_TYPEOF_REGISTER_TEMPLATE(t0, 2)
-
-BOOST_TYPEOF_REGISTER_TEMPLATE(t1, (class)(int))
-
-BOOST_TYPEOF_REGISTER_TEMPLATE(t2,
-                               (BOOST_TYPEOF_TEMPLATE(2))
-                               (BOOST_TYPEOF_TEMPLATE((class)(int)))
-                               )
-
-BOOST_STATIC_ASSERT((boost::type_of::test<t2<t0, t1> >::value));

test/template_type.cpp

@@ -1,17 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-struct P1;
-struct P2;
-
-template<class P1, class P2> struct Tpl;
-
-BOOST_TYPEOF_REGISTER_TYPE(P1)
-BOOST_TYPEOF_REGISTER_TYPE(P2)
-BOOST_TYPEOF_REGISTER_TEMPLATE(Tpl, 2)
-
-BOOST_STATIC_ASSERT((boost::type_of::test<Tpl<P1, P2> >::value));

test/test.hpp

@@ -1,35 +0,0 @@
-// Copyright (C) 2005 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPEOF_TEST_HPP_INCLUDED
-#define BOOST_TYPEOF_TEST_HPP_INCLUDED
-
-#include <boost/typeof/typeof.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost { namespace type_of {
-
-    template<class T, class U>
-    struct test_wrapper{};
-
-    template<class T>
-    T test_make(T*);
-
-    template<class T>
-    struct test
-    {
-        BOOST_STATIC_CONSTANT(std::size_t,value = (boost::is_same<
-            BOOST_TYPEOF_TPL(test_make((test_wrapper<T, int>*)0)),
-            test_wrapper<T, int>
-            >::value)
-        );
-    };
-
-}}
-
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::type_of::test_wrapper, 2)
-
-#endif//BOOST_TYPEOF_TEST_HPP_INCLUDED

test/type.cpp

@@ -1,11 +0,0 @@
-// Copyright (C) 2006 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#include "test.hpp"
-#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-
-struct A;
-BOOST_TYPEOF_REGISTER_TYPE(A)
-
-BOOST_STATIC_ASSERT(boost::type_of::test<A>::value);