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

@@ -1,40 +1,20 @@
-#
-# Copyright Troy D. Straszheim
-#
+# Copyright 2018 Mike Dev
+# Copyright 2019 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-#
-#----------------------------------------------------------------------------
-# This file was automatically generated from the original CMakeLists.txt file
-# Add a variable to hold the headers for the library
-set (lib_headers
-    type_traits.hpp
-    type_traits
+# 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
 )
-
-# Add a library target to the build system
-boost_library_project(
-  type_traits
-  #  SRCDIRS 
-  TESTDIRS  test
-  HEADERS ${lib_headers}
-  #  DOCDIRS 
-  DESCRIPTION  "Templates for fundamental properties of types."
-  MODULARIZED 
-  AUTHORS  "David Abrahams <dave -at- boostpro.com>"
-           "Steve Cleary" 
-           "Beman Dawes <bdawes -at- acm.org>" 
-           "Aleksey Gurtovoy <agurtovoy -at- meta-comm.com>" 
-           "Howard Hinnant" 
-           "Jesse Jones" 
-           "Mat Marcus" 
-           "Itay Maman" 
-           "John Maddock <john -at- johnmaddock.co.uk>" 
-           "Alexander Nasonov <alexander.nasonov -at- gmail.com>" 
-           "Thorsten Ottosen <nesotto -at- cs.auc.dk>"
-           "Robert Ramey <ramey -at- rrsd.com>" 
-           "Jeremy Siek <jeremy.siek -at- gmail.com>"
-  #  MAINTAINERS 
-)
-
-

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

@@ -3,21 +3,21 @@
 # subject to the Boost Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+import modules ;
 using quickbook ;
+using auto-index ;
 
 path-constant boost-images : ../../../doc/src/images ;
+path-constant here : . ;
 
 xml type_traits : type_traits.qbk ;
 boostbook standalone
     :
         type_traits
     :
+        # Index generation:
         # Path for links to Boost:
         <xsl:param>boost.root=../../../..
-        # Path for libraries index:
-        <xsl:param>boost.libraries=../../../libraries.htm
-        # Use the main Boost stylesheet:
-        <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
         
         # Some general style settings:
         <xsl:param>table.footnote.number.format=1
@@ -59,11 +59,18 @@ boostbook standalone
         <format>pdf:<xsl:param>admon.graphics.extension=".svg"
         <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
         <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/type_traits/doc/html
+        <format>pdf:<auto-index-internal>off
+        <format>html:<auto-index-internal>on
+        <auto-index-script>$(here)/index.idx
+        <auto-index-prefix>$(here)/../../.. 
+        <auto-index>on
     ;
 
-#install html : ../../../doc/html/boostbook.css ;
-#install ../ : ../../../boost.png ;
-
-
-
+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

@@ -0,0 +1,47 @@
+[/ 
+  Copyright 2010 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:add_lvalue_reference add_lvalue_reference]
+
+   template <class T>
+   struct add_lvalue_reference
+   {
+      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.
+
+__header ` #include <boost/type_traits/add_lvalue_reference.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`add_lvalue_reference<int>::type`][`int&`]]
+
+[[`add_lvalue_reference<int const&>::type`] [`int const&`]]
+
+[[`add_lvalue_reference<int*>::type`] [`int*&`]]
+
+[[`add_lvalue_reference<int*&>::type`] [`int*&`]]
+
+[[`add_lvalue_reference<int&&>::type`][`int&`]]
+
+[[`add_lvalue_reference<void>::type`][`void`]]
+
+]
+
+[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

@@ -7,20 +7,24 @@
 
 [section:add_reference add_reference]
 
+[note This trait has been made obsolete by __add_lvalue_reference and __add_rvalue_reference, 
+and new code should use these new traits rather than __is_reference which is retained
+for backwards compatibility only.
+]
+
+
    template <class T>
    struct add_reference
    {
       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
@@ -37,5 +41,7 @@ __header ` #include <boost/type_traits/add_reference.hpp>` or ` #include <boost/
 
 ]
 
+[all_compilers]
+
 [endsect]
 

doc/add_rvalue_reference.qbk

@@ -0,0 +1,49 @@
+[/ 
+  Copyright 2010 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:add_rvalue_reference add_rvalue_reference]
+
+   template <class T>
+   struct add_rvalue_reference
+   {
+      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
+a type U&, the type `add_rvalue_reference<T>::type` is not an rvalue
+reference. -end note\]].
+
+__std_ref 20.7.6.2.
+
+__header ` #include <boost/type_traits/add_rvalue_reference.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`add_rvalue_reference<int>::type`][`int&&`]]
+
+[[`add_rvalue_reference<int const&>::type`] [`int const&`]]
+
+[[`add_rvalue_reference<int*>::type`] [`int*&&`]]
+
+[[`add_rvalue_reference<int*&>::type`] [`int*&`]]
+
+[[`add_rvalue_reference<int&&>::type`][`int&&`]]
+
+[[`add_rvalue_reference<void>::type`][`void`]]
+
+]
+
+__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/background.qbk

@@ -42,7 +42,7 @@ properties wrapped up in a single class - what Nathan Myers termed 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 a 
+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. As we will show, these classes can be used in 
 generic programming to determine the properties of a given type and introduce 

doc/common_type.qbk

@@ -0,0 +1,218 @@
+[/ 
+  Copyright 2008 Howard Hinnant
+  Copyright 2008 Beman Dawes
+  Copyright 2010 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:common_type common_type]
+[/===================================================================]
+
+__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> 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 
+operating on multiple input types such as in mixed-mode arithmetic..
+
+The nested typedef `::type` could be defined as follows:
+
+    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 <>
+    struct common_type<> {
+    };
+
+    template <class T>
+    struct common_type<T> {
+        typedef typename __decay<T>::type type;
+    };
+
+    template <class T, class U>
+    struct common_type<T, U> {
+        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.
+
+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 Tutorial]
+
+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.
+
+[*Example:]
+
+    template <class T, class U>
+    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`. 
+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
+    min(T... t);
+
+This is a very useful and broadly applicable utility. 
+
+[h4 How to get the common type of types with explicit conversions?]
+
+Another choice for the author of the preceding operator could be
+
+    template <class T, class U>
+    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.
+
+    template <class T, class U>
+    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?]
+
+The order of the template parameters is important. 
+
+`common_type<A,B,C>::type` is not equivalent to `common_type<C,A,B>::type`, but to `common_type<common_type<A,B>::type, C>::type`.
+
+Consider
+
+    struct A {};
+    struct B {};
+    struct C {
+        C() {}
+        C(A const&) {}
+        C(B const&) {}
+        C& operator=(C const&) {
+            return *this;
+        }
+    };
+
+The following doesn't compile
+
+    typedef boost::common_type<A, B, C>::type ABC; // Does not compile
+
+while 
+
+    typedef boost::common_type<C, A, B>::type ABC;
+
+compiles.
+
+Thus, as `common_type<A,B>::type` is undefined,  `common_type<A,B,C>::type` is also undefined.
+
+It is intended that clients who wish for `common_type<A, B>` to be well
+defined to define it themselves:
+
+    namespace boost
+    {
+
+    template <>
+    struct common_type<A, B> {typedef C type;};
+
+    } 
+
+Now this client can ask for `common_type<A, B, C>` (and get
+the same answer).
+
+Clients wanting to ask `common_type<A, B, C>` in any order and get the same result need to add in addition:
+
+    namespace boost
+    {
+
+    template <> struct common_type<B, A>
+    : public common_type<A, B> {};
+
+    } 
+
+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?]
+
+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>` 
+to be well defined to define it themselves:
+
+    namespace boost
+    {
+
+    template <>
+    struct common_type<A, B> {typedef C type;};
+
+    template <> struct common_type<B, A>
+    : public common_type<A, B> {};
+
+    } 
+
+Now this client can ask for `common_type<A, B>`.
+
+[h4 How does `common_type` behave with pointers?]
+
+Consider
+
+    struct C { }:
+    struct B : C { };
+    struct A : C { };
+
+
+Shouldn't `common_type<A*,B*>::type` be `C*`? I would say yes, but the default implementation will make it ill-formed.
+
+The library could add a specialization for pointers, as
+
+    namespace boost
+    {
+
+        template <typename A, typename B>
+        struct common_type<A*, B*> {
+            typedef common_type<A, B>* type;
+        };
+    }
+    
+But in the absence of a motivating use cases, we prefer not to add more than the standard specifies. 
+
+Of course the user can always make this specialization.
+
+[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
+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 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.
+
+It is meant to be customizable (via specialization) if this default is not appropriate.
+
+[endsect]
+

doc/conditional.qbk

@@ -0,0 +1,23 @@
+[/ 
+  Copyright 2010 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:conditional conditional]
+[/===================================================================]
+
+
+__header ` #include <boost/type_traits/conditional.hpp>` or ` #include <boost/type_traits.hpp>`
+
+    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.
+
+[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>*`, otherwise if `U` is a 
-function type then the result is `U*`, otherwise the result is `U`.
+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 `remove_cv<U>::type`.
 
 __std_ref 3.9.1.
 
@@ -25,16 +27,18 @@ __header ` #include <boost/type_traits/decay.hpp>` or ` #include <boost/type_tra
 
 [ [Expression] [Result Type]]
 
-[[`decay<int[2][3]>::type`][`int[2]*`]]
+[[`decay<int[2][3]>::type`][`int[3]*`]]
 
 [[`decay<int(&)[2]>::type`] [`int*`]]
 
 [[`decay<int(&)(double)>::type`] [`int(*)(double)`]]
 
-[[`int(*)(double`] [`int(*)(double)`]]
+[[`int(*)(double)`] [`int(*)(double)`]]
 [[`int(double)`] [`int(*)(double)`]]
 
 ]
 
