Add missing #include.

Add missing copyright.

.circleci/config.yml

@@ -0,0 +1,57 @@
+version: 2
+
+jobs:
+  build:
+    environment:
+      - BOOST_LIBRARY=type_traits
+      - CXX_STANDARD=gnu++11
+    docker:
+      - image: gcc:7
+    steps:
+      - checkout
+      - run:
+          name: Setting up Environment
+          command: |
+            echo 'export BOOST="$HOME/boost-local"' >> $BASH_ENV
+            if [ $CIRCLE_BRANCH = "master" ]; then
+                echo 'export BOOST_BRANCH="master"' >> $BASH_ENV;
+            else
+                echo 'export BOOST_BRANCH="develop"' >> $BASH_ENV;
+            fi
+            echo 'export BOOST_REMOVE="$BOOST/boost/libs/$BOOST_LIBRARY"' >> $BASH_ENV
+            HOME_SED_=$(echo $HOME | sed -e 's/\//\\\//g')
+            echo 'export HOME_SED=$HOME_SED_' >> $BASH_ENV
+      - run:
+          name: install pre dependencies
+          command: |
+            apt-get update -yqq
+            apt-get install git xsltproc docbook-xsl docbook-xml -y
+      - run:
+          name: Initializing git repo for boost
+          command: |
+            echo BOOST=$BOOST BOOST_REMOVE=$BOOST_REMOVE BOOST_LIBRARY=$BOOST_LIBRARY BOOST_BRANCH=$BOOST_BRANCH PWD=$PWD
+            mkdir $BOOST
+            cd $BOOST
+            git clone --single-branch --branch $BOOST_BRANCH https://github.com/boostorg/boost.git
+            cd boost
+            git submodule update --init --merge
+            rm -rf $BOOST_REMOVE
+            mv $HOME/project $BOOST_REMOVE
+      - run:
+          name: Bootstrapping boost-build
+          command: |
+            cd $BOOST/boost && ./bootstrap.sh && ./b2 headers
+            echo "using xsltproc ;" | tee $HOME/user-config.jam
+            echo "using boostbook : /usr/share/xml/docbook/stylesheet/docbook-xsl : /usr/share/sgml/docbook/dtd/xml/4.2 ;" | tee -a $HOME/user-config.jam
+      - run:
+          name: Building inspect
+          command: |
+            cd $BOOST/boost/tools/inspect/build && ../../../b2 -j2 address-model=64 architecture=x86 toolset=gcc cxxflags="-std=gnu++14" release dist-bin
+      - run:
+          name: Building docs
+          command: |
+            cd $BOOST_REMOVE/doc && rm -rf html && ../../../b2 -j2 address-model=64 architecture=x86 toolset=gcc cxxflags="-std=gnu++14" release
+      - run:
+          name: Running Inspect
+          command: |
+            cd $BOOST_REMOVE && ../../dist/bin/inspect -text

.drone.star