+[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

@@ -36,7 +36,7 @@ determine whether to use `memcpy` to optimise the copy operation
    template<typename T>
    T* copy_imp(const T* first, const T* last, T* out, const boost::__true_type&)
    {
-      memcpy(out, first, (last-first)*sizeof(T));
+      memmove(out, first, (last-first)*sizeof(T));
       return out+(last-first);
    }
 
@@ -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{
@@ -216,5 +216,22 @@ and enum types to double:
 
 [endsect]
 
+[section:improved_min Improving std::min with common_type]
+
+An improved `std::min` function could be written like this:
+
+   template <class T, class U>
+   typename __common_type<T, U>::type min(T t, U u)
+   {
+      return t < u ? t : u;
+   }
+
+And now expressions such as:
+
+   min(1, 2.0)
+
+will actually compile and return the correct type!
+
+[endsect]
 [endsect]
 

doc/extent.qbk

@@ -10,9 +10,9 @@
    struct extent : public __integral_constant<std::size_t, EXTENT(T,N)> {};
   
 __inherit Class template extent inherits from `__integral_constant<std::size_t, EXTENT(T,N)>`, 
-where `EXTENT(T,N)` is the number of elements in the N'th array dimention of type `T`.
+where `EXTENT(T,N)` is the number of elements in the N'th array dimension of type `T`.
 
-If `T` is not an array type, or if `N > __rank<T>::value`, or if the N'th array bound
+If `T` is not a (built-in) array type, or if `N > __rank<T>::value`, or if the N'th array bound
 is incomplete, then `EXTENT(T,N)` is zero.
 
 __header ` #include <boost/type_traits/extent.hpp>` or ` #include <boost/type_traits.hpp>`
@@ -21,8 +21,12 @@ __examples
 
 [:`extent<int[1]>` inherits from `__integral_constant<std::size_t, 1>`.]
 
+[:`extent<double[2][3][4], 0>::type` is the type `__integral_constant<std::size_t, 2>`.]
+
 [:`extent<double[2][3][4], 1>::type` is the type `__integral_constant<std::size_t, 3>`.]
 
+[:`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/.]
 
@@ -35,7 +39,12 @@ expression that evaluates to /2/.]
 [:`extent<int*>::value` is an integral constant 
 expression that evaluates to /0/.]
 
+[:`extent<boost::array<int, 3> >::value` is an integral constant 
+expression that evaluates to /0/: `boost::array` is a class type and [*not an array type]!]
+
 [:`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

@@ -0,0 +1,52 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_bit_and has_bit_and]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_bit_and : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs&rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs&rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator&`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs&rhs); // is valid if has_bit_and<Lhs, Rhs, Ret>::value==true
+``
+If `Ret=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/has_bit_and.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_bit_and<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
+[:`has_bit_and<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_bit_and<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_bit_and<long>` inherits from `__true_type`.]
+
+[:`has_bit_and<int, int, int>` inherits from `__true_type`.]
+[:`has_bit_and<const int, int>` inherits from `__true_type`.]
+
+[:`has_bit_and<int, double, bool>` inherits from `__false_type`.]
+[:`has_bit_and<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[has_binary_operator_compat]
+
+[binary_operator_known_issues has_bit_and..&..A..contains<T>..const ]
+
+[endsect]
+

doc/has_bit_and_assign.qbk

@@ -0,0 +1,52 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_bit_and_assign has_bit_and_assign]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_bit_and_assign : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs&=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs&=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator&=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs&=rhs); // is valid if has_bit_and_assign<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_bit_and_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_bit_and_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_bit_and_assign<long>` inherits from `__true_type`.]
+
+[:`has_bit_and_assign<int, int, int>` inherits from `__true_type`.]
+
+[:`has_bit_and_assign<const int, int>` inherits from `__false_type`.]
+[:`has_bit_and_assign<int, double, bool>` inherits from `__false_type`.]
+[:`has_bit_and_assign<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_bit_and_assign..&=..A&..contains<T>&..[/Nothing]]
+
+[endsect]
+

doc/has_bit_or.qbk

@@ -0,0 +1,52 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_bit_or has_bit_or]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_bit_or : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs|rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs|rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator|`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs|rhs); // is valid if has_bit_or<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_bit_or<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_bit_or<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_bit_or<long>` inherits from `__true_type`.]
+
+[:`has_bit_or<int, int, int>` inherits from `__true_type`.]
+[:`has_bit_or<const int, int>` inherits from `__true_type`.]
+
+[:`has_bit_or<int, double, bool>` inherits from `__false_type`.]
+[:`has_bit_or<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_bit_or..|..A..contains<T>..const ]
+
+[endsect]
+

doc/has_bit_or_assign.qbk

@@ -0,0 +1,52 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_bit_or_assign has_bit_or_assign]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_bit_or_assign : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs|=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs|=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator|=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs|=rhs); // is valid if has_bit_or_assign<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_bit_or_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_bit_or_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_bit_or_assign<long>` inherits from `__true_type`.]
+
+[:`has_bit_or_assign<int, int, int>` inherits from `__true_type`.]
+
+[:`has_bit_or_assign<const int, int>` inherits from `__false_type`.]
+[:`has_bit_or_assign<int, double, bool>` inherits from `__false_type`.]
+[:`has_bit_or_assign<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_bit_or_assign..|=..A&..contains<T>&..[/Nothing]]
+
+[endsect]
+

doc/has_bit_xor.qbk

@@ -0,0 +1,52 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_bit_xor has_bit_xor]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_bit_xor : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs^rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs^rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator^`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs^rhs); // is valid if has_bit_xor<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_bit_xor<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_bit_xor<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_bit_xor<long>` inherits from `__true_type`.]
+
+[:`has_bit_xor<int, int, int>` inherits from `__true_type`.]
+[:`has_bit_xor<const int, int>` inherits from `__true_type`.]
+
+[:`has_bit_xor<int, double, bool>` inherits from `__false_type`.]
+[:`has_bit_xor<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_bit_xor..^..A..contains<T>..const ]
+
+[endsect]
+

doc/has_bit_xor_assign.qbk

@@ -0,0 +1,52 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_bit_xor_assign has_bit_xor_assign]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_bit_xor_assign : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs^=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs^=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator^=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs^=rhs); // is valid if has_bit_xor_assign<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_bit_xor_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_bit_xor_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_bit_xor_assign<long>` inherits from `__true_type`.]
+
+[:`has_bit_xor_assign<int, int, int>` inherits from `__true_type`.]
+
+[:`has_bit_xor_assign<const int, int>` inherits from `__false_type`.]
+[:`has_bit_xor_assign<int, double, bool>` inherits from `__false_type`.]
+[:`has_bit_xor_assign<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_bit_xor_assign..^=..A&..contains<T>&..[/Nothing]]
+
+[endsect]
+

doc/has_complement.qbk

@@ -0,0 +1,111 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_complement has_complement]
+   template <class Rhs, class Ret=dont_care>
+   struct has_complement : public __tof {};
+
+__inherit
+If (i) `rhs` of type `Rhs` can be used in expression `~rhs`,
+and (ii) `Ret=dont_care` or the result of expression `~rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator~`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Rhs rhs;
+f(~rhs); // is valid if has_complement<Rhs, Ret>::value==true
+``
+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`.]
+[:`has_complement<Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_complement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_complement<long>` inherits from `__true_type`.]
+
+[:`has_complement<int, int>` inherits from `__true_type`.]
+[:`has_complement<int, long>` inherits from `__true_type`.]
+[:`has_complement<const int>` inherits from `__true_type`.]
+
+[:`has_complement<int*>` inherits from `__false_type`.]
+[:`has_complement<double, double>` inherits from `__false_type`.]
+[:`has_complement<double, int>` inherits from `__false_type`.]
+[:`has_complement<int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[*Known issues:]
+
+* This trait cannot detect whether prefix `operator~` is public or not:
+if `operator~` is defined as a private member of `Rhs` then
+instantiating `has_complement<Rhs>` will produce a compiler error.
+For this reason `has_complement` cannot be used to determine whether a type has a public `operator~` or not.
+``
+struct A { private: void operator~(); };
+boost::has_complement<A>::value; // error: A::operator~() 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&);
+struct B { operator A(); };
+boost::has_complement<A>::value; // this is fine
+boost::has_complement<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_complement.hpp>
+#include <iostream>
+
+template <class T>
+struct contains { T data; };
+
+template <class T>
+bool operator~(const contains<T> &rhs) {
+	return f(rhs.data);
+}
+
+class bad { };
+class good { };
+bool f(const good&) { }
+
+int main() {
+	std::cout<<std::boolalpha;
+	// works fine for contains<good>
+	std::cout<<boost::has_complement< contains< good > >::value<<'\n'; // true
+	contains<good> g;
+	~g; // ok
+	// does not work for contains<bad>
+	std::cout<<boost::has_complement< contains< bad > >::value<<'\n'; // true, should be false
+	contains<bad> b;
+	~b; // compile time error
+	return 0;
+}
+``
+
+* `volatile` qualifier is not properly handled and would lead to undefined behavior
+
+[prefix_operator_known_issues has_complement..~]
+
+[endsect]
+

doc/has_dereference.qbk

@@ -0,0 +1,112 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_dereference has_dereference]
+   template <class Rhs, class Ret=dont_care>
+   struct has_dereference : public __tof {};
+
+__inherit
+If (i) `rhs` of type `Rhs` can be used in expression `*rhs`,
+and (ii) `Ret=dont_care` or the result of expression `*rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator*`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Rhs rhs;
+f(*rhs); // is valid if has_dereference<Rhs, Ret>::value==true
+``
+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`.]
+[:`has_dereference<Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_dereference<int*>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_dereference<long*>` inherits from `__true_type`.]
+
+
+[:`has_dereference<int*, int>` inherits from `__true_type`.]
+[:`has_dereference<int*, const int>` inherits from `__true_type`.]
+[:`has_dereference<int const *>` inherits from `__true_type`.]
+[:`has_dereference<int * const>` inherits from `__true_type`.]
+[:`has_dereference<int const * const>` inherits from `__true_type`.]
+
+[:`has_dereference<int>` inherits from `__false_type`.]
+[:`has_dereference<double>` inherits from `__false_type`.]
+[:`has_dereference<void*>` inherits from `__false_type`.]
+[:`has_dereference<const int*, int&>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[*Known issues:]
+
+* This trait cannot detect whether prefix `operator*` is public or not:
+if `operator*` is defined as a private member of `Rhs` then
+instantiating `has_dereference<Rhs>` will produce a compiler error.
+For this reason `has_dereference` cannot be used to determine whether a type has a public `operator*` or not.
+``
+struct A { private: void operator*(); };
+boost::has_dereference<A>::value; // error: A::operator*() 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&);
+struct B { operator A(); };
+boost::has_dereference<A>::value; // this is fine
+boost::has_dereference<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_dereference.hpp>
+#include <iostream>
+
+template <class T>
+struct contains { T data; };
+
+template <class T>
+bool operator*(const contains<T> &rhs) {
+	return f(rhs.data);
+}
+
+class bad { };
+class good { };
+bool f(const good&) { }
+
+int main() {
+	std::cout<<std::boolalpha;
+	// works fine for contains<good>
+	std::cout<<boost::has_dereference< contains< good > >::value<<'\n'; // true
+	contains<good> g;
+	*g; // ok
+	// does not work for contains<bad>
+	std::cout<<boost::has_dereference< contains< bad > >::value<<'\n'; // true, should be false
+	contains<bad> b;
+	*b; // compile time error
+	return 0;
+}
+``
+
+* `volatile` qualifier is not properly handled and would lead to undefined behavior
+
+[endsect]
+

doc/has_divides.qbk

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_divides has_divides]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_divides : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs/rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs/rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator/`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs/rhs); // is valid if has_divides<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_divides<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_divides<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_divides<long>` inherits from `__true_type`.]
+
+[:`has_divides<int, int, int>` inherits from `__true_type`.]
+[:`has_divides<int, int, long>` inherits from `__true_type`.]
+[:`has_divides<int, double, double>` inherits from `__true_type`.]
+[:`has_divides<int, double, int>` inherits from `__true_type`.]
+[:`has_divides<const int, int>::value` inherits from `__true_type`.]
+
+[:`has_divides<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_divides../..A..contains<T>..const ]
+
+[endsect]
+

doc/has_divides_assign.qbk

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_divides_assign has_divides_assign]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_divides_assign : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs/=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs/=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator/=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs/=rhs); // is valid if has_divides_assign<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_divides_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_divides_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_divides_assign<long>` inherits from `__true_type`.]
+
+[:`has_divides_assign<int, int, int>` inherits from `__true_type`.]
+[:`has_divides_assign<int, int, long>` inherits from `__true_type`.]
+[:`has_divides_assign<int, double, double>` inherits from `__true_type`.]
+[:`has_divides_assign<int, double, int>` inherits from `__true_type`.]
+
+[:`has_divides_assign<const int, int>::value` inherits from `__false_type`.]
+[:`has_divides_assign<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_divides_assign../=..A&..contains<T>&..[/Nothing]]
+
+[endsect]
+

doc/has_equal_to.qbk

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_equal_to has_equal_to]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_equal_to : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs==rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs==rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator==`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs==rhs); // is valid if has_equal_to<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_equal_to<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_equal_to<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_equal_to<long>` inherits from `__true_type`.]
+
+[:`has_equal_to<int, int, bool>` inherits from `__true_type`.]
+[:`has_equal_to<int, double, bool>` inherits from `__true_type`.]
+[:`has_equal_to<const int>` inherits from `__true_type`.]
+
+[:`has_equal_to<int*, int>` inherits from `__false_type`.]
+[:`has_equal_to<int*, double*>` inherits from `__false_type`.]
+[:`has_equal_to<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_equal_to..==..bool..bool..const ]
+
+[endsect]
+

doc/has_greater.qbk

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_greater has_greater]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_greater : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs>rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs>rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator>`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs>rhs); // is valid if has_greater<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_greater<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_greater<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_greater<long>` inherits from `__true_type`.]
+
+[:`has_greater<int, int, bool>` inherits from `__true_type`.]
+[:`has_greater<int, double, bool>` inherits from `__true_type`.]
+[:`has_greater<const int>` inherits from `__true_type`.]
+
+[:`has_greater<int*, int>` inherits from `__false_type`.]
+[:`has_greater<int*, double*>` inherits from `__false_type`.]
+[:`has_greater<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_greater..>..bool..bool..const ]
+
+[endsect]
+

doc/has_greater_equal.qbk

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_greater_equal has_greater_equal]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_greater_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs>=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs>=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator>=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs>=rhs); // is valid if has_greater_equal<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_greater_equal<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_greater_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_greater_equal<long>` inherits from `__true_type`.]
+
+[:`has_greater_equal<int, int, bool>` inherits from `__true_type`.]
+[:`has_greater_equal<int, double, bool>` inherits from `__true_type`.]
+[:`has_greater_equal<const int>` inherits from `__true_type`.]
+
+[:`has_greater_equal<int*, int>` inherits from `__false_type`.]
+[:`has_greater_equal<int*, double*>` inherits from `__false_type`.]
+[:`has_greater_equal<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_greater_equal..>=..bool..bool..const ]
+
+[endsect]
+

doc/has_left_shift.qbk

@@ -0,0 +1,55 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_left_shift has_left_shift]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_left_shift : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs<<rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs<<rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator<<`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs<<rhs); // is valid if has_left_shift<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_left_shift<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_left_shift<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_left_shift<long>` inherits from `__true_type`.]
+
+[:`has_left_shift<int, int, int>` inherits from `__true_type`.]
+[:`has_left_shift<const int, int>` inherits from `__true_type`.]
+[:`has_left_shift<std::ostream, int>` inherits from `__true_type`.]
+[:`has_left_shift<std::ostream, char*, std::ostream>` inherits from `__true_type`.]
+[:`has_left_shift<std::ostream, std::string>` inherits from `__true_type`.]
+
+[:`has_left_shift<int, double, bool>` inherits from `__false_type`.]
+[:`has_left_shift<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_left_shift..<<..A..contains<T>..const ]
+
+[endsect]
+

doc/has_left_shift_assign.qbk

@@ -0,0 +1,52 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_left_shift_assign has_left_shift_assign]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_left_shift_assign : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs<<=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs<<=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator<<=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs<<=rhs); // is valid if has_left_shift_assign<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_left_shift_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_left_shift_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_left_shift_assign<long>` inherits from `__true_type`.]
+
+[:`has_left_shift_assign<int, int, int>` inherits from `__true_type`.]
+
+[:`has_left_shift_assign<const int, int>` inherits from `__false_type`.]
+[:`has_left_shift_assign<int, double, bool>` inherits from `__false_type`.]
+[:`has_left_shift_assign<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_left_shift_assign..<<=..A&..contains<T>&..[/]]
+
+[endsect]
+

doc/has_less.qbk

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_less has_less]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_less : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs<rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs<rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator<`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs<rhs); // is valid if has_less<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_less<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_less<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_less<long>` inherits from `__true_type`.]
+
+[:`has_less<int, int, bool>` inherits from `__true_type`.]
+[:`has_less<int, double, bool>` inherits from `__true_type`.]
+[:`has_less<const int>` inherits from `__true_type`.]
+
+[:`has_less<int*, int>` inherits from `__false_type`.]
+[:`has_less<int*, double*>` inherits from `__false_type`.]
+[:`has_less<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_less..<..bool..bool..const ]
+
+[endsect]
+

doc/has_less_equal.qbk

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_less_equal has_less_equal]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_less_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs<=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs<=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator<=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs<=rhs); // is valid if has_less_equal<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_less_equal<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_less_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_less_equal<long>` inherits from `__true_type`.]
+
+[:`has_less_equal<int, int, bool>` inherits from `__true_type`.]
+[:`has_less_equal<int, double, bool>` inherits from `__true_type`.]
+[:`has_less_equal<const int>` inherits from `__true_type`.]
+
+[:`has_less_equal<int*, int>` inherits from `__false_type`.]
+[:`has_less_equal<int*, double*>` inherits from `__false_type`.]
+[:`has_less_equal<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_less_equal..<=..bool..bool..const ]
+
+[endsect]
+

doc/has_logical_and.qbk

@@ -0,0 +1,53 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_logical_and has_logical_and]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_logical_and : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs&&rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs&&rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator&&`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs&&rhs); // is valid if has_logical_and<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_logical_and<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_logical_and<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_logical_and<bool>` inherits from `__true_type`.]
+
+[:`has_logical_and<int, int, bool>` inherits from `__true_type`.]
+[:`has_logical_and<int, int, long>` inherits from `__true_type`.]
+[:`has_logical_and<int, double, bool>` inherits from `__true_type`.]
+[:`has_logical_and<const int, int>::value` inherits from `__true_type`.]
+
+[:`has_logical_and<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+[binary_operator_known_issues has_logical_and..&&..bool..bool..const ]
+
+
+[endsect]
+

doc/has_logical_not.qbk

@@ -0,0 +1,108 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_logical_not has_logical_not]
+   template <class Rhs, class Ret=dont_care>
+   struct has_logical_not : public __tof {};
+
+__inherit
+If (i) `rhs` of type `Rhs` can be used in expression `!rhs`,
+and (ii) `Ret=dont_care` or the result of expression `!rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator!`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Rhs rhs;
+f(!rhs); // is valid if has_logical_not<Rhs, Ret>::value==true
+``
+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`.]
+[:`has_logical_not<Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_logical_not<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_logical_not<bool>` inherits from `__true_type`.]
+
+[:`has_logical_not<int, bool>` inherits from `__true_type`.]
+[:`has_logical_not<int, long>` inherits from `__true_type`.]
+[:`has_logical_not<double, double>` inherits from `__true_type`.]
+[:`has_logical_not<double, bool>` inherits from `__true_type`.]
+[:`has_logical_not<const bool>` inherits from `__true_type`.]
+
+[:`has_logical_not<int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[*Known issues:]
+
+* This trait cannot detect whether prefix `operator!` is public or not:
+if `operator!` is defined as a private member of `Rhs` then
+instantiating `has_logical_not<Rhs>` will produce a compiler error.
+For this reason `has_logical_not` cannot be used to determine whether a type has a public `operator!` or not.
+``
+struct A { private: void operator!(); };
+boost::has_logical_not<A>::value; // error: A::operator!() 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&);
+struct B { operator A(); };
+boost::has_logical_not<A>::value; // this is fine
+boost::has_logical_not<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_not.hpp>
+#include <iostream>
+
+template <class T>
+struct contains { T data; };
+
+template <class T>
+bool operator!(const contains<T> &rhs) {
+	return f(rhs.data);
+}
+
+class bad { };
+class good { };
+bool f(const good&) { }
+
+int main() {
+	std::cout<<std::boolalpha;
+	// works fine for contains<good>
+	std::cout<<boost::has_logical_not< contains< good > >::value<<'\n'; // true
+	contains<good> g;
+	!g; // ok
+	// does not work for contains<bad>
+	std::cout<<boost::has_logical_not< contains< bad > >::value<<'\n'; // true, should be false
+	contains<bad> b;
+	!b; // compile time error
+	return 0;
+}
+``
+
+* `volatile` qualifier is not properly handled and would lead to undefined behavior
+
+[endsect]
+

doc/has_logical_or.qbk

@@ -0,0 +1,53 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_logical_or has_logical_or]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_logical_or : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs||rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs||rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator||`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs||rhs); // is valid if has_logical_or<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_logical_or<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_logical_or<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_logical_or<bool>` inherits from `__true_type`.]
+
+[:`has_logical_or<int, int, bool>` inherits from `__true_type`.]
+[:`has_logical_or<int, int, long>` inherits from `__true_type`.]
+[:`has_logical_or<int, double, bool>` inherits from `__true_type`.]
+[:`has_logical_or<const int, int>::value` inherits from `__true_type`.]
+
+[:`has_logical_or<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_logical_or..||..bool..bool..const ]
+
+[endsect]
+

doc/has_minus.qbk

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_minus has_minus]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_minus : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs-rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs-rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator-`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs-rhs); // is valid if has_minus<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_minus<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_minus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_minus<long>` inherits from `__true_type`.]
+
+[:`has_minus<int, int, int>` inherits from `__true_type`.]
+[:`has_minus<int, int, long>` inherits from `__true_type`.]
+[:`has_minus<int, double, double>` inherits from `__true_type`.]
+[:`has_minus<int, double, int>` inherits from `__true_type`.]
+[:`has_minus<const int, int>::value` inherits from `__true_type`.]
+
+[:`has_minus<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_minus..-..A..contains<T>..const ]
+
+[endsect]
+

doc/has_minus_assign.qbk

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_minus_assign has_minus_assign]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_minus_assign : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs-=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs-=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator-=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs-=rhs); // is valid if has_minus_assign<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_minus_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_minus_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_minus_assign<long>` inherits from `__true_type`.]
+
+[:`has_minus_assign<int, int, int>` inherits from `__true_type`.]
+[:`has_minus_assign<int, int, long>` inherits from `__true_type`.]
+[:`has_minus_assign<int, double, double>` inherits from `__true_type`.]
+[:`has_minus_assign<int, double, int>` inherits from `__true_type`.]
+
+[:`has_minus_assign<const int, int>::value` inherits from `__false_type`.]
+[:`has_minus_assign<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_minus_assign..-=..A&..contains<T>&..[/]]
+
+[endsect]
+

doc/has_modulus.qbk

@@ -0,0 +1,52 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_modulus has_modulus]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_modulus : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs%rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs%rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator%`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs%rhs); // is valid if has_modulus<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_modulus<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_modulus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_modulus<long>` inherits from `__true_type`.]
+
+[:`has_modulus<int, int, int>` inherits from `__true_type`.]
+[:`has_modulus<int, int, long>` inherits from `__true_type`.]
+[:`has_modulus<const int, int>::value` inherits from `__true_type`.]
+
+[:`has_modulus<int, double>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_modulus..%..A..contains<T>..const ]
+
+[endsect]
+

doc/has_modulus_assign.qbk

@@ -0,0 +1,52 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_modulus_assign has_modulus_assign]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_modulus_assign : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs%=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs%=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator%=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs%=rhs); // is valid if has_modulus_assign<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_modulus_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_modulus_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_modulus_assign<long>` inherits from `__true_type`.]
+
+[:`has_modulus_assign<int, int, int>` inherits from `__true_type`.]
+[:`has_modulus_assign<int, int, long>` inherits from `__true_type`.]
+
+[:`has_modulus_assign<const int, int>::value` inherits from `__false_type`.]
+[:`has_modulus_assign<int, double>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_modulus_assign..%=..A&..contains<T>&..[/]]
+
+[endsect]
+

doc/has_multiplies.qbk

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_multiplies has_multiplies]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_multiplies : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs*rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs*rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator*`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs*rhs); // is valid if has_multiplies<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_multiplies<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_multiplies<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_multiplies<long>` inherits from `__true_type`.]
+
+[:`has_multiplies<int, int, int>` inherits from `__true_type`.]
+[:`has_multiplies<int, int, long>` inherits from `__true_type`.]
+[:`has_multiplies<int, double, double>` inherits from `__true_type`.]
+[:`has_multiplies<int, double, int>` inherits from `__true_type`.]
+[:`has_multiplies<const int, int>::value` inherits from `__true_type`.]
+
+[:`has_multiplies<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_multiplies..*..A..contains<T>..const ]
+
+[endsect]
+

doc/has_multiplies_assign.qbk

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_multiplies_assign has_multiplies_assign]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_multiplies_assign : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs*=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs*=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator*=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs*=rhs); // is valid if has_multiplies_assign<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_multiplies_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_multiplies_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_multiplies_assign<long>` inherits from `__true_type`.]
+
+[:`has_multiplies_assign<int, int, int>` inherits from `__true_type`.]
+[:`has_multiplies_assign<int, int, long>` inherits from `__true_type`.]
+[:`has_multiplies_assign<int, double, double>` inherits from `__true_type`.]
+[:`has_multiplies_assign<int, double, int>` inherits from `__true_type`.]
+
+[:`has_multiplies_assign<const int, int>::value` inherits from `__false_type`.]
+[:`has_multiplies_assign<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_multiplies_assign..*=..A&..contains<T>&..[/]]
+
+[endsect]
+

doc/has_negate.qbk

@@ -0,0 +1,108 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_negate has_negate]
+   template <class Rhs, class Ret=dont_care>
+   struct has_negate : public __tof {};
+
+__inherit
+If (i) `rhs` of type `Rhs` can be used in expression `-rhs`,
+and (ii) `Ret=dont_care` or the result of expression `-rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator-`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Rhs rhs;
+f(-rhs); // is valid if has_negate<Rhs, Ret>::value==true
+``
+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`.]
+[:`has_negate<Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_negate<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_negate<long>` inherits from `__true_type`.]
+
+[:`has_negate<int, int>` inherits from `__true_type`.]
+[:`has_negate<int, long>` inherits from `__true_type`.]
+[:`has_negate<double, double>` inherits from `__true_type`.]
+[:`has_negate<double, int>` inherits from `__true_type`.]
+[:`has_negate<const int>` inherits from `__true_type`.]
+
+[:`has_negate<int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[*Known issues:]
+
+* This trait cannot detect whether prefix `operator-` is public or not:
+if `operator-` is defined as a private member of `Rhs` then
+instantiating `has_negate<Rhs>` will produce a compiler error.
+For this reason `has_negate` cannot be used to determine whether a type has a public `operator-` or not.
+``
+struct A { private: void operator-(); };
+boost::has_negate<A>::value; // error: A::operator-() 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&);
+struct B { operator A(); };
+boost::has_negate<A>::value; // this is fine
+boost::has_negate<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_negate.hpp>
+#include <iostream>
+
+template <class T>
+struct contains { T data; };
+
+template <class T>
+bool operator-(const contains<T> &rhs) {
+	return f(rhs.data);
+}
+
+class bad { };
+class good { };
+bool f(const good&) { }
+
+int main() {
+	std::cout<<std::boolalpha;
+	// works fine for contains<good>
+	std::cout<<boost::has_negate< contains< good > >::value<<'\n'; // true
+	contains<good> g;
+	-g; // ok
+	// does not work for contains<bad>
+	std::cout<<boost::has_negate< contains< bad > >::value<<'\n'; // true, should be false
+	contains<bad> b;
+	-b; // compile time error
+	return 0;
+}
+``
+
+* `volatile` qualifier is not properly handled and would lead to undefined behavior
+
+[endsect]
+

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

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_not_equal_to has_not_equal_to]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_not_equal_to : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs!=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs!=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator!=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs!=rhs); // is valid if has_not_equal_to<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_not_equal_to<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_not_equal_to<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_not_equal_to<long>` inherits from `__true_type`.]
+
+[:`has_not_equal_to<int, int, bool>` inherits from `__true_type`.]
+[:`has_not_equal_to<int, double, bool>` inherits from `__true_type`.]
+[:`has_not_equal_to<const int>` inherits from `__true_type`.]
+
+[:`has_not_equal_to<int*, int>` inherits from `__false_type`.]
+[:`has_not_equal_to<int*, double*>` inherits from `__false_type`.]
+[:`has_not_equal_to<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[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,14 +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_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 2005) only Visual C++ 8 has the necessary compiler __intrinsics 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_constructor.hpp>` or ` #include <boost/type_traits.hpp>`
 

doc/has_nothrow_copy.qbk

@@ -19,14 +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 2005) only Visual C++ 8 has the necessary compiler __intrinsics 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_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

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_plus has_plus]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_plus : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs+rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs+rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator+`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs+rhs); // is valid if has_plus<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_plus<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_plus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_plus<long>` inherits from `__true_type`.]
+
+[:`has_plus<int, int, int>` inherits from `__true_type`.]
+[:`has_plus<int, int, long>` inherits from `__true_type`.]
+[:`has_plus<int, double, double>` inherits from `__true_type`.]
+[:`has_plus<int, double, int>` inherits from `__true_type`.]
+[:`has_plus<const int, int>::value` inherits from `__true_type`.]
+
+[:`has_plus<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_plus..+..A..contains<T>..const ]
+
+[endsect]
+

doc/has_plus_assign.qbk

@@ -0,0 +1,54 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_plus_assign has_plus_assign]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_plus_assign : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs+=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs+=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator+=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs+=rhs); // is valid if has_plus_assign<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_plus_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_plus_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_plus_assign<long>` inherits from `__true_type`.]
+
+[:`has_plus_assign<int, int, int>` inherits from `__true_type`.]
+[:`has_plus_assign<int, int, long>` inherits from `__true_type`.]
+[:`has_plus_assign<int, double, double>` inherits from `__true_type`.]
+[:`has_plus_assign<int, double, int>` inherits from `__true_type`.]
+
+[:`has_plus_assign<const int, int>::value` inherits from `__false_type`.]
+[:`has_plus_assign<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_plus_assign..+=..A&..contains<T>&..const ]
+
+[endsect]
+

doc/has_post_decrement.qbk

@@ -0,0 +1,112 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_post_decrement has_post_decrement]
+   template <class Lhs, class Ret=dont_care>
+   struct has_post_decrement : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` can be used in expression `lhs--`,
+and (ii) `Ret=dont_care` or the result of expression `lhs--` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of postfix `operator--`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+f(lhs--); // is valid if has_post_decrement<Lhs, Ret>::value==true
+``
+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`.]
+[:`has_post_decrement<Lhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_post_decrement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_post_decrement<long>` inherits from `__true_type`.]
+
+[:`has_post_decrement<int, int>` inherits from `__true_type`.]
+[:`has_post_decrement<int, long>` inherits from `__true_type`.]
+[:`has_post_decrement<double, double>` inherits from `__true_type`.]
+[:`has_post_decrement<double, int>` inherits from `__true_type`.]
+
+[:`has_post_decrement<bool>` inherits from `__false_type`.]
+[:`has_post_decrement<const int>` inherits from `__false_type`.]
+[:`has_post_decrement<void*>` inherits from `__false_type`.]
+[:`has_post_decrement<int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[*Known issues:]
+
+* This trait cannot detect whether postfix `operator--` is public or not:
+if `operator--` is defined as a private member of `Lhs` then
+instantiating `has_post_decrement<Lhs>` will produce a compiler error.
+For this reason `has_post_decrement` cannot be used to determine whether a type has a public `operator--` or not.
+``
+struct A { private: void operator--(int); };
+boost::has_post_decrement<A>::value; // error: A::operator--(int) 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&, int);
+struct B { operator A(); };
+boost::has_post_decrement<A>::value; // this is fine
+boost::has_post_decrement<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_post_decrement.hpp>
+#include <iostream>
+
+template <class T>
+struct contains { T data; };
+
+template <class T>
+bool operator--(const contains<T> &lhs, int) {
+	return f(lhs.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_post_decrement< contains< good > >::value<<'\n'; // true
+	contains<good> g;
+	g--; // ok
+	// does not work for contains<bad>
+	std::cout<<boost::has_post_decrement< contains< bad > >::value<<'\n'; // true, should be false
+	contains<bad> b;
+	b--; // compile time error
+	return 0;
+}
+``
+
+* `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

@@ -0,0 +1,112 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_post_increment has_post_increment]
+   template <class Lhs, class Ret=dont_care>
+   struct has_post_increment : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` can be used in expression `lhs++`,
+and (ii) `Ret=dont_care` or the result of expression `lhs++` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of postfix `operator++`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+f(lhs++); // is valid if has_post_increment<Lhs, Ret>::value==true
+``
+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`.]
+[:`has_post_increment<Lhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_post_increment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_post_increment<long>` inherits from `__true_type`.]
+
+[:`has_post_increment<int, int>` inherits from `__true_type`.]
+[:`has_post_increment<int, long>` inherits from `__true_type`.]
+[:`has_post_increment<double, double>` inherits from `__true_type`.]
+[:`has_post_increment<double, int>` inherits from `__true_type`.]
+[:`has_post_increment<bool>` inherits from `__true_type`.]
+
+[:`has_post_increment<const int>` inherits from `__false_type`.]
+[:`has_post_increment<void*>` inherits from `__false_type`.]
+[:`has_post_increment<int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[*Known issues:]
+
+* This trait cannot detect whether postfix `operator++` is public or not:
+if `operator++` is defined as a private member of `Lhs` then
+instantiating `has_post_increment<Lhs>` will produce a compiler error.
+For this reason `has_post_increment` cannot be used to determine whether a type has a public `operator++` or not.
+``
+struct A { private: void operator++(int); };
+boost::has_post_increment<A>::value; // error: A::operator++(int) 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&, int);
+struct B { operator A(); };
+boost::has_post_increment<A>::value; // this is fine
+boost::has_post_increment<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_post_increment.hpp>
+#include <iostream>
+
+template <class T>
+struct contains { T data; };
+
+template <class T>
+bool operator++(const contains<T> &lhs, int) {
+	return f(lhs.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_post_increment< contains< good > >::value<<'\n'; // true
+	contains<good> g;
+	g++; // ok
+	// does not work for contains<bad>
+	std::cout<<boost::has_post_increment< contains< bad > >::value<<'\n'; // true, should be false
+	contains<bad> b;
+	b++; // compile time error
+	return 0;
+}
+``
+
+* `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

@@ -0,0 +1,112 @@
+#[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_pre_decrement has_pre_decrement]
+   template <class Rhs, class Ret=dont_care>
+   struct has_pre_decrement : public __tof {};
+
+__inherit
+If (i) `rhs` of type `Rhs` can be used in expression `--rhs`,
+and (ii) `Ret=dont_care` or the result of expression `--rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator--`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Rhs rhs;
+f(--rhs); // is valid if has_pre_decrement<Rhs, Ret>::value==true
+``
+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`.]
+[:`has_pre_decrement<Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_pre_decrement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_pre_decrement<long>` inherits from `__true_type`.]
+
+[:`has_pre_decrement<int, int>` inherits from `__true_type`.]
+[:`has_pre_decrement<int, long>` inherits from `__true_type`.]
+[:`has_pre_decrement<double, double>` inherits from `__true_type`.]
+[:`has_pre_decrement<double, int>` inherits from `__true_type`.]
+
+[:`has_pre_decrement<bool>` inherits from `__false_type`.]
+[:`has_pre_decrement<const int>` inherits from `__false_type`.]
+[:`has_pre_decrement<void*>` inherits from `__false_type`.]
+[:`has_pre_decrement<int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[*Known issues:]
+
+* This trait cannot detect whether prefix `operator--` is public or not:
+if `operator--` is defined as a private member of `Rhs` then
+instantiating `has_pre_decrement<Rhs>` will produce a compiler error.
+For this reason `has_pre_decrement` cannot be used to determine whether a type has a public `operator--` or not.
+``
+struct A { private: void operator--(); };
+boost::has_pre_decrement<A>::value; // error: A::operator--() 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&);
+struct B { operator A(); };
+boost::has_pre_decrement<A>::value; // this is fine
+boost::has_pre_decrement<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_pre_decrement.hpp>
+#include <iostream>
+
+template <class T>
+struct contains { T data; };
+
+template <class T>
+bool operator--(const contains<T> &rhs) {
+	return f(rhs.data);
+}
+
+class bad { };
+class good { };
+bool f(const good&) { }
+
+int main() {
+	std::cout<<std::boolalpha;
+	// works fine for contains<good>
+	std::cout<<boost::has_pre_decrement< contains< good > >::value<<'\n'; // true
+	contains<good> g;
+	--g; // ok
+	// does not work for contains<bad>
+	std::cout<<boost::has_pre_decrement< contains< bad > >::value<<'\n'; // true, should be false
+	contains<bad> b;
+	--b; // compile time error
+	return 0;
+}
+``
+
+* `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

@@ -0,0 +1,112 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_pre_increment has_pre_increment]
+   template <class Rhs, class Ret=dont_care>
+   struct has_pre_increment : public __tof {};
+
+__inherit
+If (i) `rhs` of type `Rhs` can be used in expression `++rhs`,
+and (ii) `Ret=dont_care` or the result of expression `++rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator++`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Rhs rhs;
+f(++rhs); // is valid if has_pre_increment<Rhs, Ret>::value==true
+``
+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`.]
+[:`has_pre_increment<Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_pre_increment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_pre_increment<long>` inherits from `__true_type`.]
+
+[:`has_pre_increment<int, int>` inherits from `__true_type`.]
+[:`has_pre_increment<int, long>` inherits from `__true_type`.]
+[:`has_pre_increment<double, double>` inherits from `__true_type`.]
+[:`has_pre_increment<double, int>` inherits from `__true_type`.]
+[:`has_pre_increment<bool>` inherits from `__true_type`.]
+
+[:`has_pre_increment<const int>` inherits from `__false_type`.]
+[:`has_pre_increment<void*>` inherits from `__false_type`.]
+[:`has_pre_increment<int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[*Known issues:]
+
+* This trait cannot detect whether prefix `operator++` is public or not:
+if `operator++` is defined as a private member of `Rhs` then
+instantiating `has_pre_increment<Rhs>` will produce a compiler error.
+For this reason `has_pre_increment` cannot be used to determine whether a type has a public `operator++` or not.
+``
+struct A { private: void operator++(); };
+boost::has_pre_increment<A>::value; // error: A::operator++() 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&);
+struct B { operator A(); };
+boost::has_pre_increment<A>::value; // this is fine
+boost::has_pre_increment<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_pre_increment.hpp>
+#include <iostream>
+
+template <class T>
+struct contains { T data; };
+
+template <class T>
+bool operator++(const contains<T> &rhs) {
+	return f(rhs.data);
+}
+
+class bad { };
+class good { };
+bool f(const good&) { }
+
+int main() {
+	std::cout<<std::boolalpha;
+	// works fine for contains<good>
+	std::cout<<boost::has_pre_increment< contains< good > >::value<<'\n'; // true
+	contains<good> g;
+	++g; // ok
+	// does not work for contains<bad>
+	std::cout<<boost::has_pre_increment< contains< bad > >::value<<'\n'; // true, should be false
+	contains<bad> b;
+	++b; // compile time error
+	return 0;
+}
+``
+
+* `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

@@ -0,0 +1,55 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_right_shift has_right_shift]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_right_shift : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs>>rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs>>rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator>>`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs>>rhs); // is valid if has_right_shift<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_right_shift<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_right_shift<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_right_shift<long>` inherits from `__true_type`.]
+
+[:`has_right_shift<int, int, int>` inherits from `__true_type`.]
+[:`has_right_shift<const int, int>` inherits from `__true_type`.]
+[:`has_right_shift<std::istream, int&>` inherits from `__true_type`.]
+[:`has_right_shift<std::istream, char*, std::ostream>` inherits from `__true_type`.]
+[:`has_right_shift<std::istream, std::string&>` inherits from `__true_type`.]
+
+[:`has_right_shift<int, double, bool>` inherits from `__false_type`.]
+[:`has_right_shift<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_right_shift..>>..A..contains<T>..const ]
+
+[endsect]
+

doc/has_right_shift_assign.qbk

@@ -0,0 +1,52 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_right_shift_assign has_right_shift_assign]
+   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
+   struct has_right_shift_assign : public __tof {};
+
+__inherit
+If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs>>=rhs`,
+and (ii) `Ret=dont_care` or the result of expression `lhs>>=rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator>>=`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Lhs lhs;
+Rhs rhs;
+f(lhs>>=rhs); // is valid if has_right_shift_assign<Lhs, Rhs, Ret>::value==true
+``
+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`.]
+[:`has_right_shift_assign<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_right_shift_assign<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_right_shift_assign<long>` inherits from `__true_type`.]
+
+[:`has_right_shift_assign<int, int, int>` inherits from `__true_type`.]
+
+[:`has_right_shift_assign<const int, int>` inherits from `__false_type`.]
+[:`has_right_shift_assign<int, double, bool>` inherits from `__false_type`.]
+[:`has_right_shift_assign<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[binary_operator_known_issues has_right_shift_assign..>>=..A&..contains<T>&..[/]]
+
+[endsect]
+

doc/has_trivial_assign.qbk

@@ -16,14 +16,16 @@ 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 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect 
-user-defined classes with trivial constructors.
+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.
+
 
 __std_ref 12.8p11.
 

doc/has_trivial_constructor.qbk

@@ -24,14 +24,16 @@ 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 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect 
-user-defined classes with trivial constructors.
+trivial constructor; this is always safe, if possibly sub-optimal.  
+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.
+
 
 __std_ref 12.1p6.
 

doc/has_trivial_copy.qbk

@@ -22,14 +22,16 @@ 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 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect 
-user-defined classes with trivial constructors.
+trivial constructor; this is always safe, if possibly sub-optimal.  
+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.
+
 
 __std_ref 12.8p6.
 

doc/has_trivial_destructor.qbk

@@ -18,14 +18,16 @@ 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 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect 
-user-defined classes with trivial constructors.
+trivial destructor; this is always safe, if possibly sub-optimal.  
+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.
+
 
 __std_ref 12.4p3.
 

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

@@ -0,0 +1,110 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_unary_minus has_unary_minus]
+   template <class Rhs, class Ret=dont_care>
+   struct has_unary_minus : public __tof {};
+
+__inherit
+If (i) `rhs` of type `Rhs` can be used in expression `-rhs`,
+and (ii) `Ret=dont_care` or the result of expression `-rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator-`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Rhs rhs;
+f(-rhs); // is valid if has_unary_minus<Rhs, Ret>::value==true
+``
+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`.]
+[:`has_unary_minus<Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_unary_minus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_unary_minus<long>` inherits from `__true_type`.]
+
+[:`has_unary_minus<int, int>` inherits from `__true_type`.]
+[:`has_unary_minus<int, long>` inherits from `__true_type`.]
+[:`has_unary_minus<double, double>` inherits from `__true_type`.]
+[:`has_unary_minus<double, int>` inherits from `__true_type`.]
+[:`has_unary_minus<const int>` inherits from `__true_type`.]
+
+[:`has_unary_minus<int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[*Known issues:]
+
+* This trait cannot detect whether prefix `operator-` is public or not:
+if `operator-` is defined as a private member of `Rhs` then
+instantiating `has_unary_minus<Rhs>` will produce a compiler error.
+For this reason `has_unary_minus` cannot be used to determine whether a type has a public `operator-` or not.
+``
+struct A { private: void operator-(); };
+boost::has_unary_minus<A>::value; // error: A::operator-() 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&);
+struct B { operator A(); };
+boost::has_unary_minus<A>::value; // this is fine
+boost::has_unary_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_unary_minus.hpp>
+#include <iostream>
+
+template <class T>
+struct contains { T data; };
+
+template <class T>
+bool operator-(const contains<T> &rhs) {
+	return f(rhs.data);
+}
+
+class bad { };
+class good { };
+bool f(const good&) { }
+
+int main() {
+	std::cout<<std::boolalpha;
+	// works fine for contains<good>
+	std::cout<<boost::has_unary_minus< contains< good > >::value<<'\n'; // true
+	contains<good> g;
+	-g; // ok
+	// does not work for contains<bad>
+	std::cout<<boost::has_unary_minus< contains< bad > >::value<<'\n'; // true, should be false
+	contains<bad> b;
+	-b; // compile time error
+	return 0;
+}
+``
+
+* `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

@@ -0,0 +1,110 @@
+[/
+  (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
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:has_unary_plus has_unary_plus]
+   template <class Rhs, class Ret=dont_care>
+   struct has_unary_plus : public __tof {};
+
+__inherit
+If (i) `rhs` of type `Rhs` can be used in expression `+rhs`,
+and (ii) `Ret=dont_care` or the result of expression `+rhs` is convertible to `Ret`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`Ret=dont_care`) is to not check for the return value of prefix `operator+`.
+If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
+Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
+``
+void f(Ret);
+Rhs rhs;
+f(+rhs); // is valid if has_unary_plus<Rhs, Ret>::value==true
+``
+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`.]
+[:`has_unary_plus<Rhs, Ret>::value` is a `bool` integral constant expression.]
+[:`has_unary_plus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`has_unary_plus<long>` inherits from `__true_type`.]
+
+[:`has_unary_plus<int, int>` inherits from `__true_type`.]
+[:`has_unary_plus<int, long>` inherits from `__true_type`.]
+[:`has_unary_plus<double, double>` inherits from `__true_type`.]
+[:`has_unary_plus<double, int>` inherits from `__true_type`.]
+[:`has_unary_plus<const int>` inherits from `__true_type`.]
+
+[:`has_unary_plus<int, std::string>` inherits from `__false_type`.]
+
+
+[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+
+[*Known issues:]
+
+* This trait cannot detect whether prefix `operator+` is public or not:
+if `operator+` is defined as a private member of `Rhs` then
+instantiating `has_unary_plus<Rhs>` will produce a compiler error.
+For this reason `has_unary_plus` cannot be used to determine whether a type has a public `operator+` or not.
+``
+struct A { private: void operator+(); };
+boost::has_unary_plus<A>::value; // error: A::operator+() 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&);
+struct B { operator A(); };
+boost::has_unary_plus<A>::value; // this is fine
+boost::has_unary_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_unary_plus.hpp>
+#include <iostream>
+
+template <class T>
+struct contains { T data; };
+
+template <class T>
+bool operator+(const contains<T> &rhs) {
+	return f(rhs.data);
+}
+
+class bad { };
+class good { };
+bool f(const good&) { }
+
+int main() {
+	std::cout<<std::boolalpha;
+	// works fine for contains<good>
+	std::cout<<boost::has_unary_plus< contains< good > >::value<<'\n'; // true
+	contains<good> g;
+	+g; // ok
+	// does not work for contains<bad>
+	std::cout<<boost::has_unary_plus< contains< bad > >::value<<'\n'; // true, should be false
+	contains<bad> b;
+	+b; // compile time error
+	return 0;
+}
+``
+
+* `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,13 +12,16 @@
 __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 2005) only Visual C++
-8 and GCC-4.3 have the necessary __intrinsics.
+that enable the trait to do the right thing: 
+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.
+
 
 __std_ref 12.4.
 

doc/history.qbk

@@ -0,0 +1,93 @@
+[/ 
+  Copyright 2009 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: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.
+* Fixed issues [@https://svn.boost.org/trac/boost/ticket/5271 #5271],
+[@https://svn.boost.org/trac/boost/ticket/4530 #4530].
+
+
+[h4 Boost 1.45.0]
+
+* Added new traits __add_rvalue_reference, __add_lvalue_reference and __common_type.
+* Minor fixes to __is_signed, __is_unsigned and __is_virtual_base_of.
+
+[h4 Boost 1.44.0]
+
+* Added support for rvalue references throughout the library, plus two new traits classes
+__is_rvalue_reference and __is_lvalue_reference.  Fixes [@https://svn.boost.org/trac/boost/ticket/4407 #4407]
+and [@https://svn.boost.org/trac/boost/ticket/3804 #3804].
+* Fixed ticket [@https://svn.boost.org/trac/boost/ticket/3621 #3621].
+
+[h4 Boost 1.42.0]
+
+* Fixed issue [@https://svn.boost.org/trac/boost/ticket/3704 #3704].
+
+
+[endsect]
+

doc/html/boost_typetraits/background.html

@@ -1,11 +1,11 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Background and Tutorial</title>
-<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
-<link rel="home" href="../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
-<link rel="up" href="../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<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>
@@ -13,18 +13,18 @@
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="intro.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="category.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<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" lang="en">
+<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>
+<a name="boost_typetraits.background"></a><a class="link" href="background.html" title="Background and Tutorial">Background and Tutorial</a>
 </h2></div></div></div>
 <p>
       The following is an updated version of the article "C++ Type traits"
@@ -55,9 +55,10 @@
       terminated string, safe in the knowledge that specializations of <code class="computeroutput"><span class="identifier">char_traits</span></code> will use the most appropriate
       method available to them.
     </p>
-<a name="boost_typetraits.background.type_traits"></a><h5>
-<a name="id777154"></a>
-      <a class="link" href="background.html#boost_typetraits.background.type_traits">Type Traits</a>
+<h5>
+<a name="boost_typetraits.background.h0"></a>
+      <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>
       Class <code class="computeroutput"><span class="identifier">char_traits</span></code> is a classic
@@ -67,7 +68,7 @@
       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 a the type <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a>
+      share a unified design: each class inherits from the type <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a>
       if the type has the specified property and inherits from <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a>
       otherwise. As we will show, these classes can be used in generic programming
       to determine the properties of a given type and introduce optimizations that
@@ -83,9 +84,9 @@
       for brevity, namespace-qualification is omitted in most of the code samples
       given.
     </p>
-<a name="boost_typetraits.background.implementation"></a><h5>
-<a name="id777217"></a>
-      <a class="link" href="background.html#boost_typetraits.background.implementation">Implementation</a>
+<h5>
+<a name="boost_typetraits.background.h1"></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
@@ -97,10 +98,10 @@
       from <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code>
       only if <code class="computeroutput"><span class="identifier">T</span></code> is <code class="computeroutput"><span class="keyword">void</span></code>.
     </p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> 
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="reference/is_void.html" title="is_void">is_void</a> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a><span class="special">{};</span>
 
-<span class="keyword">template</span> <span class="special">&lt;&gt;</span> 
+<span class="keyword">template</span> <span class="special">&lt;&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="reference/is_void.html" title="is_void">is_void</a><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">{};</span>
 </pre>
 <p>
@@ -115,10 +116,10 @@
       a pointer, and a partial specialization to handle all the cases where T is
       a pointer:
     </p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> 
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="reference/is_pointer.html" title="is_pointer">is_pointer</a> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a><span class="special">{};</span>
 
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> 
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="reference/is_pointer.html" title="is_pointer">is_pointer</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">*&gt;</span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">{};</span>
 </pre>
 <p>
@@ -154,11 +155,11 @@
       that is the same type as T but with any top-level array bounds removed; this
       is an example of a traits class that performs a transformation on a type:
     </p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> 
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a>
 <span class="special">{</span> <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</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">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> 
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">[</span><span class="identifier">N</span><span class="special">]&gt;</span>
 <span class="special">{</span> <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span> <span class="special">};</span>
 </pre>
@@ -173,9 +174,10 @@
       after the class name do have to match the number and type of the parameters
       in the default template.
     </p>
-<a name="boost_typetraits.background.optimized_copy"></a><h5>
-<a name="id777954"></a>
-      <a class="link" href="background.html#boost_typetraits.background.optimized_copy">Optimized copy</a>
+<h5>
+<a name="boost_typetraits.background.h2"></a>
+      <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>
       As an example of how the type traits classes can be used, consider the standard
@@ -193,34 +195,34 @@
       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 type="disc">
-<li>
-        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.
-      </li>
-<li>
-        Both <code class="computeroutput"><span class="identifier">Iter1</span></code> and <code class="computeroutput"><span class="identifier">Iter2</span></code> must point to the same type - excluding
-        const and volatile-qualifiers.
-      </li>
-<li>
-        The type pointed to by <code class="computeroutput"><span class="identifier">Iter1</span></code>
-        must have a trivial assignment operator.
-      </li>
+<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.
+        </li>
+<li class="listitem">
+          Both <code class="computeroutput"><span class="identifier">Iter1</span></code> and <code class="computeroutput"><span class="identifier">Iter2</span></code> must point to the same type - excluding
+          const and volatile-qualifiers.
+        </li>
+<li class="listitem">
+          The type pointed to by <code class="computeroutput"><span class="identifier">Iter1</span></code>
+          must have a trivial assignment operator.
+        </li>
 </ul></div>
 <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 type="disc">
-<li>
-        The type has no user defined assignment operator.
-      </li>
-<li>
-        The type does not have any data members that are references.
-      </li>
-<li>
-        All base classes, and all data member objects must have trivial assignment
-        operators.
-      </li>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+          The type has no user defined assignment operator.
+        </li>
+<li class="listitem">
+          The type does not have any data members that are references.
+        </li>
+<li class="listitem">
+          All base classes, and all data member objects must have trivial assignment
+          operators.
+        </li>
 </ul></div>
 <p>
       If all these conditions are met then a type can be copied using <code class="computeroutput"><span class="identifier">memcpy</span></code> rather than using a compiler generated
@@ -238,17 +240,18 @@
       examples</a>. The code begins by defining a template function <code class="computeroutput"><span class="identifier">do_copy</span></code> that performs a "slow but safe"
       copy. The last parameter passed to this function may be either a <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code>
       or a <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a></code>.
-      Following that there is an overload of do<span class="underline">copy that
-      uses `memcpy`: this time the iterators are required to actually be pointers
-      to the same type, and the final parameter must be a `</span>_true_type<code class="computeroutput"><span class="special">.</span> <span class="identifier">Finally</span><span class="special">,</span> <span class="identifier">the</span> <span class="identifier">version</span>
-      <span class="identifier">of</span> </code>copy<code class="computeroutput"> <span class="identifier">calls</span>
-      </code>do<span class="underline">copy`, passing `</span>_has_trivial_assign&lt;value_type&gt;()`
-      as the final parameter: this will dispatch to the optimized version where appropriate,
-      otherwise it will call the "slow but safe version".
+      Following that there is an overload of do_copy that uses <code class="computeroutput"><span class="identifier">memcpy</span></code>:
+      this time the iterators are required to actually be pointers to the same type,
+      and the final parameter must be a <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code>.
+      Finally, the version of <code class="computeroutput"><span class="identifier">copy</span></code>
+      calls <code class="computeroutput"><span class="identifier">do_copy</span></code>, passing <code class="computeroutput"><a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a><span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;()</span></code> as the final parameter: this will dispatch
+      to the optimized version where appropriate, otherwise it will call the "slow
+      but safe version".
     </p>
-<a name="boost_typetraits.background.was_it_worth_it_"></a><h5>
-<a name="id778301"></a>
-      <a class="link" href="background.html#boost_typetraits.background.was_it_worth_it_">Was it worth it?</a>
+<h5>
+<a name="boost_typetraits.background.h3"></a>
+      <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>
       It has often been repeated in these columns that "premature optimization
@@ -264,26 +267,26 @@
       comparison between algorithms becomes difficult. However, perhaps we can add
       a couple of caveats to the premature optimization rule:
     </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-        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.
-      </li>
-<li>
-        If a component is going to be reused in many places by many people then optimizations
-        may well be worthwhile where they would not be so for a single case - in
-        other words, the likelihood that the optimization will be absolutely necessary
-        somewhere, sometime is that much higher. Just as importantly the perceived
-        value of the stock implementation will be higher: there is no point standardizing
-        an algorithm if users reject it on the grounds that there are better, more
-        heavily optimized versions available.
-      </li>
+<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.
+        </li>
+<li class="listitem">
+          If a component is going to be reused in many places by many people then
+          optimizations may well be worthwhile where they would not be so for a single
+          case - in other words, the likelihood that the optimization will be absolutely
+          necessary somewhere, sometime is that much higher. Just as importantly
+          the perceived value of the stock implementation will be higher: there is
+          no point standardizing an algorithm if users reject it on the grounds that
+          there are better, more heavily optimized versions available.
+        </li>
 </ul></div>
 <div class="table">
-<a name="id778338"></a><p class="title"><b>Table<EFBFBD>1.1.<EFBFBD>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)">
+<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)">
 <colgroup>
 <col>
 <col>
@@ -291,96 +294,97 @@
 </colgroup>
 <thead><tr>
 <th>
-          <p>
-            Version
-          </p>
-          </th>
+              <p>
+                Version
+              </p>
+            </th>
 <th>
-          <p>
-            T
-          </p>
-          </th>
+              <p>
+                T
+              </p>
+            </th>
 <th>
-          <p>
-            Time
-          </p>
-          </th>
+              <p>
+                Time
+              </p>
+            </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
-          <p>
-            "Optimized" copy
-          </p>
-          </td>
+              <p>
+                "Optimized" copy
+              </p>
+            </td>
 <td>
-          <p>
-            char
-          </p>
-          </td>
+              <p>
+                char
+              </p>
+            </td>
 <td>
-          <p>
-            0.99
-          </p>
-          </td>
+              <p>
+                0.99
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-          <p>
-            Conventional copy
-          </p>
-          </td>
+              <p>
+                Conventional copy
+              </p>
+            </td>
 <td>
-          <p>
-            char
-          </p>
-          </td>
+              <p>
+                char
+              </p>
+            </td>
 <td>
-          <p>
-            8.07
-          </p>
-          </td>
+              <p>
+                8.07
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-          <p>
-            "Optimized" copy
-          </p>
-          </td>
+              <p>
+                "Optimized" copy
+              </p>
+            </td>
 <td>
-          <p>
-            int
-          </p>
-          </td>
+              <p>
+                int
+              </p>
+            </td>
 <td>
-          <p>
-            2.52
-          </p>
-          </td>
+              <p>
+                2.52
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-          <p>
-            Conventional copy
-          </p>
-          </td>
+              <p>
+                Conventional copy
+              </p>
+            </td>
 <td>
-          <p>
-            int
-          </p>
-          </td>
+              <p>
+                int
+              </p>
+            </td>
 <td>
-          <p>
-            8.02
-          </p>
-          </td>
+              <p>
+                8.02
+              </p>
+            </td>
 </tr>
 </tbody>
 </table></div>
 </div>
-<br class="table-break"><a name="boost_typetraits.background.pair_of_references"></a><h5>
-<a name="id778476"></a>
-      <a class="link" href="background.html#boost_typetraits.background.pair_of_references">Pair of References</a>
+<br class="table-break"><h5>
+<a name="boost_typetraits.background.h4"></a>
+      <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>
       The optimized copy example shows how type traits may be used to perform optimization
@@ -395,8 +399,8 @@
       the comparison operators, default constructor, and template copy constructor
       for simplicity:
     </p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T2</span><span class="special">&gt;</span> 
-<span class="keyword">struct</span> <span class="identifier">pair</span> 
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T2</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">pair</span>
 <span class="special">{</span>
 <span class="keyword">typedef</span> <span class="identifier">T1</span> <span class="identifier">first_type</span><span class="special">;</span>
 <span class="keyword">typedef</span> <span class="identifier">T2</span> <span class="identifier">second_type</span><span class="special">;</span>
@@ -416,7 +420,7 @@
       to hold non-reference types, references, and constant references:
     </p>
 <div class="table">
-<a name="id782108"></a><p class="title"><b>Table<EFBFBD>1.2.<EFBFBD>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>
@@ -424,52 +428,52 @@
 </colgroup>
 <thead><tr>
 <th>
-          <p>
-            Type of <code class="computeroutput"><span class="identifier">T1</span></code>
-          </p>
-          </th>
+              <p>
+                Type of <code class="computeroutput"><span class="identifier">T1</span></code>
+              </p>
+            </th>
 <th>
-          <p>
-            Type of parameter to initializing constructor
-          </p>
-          </th>
+              <p>
+                Type of parameter to initializing constructor
+              </p>
+            </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
-          <p>
-            T
-          </p>
-          </td>
+              <p>
+                T
+              </p>
+            </td>
 <td>
-          <p>
-            const T &amp;
-          </p>
-          </td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-          <p>
-            T &amp;
-          </p>
-          </td>
+              <p>
+                T &amp;
+              </p>
+            </td>
 <td>
-          <p>
-            T &amp;
-          </p>
-          </td>
+              <p>
+                T &amp;
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-          <p>
-            const T &amp;
-          </p>
-          </td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
 <td>
-          <p>
-            const T &amp;
-          </p>
-          </td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
 </tr>
 </tbody>
 </table></div>
@@ -481,10 +485,8 @@
       adds a reference to its type, unless it is already a reference.
     </p>
 <div class="table">
-<a name="id782211"></a><p class="title"><b>Table<EFBFBD>1.3.<EFBFBD>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">
+<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>
 <col>
@@ -492,72 +494,73 @@
 </colgroup>
 <thead><tr>
 <th>
-          <p>
-            Type of <code class="computeroutput"><span class="identifier">T1</span></code>
-          </p>
-          </th>
+              <p>
+                Type of <code class="computeroutput"><span class="identifier">T1</span></code>
+              </p>
+            </th>
 <th>
-          <p>
-            Type of <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">T1</span></code>
-          </p>
-          </th>
+              <p>
+                Type of <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">T1</span></code>
+              </p>
+            </th>
 <th>
-          <p>
-            Type of <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">T1</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
-          </p>
-          </th>
+              <p>
+                Type of <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">const</span>
+                <span class="identifier">T1</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+              </p>
+            </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
-          <p>
-            T
-          </p>
-          </td>
+              <p>
+                T
+              </p>
+            </td>
 <td>
-          <p>
-            const T
-          </p>
-          </td>
+              <p>
+                const T
+              </p>
+            </td>
 <td>
-          <p>
-            const T &amp;
-          </p>
-          </td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-          <p>
-            T &amp;
-          </p>
-          </td>
+              <p>
+                T &amp;
+              </p>
+            </td>
 <td>
-          <p>
-            T &amp; [8]
-          </p>
-          </td>
+              <p>
+                T &amp; [8]
+              </p>
+            </td>
 <td>
-          <p>
-            T &amp;
-          </p>
-          </td>
+              <p>
+                T &amp;
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-          <p>
-            const T &amp;
-          </p>
-          </td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
 <td>
-          <p>
-            const T &amp;
-          </p>
-          </td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
 <td>
-          <p>
-            const T &amp;
-          </p>
-          </td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
 </tr>
 </tbody>
 </table></div>
@@ -567,8 +570,8 @@
       that can contain non-reference types, reference types, and constant reference
       types:
     </p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T2</span><span class="special">&gt;</span> 
-<span class="keyword">struct</span> <span class="identifier">pair</span> 
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T2</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">pair</span>
 <span class="special">{</span>
 <span class="keyword">typedef</span> <span class="identifier">T1</span> <span class="identifier">first_type</span><span class="special">;</span>
 <span class="keyword">typedef</span> <span class="identifier">T2</span> <span class="identifier">second_type</span><span class="special">;</span>
@@ -597,9 +600,9 @@
       partial specialization to the type traits classes, resulting in code that is
       easier to maintain and easier to understand.
     </p>
-<a name="boost_typetraits.background.conclusion"></a><h5>
-<a name="id782669"></a>
-      <a class="link" href="background.html#boost_typetraits.background.conclusion">Conclusion</a>
+<h5>
+<a name="boost_typetraits.background.h5"></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
@@ -610,69 +613,71 @@
       does not have to sink to the lowest common denominator, and that templates
       can be optimal as well as generic.
     </p>
-<a name="boost_typetraits.background.acknowledgements"></a><h5>
-<a name="id782686"></a>
-      <a class="link" href="background.html#boost_typetraits.background.acknowledgements">Acknowledgements</a>
+<h5>
+<a name="boost_typetraits.background.h6"></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
       comments when preparing this article.
     </p>
-<a name="background.references"></a><a name="boost_typetraits.background.references"></a><h5>
-<a name="id782707"></a>
-      <a class="link" href="background.html#boost_typetraits.background.references">References</a>
+<h5>
+<a name="boost_typetraits.background.h7"></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 type="1">
-<li>
-        Nathan C. Myers, C++ Report, June 1995.
-      </li>
-<li>
-        The type traits library is based upon contributions by Steve Cleary, Beman
-        Dawes, Howard Hinnant and John Maddock: it can be found at www.boost.org.
-      </li>
-<li>
-        A scalar type is an arithmetic type (i.e. a built-in integer or floating
-        point type), an enumeration type, a pointer, a pointer to member, or a const-
-        or volatile-qualified version of one of these types.
-      </li>
-<li>
-        This quote is from Donald Knuth, ACM Computing Surveys, December 1974, pg
-        268.
-      </li>
-<li>
-        The test code is available as part of the boost utility library (see algo_opt_examples.cpp),
-        the code was compiled with gcc 2.95 with all optimisations turned on, tests
-        were conducted on a 400MHz Pentium II machine running Microsoft Windows 98.
-      </li>
-<li>
-        John Maddock and Howard Hinnant have submitted a "compressed_pair"
-        library to Boost, which uses a technique similar to the one described here
-        to hold references. Their pair also uses type traits to determine if any
-        of the types are empty, and will derive instead of contain to conserve space
-        -- hence the name "compressed".
-      </li>
-<li>
-        This is actually an issue with the C++ Core Language Working Group (issue
-        #106), submitted by Bjarne Stroustrup. The tentative resolution is to allow
-        a "reference to a reference to T" to mean the same thing as a "reference
-        to T", but only in template instantiation, in a method similar to multiple
-        cv-qualifiers.
-      </li>
-<li>
-        For those of you who are wondering why this shouldn't be const-qualified,
-        remember that references are always implicitly constant (for example, you
-        can't re-assign a reference). Remember also that "const T &amp;"
-        is something completely different. For this reason, cv-qualifiers on template
-        type arguments that are references are ignored.
-      </li>
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+          Nathan C. Myers, C++ Report, June 1995.
+        </li>
+<li class="listitem">
+          The type traits library is based upon contributions by Steve Cleary, Beman
+          Dawes, Howard Hinnant and John Maddock: it can be found at www.boost.org.
+        </li>
+<li class="listitem">
+          A scalar type is an arithmetic type (i.e. a built-in integer or floating
+          point type), an enumeration type, a pointer, a pointer to member, or a
+          const- or volatile-qualified version of one of these types.
+        </li>
+<li class="listitem">
+          This quote is from Donald Knuth, ACM Computing Surveys, December 1974,
+          pg 268.
+        </li>
+<li class="listitem">
+          The test code is available as part of the boost utility library (see algo_opt_examples.cpp),
+          the code was compiled with gcc 2.95 with all optimisations turned on, tests
+          were conducted on a 400MHz Pentium II machine running Microsoft Windows
+          98.
+        </li>
+<li class="listitem">
+          John Maddock and Howard Hinnant have submitted a "compressed_pair"
+          library to Boost, which uses a technique similar to the one described here
+          to hold references. Their pair also uses type traits to determine if any
+          of the types are empty, and will derive instead of contain to conserve
+          space -- hence the name "compressed".
+        </li>
+<li class="listitem">
+          This is actually an issue with the C++ Core Language Working Group (issue
+          #106), submitted by Bjarne Stroustrup. The tentative resolution is to allow
+          a "reference to a reference to T" to mean the same thing as a
+          "reference to T", but only in template instantiation, in a method
+          similar to multiple cv-qualifiers.
+        </li>
+<li class="listitem">
+          For those of you who are wondering why this shouldn't be const-qualified,
+          remember that references are always implicitly constant (for example, you
+          can't re-assign a reference). Remember also that "const T &amp;"
+          is something completely different. For this reason, cv-qualifiers on template
+          type arguments that are references are ignored.
+        </li>
 </ol></div>
 </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 <EFBFBD> 2000, 2006 Adobe Systems Inc, David Abrahams,
-      Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat
-      Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek<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>
@@ -680,7 +685,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="intro.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="category.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

doc/html/boost_typetraits/category.html

@@ -1,11 +1,11 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Type Traits by Category</title>
-<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
-<link rel="home" href="../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
-<link rel="up" href="../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<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>
@@ -13,44 +13,47 @@
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="background.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="category/value_traits.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<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" lang="en">
+<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>
+<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>
-<dt><span class="section"><a href="category/value_traits.html"> Type Traits
-      that Describe the Properties of a Type</a></span></dt>
+<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>
-<dt><span class="section"><a href="category/value_traits/primary.html"> Categorizing
+<dt><span class="section"><a href="category/value_traits/primary.html">Categorizing
         a Type</a></span></dt>
-<dt><span class="section"><a href="category/value_traits/properties.html">
-        General Type Properties</a></span></dt>
-<dt><span class="section"><a href="category/value_traits/relate.html"> Relationships
+<dt><span class="section"><a href="category/value_traits/properties.html">General
+        Type Properties</a></span></dt>
+<dt><span class="section"><a href="category/value_traits/relate.html">Relationships
         Between Two Types</a></span></dt>
+<dt><span class="section"><a href="category/value_traits/operators.html">Operator
+        Type Traits</a></span></dt>
 </dl></dd>
-<dt><span class="section"><a href="category/transform.html"> Type Traits that
+<dt><span class="section"><a href="category/transform.html">Type Traits that
       Transform One Type to Another</a></span></dt>
-<dt><span class="section"><a href="category/alignment.html"> Synthesizing Types
+<dt><span class="section"><a href="category/alignment.html">Synthesizing Types
       with Specific Alignments</a></span></dt>
-<dt><span class="section"><a href="category/function.html"> Decomposing Function
+<dt><span class="section"><a href="category/function.html">Decomposing Function
       Types</a></span></dt>
 </dl></div>
 </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 <EFBFBD> 2000, 2006 Adobe Systems Inc, David Abrahams,
-      Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat
-      Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek<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>
@@ -58,7 +61,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="background.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="category/value_traits.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

doc/html/boost_typetraits/category/alignment.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Synthesizing Types with Specific Alignments</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
-<link rel="home" href="../../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<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">
@@ -13,18 +13,18 @@
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="transform.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="function.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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" lang="en">
+<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
+<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>
 </h3></div></div></div>
 <p>
@@ -45,10 +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 <EFBFBD> 2000, 2006 Adobe Systems Inc, David Abrahams,
-      Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat
-      Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek<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>
@@ -56,7 +57,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="transform.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="function.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

doc/html/boost_typetraits/category/function.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Decomposing Function Types</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
-<link rel="home" href="../../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<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">
@@ -13,18 +13,18 @@
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="alignment.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../user_defined.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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" lang="en">
+<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
+<a name="boost_typetraits.category.function"></a><a class="link" href="function.html" title="Decomposing Function Types">Decomposing Function
       Types</a>
 </h3></div></div></div>
 <p>
@@ -42,10 +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 <EFBFBD> 2000, 2006 Adobe Systems Inc, David Abrahams,
-      Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat
-      Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek<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>
@@ -53,7 +54,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="alignment.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../user_defined.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

doc/html/boost_typetraits/category/transform.html

@@ -1,30 +1,30 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<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/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
-<link rel="home" href="../../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<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/relate.html" title="Relationships Between Two Types">
+<link rel="prev" href="value_traits/operators.html" title="Operator Type Traits">
 <link rel="next" href="alignment.html" title="Synthesizing Types with Specific Alignments">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="value_traits/relate.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="alignment.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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" lang="en">
+<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
+<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>
 </h3></div></div></div>
 <p>
@@ -42,15 +42,30 @@
 <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/add_cv.html" title="add_cv">add_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/add_lvalue_reference.html" title="add_lvalue_reference">add_lvalue_reference</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/add_pointer.html" title="add_pointer">add_pointer</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/add_reference.html" title="add_reference">add_reference</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/add_rvalue_reference.html" title="add_rvalue_reference">add_rvalue_reference</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/add_volatile.html" title="add_volatile">add_volatile</a><span class="special">;</span>
 
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">bool</span> <span class="identifier">B</span><span class="special">,</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/conditional.html" title="conditional">conditional</a><span class="special">;</span>
+
+<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>
 
@@ -89,70 +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>
-<a name="boost_typetraits.category.transform.broken_compiler_workarounds_"></a><h5>
-<a name="id785406"></a>
-        <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 <EFBFBD> 2000, 2006 Adobe Systems Inc, David Abrahams,
-      Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat
-      Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek<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>
@@ -160,7 +123,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="value_traits/relate.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="alignment.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

doc/html/boost_typetraits/category/value_traits.html

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<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/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
-<link rel="home" href="../../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<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">
@@ -13,27 +13,29 @@
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../category.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="value_traits/primary.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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" lang="en">
+<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>
+<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>
-<dt><span class="section"><a href="value_traits/primary.html"> Categorizing
+<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 Type Properties</a></span></dt>
-<dt><span class="section"><a href="value_traits/relate.html"> Relationships
+<dt><span class="section"><a href="value_traits/properties.html">General
+        Type Properties</a></span></dt>
+<dt><span class="section"><a href="value_traits/relate.html">Relationships
         Between Two Types</a></span></dt>
+<dt><span class="section"><a href="value_traits/operators.html">Operator
+        Type Traits</a></span></dt>
 </dl></div>
 <p>
         These traits are all <span class="emphasis"><em>value traits</em></span>, which is to say the
@@ -48,10 +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 <EFBFBD> 2000, 2006 Adobe Systems Inc, David Abrahams,
-      Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat
-      Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek<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>
@@ -59,7 +62,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../category.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="value_traits/primary.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

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

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Categorizing a Type</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
-<link rel="home" href="../../../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<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">
@@ -13,18 +13,18 @@
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../value_traits.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="properties.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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" lang="en">
+<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 name="boost_typetraits.category.value_traits.primary"></a><a class="link" href="primary.html" title="Categorizing a Type">Categorizing
         a Type</a>
 </h4></div></div></div>
 <p>
@@ -50,40 +50,43 @@
         </p>
 <pre class="programlisting"><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_array.html" title="is_array">is_array</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_class.html" title="is_class">is_class</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_complex.html" title="is_complex">is_complex</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_enum.html" title="is_enum">is_enum</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_floating_point.html" title="is_floating_point">is_floating_point</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_function.html" title="is_function">is_function</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_integral.html" title="is_integral">is_integral</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_member_function_pointer.html" title="is_member_function_pointer">is_member_function_pointer</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_member_object_pointer.html" title="is_member_object_pointer">is_member_object_pointer</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_pointer.html" title="is_pointer">is_pointer</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_reference.html" title="is_reference">is_reference</a><span class="special">;</span>
-  
+<span class="keyword">struct</span> <a class="link" href="../../reference/is_lvalue_reference.html" title="is_lvalue_reference">is_lvalue_reference</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_rvalue_reference.html" title="is_rvalue_reference">is_rvalue_reference</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_union.html" title="is_union">is_union</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_void.html" title="is_void">is_void</a><span class="special">;</span>
 </pre>
@@ -107,16 +110,20 @@
 <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_object.html" title="is_object">is_object</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_reference.html" title="is_reference">is_reference</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_scalar.html" title="is_scalar">is_scalar</a><span class="special">;</span>
 </pre>
 </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 <EFBFBD> 2000, 2006 Adobe Systems Inc, David Abrahams,
-      Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat
-      Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek<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>
@@ -124,7 +131,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="../value_traits.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="properties.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

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

@@ -1,10 +1,10 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>General Type Properties</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
-<link rel="home" href="../../../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<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">
@@ -13,19 +13,19 @@
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="primary.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="relate.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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" lang="en">
+<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>
+<a name="boost_typetraits.category.value_traits.properties"></a><a class="link" href="properties.html" title="General Type Properties">General
+        Type Properties</a>
 </h4></div></div></div>
 <p>
           The following templates describe the general properties of a type.
@@ -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,10 +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 <EFBFBD> 2000, 2006 Adobe Systems Inc, David Abrahams,
-      Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat
-      Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek<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>
@@ -122,7 +150,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="primary.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="relate.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

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

@@ -1,30 +1,30 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Relationships Between Two Types</title>
-<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
-<link rel="home" href="../../../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<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="../transform.html" title="Type Traits that Transform One Type to Another">
+<link rel="next" href="operators.html" title="Operator Type Traits">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="properties.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../transform.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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" lang="en">
+<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
+<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>
 </h4></div></div></div>
 <p>
@@ -49,10 +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 <EFBFBD> 2000, 2006 Adobe Systems Inc, David Abrahams,
-      Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat
-      Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek<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>
@@ -60,7 +61,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="properties.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../transform.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>

doc/html/boost_typetraits/credits.html

@@ -1,29 +1,30 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Credits</title>
-<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
-<link rel="home" href="../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
-<link rel="up" href="../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
-<link rel="prev" href="reference/type_with_alignment.html" title="type_with_alignment">
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<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>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="reference/type_with_alignment.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a>
+<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" lang="en">
+<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>
+<a name="boost_typetraits.credits"></a><a class="link" href="credits.html" title="Credits">Credits</a>
 </h2></div></div></div>
 <p>
       This documentation was pulled together by John Maddock, using <a href="../../../../../doc/html/quickbook.html" target="_top">Boost.Quickbook</a>
@@ -38,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
@@ -61,10 +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 <EFBFBD> 2000, 2006 Adobe Systems Inc, David Abrahams,
-      Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat
-      Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek<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>
@@ -72,7 +74,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="reference/type_with_alignment.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a>
+<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>
 </body>
 </html>

doc/html/boost_typetraits/examples.html

@@ -1,11 +1,11 @@
 <html>
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Examples</title>
-<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
-<link rel="home" href="../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
-<link rel="up" href="../index.html" title="Chapter<EFBFBD>1.<EFBFBD>Boost.TypeTraits">
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<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>
@@ -13,38 +13,41 @@
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="mpl.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/copy.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<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" lang="en">
+<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>
+<a name="boost_typetraits.examples"></a><a class="link" href="examples.html" title="Examples">Examples</a>
 </h2></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="examples/copy.html"> An Optimized Version
+<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
+<dt><span class="section"><a href="examples/fill.html">An Optimised Version
       of std::fill</a></span></dt>
-<dt><span class="section"><a href="examples/destruct.html"> An Example that
-      Omits Destructor Calls For Types with Trivial Destructors</a></span></dt>
-<dt><span class="section"><a href="examples/iter.html"> An improved Version
-      of std::iter_swap</a></span></dt>
-<dt><span class="section"><a href="examples/to_double.html"> Convert Numeric
+<dt><span class="section"><a href="examples/destruct.html">An Example that Omits
+      Destructor Calls For Types with Trivial Destructors</a></span></dt>
+<dt><span class="section"><a href="examples/iter.html">An improved Version of
+      std::iter_swap</a></span></dt>
+<dt><span class="section"><a href="examples/to_double.html">Convert Numeric
       Types and Enums to double</a></span></dt>
+<dt><span class="section"><a href="examples/improved_min.html">Improving std::min
+      with common_type</a></span></dt>
 </dl></div>
 </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 <EFBFBD> 2000, 2006 Adobe Systems Inc, David Abrahams,
-      Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat
-      Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek<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>
@@ -52,7 +55,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="mpl.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/copy.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<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>
 </body>
 </html>