@@ -0,0 +1,54 @@
+# Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE.txt)
+#
+# Copyright Rene Rivera 2020.
+
+# For Drone CI we use the Starlark scripting language to reduce duplication.
+# As the yaml syntax for Drone CI is rather limited.
+#
+#
+globalenv={}
+linuxglobalimage="cppalliance/droneubuntu1604:1"
+windowsglobalimage="cppalliance/dronevs2019"
+
+def main(ctx):
+  return [
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x Job 1", "g++", packages="g++-4.4", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.4', 'CXXSTD': '98,0x'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x Job 2", "g++", packages="g++-4.6", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.6', 'CXXSTD': '03,0x'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11 Job 3", "g++-4.7", packages="g++-4.7", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.7', 'CXXSTD': '03,11'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11 Job 4", "g++-4.8", packages="g++-4.8", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.8', 'CXXSTD': '03,11'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11 Job 5", "g++-4.9", packages="g++-4.9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.9', 'CXXSTD': '03,11'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z Job 6", "g++-5", packages="g++-5", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '03,11,14,1z'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z Job 7", "g++-5", packages="g++-5", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '03,11,14,1z', 'CXXSTD_DIALECT': 'cxxstd-dialect=gnu'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z Job 8", "g++-6", packages="g++-6", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '03,11,14,1z'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z Job 9", "g++-6", packages="g++-6", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '03,11,14,1z', 'CXXSTD_DIALECT': 'cxxstd-dialect=gnu'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17 Job 10", "g++-7", packages="g++-7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '03,11,14,17'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17 Job 11", "g++-8", packages="g++-8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '03,11,14,17'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17 Job 12", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '03,11,14,17,2a'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,17,20 Job 13", "g++-10", packages="g++-10", image="cppalliance/droneubuntu2004:1", buildtype="boost", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '03,11,14,17,20'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03, Job 15", "clang++", packages="clang-3.5", llvm_os="precise", llvm_ver="3.5", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.5', 'CXXSTD': '03,11,14,1z'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03, Job 16", "clang++", packages="clang-3.6", llvm_os="precise", llvm_ver="3.6", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.6', 'CXXSTD': '03,11,14,1z'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03, Job 17", "clang++", packages="clang-3.7", llvm_os="precise", llvm_ver="3.7", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.7', 'CXXSTD': '03,11,14,1z'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03, Job 18", "clang++-3.8", packages="clang-3.8", llvm_os="precise", llvm_ver="3.8", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.8', 'CXXSTD': '03,11,14,1z'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03, Job 19", "clang++-3.9", packages="clang-3.9", llvm_os="precise", llvm_ver="3.9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.9', 'CXXSTD': '03,11,14,1z'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03, Job 20", "clang++-4.0", packages="clang-4.0", llvm_os="xenial", llvm_ver="4.0", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '03,11,14,1z'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03, Job 21", "clang++-5.0", packages="clang-5.0", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '03,11,14,1z'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-5.0 -stdlib=libc++ CXXSTD=03,11,14 Job 22", "clang++-5.0 -stdlib=libc++", packages="libc++-dev clang-5.0", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", image=linuxglobalimage, environment={'COMPILER': 'clang++-5.0 -stdlib=libc++', 'TOOLSET': 'clang', 'CXXSTD': '03,11,14'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,1z, Job 23", "clang++-6.0", packages="clang-6.0", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-6.0', 'CXXSTD': '03,11,14,1z'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-6.0 -stdlib=libc++ CXXSTD=03,11,14 Job 24", "clang++-6.0 -stdlib=libc++", packages="clang-6.0 libc++-dev", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", image=linuxglobalimage, environment={'COMPILER': 'clang++-6.0 -stdlib=libc++', 'TOOLSET': 'clang', 'CXXSTD': '03,11,14'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,1z Job 25", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '03,11,14,1z'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17 2a Job 26", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '03,11,14,17,2a'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11,14,17,2a Job 27", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '03,11,14,17,2a'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20 Job 28", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '03,11,14,17,20'}, globalenv=globalenv),
+  osx_cxx("XCode-11.7 CXXSTD=03,11,14,17,2a Job 29", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_OS_NAME': 'osx'}, globalenv=globalenv),
+  osx_cxx("XCode-10.2 CXXSTD=03,11,14,17,2a Job 30", "clang++", packages="", buildtype="boost", xcode_version="10.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_OS_NAME': 'osx'}, globalenv=globalenv),
+  osx_cxx("XCode-9.4 CXXSTD=03,11,14,1z Job 31", "clang++", packages="", buildtype="boost", xcode_version="9.4", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_OS_NAME': 'osx'}, globalenv=globalenv),
+  osx_cxx("XCode-9.0 CXXSTD=03,11,14,1z Job 32", "clang++", packages="", buildtype="boost", xcode_version="9", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_OS_NAME': 'osx'}, globalenv=globalenv),
+  osx_cxx("XCode-8.3 CXXSTD=03,11,14,1z Job 33", "clang++", packages="", buildtype="boost", xcode_version="8.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_OS_NAME': 'osx'}, globalenv=globalenv),
+  osx_cxx("XCode-8.0 CXXSTD=03,11,14,1z Job 34", "clang++", packages="", buildtype="boost", xcode_version="8", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_OS_NAME': 'osx'}, globalenv=globalenv),
+  osx_cxx("XCode-7.3 CXXSTD=03,11,14,1z Job 35", "clang++", packages="", buildtype="boost", xcode_version="7.3", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_OS_NAME': 'osx'}, globalenv=globalenv),
+  ]
+
+# from https://github.com/boostorg/boost-ci
+load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx")

.drone/after-success.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+

.drone/before-install.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+

.drone/before-script.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+

.drone/boost.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+
+set -ex
+export TRAVIS_BUILD_DIR=$(pwd)
+export DRONE_BUILD_DIR=$(pwd)
+export TRAVIS_BRANCH=$DRONE_BRANCH
+export VCS_COMMIT_ID=$DRONE_COMMIT
+export GIT_COMMIT=$DRONE_COMMIT
+export REPO_NAME=$DRONE_REPO
+export PATH=~/.local/bin:/usr/local/bin:$PATH
+
+echo '==================================> BEFORE_INSTALL'
+
+. .drone/before-install.sh
+
+echo '==================================> INSTALL'
+
+cd ..
+git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/build
+git submodule update --init tools/boost_install
+git submodule update --init libs/headers
+git submodule update --init libs/config
+git submodule update --init libs/assert
+git submodule update --init libs/bind
+git submodule update --init libs/core
+git submodule update --init libs/detail
+git submodule update --init libs/function
+git submodule update --init libs/integer
+git submodule update --init libs/move
+git submodule update --init libs/mpl
+git submodule update --init libs/preprocessor
+git submodule update --init libs/static_assert
+git submodule update --init libs/throw_exception
+git submodule update --init libs/type_index
+git submodule update --init libs/utility
+cp -r $TRAVIS_BUILD_DIR/* libs/type_traits
+./bootstrap.sh
+./b2 headers
+
+echo '==================================> BEFORE_SCRIPT'
+
+. $DRONE_BUILD_DIR/.drone/before-script.sh
+
+echo '==================================> SCRIPT'
+
+echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+IFS=','
+for CXXLOCAL in $CXXSTD; do  (cd libs/config/test && ../../../b2 config_info_travis_install toolset=$TOOLSET cxxstd=$CXXLOCAL $CXXSTD_DIALECT && echo With Standard Version $CXXLOCAL && ./config_info_travis && rm ./config_info_travis)  done
+unset IFS
+./b2 libs/type_traits/test toolset=$TOOLSET cxxstd=$CXXSTD $CXXSTD_DIALECT
+
+echo '==================================> AFTER_SUCCESS'
+
+. $DRONE_BUILD_DIR/.drone/after-success.sh

.github/workflows/ci.yml

@@ -0,0 +1,482 @@
+# Copyright 2020 Evan Miller
+# Copyright 2020 Matt Borland
+# Copyright 2021 John Maddock
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+name: CI
+on:
+  push:
+    branches:
+      - master
+      - develop
+  pull_request:
+  release:
+    types: [published, created, edited]
+jobs:
+  ubuntu-focal:
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [ g++-9, g++-10, clang++-9, clang++-10 ]
+        standard: [ c++03, c++11, c++14, c++17, c++2a, gnu++03, gnu++11, gnu++14, gnu++17, gnu++2a ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[windows];[Windows];[WINDOWS];[apple];[Apple];[APPLE]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Set TOOLSET
+        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
+      - name: Add repository
+        continue-on-error: true
+        id: addrepo
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Retry Add Repo
+        continue-on-error: true
+        id: retry1
+        if: steps.addrepo.outcome=='failure'
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Retry Add Repo 2
+        continue-on-error: true
+        id: retry2
+        if: steps.retry1.outcome=='failure'
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Install packages
+        run: sudo apt install g++-9 g++-10 clang-9 clang-10 libgmp-dev libmpfr-dev libfftw3-dev
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: cp -r $GITHUB_WORKSPACE/* libs/type_traits
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py type_traits
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: ./bootstrap.sh
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: ./b2 headers
+        working-directory: ../boost-root
+      - name: Generate user config
+        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} : <cxxflags>-std=${{ matrix.standard }} ;" > ~/user-config.jam'
+        working-directory: ../boost-root
+      - name: Config info install
+        run: ../../../b2 config_info_travis_install toolset=$TOOLSET
+        working-directory: ../boost-root/libs/config/test
+      - name: Config info
+        run: ./config_info_travis
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ../../../b2 toolset=$TOOLSET
+        working-directory: ../boost-root/libs/type_traits/test
+  ubuntu-bionic:
+    runs-on: ubuntu-18.04
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [ g++-7, g++-8, clang++-7, clang++-8 ]
+        standard: [ c++03, c++11, c++14, c++17, gnu++03, gnu++11, gnu++14, gnu++17  ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[windows];[Windows];[WINDOWS];[apple];[Apple];[APPLE]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Set TOOLSET
+        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
+      - name: Add repository
+        continue-on-error: true
+        id: addrepo
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Retry Add Repo
+        continue-on-error: true
+        id: retry1
+        if: steps.addrepo.outcome=='failure'
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Retry Add Repo 2
+        continue-on-error: true
+        id: retry2
+        if: steps.retry1.outcome=='failure'
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Install packages
+        run: sudo apt install g++-7 g++-8 clang-7 clang-8 libgmp-dev libmpfr-dev libfftw3-dev
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: cp -r $GITHUB_WORKSPACE/* libs/type_traits
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py type_traits
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: ./bootstrap.sh
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: ./b2 headers
+        working-directory: ../boost-root
+      - name: Generate user config
+        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} : <cxxflags>-std=${{ matrix.standard }} ;" > ~/user-config.jam'
+        working-directory: ../boost-root
+      - name: Config info install
+        run: ../../../b2 config_info_travis_install toolset=$TOOLSET
+        working-directory: ../boost-root/libs/config/test
+      - name: Config info
+        run: ./config_info_travis
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ../../../b2 toolset=$TOOLSET
+        working-directory: ../boost-root/libs/type_traits/test
+  macos:
+    runs-on: macos-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        toolset: [ clang ]
+        standard: [ "03", 11, 14, 17, 2a ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[windows];[Windows];[WINDOWS];[linux];[Linux];[LINUX]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: cp -r $GITHUB_WORKSPACE/* libs/type_traits
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py type_traits
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: ./bootstrap.sh
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: ./b2 headers
+        working-directory: ../boost-root
+      - name: Config info install
+        run: ../../../b2 config_info_travis_install toolset=${{ matrix.toolset }} cxxstd=${{ matrix.standard }}
+        working-directory: ../boost-root/libs/config/test
+      - name: Config info
+        run: ./config_info_travis
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ../../../b2 toolset=${{ matrix.toolset }} cxxstd=${{ matrix.standard }}
+        working-directory: ../boost-root/libs/type_traits/test
+  windows_gcc:
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: cmd
+    env:
+      ARGS: toolset=${{ matrix.toolset }} address-model=64 cxxstd=${{ matrix.standard }}
+    strategy:
+      fail-fast: false
+      matrix:
+        standard: [ 11, 14, 17 ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[apple];[Apple];[APPLE];[linux];[Linux];[LINUX]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: xcopy /s /e /q %GITHUB_WORKSPACE% libs\type_traits
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py type_traits
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: bootstrap
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: b2 headers
+        working-directory: ../boost-root
+      - name: Config info install
+        run: ..\..\..\b2 config_info_travis_install cxxstd=${{ matrix.standard }} toolset=gcc
+        working-directory: ../boost-root/libs/config/test
+      - name: Config info
+        run: config_info_travis
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ..\..\..\b2 --hash cxxstd=${{ matrix.standard }} toolset=gcc
+        working-directory: ../boost-root/libs/type_traits/test
+  windows_msvc_14_0:
+    runs-on: windows-2019
+    defaults:
+      run:
+        shell: cmd
+    strategy:
+      fail-fast: false
+      matrix:
+        standard: [ 14, 17 ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[apple];[Apple];[APPLE];[linux];[Linux];[LINUX]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: xcopy /s /e /q %GITHUB_WORKSPACE% libs\type_traits
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py type_traits
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: bootstrap
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: b2 headers
+        working-directory: ../boost-root
+      - name: Config info install
+        run: ..\..\..\b2 config_info_travis_install cxxstd=${{ matrix.standard }} toolset=msvc-14.0
+        working-directory: ../boost-root/libs/config/test
+      - name: Config info
+        run: config_info_travis
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ..\..\..\b2 --hash cxxstd=${{ matrix.standard }} toolset=msvc-14.0 define=CI_SUPPRESS_KNOWN_ISSUES
+        working-directory: ../boost-root/libs/type_traits/test
+  windows_msvc_14_2:
+    runs-on: windows-2019
+    defaults:
+      run:
+        shell: cmd
+    strategy:
+      fail-fast: false
+      matrix:
+        standard: [ 14, 17, latest ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[apple];[Apple];[APPLE];[linux];[Linux];[LINUX]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: xcopy /s /e /q %GITHUB_WORKSPACE% libs\type_traits
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py type_traits
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: bootstrap
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: b2 headers
+        working-directory: ../boost-root
+      - name: Config info install
+        run: ..\..\..\b2 config_info_travis_install cxxstd=${{ matrix.standard }} toolset=msvc-14.2
+        working-directory: ../boost-root/libs/config/test
+      - name: Config info
+        run: config_info_travis
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ..\..\..\b2 --hash cxxstd=${{ matrix.standard }} toolset=msvc-14.2 define=CI_SUPPRESS_KNOWN_ISSUES
+        working-directory: ../boost-root/libs/type_traits/test
+  windows_msvc_14_3:
+    runs-on: windows-2022
+    defaults:
+      run:
+        shell: cmd
+    strategy:
+      fail-fast: false
+      matrix:
+        standard: [ 14, 17, latest ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[apple];[Apple];[APPLE];[linux];[Linux];[LINUX]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: xcopy /s /e /q %GITHUB_WORKSPACE% libs\type_traits
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py type_traits
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: bootstrap
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: b2 headers
+        working-directory: ../boost-root
+      - name: Config info install
+        run: ..\..\..\b2 config_info_travis_install cxxstd=${{ matrix.standard }} toolset=msvc-14.3
+        working-directory: ../boost-root/libs/config/test
+      - name: Config info
+        run: config_info_travis
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ..\..\..\b2 --hash cxxstd=${{ matrix.standard }} toolset=msvc-14.3 define=CI_SUPPRESS_KNOWN_ISSUES
+        working-directory: ../boost-root/libs/type_traits/test
+  windows_msvc_14_2_clr:
+    runs-on: windows-2019
+    defaults:
+      run:
+        shell: cmd
+    strategy:
+      fail-fast: false
+      matrix:
+        standard: [ 14, 17 ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[apple];[Apple];[APPLE];[linux];[Linux];[LINUX]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: xcopy /s /e /q %GITHUB_WORKSPACE% libs\type_traits
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py type_traits
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: bootstrap
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: b2 headers
+        working-directory: ../boost-root
+      - name: Config info install
+        run: ..\..\..\b2 config_info_travis_install cxxstd=${{ matrix.standard }} toolset=msvc-14.2 cxxflags=-clr asynch-exceptions=on
+        working-directory: ../boost-root/libs/config/test
+      - name: Config info
+        run: config_info_travis
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ..\..\..\b2 --hash cxxstd=${{ matrix.standard }} toolset=msvc-14.2 define=CI_SUPPRESS_KNOWN_ISSUES cxxflags=-clr asynch-exceptions=on
+        working-directory: ../boost-root/libs/type_traits/test
+  ubuntu-cuda:
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        standard: [ 11, 14, 17 ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: Jimver/cuda-toolkit@v0.2.4
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[windows];[Windows];[WINDOWS];[apple];[Apple];[APPLE]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Add repository
+        continue-on-error: true
+        id: addrepo
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Retry Add Repo
+        continue-on-error: true
+        id: retry1
+        if: steps.addrepo.outcome=='failure'
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Retry Add Repo 2
+        continue-on-error: true
+        id: retry2
+        if: steps.retry1.outcome=='failure'
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Install packages
+        run: sudo apt install clang-10
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: cp -r $GITHUB_WORKSPACE/* libs/type_traits
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py type_traits
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: ./bootstrap.sh
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: ./b2 headers
+        working-directory: ../boost-root
+      - name: nvcc version
+        run: nvcc --version
+        working-directory: ../boost-root/libs/config/test
+      - name: Testing nvcc
+        run: for file in $(cat cuda/cuda_tests.txt); do echo "testing $file.cpp" && nvcc -std=c++${{ matrix.standard }} -I../../.. -c -DTEST_VIA_STATIC_ASSERT $file.cpp || break -1; done
+        working-directory: ../boost-root/libs/type_traits/test
+      - name: Testing nvcc+clang
+        run: for file in $(cat cuda/cuda_tests.txt); do echo "testing $file.cpp" && nvcc --compiler-bindir=clang++ -std=c++${{ matrix.standard }} -I../../.. -c -DTEST_VIA_STATIC_ASSERT $file.cpp || break -1; done
+        working-directory: ../boost-root/libs/type_traits/test
+      - name: Create .cu files
+        run: for file in $(cat cuda/cuda_tests.txt); do cp $file.cpp $file.cu; done
+        working-directory: ../boost-root/libs/type_traits/test
+      - name: Testing nvcc on .cu files
+        run: for file in $(cat cuda/cuda_tests.txt); do echo "testing $file.cu" && nvcc -std=c++${{ matrix.standard }} -I../../.. -c -DTEST_VIA_STATIC_ASSERT $file.cu || break -1; done
+        working-directory: ../boost-root/libs/type_traits/test
+      - name: Testing nvcc+clang on .cu files
+        run: for file in $(cat cuda/cuda_tests.txt); do echo "testing $file.cu" && nvcc --compiler-bindir=clang++ -std=c++${{ matrix.standard }} -I../../.. -c -DTEST_VIA_STATIC_ASSERT $file.cu || break -1; done
+        working-directory: ../boost-root/libs/type_traits/test
+      - name: Testing clang on .cu files
+        run: for file in $(cat cuda/cuda_tests.txt); do echo "testing $file.cu" && clang++ -nocudalib --no-cuda-version-check --cuda-gpu-arch=sm_75 -std=c++${{ matrix.standard }} -I../../.. -c -DTEST_VIA_STATIC_ASSERT $file.cu || break -1; done
+        working-directory: ../boost-root/libs/type_traits/test
+      - name: Testing nvcc on .cu files
+        run: for file in $(cat cuda/cuda_tests.txt); do echo "testing $file.cu" && nvcc -std=c++${{ matrix.standard }} -I../../.. -c -DTEST_CUDA_DEVICE $file.cu || break -1; done
+        working-directory: ../boost-root/libs/type_traits/test
+      - name: Testing clang on .cu files
+        run: for file in $(cat cuda/cuda_tests.txt); do echo "testing $file.cu" && clang++ -nocudalib --no-cuda-version-check --cuda-gpu-arch=sm_75 -std=c++${{ matrix.standard }} -I../../.. -c -DTEST_CUDA_DEVICE $file.cu || break -1; done
+        working-directory: ../boost-root/libs/type_traits/test

CMakeLists.txt

@@ -0,0 +1,20 @@
+# Copyright 2018 Mike Dev
+# Copyright 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
+
+# We support CMake 3.5, but prefer 3.16 policies and behavior
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(boost_type_traits VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_type_traits INTERFACE)
+add_library(Boost::type_traits ALIAS boost_type_traits)
+
+target_include_directories(boost_type_traits INTERFACE include)
+
+target_link_libraries(boost_type_traits
+  INTERFACE
+    Boost::config
+    Boost::static_assert
+)

README.md

@@ -0,0 +1,47 @@
+Boost TypeTraits Library
+============================
+
+The Boost type-traits library contains a set of very specific traits classes, each of which encapsulate a single trait 
+from the C++ type system; for example, is a type a pointer or a reference type? Or does a type have a trivial constructor, or a const-qualifier?
+
+The type-traits classes share a unified design: each class inherits from the type true_type if the type has the specified property and inherits from false_type otherwise.
+
+The type-traits library also contains a set of classes that perform a specific transformation on a type; for example, they can remove a top-level const or 
+volatile qualifier from a type. Each class that performs a transformation defines a single typedef-member type that is the result of the transformation. 
+
+The full documentation is available on [boost.org](http://www.boost.org/doc/libs/release/libs/type_traits/index.html).
+
+|                  |  Master  |   Develop   |
+|------------------|----------|-------------|
+| Travis           | [![Build Status](https://travis-ci.org/boostorg/type_traits.svg?branch=master)](https://travis-ci.org/boostorg/type_traits)  |  [![Build Status](https://travis-ci.org/boostorg/type_traits.svg)](https://travis-ci.org/boostorg/type_traits) |
+| Appveyor         | [![Build status](https://ci.appveyor.com/api/projects/status/lwjqu4087qiolje8/branch/master?svg=true)](https://ci.appveyor.com/project/jzmaddock/type-traits/branch/master) | [![Build status](https://ci.appveyor.com/api/projects/status/lwjqu4087qiolje8/branch/develop?svg=true)](https://ci.appveyor.com/project/jzmaddock/type-traits/branch/develop)  |
+
+
+## Support, bugs and feature requests ##
+
+Bugs and feature requests can be reported through the [Gitub issue tracker](https://github.com/boostorg/type_traits/issues)
+(see [open issues](https://github.com/boostorg/type_traits/issues) and
+[closed issues](https://github.com/boostorg/type_traits/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aclosed)).
+
+You can submit your changes through a [pull request](https://github.com/boostorg/type_traits/pulls).
+
+There is no mailing-list specific to Boost TypeTraits, although you can use the general-purpose Boost [mailing-list](http://lists.boost.org/mailman/listinfo.cgi/boost-users) using the tag [type_traits].
+
+
+## Development ##
+
+Clone the whole boost project, which includes the individual Boost projects as submodules ([see boost+git doc](https://github.com/boostorg/boost/wiki/Getting-Started)): 
+
+    git clone https://github.com/boostorg/boost
+    cd boost
+    git submodule update --init
+
+The Boost TypeTraits Library is located in `libs/type_traits/`. 
+
+### Running tests ###
+First, make sure you are in `libs/type_traits/test`. 
+You can either run all the tests listed in `Jamfile.v2` or run a single test:
+
+    ../../../b2                        <- run all tests
+    ../../../b2 config_info            <- single test
+

doc/Jamfile.v2

@@ -69,4 +69,8 @@ boostbook standalone
 install pdfinstall : standalone/<format>pdf : <install-type>PDF <location>. <name>type_traits.pdf ;
 explicit pdfinstall ;
 
-
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : standalone ;
+explicit boostrelease ;

doc/add_const.qbk

@@ -12,15 +12,13 @@
    {
       typedef __below type;
    };
-  
+   
+   template <class T> using add_const_t = typename add_const<T>::type; // C++11 and above
+
 __type The same type as `T const` for all `T`.  
 
 __std_ref 3.9.3.
 
-__compat If the compiler does not support partial specialization of class-templates
-then this template will compile, but the member `type` will always be the same as 
-type `T` except where __transform_workaround have been applied.
-
 __header ` #include <boost/type_traits/add_const.hpp>` or ` #include <boost/type_traits.hpp>`
 
 [table Examples
@@ -37,5 +35,7 @@ __header ` #include <boost/type_traits/add_const.hpp>` or ` #include <boost/type
 
 ]
 
+[all_compilers]
+
 [endsect]
 

doc/add_cv.qbk

@@ -12,15 +12,13 @@
    {
       typedef __below type;
    };
-  
+   
+   template <class T> using add_cv_t = typename add_cv<T>::type; // C++11 and above
+
 __type The same type as `T const volatile` for all `T`.  
 
 __std_ref 3.9.3.
 
-__compat If the compiler does not support partial specialization of class-templates
-then this template will compile, but the member `type` will always be the same as 
-type `T` except where __transform_workaround have been applied.
-
 __header ` #include <boost/type_traits/add_cv.hpp>` or ` #include <boost/type_traits.hpp>`
 
 [table Examples
@@ -37,5 +35,7 @@ __header ` #include <boost/type_traits/add_cv.hpp>` or ` #include <boost/type_tr
 
 ]
 
+[all_compilers]
+
 [endsect]
 

doc/add_lvalue_reference.qbk

@@ -12,17 +12,15 @@
    {
       typedef __below type;
    };
-  
+   
+   template <class T> using add_lvalue_reference_t = typename add_lvalue_reference<T>::type; // C++11 and above
+
 __type If `T` names an object or function type then the member typedef `type`
 shall name `T&`; otherwise, if `T` names a type ['rvalue reference to U] then
 the member typedef type shall name `U&`; otherwise, type shall name `T`.
 
 __std_ref 20.7.6.2.
 
-__compat If the compiler does not support partial specialization of class-templates
-then this template will compile, but the member `type` will always be the same as 
-type `T` except where __transform_workaround have been applied.
-
 __header ` #include <boost/type_traits/add_lvalue_reference.hpp>` or ` #include <boost/type_traits.hpp>`
 
 [table Examples
@@ -43,5 +41,7 @@ __header ` #include <boost/type_traits/add_lvalue_reference.hpp>` or ` #include
 
 ]
 
+[all_compilers]
+
 [endsect]
 

doc/add_pointer.qbk

@@ -12,19 +12,17 @@
    {
       typedef __below type;
    };
-  
+   
+   template <class T> using add_pointer_t = typename add_pointer<T>::type; // C++11 and above
+
 __type The same type as `remove_reference<T>::type*`.  
 
 The rationale for this template
-is that it produces the same type as `TYPEOF(&t)`, 
+is that it produces the same type as `decltype(&t)`, 
 where `t` is an object of type `T`.
 
 __std_ref 8.3.1.
 
-__compat If the compiler does not support partial specialization of class-templates
-then this template will compile, but the member `type` will always be the same as 
-type `T` except where __transform_workaround have been applied.
-
 __header ` #include <boost/type_traits/add_pointer.hpp>` or ` #include <boost/type_traits.hpp>`
 
 [table Examples
@@ -41,5 +39,7 @@ __header ` #include <boost/type_traits/add_pointer.hpp>` or ` #include <boost/ty
 
 ]
 
+[all_compilers]
+
 [endsect]
 

doc/add_reference.qbk

@@ -18,15 +18,13 @@ for backwards compatibility only.
    {
       typedef __below type;
    };
+
+   template <class T> using add_reference_t = typename add_reference<T>::type; // C++11 and above
   
 __type If `T` is not a reference type then `T&`, otherwise `T`.
 
 __std_ref 8.3.2.
 
-__compat If the compiler does not support partial specialization of class-templates
-then this template will compile, but the member `type` will always be the same as 
-type `T` except where __transform_workaround have been applied.
-
 __header ` #include <boost/type_traits/add_reference.hpp>` or ` #include <boost/type_traits.hpp>`
 
 [table Examples
@@ -43,5 +41,7 @@ __header ` #include <boost/type_traits/add_reference.hpp>` or ` #include <boost/
 
 ]
 
+[all_compilers]
+
 [endsect]
 

doc/add_rvalue_reference.qbk

@@ -12,7 +12,9 @@
    {
       typedef __below type;
    };
-  
+   
+   template <class T> using add_rvalue_reference_t = typename add_rvalue_reference<T>::type; // C++11 and above
+
 __type If `T` names an object or function type then the member typedef type
 shall name `T&&`; otherwise, type shall name `T`. ['\[Note: This rule reflects
 the semantics of reference collapsing. For example, when a type `T` names
@@ -21,11 +23,6 @@ reference. -end note\]].
 
 __std_ref 20.7.6.2.
 
-__compat If the compiler does not support partial specialization of class-templates
-and rvalue references
-then this template will compile, but the member `type` will always be the same as 
-type `T`.
-
 __header ` #include <boost/type_traits/add_rvalue_reference.hpp>` or ` #include <boost/type_traits.hpp>`
 
 [table Examples
@@ -46,5 +43,7 @@ __header ` #include <boost/type_traits/add_rvalue_reference.hpp>` or ` #include
 
 ]
 
+__compat In the absence of rvalue-reference support this trait has no effect.
+
 [endsect]
 

doc/add_volatile.qbk

@@ -12,15 +12,13 @@
    {
       typedef __below type;
    };
-  
+   
+   template <class T> using add_volatile_t = typename add_volatile<T>::type; // C++11 and above
+
 __type The same type as `T volatile` for all `T`.  
 
 __std_ref 3.9.3.
 
-__compat If the compiler does not support partial specialization of class-templates
-then this template will compile, but the member `type` will always be the same as 
-type `T` except where __transform_workaround have been applied.
-
 __header ` #include <boost/type_traits/add_volatile.hpp>` or ` #include <boost/type_traits.hpp>`
 
 [table Examples
@@ -37,5 +35,7 @@ __header ` #include <boost/type_traits/add_volatile.hpp>` or ` #include <boost/t
 
 ]
 
+[all_compilers]
+
 [endsect]
 

doc/aligned_storage.qbk

@@ -18,5 +18,37 @@ that is a multiple of `Align`.
 
 __header ` #include <boost/type_traits/aligned_storage.hpp>` or ` #include <boost/type_traits.hpp>`
 
+On the GCC and Visual C++ compilers (or compilers that are compatible with them), we support
+requests for types with alignments greater than any built in type (up to 128-bit alignment).
+Visual C++ users should note that such "extended" types can not be passed down the stack as
+by-value function arguments.
+
+[important
+Visual C++ users should be aware that MSVC has an elastic definition of alignment, for
+example consider the following code:
+
+``
+   typedef boost::aligned_storage<8,8>::type align_t;
+   assert(boost::alignment_of<align_t>::value % 8 == 0);
+   align_t a;
+   assert(((std::uintptr_t)&a % 8) == 0);
+   char c = 0;
+   align_t a1;
+   assert(((std::uintptr_t)&a1 % 8) == 0);
+``
+
+In this code the final assert will fail for a 32-bit build because variable `a1` is not
+aligned on an 8-byte boundary.  Had we used the MSVC intrinsic `__alignof` in
+place of `alignment_of` or `std::aligned_storage` in place of `boost::aligned_storage`
+the result would have been no different.  In MSVC alignment requirements/promises only
+really apply to variables on the heap, not on the stack.
+
+Further, although MSVC has a mechanism for generating new types with arbitrary alignment 
+requirements, such types cannot be passed as function arguments on the program stack.
+Therefore had `boost::aligned_storage<8,8>::type` been a type declared with
+`__declspec(align(8))` we would break a great deal of existing code that relies on
+being able to pass such types through the program stack.
+]
+
 [endsect]
 

doc/alignment_of.qbk

@@ -30,5 +30,26 @@ expression with value `ALIGNOF(double)`.]
 
 [:`alignment_of<T>::value_type` is the type `std::size_t`.]
 
+[important
+Visual C++ users should note that MSVC has varying definitions of "alignment".
+For example consider the following code:
+
+``
+   typedef long long align_t;
+   assert(boost::alignment_of<align_t>::value % 8 == 0);
+   align_t a;
+   assert(((std::uintptr_t)&a % 8) == 0);
+   char c = 0;
+   align_t a1;
+   assert(((std::uintptr_t)&a1 % 8) == 0);
+``
+
+In this code, even though `boost::alignment_of<align_t>` reports that `align_t` has 8-byte
+alignment, the final assert will fail for a 32-bit build because `a1` is not aligned on an
+8 byte boundary.  Note that had we used the MSVC intrinsic `__alignof` in place of `boost::alignment_of`
+we would still get the same result.  In fact for MSVC alignment requirements (and promises) only really 
+apply to dynamic storage, and not the stack.
+]
+
 [endsect]
 

doc/common_type.qbk

@@ -11,83 +11,74 @@
 [section:common_type common_type]
 [/===================================================================]
 
-[def __declval [@../../../utility/doc/html/declval.html declval]]
-
-
 __header ` #include <boost/type_traits/common_type.hpp>` or ` #include <boost/type_traits.hpp>`
 
     namespace boost {
-      template <class ...T>  struct __common_type;
+      template <class... T> struct common_type;
+      template<class... T> using common_type_t = typename common_type<T...>::type; // C++11 and above
     }
 
 
-__common_type is a traits class used to deduce a type common to a several types, useful as the return type of functions 
+`common_type` is a traits class used to deduce a type common to a several types, useful as the return type of functions 
 operating on multiple input types such as in mixed-mode arithmetic..
 
 The nested typedef `::type` could be defined as follows:
 
-    template <class ...T>
+    template <class... T>
     struct common_type;
     
-    template <class T, class U, class ...V>
-    struct common_type<T,U,...V> {
-        typedef typename __common_type<typename __common_type<T, U>::type, V...>::type type;
+    template <class T, class U, class... V>
+    struct common_type<T, U, V...> {
+        typedef typename common_type<typename common_type<T, U>::type, V...>::type type;
+    };
+
+    template <>
+    struct common_type<> {
     };
 
     template <class T>
     struct common_type<T> {
-        typedef T type;
+        typedef typename __decay<T>::type type;
     };
 
     template <class T, class U>
     struct common_type<T, U> {
-        typedef decltype(__declval<bool>() ? __declval<T>() : __declval<U>()) type;
+        typedef typename __decay<
+            decltype( __declval<bool>()?
+                __declval<typename __decay<T>::type>():
+                __declval<typename __decay<U>::type>() )
+        >::type type;
     };
 
 All parameter types must be complete. This trait is permitted to be specialized by a user if at least one 
 template parameter is a user-defined type. [*Note:] Such specializations are required when only explicit conversions 
-are desired among the __common_type arguments.
+are desired among the `common_type` arguments.
 
-Note that when the compiler does not support variadic templates (and the macro BOOST_NO_VARIADIC_TEMPLATES is defined)
-then the maximum number of template arguments is 3.
+Note that when the compiler does not support variadic templates (and the macro `BOOST_NO_CXX11_VARIADIC_TEMPLATES` is defined)
+then the maximum number of template arguments is 9.
 
 
-[h4 Configuration macros]
-
-When the compiler does not support static assertions then the user can select the way static assertions are reported. Define
-
-* BOOST_COMMON_TYPE_USES_STATIC_ASSERT: define it if you want to use Boost.StaticAssert
-* BOOST_COMMON_TYPE_USES_MPL_ASSERT: define it if you want to use Boost.MPL static asertions
-
-The default behavior is to use mpl assertions in this case, but setting BOOST_COMMON_TYPE_USES_STATIC_ASSERT may reduce
-compile times and header dependencies somewhat.
-
-Depending on the static assertion used you will have an hint of the failing assertion either through the symbol or through the text.
-
-When possible common_type is implemented using `decltype`. Otherwise when BOOST_COMMON_TYPE_DONT_USE_TYPEOF is not defined 
-it uses Boost.TypeOf.
-
 [h4 Tutorial]
 
-In a nutshell, __common_type is a trait that takes 1 or more types, and returns a type which 
+In a nutshell, `common_type` is a trait that takes 1 or more types, and returns a type which 
 all of the types will convert to. The default definition demands this conversion be implicit. 
 However the trait can be specialized for user-defined types which want to limit their inter-type conversions to explicit, 
-and yet still want to interoperate with the __common_type facility.
+and yet still want to interoperate with the `common_type` facility.
 
 [*Example:]
 
     template <class T, class U>
-    complex<typename __common_type<T, U>::type>
+    complex<typename common_type<T, U>::type>
     operator+(complex<T>, complex<U>);
 
 
-In the above example, "mixed-mode" complex arithmetic is allowed. The return type is described by __common_type. 
+In the above example, "mixed-mode" complex arithmetic is allowed. The return type is described by `common_type`. 
 For example the resulting type of adding a `complex<float>` and `complex<double>` might be a `complex<double>`. 
 
 Here is how someone might produce a variadic comparison function:
 
     template <class ...T>
-    typename __common_type<T...>::type
+    typename common_type<T...>::type
     min(T... t);
 
 This is a very useful and broadly applicable utility. 
@@ -97,17 +88,17 @@ This is a very useful and broadly applicable utility.
 Another choice for the author of the preceding operator could be
 
     template <class T, class U>
-    typename __common_type<complex<T>, complex<U> >::type
+    typename common_type<complex<T>, complex<U> >::type
     operator+(complex<T>, complex<U>);
 
-As the default definition of __common_type demands the conversion be implicit, we need to specialize the trait for complex types as follows.
+As the default definition of `common_type` demands the conversion be implicit, we need to specialize the trait for complex types as follows.
 
     template <class T, class U>
-    struct __common_type<complex<T>, complex<U> > {
-        typedef complex< __common_type<T, U> > type;
+    struct common_type<complex<T>, complex<U> > {
+        typedef complex< common_type<T, U> > type;
     };
 
-[h4 How important is the order of the common_type<> template arguments?]
+[h4 How important is the order of the `common_type<>` template arguments?]
 
 The order of the template parameters is important. 
 
@@ -164,7 +155,7 @@ Clients wanting to ask `common_type<A, B, C>` in any order and get the same resu
 
 This is needed as the specialization of `common_type<A, B>` is not be used implicitly for `common_type<B, A>`.
 
-[h4 Can the common_type of two types be a third type?]
+[h4 Can the `common_type` of two types be a third type?]
 
 Given the preceding example, one might expect `common_type<A,B>::type` to be `C` without any intervention from the user. 
 But the default `common_type<>` implementation doesn't grant that. It is intended that clients who wish for `common_type<A, B>` 
@@ -183,7 +174,7 @@ to be well defined to define it themselves:
 
 Now this client can ask for `common_type<A, B>`.
 
-[h4 How common_type behaves with pointers?]
+[h4 How does `common_type` behave with pointers?]
 
 Consider
 
@@ -209,17 +200,17 @@ But in the absence of a motivating use cases, we prefer not to add more than the
 
 Of course the user can always make this specialization.
 
-[h4 Can you explain the pros/cons of common_type against Boost.Typeof?]
+[h4 Can you explain the pros/cons of `common_type` against Boost.Typeof?]
 
-Even if they appear to be close, `__common_type` and `typeof` have
+Even if they appear to be close, `common_type` and `typeof` have
 different purposes. You use `typeof` to get the type of an expression, while
-you use __common_type to set explicitly the type returned of a template
-function. Both are complementary, and indeed __common_type is equivalent to 
-`decltype(__declval<bool>() ? __declval<T>() : __declval<U>())` 
+you use `common_type` to set explicitly the type returned of a template
+function. Both are complementary, and indeed `common_type` is approximately equivalent to 
+`decltype(__declval<bool>() ? __declval<T>() : __declval<U>())`.
 
-__common_type is also similar to promote_args<class ...T> in boost/math/tools/promotion.hpp, 
-though it is not exactly the same as promote_args either.  __common_type<T1, T2>::type simply represents the result of some 
-operation on T1 and T2, and defaults to the type obtained by putting T1 and T2 into a conditional statement.
+`common_type` is also similar to `promote_args<class ...T>` in `boost/math/tools/promotion.hpp`, 
+though it is not exactly the same as `promote_args` either.  `common_type<T1, T2>::type` simply represents the result of some 
+operation on `T1` and `T2`, and defaults to the type obtained by putting `T1` and `T2` into a conditional statement.
 
 It is meant to be customizable (via specialization) if this default is not appropriate.
 

doc/conditional.qbk

@@ -14,11 +14,10 @@ __header ` #include <boost/type_traits/conditional.hpp>` or ` #include <boost/ty
 
     namespace boost {
       template <bool B, class T, class U>  struct __conditional;
+      template <bool B, class T, class U>  using conditional_t = typename conditional<B, T, U>::type; // C++11 and above
     }
 
 If B is true, the member typedef type shall equal T. If B is false, the member typedef type shall equal U.
 
-This trait is really just an alias for `boost::mpl::if_c`.
-
 [endsect]
 

doc/conjunction.qbk

@@ -0,0 +1,36 @@
+[/
+Copyright 2020 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt
+or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:conjunction conjunction]
+
+    template<class... T>
+    struct conjunction;
+
+__inherit Inherits from the first type `U` in the list for which
+`bool(U::value)` is `false`, or the last type in the list if there is no such
+type. If `sizeof...(T)` is `0` then inherits from `__true_type`.
+
+__header `#include <boost/type_traits/conjunction.hpp>`
+
+[all_compilers] In the absence of variadic-template support, `conjunction` has
+only 2 parameters.
+
+__examples
+
+[:Given: `template<int N> struct Int { static const int value = N };` ]
+
+[:`conjunction<>` inherits from `__true_type`.]
+
+[:`conjunction<Int<1> >` inherits from `Int<1>`.]
+
+[:`conjunction<Int<1>, Int<2>, Int<3> >` inherits from `Int<3>`.]
+
+[:`conjunction<Int<1>, Int<0>, Int<3> >` inherits from `Int<0>`.]
+
+[endsect]

doc/copy_cv.qbk

@@ -0,0 +1,41 @@
+[/ 
+  Copyright 2015 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).
+]
+
+[section:copy_cv copy_cv]
+
+   template <class T, class U>
+   struct copy_cv
+   {
+      typedef __below type;
+   };
+   
+   template <class T, class U> using copy_cv_t = typename copy_cv<T, U>::type; // C++11 and above
+
+__type [^T /cv/], where /cv/ are the cv-qualifiers of `U`.
+
+__header ` #include <boost/type_traits/copy_cv.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`copy_cv<int, void>::type`][`int`]]
+
+[[`copy_cv<int const, void>::type`][`int const`]]
+
+[[`copy_cv<int, void const>::type`][`int const`]]
+
+[[`copy_cv<int volatile, void const>::type`][`int const volatile`]]
+
+[[`copy_cv<int&, void const>::type`] [`int&`]]
+
+[[`copy_cv<int*, void volatile>::type`] [`int* volatile`]]
+
+]
+
+[endsect]
+

doc/copy_cv_ref.qbk

@@ -0,0 +1,65 @@
+[/
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt
+or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:copy_cv_ref copy_cv_ref]
+
+    template<class T, class U>
+    struct copy_cv_ref
+    {
+        typedef __below type;
+    };
+
+    template<class T, class U>
+    using copy_cv_ref_t = typename copy_cv_ref<T, U>::type;
+
+__type [^T /cvref/], where /cvref/ are the cvref-qualifiers of `U`.
+
+__header `#include <boost/type_traits/copy_cv_ref.hpp>` or
+`#include <boost/type_traits.hpp>>`
+
+[table Examples
+
+[[Expression] [Result Type]]
+
+[[`copy_cv_ref<int, const char>::type`][`const int`]]
+
+[[`copy_cv_ref<int, volatile char>::type`][`volatile int`]]
+
+[[`copy_cv_ref<int, const volatile char>::type`][`const volatile int`]]
+
+[[`copy_cv_ref<int, char&>::type`][`int&`]]
+
+[[`copy_cv_ref<int, const char&>::type`][`const int&`]]
+
+[[`copy_cv_ref<int, volatile char&>::type`][`volatile int&`]]
+
+[[`copy_cv_ref<int, const volatile char&>::type`][`const volatile int&`]]
+
+[[`copy_cv_ref<int, char&&>::type`][`int&&`]]
+
+[[`copy_cv_ref<int, const char&&>::type`][`const int&&`]]
+
+[[`copy_cv_ref<int, volatile char&&>::type`][`volatile int&&`]]
+
+[[`copy_cv_ref<int, const volatile char&&>::type`][`const volatile int&&`]]
+
+[[`copy_cv_ref<int&&, char&>::type`][`int&`]]
+
+[[`copy_cv_ref<int&, const char>::type`][`int&`]]
+
+[[`copy_cv_ref<int&, volatile char&>::type`][`int&`]]
+
+[[`copy_cv_ref<int&, const volatile char&&>::type`][`int&`]]
+
+]
+
+[all_compilers] The type alias `copy_cv_ref_t` is only available if the compiler
+supports template aliases.
+
+[endsect]

doc/copy_reference.qbk

@@ -0,0 +1,53 @@
+[/
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt
+or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:copy_reference copy_reference_]
+
+    template<class T, class U>
+    struct copy_reference
+    {
+        typedef __below type;
+    };
+
+    template<class T, class U>
+    using copy_reference_t = typename copy_reference<T, U>::type;
+
+__type [^T /ref/], where /ref/ are the ref-qualifiers of `U`.
+
+__header `#include <boost/type_traits/copy_reference.hpp>` or
+`#include <boost/type_traits.hpp>>`
+
+[table Examples
+
+[[Expression] [Result Type]]
+
+[[`copy_reference<int, char>::type`][`int`]]
+
+[[`copy_reference<int, char&>::type`] [`int&`]]
+
+[[`copy_reference<int, char&&>::type`] [`int&&`]]
+
+[[`copy_reference<int&, char>::type`] [`int&`]]
+
+[[`copy_reference<int&, char&>::type`] [`int&`]]
+
+[[`copy_reference<int&, char&&>::type`] [`int&`]]
+
+[[`copy_reference<int&&, char>::type`] [`int&&`]]
+
+[[`copy_reference<int&&, char&>::type`] [`int&`]]
+
+[[`copy_reference<int&&, char&&>::type`] [`int&&`]]
+
+]
+
+[all_compilers] The type alias `copy_reference_t` is only available if the compiler
+supports template aliases.
+
+[endsect]

doc/credits.qbk

@@ -18,7 +18,8 @@ current maintainer of the library.
 This version of type traits library is based on contributions by 
 Adobe Systems Inc, David Abrahams, Steve Cleary, 
 Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, 
-Itay Maman, John Maddock, Thorsten Ottosen, Robert Ramey and Jeremy Siek.
+Itay Maman, John Maddock, Thorsten Ottosen, Robert Ramey, Jeremy Siek,
+Antony Polukhin and Glen Fernandes.
 
 Mat Marcus and Jesse Jones invented, and 
 [@http://opensource.adobe.com/project4/project.shtml published a paper describing], 

doc/decay.qbk

@@ -12,10 +12,12 @@
    {
       typedef __below type;
    };
-  
+   
+   template <class T> using decay_t = typename decay<T>::type; // C++11 and above
+
 __type Let `U` be the result of `remove_reference<T>::type`, then if `U` is
 an array type, the result is `remove_extent<U>::type*`, otherwise if `U` is a 
-function type then the result is `U*`, otherwise the result is `U`.
+function type then the result is `U*`, otherwise the result is `remove_cv<U>::type`.
 
 __std_ref 3.9.1.
 
@@ -36,5 +38,7 @@ __header ` #include <boost/type_traits/decay.hpp>` or ` #include <boost/type_tra
 
 ]
 
+[all_compilers]
+
 [endsect]
 

doc/declval.qbk

@@ -0,0 +1,21 @@
+[/ 
+  Copyright 2015 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).
+]
+
+[section:declval declval]
+
+   template <class T>
+   typename add_rvalue_reference<T>::type declval() noexcept; // as unevaluated operand
+
+__std_ref C++11 20.2.4 [declval].
+
+__header ` #include <boost/type_traits/declval.hpp>` or ` #include <boost/type_traits.hpp>`
+
+The function template `declval` is used when a value of a certain type is required in
+a type computation context. For example, the type of the result of adding an `int` and
+a `float` can be obtained with the expression `decltype( declval<int>() + declval<float>() )`.
+
+[endsect]

doc/detected.qbk

@@ -0,0 +1,40 @@
+[/
+Copyright 2018 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt
+or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:detected detected]
+
+    template<template<class...> class Op, class... Args>
+    using detected_t = __below;
+
+__alias `Op<Args...>` if it is a valid template-id, otherwise
+`boost::nonesuch`.
+
+__std_paper [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf N4502]
+
+__compat Requires C++11 variadic templates and C++11 template aliases.
+
+__header `#include <boost/type_traits/detected.hpp>`
+
+__examples
+
+Suppose you wish to determine whether a type has a `size()` const-member function, then given the meta-functions:
+
+   template <class T>
+   using size_member_tester = decltype(std::declval<const T&>().size());
+
+   template <class T>
+   using size_member_t = boost::detected_t<size_member_tester, T >;
+
+
+Then the type `size_member_t<T>` is an alias for `size_member_tester<T>` if the operation is valid, and an alias for
+`boost::nonesuch` otherwise.
+
+See also: __is_detected, __is_detected_convertible, __is_detected_exact.
+
+[endsect]

doc/detected_or.qbk

@@ -0,0 +1,45 @@
+[/
+Copyright 2018 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt
+or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:detected_or detected_or]
+
+    template<class Default, template<class...> class Op, class... Args>
+    using detected_or = __below;
+
+    template<class Default, template<class...> class Op, class... Args>
+    using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+__alias An unspecified type with two public member type definitions:
+
+* `value_t` is __true_type if `Op<Args...>` is a valid template-id, otherwise
+  __false_type
+* `type` is `Op<Args...>` if it is a valid template-id, otherwise `Default`
+
+__std_paper [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf N4502]
+
+__compat Requires C++11 variadic templates and C++11 template aliases.
+
+__header `#include <boost/type_traits/detected_or.hpp>`
+
+__examples
+
+Suppose we wish to declare a type that represents the difference between two values of type T, it should be
+T::difference_type if such a type exists, or std::ptrdiff_t otherwise:
+
+    template<class T>
+    using difference_t = typename T::difference_type;
+
+    template<class T>
+    using difference_type = boost::detected_or_t<std::ptrdiff_t, difference_t, T>;
+
+Now the type `difference_type<T>` gives us what we need.
+
+See also: __is_detected, __is_detected_convertible, __is_detected_exact.
+
+[endsect]

doc/disjunction.qbk

@@ -0,0 +1,36 @@
+[/
+Copyright 2020 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt
+or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:disjunction disjunction]
+
+    template<class... T>
+    struct disjunction;
+
+__inherit Inherits from the first type `U` in the list for which
+`bool(U::value)` is `true`, or the last type in the list if there is no such
+type. If `sizeof...(T)` is `0` then inherits from `__false_type`.
+
+__header `#include <boost/type_traits/disjunction.hpp>`
+
+[all_compilers] In the absence of variadic-template support, `disjunction` has
+only 2 parameters.
+
+__examples
+
+[:Given: `template<int N> struct Int { static const int value = N };` ]
+
+[:`disjunction<>` inherits from `__false_type`.]
+
+[:`disjunction<Int<1> >` inherits from `Int<1>`.]
+
+[:`disjunction<Int<1>, Int<2>, Int<3> >` inherits from `Int<1>`.]
+
+[:`disjunction<Int<0>, Int<2>, Int<3> >` inherits from `Int<2>`.]
+
+[endsect]

doc/enable_if.qbk

@@ -0,0 +1,48 @@
+[/
+Copyright 2018 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt
+or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:enable_if enable_if_]
+
+    template<bool B, class T = void>
+    struct enable_if_;
+
+    template<bool B, class T = void>
+    using enable_if_t = typename enable_if_<B, T>::type;
+
+__type If `B` is true, then the member `type` is defined to be `T`. Otherwise
+there is no member `type`.
+
+__header `#include <boost/type_traits/enable_if.hpp>`
+
+[note The trait has the name `enable_if_` (with a trailing underscore) but
+behaves like `std::enable_if` or `boost::enable_if_c`. The existing trait
+with the name `boost::enable_if` has a different interface.]
+
+__examples
+
+The following function can be used to destroy each element of an array and
+specially handle arrays of trivially destructible types.
+
+    template<class T>
+    typename boost::enable_if_<!boost::has_trivial_destructor<T>::value>::type
+    destroy(T* ptr, std::size_t size)
+    {
+        while (size > 0) {
+            ptr[--size].~T();
+        }
+    }
+
+    template<class T>
+    typename boost::enable_if_<boost::has_trivial_destructor<T>::value>::type
+    destroy(T*, std::size_t) { }
+
+[all_compilers] The type alias `enable_if_t` is only available if the compiler
+supports template aliases.
+
+[endsect]

doc/examples.qbk

@@ -146,18 +146,18 @@ determine whether to destructors need to be called
 [section:iter An improved Version of std::iter_swap]
 
 Demonstrates a version of `std::iter_swap` that use type traits to
-determine whether an it's arguments are proxying iterators or not,
+determine whether an it's arguments are proxy iterators or not,
 if they're not then it just does a `std::swap` of it's dereferenced 
 arguments (the
-same as `std::iter_swap` does), however if they are proxying iterators
+same as `std::iter_swap` does), however if they are proxy iterators
 then takes special care over the swap to ensure that the algorithm
-works correctly for both proxying iterators, and even iterators of
+works correctly for both proxy iterators, and even iterators of
 different types 
 (see [@../../examples/iter_swap_example.cpp iter_swap_example.cpp]):
 
    //
    // iter_swap:
-   // tests whether iterator is a proxying iterator or not, and
+   // tests whether iterator is a proxy iterator or not, and
    // uses optimal form accordingly:
    //
    namespace detail{
@@ -221,7 +221,7 @@ and enum types to double:
 An improved `std::min` function could be written like this:
 
    template <class T, class U>
-   typename __common_type<T, U>::type min(T t, T u)
+   typename __common_type<T, U>::type min(T t, U u)
    {
       return t < u ? t : u;
    }

doc/extent.qbk

@@ -25,7 +25,7 @@ __examples
 
 [:`extent<double[2][3][4], 1>::type` is the type `__integral_constant<std::size_t, 3>`.]
 
-[:`extent<double[2][3][4], 3>::type` is the type `__integral_constant<std::size_t, 4>`.]
+[:`extent<double[2][3][4], 2>::type` is the type `__integral_constant<std::size_t, 4>`.]
 
 [:`extent<int[4]>::value` is an integral constant 
 expression that evaluates to /4/.]
@@ -44,5 +44,7 @@ expression that evaluates to /0/: `boost::array` is a class type and [*not an ar
 
 [:`extent<T>::value_type` is the type `std::size_t`.]
 
+[all_compilers]
+
 [endsect]
 

doc/floating_point_promotion.qbk

@@ -12,7 +12,9 @@
    {
       typedef __below type;
    };
-  
+   
+   template <class T> using floating_point_promotion_t = typename floating_point_promotion<T>::type; // C++11 and above
+
 __type If floating point promotion can be applied to an rvalue of type `T`,
 then applies floating point promotion to `T` and keeps cv-qualifiers of `T`,
 otherwise leaves `T` unchanged.
@@ -33,5 +35,7 @@ __header ` #include <boost/type_traits/floating_point_promotion.hpp>` or ` #incl
 
 ]
 
+[all_compilers]
+
 [endsect]
 

doc/function_traits.qbk

@@ -52,5 +52,7 @@ type use __remove_pointer.]
 
 ]
    
+[all_compilers]
+
 [endsect]
 

doc/has_bit_and.qbk

@@ -44,66 +44,9 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
+[has_binary_operator_compat]
 
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator&` is public or not:
-if `operator&` is defined as a private member of `Lhs` then
-instantiating `has_bit_and<Lhs>` will produce a compiler error.
-For this reason `has_bit_and` cannot be used to determine whether a type has a public `operator&` or not.
-``
-struct A { private: void operator&(const A&); };
-boost::has_bit_and<A>::value; // error: A::operator&(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator&(const A&, const A&);
-struct B { operator A(); };
-boost::has_bit_and<A>::value; // this is fine
-boost::has_bit_and<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator&` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_bit_and.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator&(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_bit_and< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g&g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_bit_and< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b&b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_bit_and..&..A..contains<T>..const ]
 
 [endsect]
 

doc/has_bit_and_assign.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_bit_and_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_bit_and_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -44,66 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator&=` is public or not:
-if `operator&=` is defined as a private member of `Lhs` then
-instantiating `has_bit_and_assign<Lhs>` will produce a compiler error.
-For this reason `has_bit_and_assign` cannot be used to determine whether a type has a public `operator&=` or not.
-``
-struct A { private: void operator&=(const A&); };
-boost::has_bit_and_assign<A>::value; // error: A::operator&=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator&=(const A&, const A&);
-struct B { operator A(); };
-boost::has_bit_and_assign<A>::value; // this is fine
-boost::has_bit_and_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator&=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_bit_and_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator&=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_bit_and_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g&=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_bit_and_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b&=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_bit_and_assign..&=..A&..contains<T>&..[/Nothing]]
 
 [endsect]
 

doc/has_bit_or.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_bit_or.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_bit_or<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -44,66 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator|` is public or not:
-if `operator|` is defined as a private member of `Lhs` then
-instantiating `has_bit_or<Lhs>` will produce a compiler error.
-For this reason `has_bit_or` cannot be used to determine whether a type has a public `operator|` or not.
-``
-struct A { private: void operator|(const A&); };
-boost::has_bit_or<A>::value; // error: A::operator|(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator|(const A&, const A&);
-struct B { operator A(); };
-boost::has_bit_or<A>::value; // this is fine
-boost::has_bit_or<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator|` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_bit_or.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator|(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_bit_or< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g|g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_bit_or< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b|b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_bit_or..|..A..contains<T>..const ]
 
 [endsect]
 

doc/has_bit_or_assign.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_bit_or_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_bit_or_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -44,66 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator|=` is public or not:
-if `operator|=` is defined as a private member of `Lhs` then
-instantiating `has_bit_or_assign<Lhs>` will produce a compiler error.
-For this reason `has_bit_or_assign` cannot be used to determine whether a type has a public `operator|=` or not.
-``
-struct A { private: void operator|=(const A&); };
-boost::has_bit_or_assign<A>::value; // error: A::operator|=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator|=(const A&, const A&);
-struct B { operator A(); };
-boost::has_bit_or_assign<A>::value; // this is fine
-boost::has_bit_or_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator|=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_bit_or_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator|=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_bit_or_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g|=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_bit_or_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b|=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_bit_or_assign..|=..A&..contains<T>&..[/Nothing]]
 
 [endsect]
 

doc/has_bit_xor.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_bit_xor.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_bit_xor<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -44,66 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator^` is public or not:
-if `operator^` is defined as a private member of `Lhs` then
-instantiating `has_bit_xor<Lhs>` will produce a compiler error.
-For this reason `has_bit_xor` cannot be used to determine whether a type has a public `operator^` or not.
-``
-struct A { private: void operator^(const A&); };
-boost::has_bit_xor<A>::value; // error: A::operator^(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator^(const A&, const A&);
-struct B { operator A(); };
-boost::has_bit_xor<A>::value; // this is fine
-boost::has_bit_xor<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator^` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_bit_xor.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator^(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_bit_xor< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g^g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_bit_xor< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b^b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_bit_xor..^..A..contains<T>..const ]
 
 [endsect]
 

doc/has_bit_xor_assign.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_bit_xor_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_bit_xor_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -44,66 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator^=` is public or not:
-if `operator^=` is defined as a private member of `Lhs` then
-instantiating `has_bit_xor_assign<Lhs>` will produce a compiler error.
-For this reason `has_bit_xor_assign` cannot be used to determine whether a type has a public `operator^=` or not.
-``
-struct A { private: void operator^=(const A&); };
-boost::has_bit_xor_assign<A>::value; // error: A::operator^=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator^=(const A&, const A&);
-struct B { operator A(); };
-boost::has_bit_xor_assign<A>::value; // this is fine
-boost::has_bit_xor_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator^=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_bit_xor_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator^=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_bit_xor_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g^=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_bit_xor_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b^=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_bit_xor_assign..^=..A&..contains<T>&..[/Nothing]]
 
 [endsect]
 

doc/has_complement.qbk

@@ -27,6 +27,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_complement.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_complement<Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,10 +48,6 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
 [*Known issues:]
 
 * This trait cannot detect whether prefix `operator~` is public or not:
@@ -107,5 +105,7 @@ int main() {
 
 * `volatile` qualifier is not properly handled and would lead to undefined behavior
 
+[prefix_operator_known_issues has_complement..~]
+
 [endsect]
 

doc/has_dereference.qbk

@@ -27,6 +27,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_dereference.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_dereference<Rhs, Ret>::value_type` is the type `bool`.]
@@ -49,10 +51,6 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
 [*Known issues:]
 
 * This trait cannot detect whether prefix `operator*` is public or not:

doc/has_divides.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_divides.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_divides<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator/` is public or not:
-if `operator/` is defined as a private member of `Lhs` then
-instantiating `has_divides<Lhs>` will produce a compiler error.
-For this reason `has_divides` cannot be used to determine whether a type has a public `operator/` or not.
-``
-struct A { private: void operator/(const A&); };
-boost::has_divides<A>::value; // error: A::operator/(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator/(const A&, const A&);
-struct B { operator A(); };
-boost::has_divides<A>::value; // this is fine
-boost::has_divides<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator/` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_divides.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator/(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_divides< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g/g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_divides< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b/b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_divides../..A..contains<T>..const ]
 
 [endsect]
 

doc/has_divides_assign.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_divides_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_divides_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator/=` is public or not:
-if `operator/=` is defined as a private member of `Lhs` then
-instantiating `has_divides_assign<Lhs>` will produce a compiler error.
-For this reason `has_divides_assign` cannot be used to determine whether a type has a public `operator/=` or not.
-``
-struct A { private: void operator/=(const A&); };
-boost::has_divides_assign<A>::value; // error: A::operator/=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator/=(const A&, const A&);
-struct B { operator A(); };
-boost::has_divides_assign<A>::value; // this is fine
-boost::has_divides_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator/=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_divides_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator/=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_divides_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g/=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_divides_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b/=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_divides_assign../=..A&..contains<T>&..[/Nothing]]
 
 [endsect]
 

doc/has_equal_to.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_equal_to.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_equal_to<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator==` is public or not:
-if `operator==` is defined as a private member of `Lhs` then
-instantiating `has_equal_to<Lhs>` will produce a compiler error.
-For this reason `has_equal_to` cannot be used to determine whether a type has a public `operator==` or not.
-``
-struct A { private: void operator==(const A&); };
-boost::has_equal_to<A>::value; // error: A::operator==(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator==(const A&, const A&);
-struct B { operator A(); };
-boost::has_equal_to<A>::value; // this is fine
-boost::has_equal_to<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator==` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_equal_to.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator==(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_equal_to< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g==g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_equal_to< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b==b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_equal_to..==..bool..bool..const ]
 
 [endsect]
 

doc/has_greater.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_greater.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_greater<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator>` is public or not:
-if `operator>` is defined as a private member of `Lhs` then
-instantiating `has_greater<Lhs>` will produce a compiler error.
-For this reason `has_greater` cannot be used to determine whether a type has a public `operator>` or not.
-``
-struct A { private: void operator>(const A&); };
-boost::has_greater<A>::value; // error: A::operator>(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator>(const A&, const A&);
-struct B { operator A(); };
-boost::has_greater<A>::value; // this is fine
-boost::has_greater<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator>` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_greater.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator>(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_greater< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g>g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_greater< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b>b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_greater..>..bool..bool..const ]
 
 [endsect]
 

doc/has_greater_equal.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_greater_equal.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_greater_equal<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator>=` is public or not:
-if `operator>=` is defined as a private member of `Lhs` then
-instantiating `has_greater_equal<Lhs>` will produce a compiler error.
-For this reason `has_greater_equal` cannot be used to determine whether a type has a public `operator>=` or not.
-``
-struct A { private: void operator>=(const A&); };
-boost::has_greater_equal<A>::value; // error: A::operator>=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator>=(const A&, const A&);
-struct B { operator A(); };
-boost::has_greater_equal<A>::value; // this is fine
-boost::has_greater_equal<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator>=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_greater_equal.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator>=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_greater_equal< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g>=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_greater_equal< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b>=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_greater_equal..>=..bool..bool..const ]
 
 [endsect]
 

doc/has_left_shift.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_left_shift.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_left_shift<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -47,66 +49,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator<<` is public or not:
-if `operator<<` is defined as a private member of `Lhs` then
-instantiating `has_left_shift<Lhs>` will produce a compiler error.
-For this reason `has_left_shift` cannot be used to determine whether a type has a public `operator<<` or not.
-``
-struct A { private: void operator<<(const A&); };
-boost::has_left_shift<A>::value; // error: A::operator<<(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator<<(const A&, const A&);
-struct B { operator A(); };
-boost::has_left_shift<A>::value; // this is fine
-boost::has_left_shift<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator<<` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_left_shift.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator<<(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_left_shift< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g<<g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_left_shift< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b<<b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_left_shift..<<..A..contains<T>..const ]
 
 [endsect]
 

doc/has_left_shift_assign.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_left_shift_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_left_shift_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -44,66 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator<<=` is public or not:
-if `operator<<=` is defined as a private member of `Lhs` then
-instantiating `has_left_shift_assign<Lhs>` will produce a compiler error.
-For this reason `has_left_shift_assign` cannot be used to determine whether a type has a public `operator<<=` or not.
-``
-struct A { private: void operator<<=(const A&); };
-boost::has_left_shift_assign<A>::value; // error: A::operator<<=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator<<=(const A&, const A&);
-struct B { operator A(); };
-boost::has_left_shift_assign<A>::value; // this is fine
-boost::has_left_shift_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator<<=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_left_shift_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator<<=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_left_shift_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g<<=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_left_shift_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b<<=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_left_shift_assign..<<=..A&..contains<T>&..[/]]
 
 [endsect]
 

doc/has_less.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_less.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_less<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator<` is public or not:
-if `operator<` is defined as a private member of `Lhs` then
-instantiating `has_less<Lhs>` will produce a compiler error.
-For this reason `has_less` cannot be used to determine whether a type has a public `operator<` or not.
-``
-struct A { private: void operator<(const A&); };
-boost::has_less<A>::value; // error: A::operator<(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator<(const A&, const A&);
-struct B { operator A(); };
-boost::has_less<A>::value; // this is fine
-boost::has_less<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator<` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_less.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator<(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_less< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g<g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_less< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b<b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_less..<..bool..bool..const ]
 
 [endsect]
 

doc/has_less_equal.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_less_equal.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_less_equal<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator<=` is public or not:
-if `operator<=` is defined as a private member of `Lhs` then
-instantiating `has_less_equal<Lhs>` will produce a compiler error.
-For this reason `has_less_equal` cannot be used to determine whether a type has a public `operator<=` or not.
-``
-struct A { private: void operator<=(const A&); };
-boost::has_less_equal<A>::value; // error: A::operator<=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator<=(const A&, const A&);
-struct B { operator A(); };
-boost::has_less_equal<A>::value; // this is fine
-boost::has_less_equal<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator<=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_less_equal.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator<=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_less_equal< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g<=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_less_equal< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b<=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_less_equal..<=..bool..bool..const ]
 
 [endsect]
 

doc/has_logical_and.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_logical_and.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_logical_and<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -44,67 +46,8 @@ __examples
 
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+[binary_operator_known_issues has_logical_and..&&..bool..bool..const ]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator&&` is public or not:
-if `operator&&` is defined as a private member of `Lhs` then
-instantiating `has_logical_and<Lhs>` will produce a compiler error.
-For this reason `has_logical_and` cannot be used to determine whether a type has a public `operator&&` or not.
-``
-struct A { private: void operator&&(const A&); };
-boost::has_logical_and<A>::value; // error: A::operator&&(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator&&(const A&, const A&);
-struct B { operator A(); };
-boost::has_logical_and<A>::value; // this is fine
-boost::has_logical_and<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator&&` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_logical_and.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator&&(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_logical_and< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g&&g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_logical_and< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b&&b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
 
 [endsect]
 

doc/has_logical_not.qbk

@@ -27,6 +27,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_logical_not.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_logical_not<Rhs, Ret>::value_type` is the type `bool`.]
@@ -45,10 +47,6 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
 [*Known issues:]
 
 * This trait cannot detect whether prefix `operator!` is public or not:

doc/has_logical_or.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_logical_or.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_logical_or<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -45,66 +47,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator||` is public or not:
-if `operator||` is defined as a private member of `Lhs` then
-instantiating `has_logical_or<Lhs>` will produce a compiler error.
-For this reason `has_logical_or` cannot be used to determine whether a type has a public `operator||` or not.
-``
-struct A { private: void operator||(const A&); };
-boost::has_logical_or<A>::value; // error: A::operator||(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator||(const A&, const A&);
-struct B { operator A(); };
-boost::has_logical_or<A>::value; // this is fine
-boost::has_logical_or<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator||` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_logical_or.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator||(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_logical_or< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g||g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_logical_or< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b||b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_logical_or..||..bool..bool..const ]
 
 [endsect]
 

doc/has_minus.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_minus.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_minus<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator-` is public or not:
-if `operator-` is defined as a private member of `Lhs` then
-instantiating `has_minus<Lhs>` will produce a compiler error.
-For this reason `has_minus` cannot be used to determine whether a type has a public `operator-` or not.
-``
-struct A { private: void operator-(const A&); };
-boost::has_minus<A>::value; // error: A::operator-(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator-(const A&, const A&);
-struct B { operator A(); };
-boost::has_minus<A>::value; // this is fine
-boost::has_minus<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator-` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_minus.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator-(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_minus< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g-g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_minus< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b-b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_minus..-..A..contains<T>..const ]
 
 [endsect]
 

doc/has_minus_assign.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_minus_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_minus_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator-=` is public or not:
-if `operator-=` is defined as a private member of `Lhs` then
-instantiating `has_minus_assign<Lhs>` will produce a compiler error.
-For this reason `has_minus_assign` cannot be used to determine whether a type has a public `operator-=` or not.
-``
-struct A { private: void operator-=(const A&); };
-boost::has_minus_assign<A>::value; // error: A::operator-=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator-=(const A&, const A&);
-struct B { operator A(); };
-boost::has_minus_assign<A>::value; // this is fine
-boost::has_minus_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator-=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_minus_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator-=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_minus_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g-=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_minus_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b-=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_minus_assign..-=..A&..contains<T>&..[/]]
 
 [endsect]
 

doc/has_modulus.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_modulus.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_modulus<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -44,66 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator%` is public or not:
-if `operator%` is defined as a private member of `Lhs` then
-instantiating `has_modulus<Lhs>` will produce a compiler error.
-For this reason `has_modulus` cannot be used to determine whether a type has a public `operator%` or not.
-``
-struct A { private: void operator%(const A&); };
-boost::has_modulus<A>::value; // error: A::operator%(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator%(const A&, const A&);
-struct B { operator A(); };
-boost::has_modulus<A>::value; // this is fine
-boost::has_modulus<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator%` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_modulus.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator%(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_modulus< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g%g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_modulus< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b%b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_modulus..%..A..contains<T>..const ]
 
 [endsect]
 

doc/has_modulus_assign.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_modulus_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_modulus_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -44,66 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator%=` is public or not:
-if `operator%=` is defined as a private member of `Lhs` then
-instantiating `has_modulus_assign<Lhs>` will produce a compiler error.
-For this reason `has_modulus_assign` cannot be used to determine whether a type has a public `operator%=` or not.
-``
-struct A { private: void operator%=(const A&); };
-boost::has_modulus_assign<A>::value; // error: A::operator%=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator%=(const A&, const A&);
-struct B { operator A(); };
-boost::has_modulus_assign<A>::value; // this is fine
-boost::has_modulus_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator%=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_modulus_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator%=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_modulus_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g%=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_modulus_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b%=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_modulus_assign..%=..A&..contains<T>&..[/]]
 
 [endsect]
 

doc/has_multiplies.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_multiplies.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_multiplies<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator*` is public or not:
-if `operator*` is defined as a private member of `Lhs` then
-instantiating `has_multiplies<Lhs>` will produce a compiler error.
-For this reason `has_multiplies` cannot be used to determine whether a type has a public `operator*` or not.
-``
-struct A { private: void operator*(const A&); };
-boost::has_multiplies<A>::value; // error: A::operator*(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator*(const A&, const A&);
-struct B { operator A(); };
-boost::has_multiplies<A>::value; // this is fine
-boost::has_multiplies<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator*` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_multiplies.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator*(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_multiplies< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g*g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_multiplies< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b*b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_multiplies..*..A..contains<T>..const ]
 
 [endsect]
 

doc/has_multiplies_assign.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_multiplies_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_multiplies_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator*=` is public or not:
-if `operator*=` is defined as a private member of `Lhs` then
-instantiating `has_multiplies_assign<Lhs>` will produce a compiler error.
-For this reason `has_multiplies_assign` cannot be used to determine whether a type has a public `operator*=` or not.
-``
-struct A { private: void operator*=(const A&); };
-boost::has_multiplies_assign<A>::value; // error: A::operator*=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator*=(const A&, const A&);
-struct B { operator A(); };
-boost::has_multiplies_assign<A>::value; // this is fine
-boost::has_multiplies_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator*=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_multiplies_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator*=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_multiplies_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g*=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_multiplies_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b*=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_multiplies_assign..*=..A&..contains<T>&..[/]]
 
 [endsect]
 

doc/has_negate.qbk

@@ -27,6 +27,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_negate.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_negate<Rhs, Ret>::value_type` is the type `bool`.]
@@ -45,10 +47,6 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
 [*Known issues:]
 
 * This trait cannot detect whether prefix `operator-` is public or not:

doc/has_new_operator.qbk

@@ -12,9 +12,7 @@
 __inherit If T is a (possibly cv-qualified) type with an overloaded new-operator
 then inherits from __true_type, otherwise inherits from __false_type.
 
-__compat Not usable with compilers that do not support "substitution failure is not an error"
-(in which case BOOST_NO_SFINAE will be defined), also known to be broken with 
-the Borland/Codegear compiler.
+[has_binary_operator_compat]  Also known to be broken with the Borland/Codegear compilers.
 
 __std_ref 12.5.
 

doc/has_not_equal_to.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_not_equal_to.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_not_equal_to<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator!=` is public or not:
-if `operator!=` is defined as a private member of `Lhs` then
-instantiating `has_not_equal_to<Lhs>` will produce a compiler error.
-For this reason `has_not_equal_to` cannot be used to determine whether a type has a public `operator!=` or not.
-``
-struct A { private: void operator!=(const A&); };
-boost::has_not_equal_to<A>::value; // error: A::operator!=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator!=(const A&, const A&);
-struct B { operator A(); };
-boost::has_not_equal_to<A>::value; // this is fine
-boost::has_not_equal_to<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator!=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_not_equal_to.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator!=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_not_equal_to< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g!=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_not_equal_to< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b!=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_not_equal_to..!=..bool..bool..const ]
 
 [endsect]
 

doc/has_nothrow_assign.qbk

@@ -14,14 +14,11 @@ __inherit If T is a (possibly cv-qualified) type with a non-throwing assignment-
 then inherits from __true_type, otherwise inherits from __false_type.  Type `T`
 must be a complete type.
 
-__compat If the compiler does not support partial-specialization of class 
-templates, then this template can not be used with function types.
-
-Without some (as yet unspecified) help from the compiler, 
-`has_nothrow_assign` will never report that a class or struct has a 
-non-throwing assignment-operator; this is always safe, if possibly sub-optimal.
-Currently (May 2005) only Visual C++ 8 has the necessary compiler support to ensure that this
-trait "just works".
+__compat Either requires C++11 `noexcept` and `decltype` or else some (unspecified) help from the compiler.
+Currently (June 2015) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
+Intel-11.0, and Codegear and all recent GCC versions have the necessary compiler __intrinsics to ensure that this 
+trait "just works".  You may test to see if the necessary support is available 
+by checking to see if `defined(BOOST_HAS_NOTHROW_CONSTRUCTOR) || (!defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_NOEXCEPT))` is true.
 
 __header ` #include <boost/type_traits/has_nothrow_assign.hpp>` or ` #include <boost/type_traits.hpp>`
 

doc/has_nothrow_constructor.qbk

@@ -19,16 +19,11 @@ must be a complete type.
 
 These two traits are synonyms for each other.
 
-__compat If the compiler does not support partial-specialization of class 
-templates, then this template can not be used with function types.
-
-Without some (unspecified) help from the compiler, 
-`has_nothrow_constructor` will never report that a class or struct has a 
-non-throwing default-constructor; this is always safe, if possibly sub-optimal.
-Currently (May 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
-Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this 
-trait "just works".  You may also test to see if the necessary __intrinsics are available 
-by checking to see if the macro `BOOST_HAS_NOTHROW_CONSTRUCTOR` is defined.
+__compat Either requires C++11 `noexcept` and `decltype` or else some (unspecified) help from the compiler.
+Currently (June 2015) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
+Intel-11.0, and Codegear and all recent GCC versions have the necessary compiler __intrinsics to ensure that this 
+trait "just works".  You may test to see if the necessary support is available 
+by checking to see if `defined(BOOST_HAS_NOTHROW_CONSTRUCTOR) || (!defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_NOEXCEPT))` is true.
 
 __header ` #include <boost/type_traits/has_nothrow_constructor.hpp>` or ` #include <boost/type_traits.hpp>`
 

doc/has_nothrow_copy.qbk

@@ -19,16 +19,11 @@ must be a complete type.
 
 These two traits are synonyms for each other.
 
-__compat If the compiler does not support partial-specialization of class 
-templates, then this template can not be used with function types.
-
-Without some (as yet unspecified) help from the compiler, 
-`has_nothrow_copy` will never report that a class or struct has a 
-non-throwing copy-constructor; this is always safe, if possibly sub-optimal.
-Currently (May 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
-Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this 
-trait "just works".  You may also test to see if the necessary __intrinsics are available 
-by checking to see if the macro `BOOST_HAS_NOTHROW_COPY` is defined.
+__compat Either requires C++11 `noexcept` and `decltype` or else some (unspecified) help from the compiler.
+Currently (June 2015) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
+Intel-11.0, and Codegear and all recent GCC versions have the necessary compiler __intrinsics to ensure that this 
+trait "just works".  You may test to see if the necessary support is available 
+by checking to see if `defined(BOOST_HAS_NOTHROW_COPY) || (!defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_NOEXCEPT))` is true.
 
 __header ` #include <boost/type_traits/has_nothrow_copy.hpp>` or ` #include <boost/type_traits.hpp>`
 

doc/has_nothrow_destruct.qbk

@@ -0,0 +1,29 @@
+[/ 
+  Copyright 2015 John Maddock.
+  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).
+]
+
+[section:has_nothrow_destruct has_nothrow_destructor]
+
+   template <class T>
+   struct has_nothrow_destructor : public __tof {};
+  
+__inherit If T is a (possibly cv-qualified) type with a non-throwing destructor
+then inherits from __true_type, otherwise inherits from __false_type.  Type `T`
+must be a complete type.
+
+__compat Either requires C++11 `noexcept` and `decltype` or else some (unspecified) help from the compiler.
+You may test to see if the necessary support is available 
+by checking to see if `!defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_NOEXCEPT)` is true.
+
+__header ` #include <boost/type_traits/has_nothrow_copy.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[note
+Note that destructors are assumed to be non-throwing unless they are explicitly marked otherwise with a `throw(something)` specification.
+This is in line with the C++11 standard.
+]
+
+[endsect]
+

doc/has_plus.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_plus.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_plus<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator+` is public or not:
-if `operator+` is defined as a private member of `Lhs` then
-instantiating `has_plus<Lhs>` will produce a compiler error.
-For this reason `has_plus` cannot be used to determine whether a type has a public `operator+` or not.
-``
-struct A { private: void operator+(const A&); };
-boost::has_plus<A>::value; // error: A::operator+(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator+(const A&, const A&);
-struct B { operator A(); };
-boost::has_plus<A>::value; // this is fine
-boost::has_plus<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator+` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_plus.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator+(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_plus< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g+g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_plus< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b+b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_plus..+..A..contains<T>..const ]
 
 [endsect]
 

doc/has_plus_assign.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_plus_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_plus_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -46,66 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator+=` is public or not:
-if `operator+=` is defined as a private member of `Lhs` then
-instantiating `has_plus_assign<Lhs>` will produce a compiler error.
-For this reason `has_plus_assign` cannot be used to determine whether a type has a public `operator+=` or not.
-``
-struct A { private: void operator+=(const A&); };
-boost::has_plus_assign<A>::value; // error: A::operator+=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator+=(const A&, const A&);
-struct B { operator A(); };
-boost::has_plus_assign<A>::value; // this is fine
-boost::has_plus_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator+=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_plus_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator+=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_plus_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g+=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_plus_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b+=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_plus_assign..+=..A&..contains<T>&..const ]
 
 [endsect]
 

doc/has_post_decrement.qbk

@@ -27,6 +27,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_post_decrement.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_post_decrement<Lhs, Ret>::value_type` is the type `bool`.]
@@ -47,10 +49,6 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
 [*Known issues:]
 
 * This trait cannot detect whether postfix `operator--` is public or not:
@@ -108,5 +106,7 @@ int main() {
 
 * `volatile` qualifier is not properly handled and would lead to undefined behavior
 
+[prefix_operator_known_issues has_post_decrement..--]
+
 [endsect]
 

doc/has_post_increment.qbk

@@ -27,6 +27,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_post_increment.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_post_increment<Lhs, Ret>::value_type` is the type `bool`.]
@@ -47,10 +49,6 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
 [*Known issues:]
 
 * This trait cannot detect whether postfix `operator++` is public or not:
@@ -108,5 +106,7 @@ int main() {
 
 * `volatile` qualifier is not properly handled and would lead to undefined behavior
 
+[prefix_operator_known_issues has_post_increment..++]
+
 [endsect]
 

doc/has_pre_decrement.qbk

@@ -1,4 +1,4 @@
-[/
+#[/
   (C) Copyright 2009-2011  Frederic Bron.
   Distributed under the Boost Software License, Version 1.0.
   (See accompanying file LICENSE_1_0.txt or copy at
@@ -27,6 +27,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_pre_decrement.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_pre_decrement<Rhs, Ret>::value_type` is the type `bool`.]
@@ -47,10 +49,6 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
 [*Known issues:]
 
 * This trait cannot detect whether prefix `operator--` is public or not:
@@ -108,5 +106,7 @@ int main() {
 
 * `volatile` qualifier is not properly handled and would lead to undefined behavior
 
+[prefix_operator_known_issues has_pre_decrement..--]
+
 [endsect]
 

doc/has_pre_increment.qbk

@@ -27,6 +27,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_pre_increment.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_pre_increment<Rhs, Ret>::value_type` is the type `bool`.]
@@ -47,10 +49,6 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
 [*Known issues:]
 
 * This trait cannot detect whether prefix `operator++` is public or not:
@@ -108,5 +106,7 @@ int main() {
 
 * `volatile` qualifier is not properly handled and would lead to undefined behavior
 
+[prefix_operator_known_issues has_pre_increment..++]
+
 [endsect]
 

doc/has_right_shift.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_right_shift.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_right_shift<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -47,66 +49,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator>>` is public or not:
-if `operator>>` is defined as a private member of `Lhs` then
-instantiating `has_right_shift<Lhs>` will produce a compiler error.
-For this reason `has_right_shift` cannot be used to determine whether a type has a public `operator>>` or not.
-``
-struct A { private: void operator>>(const A&); };
-boost::has_right_shift<A>::value; // error: A::operator>>(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator>>(const A&, const A&);
-struct B { operator A(); };
-boost::has_right_shift<A>::value; // this is fine
-boost::has_right_shift<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator>>` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_right_shift.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator>>(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_right_shift< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g>>g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_right_shift< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b>>b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_right_shift..>>..A..contains<T>..const ]
 
 [endsect]
 

doc/has_right_shift_assign.qbk

@@ -28,6 +28,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_right_shift_assign.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_right_shift_assign<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
@@ -44,66 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
-[*Known issues:]
-
-* This trait cannot detect whether binary `operator>>=` is public or not:
-if `operator>>=` is defined as a private member of `Lhs` then
-instantiating `has_right_shift_assign<Lhs>` will produce a compiler error.
-For this reason `has_right_shift_assign` cannot be used to determine whether a type has a public `operator>>=` or not.
-``
-struct A { private: void operator>>=(const A&); };
-boost::has_right_shift_assign<A>::value; // error: A::operator>>=(const A&) is private
-``
-
-* There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambiguous overload.
-``
-struct A { };
-void operator>>=(const A&, const A&);
-struct B { operator A(); };
-boost::has_right_shift_assign<A>::value; // this is fine
-boost::has_right_shift_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator>>=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_right_shift_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator>>=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_right_shift_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g>>=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_right_shift_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b>>=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_right_shift_assign..>>=..A&..contains<T>&..[/]]
 
 [endsect]
 

doc/has_trivial_assign.qbk

@@ -16,13 +16,12 @@ If a type has a trivial assignment-operator then the operator has the same effec
 as copying the bits of one object to the other: 
 calls to the operator can be safely replaced with a call to `memcpy`.
 
-__compat If the compiler does not support partial-specialization of class 
-templates, then this template can not be used with function types.
-
-Without some (as yet unspecified) help from the compiler, 
+__compat Without some (as yet unspecified) help from the compiler, 
 has_trivial_assign will never report that a user-defined class or struct has a 
-trivial constructor; this is always safe, if possibly sub-optimal.  
-Currently (May 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
+trivial constructor; this is always safe, if possibly sub-optimal.  In order to
+correctly handle deleted or private assignment operators, the compiler must also
+support C++11's `decltype`.
+Currently (May 2015) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
 Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this 
 trait "just works".  You may also test to see if the necessary __intrinsics are available 
 by checking to see if the macro `BOOST_HAS_TRIVIAL_ASSIGN` is defined.

doc/has_trivial_constructor.qbk

@@ -24,13 +24,12 @@ to omit a call to a single trivial-constructor call is of no benefit whatsoever.
 However, if loops and/or exception handling code can also be omitted, then some
 benefit in terms of code size and speed can be obtained.
 
-__compat If the compiler does not support partial-specialization of class 
-templates, then this template can not be used with function types.
-
-Without some (as yet unspecified) help from the compiler, 
+__compat Without some (as yet unspecified) help from the compiler, 
 has_trivial_constructor will never report that a user-defined class or struct has a 
 trivial constructor; this is always safe, if possibly sub-optimal.  
-Currently (May 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
+In addition, in order to correctly handle private or deleted default-constructors then
+C++11's `deltype` is required.
+Currently (May 2015) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
 Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this 
 trait "just works".  You may also test to see if the necessary __intrinsics are available 
 by checking to see if the macro `BOOST_HAS_TRIVIAL_CONSTRUCTOR` is defined.

doc/has_trivial_copy.qbk

@@ -22,13 +22,12 @@ If a type has a trivial copy-constructor then the constructor has the same effec
 as copying the bits of one object to the other: 
 calls to the constructor can be safely replaced with a call to `memcpy`.
 
-__compat If the compiler does not support partial-specialization of class 
-templates, then this template can not be used with function types.
-
-Without some (as yet unspecified) help from the compiler, 
+__compat Without some (as yet unspecified) help from the compiler, 
 has_trivial_copy will never report that a user-defined class or struct has a 
 trivial constructor; this is always safe, if possibly sub-optimal.  
-Currently (May 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
+In addition, in order to correctly handle deleted or private copy-constructors
+then C++11's `dectype` is required.
+Currently (May 2015) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
 Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this 
 trait "just works".  You may also test to see if the necessary __intrinsics are available 
 by checking to see if the macro `BOOST_HAS_TRIVIAL_COPY` is defined.

doc/has_trivial_destructor.qbk

@@ -18,13 +18,12 @@ to omit a call to a single trivial-constructor call is of no benefit whatsoever.
 However, if loops and/or exception handling code can also be omitted, then some
 benefit in terms of code size and speed can be obtained.
 
-__compat If the compiler does not support partial-specialization of class 
-templates, then this template can not be used with function types.
-
-Without some (as yet unspecified) help from the compiler, 
+__compat Without some (as yet unspecified) help from the compiler, 
 has_trivial_destructor will never report that a user-defined class or struct has a 
 trivial destructor; this is always safe, if possibly sub-optimal.  
-Currently (May 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
+In addition, in order to correctly handle deleted or private destructors then
+support for C++11's `decltype` is required.
+Currently (June 2015) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
 Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this 
 trait "just works".  You may also test to see if the necessary __intrinsics are available 
 by checking to see if the macro `BOOST_HAS_TRIVIAL_DESTRUCTOR` is defined.

doc/has_trivial_move_assign.qbk

@@ -0,0 +1,48 @@
+[/ 
+  Copyright 2007 John Maddock.
+  Copyright 2013 Antony Polukhin.
+  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).
+]
+
+[section:has_trivial_move_assign has_trivial_move_assign]
+   template <class T>
+   struct has_trivial_move_assign : public __tof {};
+  
+__inherit If T is a (possibly cv-qualified) type with a trivial move assignment-operator
+then inherits from __true_type, otherwise inherits from __false_type.
+
+If a type has a trivial move assignment-operator then the operator has the same effect
+as copying the bits of one object to the other: 
+calls to the operator can be safely replaced with a call to `memcpy`.
+
+__compat Without some (as yet unspecified) help from the compiler, 
+has_trivial_move_assign will never report that a user-defined class or struct has a 
+trivial move assign; this is always safe, if possibly sub-optimal. 
+In addition, in order to correctly handle private or deleted move assignment
+operators then c++11's `decltype` is required. 
+Currently (June 2015) compilers that have the necessary __intrinsics to ensure that this 
+trait "just works" include Clang, GCC-5.1 and MSVC-12.0.  
+You may also test to see if the necessary __intrinsics are available 
+by checking to see if the macro `BOOST_HAS_TRIVIAL_MOVE_ASSIGN` is defined.
+
+
+__header ` #include <boost/type_traits/has_trivial_move_assign.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_trivial_move_assign<int>` inherits from `__true_type`.]
+
+[:`has_trivial_move_assign<char*>::type` is the type `__true_type`.]
+
+[:`has_trivial_move_assign<int (*)(long)>::value` is an integral constant 
+expression that evaluates to /true/.]
+
+[:`has_trivial_move_assign<MyClass>::value` is an integral constant 
+expression that evaluates to /false/.]
+
+[:`has_trivial_move_assign<T>::value_type` is the type `bool`.]
+
+[endsect]
+

doc/has_trivial_move_constructor.qbk

@@ -0,0 +1,49 @@
+[/ 
+  Copyright 2007 John Maddock.
+  Copyright 2013 Antony Polukhin.
+  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).
+]
+
+[section:has_trivial_move_constructor has_trivial_move_constructor]
+
+   template <class T>
+   struct has_trivial_move_constructor : public __tof {};
+  
+__inherit If T is a (possibly cv-qualified) type with a trivial move-constructor
+then inherits from __true_type, otherwise inherits from __false_type.
+
+If a type has a trivial move-constructor then the constructor has the same effect
+as copying the bits of one object to the other: 
+calls to the constructor can be safely replaced with a call to `memcpy`.
+
+__compat Without some (as yet unspecified) help from the compiler, 
+has_trivial_move_constructor will never report that a user-defined class or struct has a 
+trivial constructor; this is always safe, if possibly sub-optimal.  
+In addition C++11's `decltype` is required to correctly support deleted or private
+move constructors.
+Currently (June 2015) compilers that have the necessary __intrinsics to ensure that this 
+trait "just works" include Clang, GCC-5.1, and MSVC-12.0.  
+You may also test to see if the necessary __intrinsics are available 
+by checking to see if the macro `BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR` is defined.
+
+
+__header ` #include <boost/type_traits/has_trivial_move_constructor.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_trivial_move_constructor<int>` inherits from `__true_type`.]
+
+[:`has_trivial_move_constructor<char*>::type` is the type `__true_type`.]
+
+[:`has_trivial_move_constructor<int (*)(long)>::value` is an integral constant 
+expression that evaluates to /true/.]
+
+[:`has_trivial_move_constructor<MyClass>::value` is an integral constant 
+expression that evaluates to /false/.]
+
+[:`has_trivial_move_constructor<T>::value_type` is the type `bool`.]
+
+[endsect]
+

doc/has_unary_minus.qbk

@@ -27,6 +27,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_unary_minus.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_unary_minus<Rhs, Ret>::value_type` is the type `bool`.]
@@ -45,10 +47,6 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
 [*Known issues:]
 
 * This trait cannot detect whether prefix `operator-` is public or not:
@@ -106,5 +104,7 @@ int main() {
 
 * `volatile` qualifier is not properly handled and would lead to undefined behavior
 
+[prefix_operator_known_issues has_unary_minus..-]
+
 [endsect]
 

doc/has_unary_plus.qbk

@@ -27,6 +27,8 @@ If `Ret=void`, the return type is checked to be exactly `void`.
 
 __header `#include <boost/type_traits/has_unary_plus.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
 
+[has_binary_operator_compat]
+
 __examples
 
 [:`has_unary_plus<Rhs, Ret>::value_type` is the type `bool`.]
@@ -45,10 +47,6 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*Limitation:]
-
-* Requires a compiler with working SFINAE.
-
 [*Known issues:]
 
 * This trait cannot detect whether prefix `operator+` is public or not:
@@ -106,5 +104,7 @@ int main() {
 
 * `volatile` qualifier is not properly handled and would lead to undefined behavior
 
+[prefix_operator_known_issues has_unary_plus..+]
+
 [endsect]
 

doc/has_virtual_destructor.qbk

@@ -12,14 +12,13 @@
 __inherit If T is a (possibly cv-qualified) type with a virtual destructor
 then inherits from __true_type, otherwise inherits from __false_type.
 
-__compat This trait is provided for completeness, since it's part of the
-Technical Report on C++ Library Extensions.  However, there is currently no 
-way to portably implement this trait.  The default version provided 
+__compat There is currently no 
+way to portably implement this trait: the default version 
 always inherits from __false_type, and has to be explicitly specialized for 
 types with virtual destructors unless the compiler used has compiler __intrinsics
 that enable the trait to do the right thing: 
-Currently (May 2011) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
-Intel-11.0, and Codegear have the necessary compiler __intrinsics to ensure that this 
+Currently (June 2015) compilers more recent than Visual C++ 8, GCC-4.3, Greenhills 6.0, 
+Intel-11.0, plus Codegear and Clang have the necessary compiler __intrinsics to ensure that this 
 trait "just works".  You may also test to see if the necessary __intrinsics are available 
 by checking to see if the macro `BOOST_HAS_VIRTUAL_DESTRUCTOR` is defined.
 

doc/history.qbk

@@ -7,6 +7,64 @@
 
 [section:history History]
 
+[h4 Boost-1.70.0]
+
+* Added new traits __is_bounded_array, __is_unbounded_array, __copy_reference, __copy_cv_ref.
+
+[h4 Boost-1.68.0]
+
+* Added support for detecting trivial moves on clang.
+* Correct some mismatched `#pragam warning push/pop`.
+* Improve __is_virtual_base_of to give more robust answers.
+* Add support for __is_final with msvc.
+
+[h4 Boost 1.67.0]
+
+* Added new traits __detected, __detected_or, __is_detected, __is_detected_convertible, __is_detected_exact, __is_complete.
+* Added greatly improved code for detecting binary operators.
+* Add assertions for completeness to traits which require complete types as arguments: this prevents various traits from giving eroneous results from incomplete types.
+* Fix minor issue with mpl compatibility, see [@https://svn.boost.org/trac/boost/ticket/12212 #12212].
+* Add macro to indicate when is_constructible is fully implemented, see [@https://svn.boost.org/trac/boost/ticket/12003 #12003].
+* Update __is_function and __is_member_function_pointer to work correctly with C++17 noexcept specifications.
+* Add workaround for __is_default_constructible and `std::pair`.
+* Added fallback for __is_nothrow_swappable on pre-C++11 compilers.
+
+[h4 Boost 1.64.0]
+
+* Added new trait __make_void.
+
+[h4 Boost 1.60.0]
+
+* Refactored traits to depend only on Boost.Config.  Greatly simplified code to improve readability and remove workarounds for old compilers no longer supported.
+* Fix __decay to follow C++11 semantics, see [@https://svn.boost.org/trac/boost/ticket/7760 #7760].
+* Added a number of new traits __is_assignable, __is_default_constructible, __is_constructible and __is_destructible required to fix bugs in a number of other traits,
+see for example [@https://svn.boost.org/trac/boost/ticket/11324 #11324].
+
+[h4 Boost 1.58.0]
+
+* Fixed issue with CUDA on Clang compiler see [@https://svn.boost.org/trac/boost/ticket/10694 #10694].
+* Fixed __is_nothrow_move_assignable and __is_nothrow_move_constructible to work on VC12 and later.
+
+[h4 Boost 1.57.0]
+
+* Added new traits __is_copy_assignable and __is_final.
+* Misc fixes for newer versions of clang and msvc-14.
+
+[h4 Boost 1.56.0]
+
+* Fixed issues [@https://svn.boost.org/trac/boost/ticket/7317 #7317],
+[@https://svn.boost.org/trac/boost/ticket/9474 #9474].
+
+
+[h4 Boost 1.55.0]
+
+* Added new trait __is_copy_constructible.
+
+[h4 Boost 1.54.0]
+
+* Added new traits __is_nothrow_move_assignable, __is_nothrow_move_constructible, __has_trivial_move_assign, 
+__has_trivial_move_constructor.
+
 [h4 Boost 1.47.0]
 
 * [* Breaking change]: changed __is_convertible to C++0x behaviour when possible.

doc/html/boost_typetraits/background.html

@@ -1,11 +1,11 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Background and Tutorial</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="prev" href="intro.html" title="Introduction">
 <link rel="next" href="category.html" title="Type Traits by Category">
 </head>
@@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="intro.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="category.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_background">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_typetraits.background"></a><a class="link" href="background.html" title="Background and Tutorial">Background and Tutorial</a>
 </h2></div></div></div>
@@ -57,7 +57,7 @@
     </p>
 <h5>
 <a name="boost_typetraits.background.h0"></a>
-      <span><a name="boost_typetraits.background.type_traits"></a></span><a class="link" href="background.html#boost_typetraits.background.type_traits">Type
+      <span class="phrase"><a name="boost_typetraits.background.type_traits"></a></span><a class="link" href="background.html#boost_typetraits.background.type_traits">Type
       Traits</a>
     </h5>
 <p>
@@ -86,7 +86,7 @@
     </p>
 <h5>
 <a name="boost_typetraits.background.h1"></a>
-      <span><a name="boost_typetraits.background.implementation"></a></span><a class="link" href="background.html#boost_typetraits.background.implementation">Implementation</a>
+      <span class="phrase"><a name="boost_typetraits.background.implementation"></a></span><a class="link" href="background.html#boost_typetraits.background.implementation">Implementation</a>
     </h5>
 <p>
       There are far too many separate classes contained in the type-traits library
@@ -176,7 +176,7 @@
     </p>
 <h5>
 <a name="boost_typetraits.background.h2"></a>
-      <span><a name="boost_typetraits.background.optimized_copy"></a></span><a class="link" href="background.html#boost_typetraits.background.optimized_copy">Optimized
+      <span class="phrase"><a name="boost_typetraits.background.optimized_copy"></a></span><a class="link" href="background.html#boost_typetraits.background.optimized_copy">Optimized
       copy</a>
     </h5>
 <p>
@@ -195,7 +195,7 @@
       copy in terms of <code class="computeroutput"><span class="identifier">memcpy</span></code> all
       of the following conditions need to be met:
     </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
           Both of the iterator types <code class="computeroutput"><span class="identifier">Iter1</span></code>
           and <code class="computeroutput"><span class="identifier">Iter2</span></code> must be pointers.
@@ -212,7 +212,7 @@
 <p>
       By trivial assignment operator we mean that the type is either a scalar type<a class="link" href="background.html#background.references">[3]</a> or:
     </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
           The type has no user defined assignment operator.
         </li>
@@ -250,7 +250,7 @@
     </p>
 <h5>
 <a name="boost_typetraits.background.h3"></a>
-      <span><a name="boost_typetraits.background.was_it_worth_it_"></a></span><a class="link" href="background.html#boost_typetraits.background.was_it_worth_it_">Was
+      <span class="phrase"><a name="boost_typetraits.background.was_it_worth_it_"></a></span><a class="link" href="background.html#boost_typetraits.background.was_it_worth_it_">Was
       it worth it?</a>
     </h5>
 <p>
@@ -267,7 +267,7 @@
       comparison between algorithms becomes difficult. However, perhaps we can add
       a couple of caveats to the premature optimization rule:
     </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
           If you use the right algorithm for the job in the first place then optimization
           will not be required; in some cases, memcpy is the right algorithm.
@@ -283,7 +283,7 @@
         </li>
 </ul></div>
 <div class="table">
-<a name="boost_typetraits.background.time_taken_to_copy_1000_elements_using__copy_const_t___t_____times_in_micro_seconds_"></a><p class="title"><b>Table&#160;1.1.&#160;Time taken to copy 1000 elements using `copy&lt;const T*, T*&gt;` (times
+<a name="boost_typetraits.background.time_taken_to_copy_1000_elements_using__copy_const_t___t_____times_in_micro_seconds_"></a><p class="title"><b>Table 1.1. Time taken to copy 1000 elements using `copy&lt;const T*, T*&gt;` (times
       in micro-seconds)</b></p>
 <div class="table-contents"><table class="table" summary="Time taken to copy 1000 elements using `copy&lt;const T*, T*&gt;` (times
       in micro-seconds)">
@@ -383,7 +383,7 @@
 </div>
 <br class="table-break"><h5>
 <a name="boost_typetraits.background.h4"></a>
-      <span><a name="boost_typetraits.background.pair_of_references"></a></span><a class="link" href="background.html#boost_typetraits.background.pair_of_references">Pair
+      <span class="phrase"><a name="boost_typetraits.background.pair_of_references"></a></span><a class="link" href="background.html#boost_typetraits.background.pair_of_references">Pair
       of References</a>
     </h5>
 <p>
@@ -420,7 +420,7 @@
       to hold non-reference types, references, and constant references:
     </p>
 <div class="table">
-<a name="boost_typetraits.background.required_constructor_argument_types"></a><p class="title"><b>Table&#160;1.2.&#160;Required Constructor Argument Types</b></p>
+<a name="boost_typetraits.background.required_constructor_argument_types"></a><p class="title"><b>Table 1.2. Required Constructor Argument Types</b></p>
 <div class="table-contents"><table class="table" summary="Required Constructor Argument Types">
 <colgroup>
 <col>
@@ -485,7 +485,7 @@
       adds a reference to its type, unless it is already a reference.
     </p>
 <div class="table">
-<a name="boost_typetraits.background.using_add_reference_to_synthesize_the_correct_constructor_type"></a><p class="title"><b>Table&#160;1.3.&#160;Using add_reference to synthesize the correct constructor type</b></p>
+<a name="boost_typetraits.background.using_add_reference_to_synthesize_the_correct_constructor_type"></a><p class="title"><b>Table 1.3. Using add_reference to synthesize the correct constructor type</b></p>
 <div class="table-contents"><table class="table" summary="Using add_reference to synthesize the correct constructor type">
 <colgroup>
 <col>
@@ -602,7 +602,7 @@
     </p>
 <h5>
 <a name="boost_typetraits.background.h5"></a>
-      <span><a name="boost_typetraits.background.conclusion"></a></span><a class="link" href="background.html#boost_typetraits.background.conclusion">Conclusion</a>
+      <span class="phrase"><a name="boost_typetraits.background.conclusion"></a></span><a class="link" href="background.html#boost_typetraits.background.conclusion">Conclusion</a>
     </h5>
 <p>
       We hope that in this article we have been able to give you some idea of what
@@ -615,7 +615,7 @@
     </p>
 <h5>
 <a name="boost_typetraits.background.h6"></a>
-      <span><a name="boost_typetraits.background.acknowledgements"></a></span><a class="link" href="background.html#boost_typetraits.background.acknowledgements">Acknowledgements</a>
+      <span class="phrase"><a name="boost_typetraits.background.acknowledgements"></a></span><a class="link" href="background.html#boost_typetraits.background.acknowledgements">Acknowledgements</a>
     </h5>
 <p>
       The authors would like to thank Beman Dawes and Howard Hinnant for their helpful
@@ -623,7 +623,7 @@
     </p>
 <h5>
 <a name="boost_typetraits.background.h7"></a>
-      <span><a name="boost_typetraits.background._anchor_id__background_references___references"></a></span><a class="link" href="background.html#boost_typetraits.background._anchor_id__background_references___references"><a name="background.references"></a>References</a>
+      <span class="phrase"><a name="boost_typetraits.background._anchor_id__background_references___references"></a></span><a class="link" href="background.html#boost_typetraits.background._anchor_id__background_references___references">References</a>
     </h5>
 <div class="orderedlist"><ol class="orderedlist" type="1">
 <li class="listitem">
@@ -673,11 +673,11 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_typetraits/category.html

@@ -1,11 +1,11 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Type Traits by Category</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="prev" href="background.html" title="Background and Tutorial">
 <link rel="next" href="category/value_traits.html" title="Type Traits that Describe the Properties of a Type">
 </head>
@@ -22,11 +22,11 @@
 <div class="spirit-nav">
 <a accesskey="p" href="background.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="category/value_traits.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_category">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_typetraits.category"></a><a class="link" href="category.html" title="Type Traits by Category">Type Traits by Category</a>
 </h2></div></div></div>
-<div class="toc"><dl>
+<div class="toc"><dl class="toc">
 <dt><span class="section"><a href="category/value_traits.html">Type Traits that
       Describe the Properties of a Type</a></span></dt>
 <dd><dl>
@@ -49,11 +49,11 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_typetraits/category/alignment.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Synthesizing Types with Specific Alignments</title>
 <link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../category.html" title="Type Traits by Category">
 <link rel="prev" href="transform.html" title="Type Traits that Transform One Type to Another">
 <link rel="next" href="function.html" title="Decomposing Function Types">
@@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="transform.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="function.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_category_alignment">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_typetraits.category.alignment"></a><a class="link" href="alignment.html" title="Synthesizing Types with Specific Alignments">Synthesizing Types
       with Specific Alignments</a>
@@ -45,11 +45,11 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_typetraits/category/function.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Decomposing Function Types</title>
 <link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../category.html" title="Type Traits by Category">
 <link rel="prev" href="alignment.html" title="Synthesizing Types with Specific Alignments">
 <link rel="next" href="../user_defined.html" title="User Defined Specializations">
@@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="alignment.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../user_defined.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_category_function">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_typetraits.category.function"></a><a class="link" href="function.html" title="Decomposing Function Types">Decomposing Function
       Types</a>
@@ -42,11 +42,11 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_typetraits/category/transform.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Type Traits that Transform One Type to Another</title>
 <link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../category.html" title="Type Traits by Category">
 <link rel="prev" href="value_traits/operators.html" title="Operator Type Traits">
 <link rel="next" href="alignment.html" title="Synthesizing Types with Specific Alignments">
@@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="value_traits/operators.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="alignment.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_category_transform">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_typetraits.category.transform"></a><a class="link" href="transform.html" title="Type Traits that Transform One Type to Another">Type Traits that
       Transform One Type to Another</a>
@@ -63,6 +63,9 @@
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="../reference/common_type.html" title="common_type">common_type</a><span class="special">;</span>
 
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../reference/copy_cv.html" title="copy_cv">copy_cv</a><span class="special">;</span>
+
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="../reference/decay.html" title="decay">decay</a><span class="special">;</span>
 
@@ -101,71 +104,18 @@
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="../reference/remove_volatile.html" title="remove_volatile">remove_volatile</a><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../reference/type_identity.html" title="type_identity">type_identity</a><span class="special">;</span>
 </pre>
-<h5>
-<a name="boost_typetraits.category.transform.h0"></a>
-        <span><a name="boost_typetraits.category.transform.broken_compiler_workarounds_"></a></span><a class="link" href="transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">Broken
-        Compiler Workarounds:</a>
-      </h5>
-<p>
-        For all of these templates support for partial specialization of class templates
-        is required to correctly implement the transformation. On the other hand,
-        practice shows that many of the templates from this category are very useful,
-        and often essential for implementing some generic libraries. Lack of these
-        templates is often one of the major limiting factors in porting those libraries
-        to compilers that do not yet support this language feature. As some of these
-        compilers are going to be around for a while, and at least one of them is
-        very wide-spread, it was decided that the library should provide workarounds
-        where possible.
-      </p>
-<p>
-        The basic idea behind the workaround is to manually define full specializations
-        of all type transformation templates for all fundamental types, and all their
-        1st and 2nd rank cv-[un]qualified derivative pointer types, and to provide
-        a user-level macro that will define all the explicit specializations needed
-        for any user-defined type T.
-      </p>
-<p>
-        The first part guarantees the successful compilation of something like this:
-      </p>
-<pre class="programlisting"><span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
-<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
-<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">volatile</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">volatile</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
-<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
-<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
-<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
-<span class="special">...</span>
-<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
-</pre>
-<p>
-        and the second part provides the library's users with a mechanism to make
-        the above code work not only for <code class="computeroutput"><span class="keyword">char</span></code>,
-        <code class="computeroutput"><span class="keyword">int</span></code> or other built-in type,
-        but for their own types as well:
-      </p>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">myspace</span><span class="special">{</span>
-   <span class="keyword">struct</span> <span class="identifier">MyClass</span> <span class="special">{};</span>
-<span class="special">}</span>
-<span class="comment">// declare this at global scope:</span>
-<span class="identifier">BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION</span><span class="special">(</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">)</span>
-<span class="comment">// transformations on myspace::MyClass now work:</span>
-<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
-<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">,</span> <span class="identifier">remove_const</span><span class="special">&lt;</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
-<span class="comment">// etc.</span>
-</pre>
-<p>
-        Note that the macro BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION evaluates
-        to nothing on those compilers that <span class="bold"><strong>do</strong></span> support
-        partial specialization.
-      </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_typetraits/category/value_traits.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Type Traits that Describe the Properties of a Type</title>
 <link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../category.html" title="Type Traits by Category">
 <link rel="prev" href="../category.html" title="Type Traits by Category">
 <link rel="next" href="value_traits/primary.html" title="Categorizing a Type">
@@ -22,12 +22,12 @@
 <div class="spirit-nav">
 <a accesskey="p" href="../category.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="value_traits/primary.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_category_value_traits">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_typetraits.category.value_traits"></a><a class="link" href="value_traits.html" title="Type Traits that Describe the Properties of a Type">Type Traits that
       Describe the Properties of a Type</a>
 </h3></div></div></div>
-<div class="toc"><dl>
+<div class="toc"><dl class="toc">
 <dt><span class="section"><a href="value_traits/primary.html">Categorizing
         a Type</a></span></dt>
 <dt><span class="section"><a href="value_traits/properties.html">General
@@ -50,11 +50,11 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_typetraits/category/value_traits/operators.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Operator Type Traits</title>
 <link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../../../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
 <link rel="prev" href="relate.html" title="Relationships Between Two Types">
 <link rel="next" href="../transform.html" title="Type Traits that Transform One Type to Another">
@@ -22,14 +22,14 @@
 <div class="spirit-nav">
 <a accesskey="p" href="relate.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../transform.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_category_value_traits_operators">
+<div class="section">
 <div class="titlepage"><div><div><h4 class="title">
 <a name="boost_typetraits.category.value_traits.operators"></a><a class="link" href="operators.html" title="Operator Type Traits">Operator
         Type Traits</a>
 </h4></div></div></div>
 <h6>
 <a name="boost_typetraits.category.value_traits.operators.h0"></a>
-          <span><a name="boost_typetraits.category.value_traits.operators.introduction"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.introduction">Introduction</a>
+          <span class="phrase"><a name="boost_typetraits.category.value_traits.operators.introduction"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.introduction">Introduction</a>
         </h6>
 <p>
           These traits are all <span class="emphasis"><em>value traits</em></span> inheriting from
@@ -65,7 +65,7 @@
         </p>
 <h6>
 <a name="boost_typetraits.category.value_traits.operators.h1"></a>
-          <span><a name="boost_typetraits.category.value_traits.operators.example_of_application"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.example_of_application">Example
+          <span class="phrase"><a name="boost_typetraits.category.value_traits.operators.example_of_application"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.example_of_application">Example
           of application</a>
         </h6>
 <p>
@@ -150,7 +150,7 @@
         </p>
 <h6>
 <a name="boost_typetraits.category.value_traits.operators.h2"></a>
-          <span><a name="boost_typetraits.category.value_traits.operators.description"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.description">Description</a>
+          <span class="phrase"><a name="boost_typetraits.category.value_traits.operators.description"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.description">Description</a>
         </h6>
 <p>
           The syntax is the following:
@@ -162,7 +162,7 @@
 <p>
           where:
         </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
               op represents the operator name
             </li>
@@ -204,7 +204,7 @@
           operators.
         </p>
 <div class="table">
-<a name="boost_typetraits.category.value_traits.operators.supported_prefix_operators"></a><p class="title"><b>Table&#160;1.4.&#160;Supported prefix operators</b></p>
+<a name="boost_typetraits.category.value_traits.operators.supported_prefix_operators"></a><p class="title"><b>Table 1.4. Supported prefix operators</b></p>
 <div class="table-contents"><table class="table" summary="Supported prefix operators">
 <colgroup>
 <col>
@@ -315,7 +315,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_typetraits.category.value_traits.operators.supported_postfix_operators"></a><p class="title"><b>Table&#160;1.5.&#160;Supported postfix operators</b></p>
+<a name="boost_typetraits.category.value_traits.operators.supported_postfix_operators"></a><p class="title"><b>Table 1.5. Supported postfix operators</b></p>
 <div class="table-contents"><table class="table" summary="Supported postfix operators">
 <colgroup>
 <col>
@@ -366,7 +366,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_typetraits.category.value_traits.operators.supported_binary_operators"></a><p class="title"><b>Table&#160;1.6.&#160;Supported binary operators</b></p>
+<a name="boost_typetraits.category.value_traits.operators.supported_binary_operators"></a><p class="title"><b>Table 1.6. Supported binary operators</b></p>
 <div class="table-contents"><table class="table" summary="Supported binary operators">
 <colgroup>
 <col>
@@ -734,7 +734,7 @@
         </p>
 <h6>
 <a name="boost_typetraits.category.value_traits.operators.h3"></a>
-          <span><a name="boost_typetraits.category.value_traits.operators.cv_qualifiers_and_references"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.cv_qualifiers_and_references">cv
+          <span class="phrase"><a name="boost_typetraits.category.value_traits.operators.cv_qualifiers_and_references"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.cv_qualifiers_and_references">cv
           qualifiers and references</a>
         </h6>
 <p>
@@ -769,7 +769,7 @@
           to be <code class="computeroutput"><span class="keyword">true</span></code>.
         </p>
 <div class="table">
-<a name="boost_typetraits.category.value_traits.operators.necessary_and_non_sufficient_condition_on_operator_argument_for_value_to_be_true"></a><p class="title"><b>Table&#160;1.7.&#160;necessary and non sufficient condition on operator argument for
+<a name="boost_typetraits.category.value_traits.operators.necessary_and_non_sufficient_condition_on_operator_argument_for_value_to_be_true"></a><p class="title"><b>Table 1.7. necessary and non sufficient condition on operator argument for
           value to be true</b></p>
 <div class="table-contents"><table class="table" summary="necessary and non sufficient condition on operator argument for
           value to be true">
@@ -905,7 +905,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="boost_typetraits.category.value_traits.operators.necessary_and_non_sufficient_condition_on_operator_return_type_for_value_to_be_true"></a><p class="title"><b>Table&#160;1.8.&#160;necessary and non sufficient condition on operator return type for
+<a name="boost_typetraits.category.value_traits.operators.necessary_and_non_sufficient_condition_on_operator_return_type_for_value_to_be_true"></a><p class="title"><b>Table 1.8. necessary and non sufficient condition on operator return type for
           value to be true</b></p>
 <div class="table-contents"><table class="table" summary="necessary and non sufficient condition on operator return type for
           value to be true">
@@ -1129,7 +1129,7 @@
 </div>
 <br class="table-break"><h6>
 <a name="boost_typetraits.category.value_traits.operators.h4"></a>
-          <span><a name="boost_typetraits.category.value_traits.operators.implementation"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.implementation">Implementation</a>
+          <span class="phrase"><a name="boost_typetraits.category.value_traits.operators.implementation"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.implementation">Implementation</a>
         </h6>
 <p>
           The implementation consists in only header files. The following headers
@@ -1226,7 +1226,7 @@
 
 <span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special">&lt;</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">true</span> <span class="special">&gt;</span> <span class="special">{</span>
-   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span>
 <span class="special">};</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">&gt;</span>
@@ -1321,17 +1321,17 @@
         </p>
 <h6>
 <a name="boost_typetraits.category.value_traits.operators.h5"></a>
-          <span><a name="boost_typetraits.category.value_traits.operators.limitation"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.limitation">Limitation</a>
+          <span class="phrase"><a name="boost_typetraits.category.value_traits.operators.limitation"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.limitation">Limitation</a>
         </h6>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
               Requires a compiler with working SFINAE.
             </li></ul></div>
 <h6>
 <a name="boost_typetraits.category.value_traits.operators.h6"></a>
-          <span><a name="boost_typetraits.category.value_traits.operators.known_issues"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.known_issues">Known
+          <span class="phrase"><a name="boost_typetraits.category.value_traits.operators.known_issues"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.known_issues">Known
           issues</a>
         </h6>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
 <li class="listitem">
               These traits cannot detect whether the operators are public or not:
               if an operator is defined as a private member of type <code class="computeroutput"><span class="identifier">T</span></code> then the instantiation of the corresponding
@@ -1411,7 +1411,7 @@
 </ul></div>
 <h6>
 <a name="boost_typetraits.category.value_traits.operators.h7"></a>
-          <span><a name="boost_typetraits.category.value_traits.operators.acknowledgments"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.acknowledgments">Acknowledgments</a>
+          <span class="phrase"><a name="boost_typetraits.category.value_traits.operators.acknowledgments"></a></span><a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.acknowledgments">Acknowledgments</a>
         </h6>
 <p>
           Frederic Bron is very thankful to numerous people from the boost mailing
@@ -1423,11 +1423,11 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_typetraits/category/value_traits/primary.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Categorizing a Type</title>
 <link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../../../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
 <link rel="prev" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
 <link rel="next" href="properties.html" title="General Type Properties">
@@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="../value_traits.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="properties.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_category_value_traits_primary">
+<div class="section">
 <div class="titlepage"><div><div><h4 class="title">
 <a name="boost_typetraits.category.value_traits.primary"></a><a class="link" href="primary.html" title="Categorizing a Type">Categorizing
         a Type</a>
@@ -119,11 +119,11 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_typetraits/category/value_traits/properties.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>General Type Properties</title>
 <link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../../../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
 <link rel="prev" href="primary.html" title="Categorizing a Type">
 <link rel="next" href="relate.html" title="Relationships Between Two Types">
@@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="primary.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="relate.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_category_value_traits_properties">
+<div class="section">
 <div class="titlepage"><div><div><h4 class="title">
 <a name="boost_typetraits.category.value_traits.properties"></a><a class="link" href="properties.html" title="General Type Properties">General
         Type Properties</a>
@@ -54,6 +54,9 @@
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="../../reference/has_nothrow_copy.html" title="has_nothrow_copy">has_nothrow_copy_constructor</a><span class="special">;</span>
 
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../../reference/has_nothrow_destruct.html" title="has_nothrow_destructor">has_nothrow_destructor</a><span class="special">;</span>
+
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="../../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a><span class="special">;</span>
 
@@ -78,12 +81,36 @@
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="../../reference/is_abstract.html" title="is_abstract">is_abstract</a><span class="special">;</span>
 
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../../reference/is_assignable.html" title="is_assignable">is_assignable</a><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../../reference/is_copy_constructible.html" title="is_copy_constructible">is_copy_constructible</a><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../../reference/is_copy_assignable.html" title="is_copy_assignable">is_copy_assignable</a><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../../reference/is_constructible.html" title="is_constructible">is_constructible</a><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../../reference/is_default_constructible.html" title="is_default_constructible">is_default_constructible</a><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../../reference/is_list_constructible.html" title="is_list_constructible">is_list_constructible</a><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../../reference/is_destructible.html" title="is_destructible">is_destructible</a><span class="special">;</span>
+
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="../../reference/is_const.html" title="is_const">is_const</a><span class="special">;</span>
 
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="../../reference/is_empty.html" title="is_empty">is_empty</a><span class="special">;</span>
 
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../../reference/is_final.html" title="is_final">is_final</a><span class="special">;</span>
+
 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="../../reference/is_stateless.html" title="is_stateless">is_stateless</a><span class="special">;</span>
 
@@ -111,11 +138,11 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_typetraits/category/value_traits/relate.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Relationships Between Two Types</title>
 <link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../../../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
 <link rel="prev" href="properties.html" title="General Type Properties">
 <link rel="next" href="operators.html" title="Operator Type Traits">
@@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="properties.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="operators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_category_value_traits_relate">
+<div class="section">
 <div class="titlepage"><div><div><h4 class="title">
 <a name="boost_typetraits.category.value_traits.relate"></a><a class="link" href="relate.html" title="Relationships Between Two Types">Relationships
         Between Two Types</a>
@@ -49,11 +49,11 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_typetraits/credits.html

@@ -1,11 +1,11 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Credits</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="prev" href="history.html" title="History">
 <link rel="next" href="../index/s11.html" title="Class Index">
 </head>
@@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="history.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../index/s11.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_credits">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_typetraits.credits"></a><a class="link" href="credits.html" title="Credits">Credits</a>
 </h2></div></div></div>
@@ -39,7 +39,7 @@
       This version of type traits library is based on contributions by Adobe Systems
       Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
       Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek.
+      Ramey, Jeremy Siek, Antony Polukhin and Glen Fernandes.
     </p>
 <p>
       Mat Marcus and Jesse Jones invented, and <a href="http://opensource.adobe.com/project4/project.shtml" target="_top">published
@@ -62,11 +62,11 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_typetraits/examples.html

@@ -1,11 +1,11 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Examples</title>
 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="prev" href="mpl.html" title="MPL Interoperability">
 <link rel="next" href="examples/copy.html" title="An Optimized Version of std::copy">
 </head>
@@ -22,11 +22,11 @@
 <div class="spirit-nav">
 <a accesskey="p" href="mpl.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="examples/copy.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_examples">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_typetraits.examples"></a><a class="link" href="examples.html" title="Examples">Examples</a>
 </h2></div></div></div>
-<div class="toc"><dl>
+<div class="toc"><dl class="toc">
 <dt><span class="section"><a href="examples/copy.html">An Optimized Version
       of std::copy</a></span></dt>
 <dt><span class="section"><a href="examples/fill.html">An Optimised Version
@@ -43,11 +43,11 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>

doc/html/boost_typetraits/examples/copy.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>An Optimized Version of std::copy</title>
 <link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
 <link rel="up" href="../examples.html" title="Examples">
 <link rel="prev" href="../examples.html" title="Examples">
 <link rel="next" href="fill.html" title="An Optimised Version of std::fill">
@@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="../examples.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fill.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
-<div class="section boost_typetraits_examples_copy">
+<div class="section">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_typetraits.examples.copy"></a><a class="link" href="copy.html" title="An Optimized Version of std::copy">An Optimized Version
       of std::copy</a>
@@ -78,11 +78,11 @@
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
-      Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
-      Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
-      Watanabe<p>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic Bron, Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy,
+      Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander
+      Nasonov, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert
+      Stewart and Steven Watanabe<p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>