glob headers

Correct CI workflow and add 2022 tests.

.circleci/config.yml

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

.drone.star

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

.drone/after-success.sh

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

.drone/before-install.sh

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

.drone/before-script.sh

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

.drone/boost.sh

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

.github/workflows/ci.yml

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

CMakeLists.txt

@@ -0,0 +1,38 @@
+# Copyright 2018 Mike Dev
+# Copyright 2019 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+if(NOT DEFINED IDF_TARGET)
+
+# 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
+)
+
+else()
+
+FILE(GLOB_RECURSE headers include/*.h include/*.hpp)
+
+idf_component_register(
+    SRCS
+        ${headers}
+    INCLUDE_DIRS
+        include
+    REQUIRES
+        boost_config
+        boost_static_assert
+)
+
+endif()

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
+

cxx_type_traits.htm

@@ -0,0 +1,19 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+  <head>
+    <meta http-equiv="refresh" content="0; URL=doc/html/boost_typetraits/background.html">
+    <!-- boostinspect:nounlinked -->
+    </head>
+  <body><P>
+    Automatic redirection failed, please go to
+    <a href="doc/html/boost_typetraits/background.html">doc/html/boost_typetraits/background.html.</a></P>
+      <P>Copyright&nbsp;John Maddock 2006</P>
+      <P>Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
+            LICENSE_1_0.txt</A> or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P>
+  </body>
+</html>
+
+
+
+
+

doc/Jamfile.v2

@@ -0,0 +1,76 @@
+
+# Copyright John Maddock 2005. Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+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=../../../..
+        
+        # Some general style settings:
+        <xsl:param>table.footnote.number.format=1
+        <xsl:param>footnote.number.format=1
+
+        # HTML options first:
+        # Use graphics not text for navigation:
+        <xsl:param>navig.graphics=1
+        # How far down we chunk nested sections, basically all of them:
+        <xsl:param>chunk.section.depth=10
+        # Don't put the first section on the same page as the TOC:
+        <xsl:param>chunk.first.sections=1
+        # How far down sections get TOC's
+        <xsl:param>toc.section.depth=10
+        # Max depth in each TOC:
+        <xsl:param>toc.max.depth=4
+        # How far down we go with TOC's
+        <xsl:param>generate.section.toc.level=10
+        
+        # PDF Options:
+        # TOC Generation: this is needed for FOP-0.9 and later:
+        <xsl:param>fop1.extensions=0
+        <xsl:param>xep.extensions=1
+        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
+        <xsl:param>fop.extensions=0
+        # No indent on body text:
+        <xsl:param>body.start.indent=0pt
+        # Margin size:
+        <xsl:param>page.margin.inner=0.5in
+        # Margin size:
+        <xsl:param>page.margin.outer=0.5in
+        # Paper type = A4
+        <xsl:param>paper.type=A4
+        # Yes, we want graphics for admonishments:
+        <xsl:param>admon.graphics=1
+        # Set this one for PDF generation *only*:
+        # default pnd graphics are awful in PDF form,
+        # better use SVG's instead:
+        <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 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

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

doc/add_cv.qbk

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

@@ -0,0 +1,45 @@
+[/ 
+  Copyright 2007 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_pointer add_pointer]
+
+   template <class T>
+   struct add_pointer
+   {
+      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 `decltype(&t)`, 
+where `t` is an object of type `T`.
+
+__std_ref 8.3.1.
+
+__header ` #include <boost/type_traits/add_pointer.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`add_pointer<int>::type`][`int*`]]
+
+[[`add_pointer<int const&>::type`] [`int const*`]]
+
+[[`add_pointer<int*>::type`] [`int**`]]
+
+[[`add_pointer<int*&>::type`] [`int**`]]
+
+]
+
+[all_compilers]
+
+[endsect]
+

doc/add_reference.qbk

@@ -0,0 +1,47 @@
+[/ 
+  Copyright 2007 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_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.
+
+__header ` #include <boost/type_traits/add_reference.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`add_reference<int>::type`][`int&`]]
+
+[[`add_reference<int const&>::type`] [`int const&`]]
+
+[[`add_reference<int*>::type`] [`int*&`]]
+
+[[`add_reference<int*&>::type`] [`int*&`]]
+
+]
+
+[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

@@ -0,0 +1,41 @@
+[/ 
+  Copyright 2007 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_volatile add_volatile]
+
+   template <class T>
+   struct add_volatile
+   {
+      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.
+
+__header ` #include <boost/type_traits/add_volatile.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`add_volatile<int>::type`][`int volatile`]]
+
+[[`add_volatile<int&>::type`] [`int&`]]
+
+[[`add_volatile<int*>::type`] [`int* volatile`]]
+
+[[`add_volatile<int const>::type`] [`int const volatile`]]
+
+]
+
+[all_compilers]
+
+[endsect]
+

doc/aligned_storage.qbk

@@ -0,0 +1,54 @@
+[/ 
+  Copyright 2007 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:aligned_storage aligned_storage]
+
+   template <std::size_t Size, std::size_t Align>
+   struct aligned_storage
+   {
+      typedef __below type;
+   };
+  
+__type a built-in or POD type with size `Size` and an alignment 
+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

@@ -0,0 +1,55 @@
+[/ 
+  Copyright 2007 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:alignment_of alignment_of]
+   template <class T>
+   struct alignment_of : public __integral_constant<std::size_t, ALIGNOF(T)> {};
+  
+__inherit Class template `alignment_of` inherits from 
+`__integral_constant<std::size_t, ALIGNOF(T)>`, where `ALIGNOF(T)` is the
+alignment of type T.  
+
+['Note: strictly speaking you should only rely on 
+the value of `ALIGNOF(T)` being a multiple of the true alignment of T, although
+in practice it does compute the correct value in all the cases we know about.]
+
+__header ` #include <boost/type_traits/alignment_of.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`alignment_of<int>` inherits from `__integral_constant<std::size_t, ALIGNOF(int)>`.]
+
+[:`alignment_of<char>::type` is the type `__integral_constant<std::size_t, ALIGNOF(char)>`.]
+
+[:`alignment_of<double>::value` is an integral constant 
+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/alignment_traits.qbk

@@ -0,0 +1,24 @@
+[/ 
+  Copyright 2007 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:alignment Synthesizing Types with Specific Alignments]
+
+Some low level memory management routines need to synthesize a POD type with
+specific alignment properties.  The template `__type_with_alignment` finds the smallest
+type with a specified alignment, while template `__aligned_storage` creates a type 
+with a specific size and alignment.
+
+[*Synopsis]
+
+   template <std::size_t Align>
+   struct __type_with_alignment;
+   
+   template <std::size_t Size, std::size_t Align>
+   struct __aligned_storage;
+
+[endsect]
+

doc/background.qbk

@@ -0,0 +1,322 @@
+[/ 
+  Copyright 2007 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:background Background and Tutorial]
+
+The following is an updated version of the article "C++ Type traits"
+by John Maddock and Steve Cleary that appeared in the October 2000 
+issue of [@http://www.ddj.com Dr Dobb's Journal].
+
+Generic programming (writing code which works with any data type meeting a 
+set of requirements) has become the method of choice for providing reusable code. 
+However, there are times in generic programming when "generic" just isn't 
+good enough - sometimes the differences between types are too large for an 
+efficient generic implementation. This is when the traits technique 
+becomes important - by encapsulating those properties that need to be 
+considered on a type by type basis inside a traits class, we can 
+minimize the amount of code that has to differ from one type to another, 
+and maximize the amount of generic code.
+
+Consider an example: when working with character strings, one common operation is 
+to determine the length of a null terminated string. Clearly it's possible to 
+write generic code that can do this, but it turns out that there are much more 
+efficient methods available: for example, the C library functions `strlen` and 
+`wcslen` are usually written in assembler, and with suitable hardware support 
+can be considerably faster than a generic version written in C++. 
+The authors of the C++ standard library realized this, and abstracted the 
+properties of `char` and `wchar_t` into the class `char_traits`. Generic code 
+that works with character strings can simply use `char_traits<>::length` to 
+determine the length of a null terminated string, safe in the knowledge 
+that specializations of `char_traits` will use the most appropriate method 
+available to them.
+
+[h4 Type Traits]
+
+Class `char_traits` is a classic example of a collection of type specific 
+properties wrapped up in a single class - what Nathan Myers termed a 
+/baggage class/[link background.references \[1\]]. In the Boost type-traits library, we[link background.references \[2\]] have written 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. As we will show, these classes can be used in 
+generic programming to determine the properties of a given type and introduce 
+optimizations that are appropriate for that case.
+
+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. All of the type-traits 
+classes are defined inside namespace `boost`; for brevity, namespace-qualification 
+is omitted in most of the code samples given.
+
+[h4 Implementation]
+
+There are far too many separate classes contained in the type-traits library 
+to give a full implementation here - see the source code in the Boost library 
+for the full details - however, most of the implementation is fairly repetitive 
+anyway, so here we will just give you a flavor for how some of the classes are 
+implemented. Beginning with possibly the simplest class in the library, 
+`is_void<T>` inherits from `__true_type` only if `T` is `void`.
+
+   template <typename T> 
+   struct __is_void : public __false_type{};
+
+   template <> 
+   struct __is_void<void> : public __true_type{};
+
+Here we define a primary version of the template class `__is_void`, and 
+provide a full-specialization when `T` is `void`. While full specialization 
+of a template class is an important technique, sometimes we need a 
+solution that is halfway between a fully generic solution, and a full 
+specialization. This is exactly the situation for which the standards committee 
+defined partial template-class specialization. As an example, consider the 
+class `boost::is_pointer<T>`: here we needed a primary version that handles 
+all the cases where T is not a pointer, and a partial specialization to 
+handle all the cases where T is a pointer:
+
+   template <typename T> 
+   struct __is_pointer : public __false_type{};
+
+   template <typename T> 
+   struct __is_pointer<T*> : public __true_type{};
+
+The syntax for partial specialization is somewhat arcane and could easily 
+occupy an article in its own right; like full specialization, in order to 
+write a partial specialization for a class, you must first declare the 
+primary template. The partial specialization contains an extra <...> after the 
+class name that contains the partial specialization parameters; these define 
+the types that will bind to that partial specialization rather than the 
+default template. The rules for what can appear in a partial specialization 
+are somewhat convoluted, but as a rule of thumb if you can legally write two 
+function overloads of the form:
+
+   void foo(T);
+   void foo(U);
+
+Then you can also write a partial specialization of the form:
+
+   template <typename T>
+   class c{ /*details*/ };
+
+   template <typename T>
+   class c<U>{ /*details*/ };
+
+This rule is by no means foolproof, but it is reasonably simple to remember 
+and close enough to the actual rule to be useful for everyday use.
+
+As a more complex example of partial specialization consider the class 
+`remove_extent<T>`. This class defines a single typedef-member `type` 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:
+
+   template <typename T> 
+   struct __remove_extent
+   { typedef T type; };
+
+   template <typename T, std::size_t N> 
+   struct __remove_extent<T[N]>
+   { typedef T type; };
+
+The aim of `__remove_extent` is this: imagine a generic algorithm that is 
+passed an array type as a template parameter, `__remove_extent` provides a 
+means of determining the underlying type of the array. For example 
+`remove_extent<int[4][5]>::type` would evaluate to the type `int[5]`. 
+This example also shows that the number of template parameters in a 
+partial specialization does not have to match the number in the 
+default template. However, the number of parameters that appear after the 
+class name do have to match the number and type of the parameters in the 
+default template.
+
+[h4 Optimized copy]
+
+As an example of how the type traits classes can be used, consider the 
+standard library algorithm copy:
+
+   template<typename Iter1, typename Iter2>
+   Iter2 copy(Iter1 first, Iter1 last, Iter2 out);
+
+Obviously, there's no problem writing a generic version of copy that works 
+for all iterator types `Iter1` and `Iter2`; however, there are some 
+circumstances when the copy operation can best be performed by a call to 
+`memcpy`. In order to implement copy in terms of `memcpy` all of the 
+following conditions need to be met:
+
+* Both of the iterator types `Iter1` and `Iter2` must be pointers. 
+* Both `Iter1` and `Iter2` must point to the same type - excluding const and 
+volatile-qualifiers. 
+* The type pointed to by `Iter1` must have a trivial assignment operator. 
+
+By trivial assignment operator we mean that the type is either a scalar type[link background.references \[3\]] or:
+
+* The type has no user defined assignment operator. 
+* The type does not have any data members that are references. 
+* All base classes, and all data member objects must have trivial assignment operators. 
+
+If all these conditions are met then a type can be copied using `memcpy` 
+rather than using a compiler generated assignment operator. The type-traits 
+library provides a class `__has_trivial_assign`, such that 
+`has_trivial_assign<T>::value` is true only if T has a trivial assignment operator. 
+This class "just works" for scalar types, but has to be explicitly 
+specialised for class/struct types that also happen to have a trivial assignment 
+operator. In other words if __has_trivial_assign gives the wrong answer, 
+it will give the "safe" wrong answer - that trivial assignment is not allowable.
+
+The code for an optimized version of copy that uses `memcpy` where appropriate is 
+given in [link boost_typetraits.examples.copy the examples]. The code begins by defining a template 
+function `do_copy` that performs a "slow but safe" copy.  The last parameter passed
+to this function may be either a `__true_type` or a `__false_type`. Following that 
+there is an overload of do_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 
+`__true_type`.  Finally, the version of `copy` calls `do_copy`, passing 
+`__has_trivial_assign<value_type>()` as the final parameter: this will dispatch
+to the optimized version where appropriate, otherwise it will call the 
+"slow but safe version".
+
+[h4 Was it worth it?]
+
+It has often been repeated in these columns that "premature optimization is the 
+root of all evil" [link background.references \[4\]]. So the question must be asked: was our optimization 
+premature? To put this in perspective the timings for our version of copy 
+compared a conventional generic copy[link background.references \[5\]] are shown in table 1.
+
+Clearly the optimization makes a difference in this case; but, to be fair, 
+the timings are loaded to exclude cache miss effects - without this 
+accurate comparison between algorithms becomes difficult. However, perhaps 
+we can add a couple of caveats to the premature optimization rule:
+
+*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. 
+*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. 
+
+[table Time taken to copy 1000 elements using `copy<const T*, T*>` (times in micro-seconds)
+
+[[Version] [T] [Time]]
+[["Optimized" copy] [char] [0.99]]
+[[Conventional copy] [char] [8.07]]
+[["Optimized" copy] [int] [2.52]]
+[[Conventional copy] [int] [8.02]]
+]
+
+[h4 Pair of References]
+The optimized copy example shows how type traits may be used to perform 
+optimization decisions at compile-time. Another important usage of type traits 
+is to allow code to compile that otherwise would not do so unless excessive 
+partial specialization is used. This is possible by delegating partial 
+specialization to the type traits classes. Our example for this form of 
+usage is a pair that can hold references [link background.references \[6\]].
+
+First, let us examine the definition of `std::pair`, omitting the 
+comparison operators, default constructor, and template copy constructor for 
+simplicity:
+
+   template <typename T1, typename T2> 
+   struct pair 
+   {
+   typedef T1 first_type;
+   typedef T2 second_type;
+
+   T1 first;
+   T2 second;
+
+   pair(const T1 & nfirst, const T2 & nsecond)
+   :first(nfirst), second(nsecond) { }
+   };
+
+Now, this "pair" cannot hold references as it currently stands, because the 
+constructor would require taking a reference to a reference, which is 
+currently illegal [link background.references \[7\]]. Let us consider what the constructor's parameters 
+would have to be in order to allow "pair" to hold non-reference types, 
+references, and constant references:
+
+[table Required Constructor Argument Types
+[[Type of `T1`] [Type of parameter to initializing constructor]]
+[[T] [const T &]]
+[[T &] [T &]]
+[[const T &] [const T &]]
+]
+
+A little familiarity with the type traits classes allows us to construct a 
+single mapping that allows us to determine the type of parameter from the 
+type of the contained class. The type traits classes provide a 
+transformation __add_reference, which adds a reference to its type, 
+unless it is already a reference.
+
+[table Using add_reference to synthesize the correct constructor type
+[[Type of `T1`] [Type of `const T1`] [Type of `add_reference<const T1>::type`]]
+[[T] [const T] [const T &]]
+[[T &] [T & \[8\]] [T &]]
+[[const T &] [const T &] [const T &]]
+]
+ 
+This allows us to build a primary template definition for `pair` that can 
+contain non-reference types, reference types, and constant reference types:
+
+   template <typename T1, typename T2> 
+   struct pair 
+   {
+   typedef T1 first_type;
+   typedef T2 second_type;
+
+   T1 first;
+   T2 second;
+
+   pair(boost::__add_reference<const T1>::type nfirst,
+         boost::__add_reference<const T2>::type nsecond)
+   :first(nfirst), second(nsecond) { }
+   };
+
+Add back in the standard comparison operators, default constructor, 
+and template copy constructor (which are all the same), and you have a 
+`std::pair` that can hold reference types!
+
+This same extension could have been done using partial template specialization 
+of `pair`, but to specialize `pair` in this way would require three partial 
+specializations, plus the primary template. Type traits allows us to 
+define a single primary template that adjusts itself auto-magically to 
+any of these partial specializations, instead of a brute-force partial 
+specialization approach. Using type traits in this fashion allows 
+programmers to delegate partial specialization to the type traits classes, 
+resulting in code that is easier to maintain and easier to understand.
+
+[h4 Conclusion]
+
+We hope that in this article we have been able to give you some idea of 
+what type-traits are all about. A more complete listing of the available 
+classes are in the boost documentation, along with further examples using 
+type traits. Templates have enabled C++ uses to take the advantage of the 
+code reuse that generic programming brings; hopefully this article has 
+shown that generic programming does not have to sink to the lowest common 
+denominator, and that templates can be optimal as well as generic.
+
+[h4 Acknowledgements]
+
+The authors would like to thank Beman Dawes and Howard Hinnant for their 
+helpful comments when preparing this article.
+
+[h4 [#background.references]References]
+
+# Nathan C. Myers, C++ Report, June 1995. 
+# 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. 
+# 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. 
+# This quote is from Donald Knuth, ACM Computing Surveys, December 1974, pg 268. 
+# 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. 
+# 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". 
+# 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. 
+# 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 &" is something completely different. For this reason, cv-qualifiers on template type arguments that are references are ignored.
+
+[endsect]
+
+

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

@@ -0,0 +1,42 @@
+[/ 
+  Copyright 2007 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:credits Credits]
+
+This documentation was pulled together by John Maddock, using 
+[@../../../../doc/html/quickbook.html Boost.Quickbook]
+and [@../../../../doc/html/boostbook.html Boost.DocBook].
+ 
+The original version of this library was created by Steve Cleary, 
+Beman Dawes, Howard Hinnant, and John Maddock.  John Maddock is the
+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, 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], 
+the partial specialization workarounds used in this library.
+
+Aleksey Gurtovoy added MPL integration to the library.
+
+The __is_convertible template is based on code originally devised by 
+Andrei Alexandrescu, see 
+"[@http://www.cuj.com/experts/1810/alexandr.htm?topic=experts 
+Generic<Programming>: Mappings between Types and Values]".
+
+The latest version of this library and documentation can be found at 
+[@http://www.boost.org www.boost.org]. Bugs, suggestions and discussion
+should be directed to boost@lists.boost.org 
+(see [@http://www.boost.org/more/mailing_lists.htm#main 
+www.boost.org/more/mailing_lists.htm#main] for subscription details).
+
+[endsect]
+

doc/decay.qbk

@@ -0,0 +1,44 @@
+[/ 
+  Copyright 2007 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:decay decay]
+
+   template <class T>
+   struct decay
+   {
+      typedef __below type;
+   };
+   
+   template <class T> using decay_t = typename decay<T>::type; // C++11 and above
+
+__type Let `U` be the result of `remove_reference<T>::type`, then if `U` is
+an array type, the result is `remove_extent<U>::type*`, otherwise if `U` is a 
+function type then the result is `U*`, otherwise the result is `remove_cv<U>::type`.
+
+__std_ref 3.9.1.
+
+__header ` #include <boost/type_traits/decay.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`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)`]]
+
+]
+
+[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/decomposing_func.qbk

@@ -0,0 +1,20 @@
+[/ 
+  Copyright 2007 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:function Decomposing Function Types]
+
+The class template __function_traits extracts information from function types
+(see also __is_function).  This traits class allows you to tell how many arguments
+a function takes, what those argument types are, and what the return type is.
+
+[*Synopsis]
+
+   template <std::size_t Align>
+   struct __function_traits;
+
+[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

@@ -0,0 +1,237 @@
+[/ 
+  Copyright 2007 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:examples Examples]
+
+[section:copy An Optimized Version of std::copy]
+
+Demonstrates a version of `std::copy` that uses `__has_trivial_assign` to
+determine whether to use `memcpy` to optimise the copy operation 
+(see [@../../examples/copy_example.cpp copy_example.cpp]):
+
+   //
+   // opt::copy
+   // same semantics as std::copy
+   // calls memcpy where appropriate.
+   //
+
+   namespace detail{
+
+   template<typename I1, typename I2, bool b>
+   I2 copy_imp(I1 first, I1 last, I2 out, const boost::__integral_constant<bool, b>&)
+   {
+      while(first != last)
+      {
+         *out = *first;
+         ++out;
+         ++first;
+      }
+      return out;
+   }
+
+   template<typename T>
+   T* copy_imp(const T* first, const T* last, T* out, const boost::__true_type&)
+   {
+      memmove(out, first, (last-first)*sizeof(T));
+      return out+(last-first);
+   }
+
+
+   }
+
+   template<typename I1, typename I2>
+   inline I2 copy(I1 first, I1 last, I2 out)
+   {
+      //
+      // We can copy with memcpy if T has a trivial assignment operator,
+      // and if the iterator arguments are actually pointers (this last
+      // requirement we detect with overload resolution):
+      //
+      typedef typename std::iterator_traits<I1>::value_type value_type;
+      return detail::copy_imp(first, last, out, boost::__has_trivial_assign<value_type>());
+   }
+
+
+[endsect]
+
+[section:fill An Optimised Version of std::fill]
+
+Demonstrates a version of `std::fill` that uses `__has_trivial_assign` to
+determine whether to use `memset` to optimise the fill operation 
+(see [@../../examples/fill_example.cpp fill_example.cpp]):
+
+   //
+   // fill
+   // same as std::fill, but uses memset where appropriate
+   //
+   namespace detail{
+
+   template <typename I, typename T, bool b>
+   void do_fill(I first, I last, const T& val, const boost::__integral_constant<bool, b>&)
+   {
+      while(first != last)
+      {
+         *first = val;
+         ++first;
+      }
+   }
+
+   template <typename T>
+   void do_fill(T* first, T* last, const T& val, const boost::__true_type&)
+   {
+      std::memset(first, val, last-first);
+   }
+
+   }
+
+   template <class I, class T>
+   inline void fill(I first, I last, const T& val)
+   {
+      //
+      // We can do an optimised fill if T has a trivial assignment 
+      // operator and if it's size is one:
+      //
+      typedef boost::__integral_constant<bool, 
+         ::boost::__has_trivial_assign<T>::value && (sizeof(T) == 1)> truth_type;
+      detail::do_fill(first, last, val, truth_type());
+   }
+
+
+[endsect]
+
+[section:destruct An Example that Omits Destructor Calls For Types with Trivial Destructors]
+
+Demonstrates a simple algorithm that uses `__has_trivial_destruct` to
+determine whether to destructors need to be called 
+(see [@../../examples/trivial_destructor_example.cpp trivial_destructor_example.cpp]):
+
+   //
+   // algorithm destroy_array:
+   // The reverse of std::unitialized_copy, takes a block of
+   // initialized memory and calls destructors on all objects therein.
+   //
+
+   namespace detail{
+
+   template <class T>
+   void do_destroy_array(T* first, T* last, const boost::__false_type&)
+   {
+      while(first != last)
+      {
+         first->~T();
+         ++first;
+      }
+   }
+
+   template <class T>
+   inline void do_destroy_array(T* first, T* last, const boost::__true_type&)
+   {
+   }
+
+   } // namespace detail
+
+   template <class T>
+   inline void destroy_array(T* p1, T* p2)
+   {
+      detail::do_destroy_array(p1, p2, ::boost::__has_trivial_destructor<T>());
+   }
+
+
+[endsect]
+
+[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 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 proxy iterators
+then takes special care over the swap to ensure that the algorithm
+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 proxy iterator or not, and
+   // uses optimal form accordingly:
+   //
+   namespace detail{
+
+   template <typename I>
+   static void do_swap(I one, I two, const boost::__false_type&)
+   {
+      typedef typename std::iterator_traits<I>::value_type v_t;
+      v_t v = *one;
+      *one = *two;
+      *two = v;
+   }
+   template <typename I>
+   static void do_swap(I one, I two, const boost::__true_type&)
+   {
+      using std::swap;
+      swap(*one, *two);
+   }
+
+   }
+
+   template <typename I1, typename I2>
+   inline void iter_swap(I1 one, I2 two)
+   {
+      //
+      // See is both arguments are non-proxying iterators, 
+      // and if both iterator the same type:
+      //
+      typedef typename std::iterator_traits<I1>::reference r1_t;
+      typedef typename std::iterator_traits<I2>::reference r2_t;
+
+      typedef boost::__integral_constant<bool,
+         ::boost::__is_reference<r1_t>::value
+         && ::boost::__is_reference<r2_t>::value
+         && ::boost::__is_same<r1_t, r2_t>::value> truth_type;
+
+      detail::do_swap(one, two, truth_type());
+   }
+
+
+[endsect]
+
+[section:to_double Convert Numeric Types and Enums to double]
+
+Demonstrates a conversion of
+[@../../../../libs/numeric/conversion/doc/html/boost_numericconversion/definitions.html#boost_numericconversion.definitions.numeric_types
+Numeric Types]
+and enum types to double:
+
+    template<class T>
+    inline double to_double(T const& value)
+    {
+        typedef typename boost::promote<T>::type promoted;
+        return boost::numeric::converter<double,promoted>::convert(value);
+    }
+
+[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

@@ -0,0 +1,50 @@
+[/ 
+  Copyright 2007 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:extent extent]
+   template <class T, std::size_t N = 0>
+   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 dimension of type `T`.
+
+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>`
+
+__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/.]
+
+[:`extent<int[][2]>::value` is an integral constant 
+expression that evaluates to /0/.]
+
+[:`extent<int[][2], 1>::value` is an integral constant 
+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

@@ -0,0 +1,41 @@
+[/ 
+  Copyright 2007 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:floating_point_promotion floating_point_promotion]
+
+   template <class T>
+   struct floating_point_promotion
+   {
+      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.
+
+__std_ref 4.6.
+
+__header ` #include <boost/type_traits/floating_point_promotion.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[table Examples
+
+[ [Expression] [Result Type]]
+
+[[`floating_point_promotion<float const>::type`][`double const`]]
+
+[[`floating_point_promotion<float&>::type`][`float&`]]
+
+[[`floating_point_promotion<short>::type`][`short`]]
+
+]
+
+[all_compilers]
+
+[endsect]
+

doc/function_traits.qbk

@@ -0,0 +1,58 @@
+[/ 
+  Copyright 2007 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:function_traits function_traits]
+[def __argN '''arg<replaceable>N</replaceable>_type''']
+
+   template <class F>
+   struct function_traits
+   {
+      static const std::size_t    arity = __below;
+      typedef __below           result_type;
+      typedef __below           __argN; 
+   };
+
+The class template function_traits will only compile if:
+
+* The compiler supports partial specialization of class templates.
+* The template argument `F` is a /function type/, note that this ['[*is not]] 
+the same thing as a /pointer to a function/.
+
+[tip
+function_traits is intended to introspect only C++ functions of the 
+form R (), R( A1 ), R ( A1, ... etc. ) and not function pointers or 
+class member functions. To convert a function pointer type to a suitable 
+type use __remove_pointer.]
+
+[table Function Traits Members 
+[[Member] [Description]] 
+[[`function_traits<F>::arity`] 
+   [An integral constant expression that gives the number of arguments accepted by the function type `F`.]]
+[[`function_traits<F>::result_type`] 
+   [The type returned by function type `F`.]]
+[[`function_traits<F>::__argN`] 
+   [The '''<replaceable>N</replaceable>th''' argument type of function type `F`, where `1 <= N <= arity` of `F`.]]
+]
+
+[table Examples
+[[Expression] [Result]] 
+[[`function_traits<void (void)>::arity`] [An integral constant expression that has the value 0.]]
+[[`function_traits<long (int)>::arity`] [An integral constant expression that has the value 1.]]
+[[`function_traits<long (int, long, double, void*)>::arity`] [An integral constant expression that has the value 4.]]
+[[`function_traits<void (void)>::result_type`] [The type `void`.]]
+[[`function_traits<long (int)>::result_type`] [The type `long`.]]
+[[`function_traits<long (int)>::arg1_type`] [The type `int`.]]
+[[`function_traits<long (int, long, double, void*)>::arg4_type`] [The type `void*`.]]
+[[`function_traits<long (int, long, double, void*)>::arg5_type`] [A compiler error: there is no `arg5_type` since there are only four arguments.]]
+[[`function_traits<long (*)(void)>::arity`] [A compiler error: argument type is a /function pointer/, and not a /function type/.]]
+
+]
+   
+[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

@@ -0,0 +1,47 @@
+[/ 
+  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:has_new_operator has_new_operator]
+   template <class T>
+   struct has_new_operator : public __tof {};
+  
+__inherit If T is a (possibly cv-qualified) type with an overloaded new-operator
+then inherits from __true_type, otherwise inherits from __false_type.
+
+[has_binary_operator_compat]  Also known to be broken with the Borland/Codegear compilers.
+
+__std_ref 12.5.
+
+__header ` #include <boost/type_traits/has_new_operator.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+Given:
+
+	class A { void* operator new(std::size_t); };
+	class B { void* operator new(std::size_t, const std::nothrow&); };
+	class C { void* operator new(std::size_t, void*); };
+	class D { void* operator new[](std::size_t); };
+	class E { void* operator new[](std::size_t, const std::nothrow&); };
+	class F { void* operator new[](std::size_t, void*); };
+	
+Then:
+
+[:`has_new_operator<A>` inherits from `__true_type`.]
+
+[:`has_new_operator<B>` inherits from `__true_type`.]
+
+[:`has_new_operator<C>` inherits from `__true_type`.]
+
+[:`has_new_operator<D>` inherits from `__true_type`.]
+
+[:`has_new_operator<E>` inherits from `__true_type`.]
+
+[:`has_new_operator<F>` inherits from `__true_type`.]
+
+[endsect]
+

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

@@ -0,0 +1,26 @@
+[/ 
+  Copyright 2007 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_assign has_nothrow_assign]
+
+   template <class T>
+   struct has_nothrow_assign : public __tof {};
+  
+__inherit If T is a (possibly cv-qualified) type with a non-throwing assignment-operator
+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.
+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>`
+
+[endsect]
+

doc/has_nothrow_constructor.qbk

@@ -0,0 +1,31 @@
+[/ 
+  Copyright 2007 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_constructor has_nothrow_constructor]
+
+   template <class T>
+   struct has_nothrow_constructor : public __tof {};
+  
+   template <class T>
+   struct has_nothrow_default_constructor : public __tof {};
+  
+__inherit If T is a (possibly cv-qualified) type with a non-throwing default-constructor
+then inherits from __true_type, otherwise inherits from __false_type.  Type `T`
+must be a complete type.
+
+These two traits are synonyms for each other.
+
+__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>`
+
+[endsect]
+

doc/has_nothrow_copy.qbk

@@ -0,0 +1,31 @@
+[/ 
+  Copyright 2007 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_copy has_nothrow_copy]
+
+   template <class T>
+   struct has_nothrow_copy : public __tof {};
+  
+   template <class T>
+   struct has_nothrow_copy_constructor : public __tof {};
+  
+__inherit If T is a (possibly cv-qualified) type with a non-throwing copy-constructor
+then inherits from __true_type, otherwise inherits from __false_type.  Type `T`
+must be a complete type.
+
+These two traits are synonyms for each other.
+
+__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>`
+
+[endsect]
+

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

@@ -0,0 +1,49 @@
+[/ 
+  Copyright 2007 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_trivial_assign has_trivial_assign]
+   template <class T>
+   struct has_trivial_assign : public __tof {};
+  
+__inherit If T is a (possibly cv-qualified) type with a trivial assignment-operator
+then inherits from __true_type, otherwise inherits from __false_type.
+
+If a type has a trivial 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_assign will never report that a user-defined class or struct has a 
+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.
+
+__header ` #include <boost/type_traits/has_trivial_assign.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_trivial_assign<int>` inherits from `__true_type`.]
+
+[:`has_trivial_assign<char*>::type` is the type `__true_type`.]
+
+[:`has_trivial_assign<int (*)(long)>::value` is an integral constant 
+expression that evaluates to /true/.]
+
+[:`has_trivial_assign<MyClass>::value` is an integral constant 
+expression that evaluates to /false/.]
+
+[:`has_trivial_assign<T>::value_type` is the type `bool`.]
+
+[endsect]
+

doc/has_trivial_constructor.qbk

@@ -0,0 +1,57 @@
+[/ 
+  Copyright 2007 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_trivial_constructor has_trivial_constructor]
+
+   template <class T>
+   struct has_trivial_constructor : public __tof {};
+  
+   template <class T>
+   struct has_trivial_default_constructor : public __tof {};
+  
+__inherit If T is a (possibly cv-qualified) type with a trivial default-constructor
+then inherits from __true_type, otherwise inherits from __false_type.
+
+These two traits are synonyms for each other.
+
+If a type has a trivial default-constructor then the constructor have no effect: 
+calls to the constructor can be safely omitted.  Note that using meta-programming
+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 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.  
+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.
+
+__header ` #include <boost/type_traits/has_trivial_constructor.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_trivial_constructor<int>` inherits from `__true_type`.]
+
+[:`has_trivial_constructor<char*>::type` is the type `__true_type`.]
+
+[:`has_trivial_constructor<int (*)(long)>::value` is an integral constant 
+expression that evaluates to /true/.]
+
+[:`has_trivial_constructor<MyClass>::value` is an integral constant 
+expression that evaluates to /false/.]
+
+[:`has_trivial_constructor<T>::value_type` is the type `bool`.]
+
+[endsect]
+

doc/has_trivial_copy.qbk

@@ -0,0 +1,55 @@
+[/ 
+  Copyright 2007 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_trivial_copy has_trivial_copy]
+
+   template <class T>
+   struct has_trivial_copy : public __tof {};
+  
+   template <class T>
+   struct has_trivial_copy_constructor : public __tof {};
+  
+__inherit If T is a (possibly cv-qualified) type with a trivial copy-constructor
+then inherits from __true_type, otherwise inherits from __false_type.
+
+These two traits are synonyms for each other.
+
+If a type has a trivial copy-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_copy will never report that a user-defined class or struct has a 
+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.
+
+__header ` #include <boost/type_traits/has_trivial_copy.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_trivial_copy<int>` inherits from `__true_type`.]
+
+[:`has_trivial_copy<char*>::type` is the type `__true_type`.]
+
+[:`has_trivial_copy<int (*)(long)>::value` is an integral constant 
+expression that evaluates to /true/.]
+
+[:`has_trivial_copy<MyClass>::value` is an integral constant 
+expression that evaluates to /false/.]
+
+[:`has_trivial_copy<T>::value_type` is the type `bool`.]
+
+[endsect]
+

doc/has_trivial_destructor.qbk

@@ -0,0 +1,51 @@
+[/ 
+  Copyright 2007 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_trivial_destructor has_trivial_destructor]
+   template <class T>
+   struct has_trivial_destructor : public __tof {};
+  
+__inherit If T is a (possibly cv-qualified) type with a trivial destructor
+then inherits from __true_type, otherwise inherits from __false_type.
+
+If a type has a trivial destructor then the destructor has no effect: 
+calls to the destructor can be safely omitted.  Note that using meta-programming
+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 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.  
+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.
+
+__header ` #include <boost/type_traits/has_trivial_destructor.hpp>` or ` #include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_trivial_destructor<int>` inherits from `__true_type`.]
+
+[:`has_trivial_destructor<char*>::type` is the type `__true_type`.]
+
+[:`has_trivial_destructor<int (*)(long)>::value` is an integral constant 
+expression that evaluates to /true/.]
+
+[:`has_trivial_destructor<MyClass>::value` is an integral constant 
+expression that evaluates to /false/.]
+
+[:`has_trivial_destructor<T>::value_type` is the type `bool`.]
+
+[endsect]
+

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

@@ -0,0 +1,31 @@
+[/ 
+  Copyright 2007 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_virtual_destructor has_virtual_destructor]
+   template <class T>
+   struct has_virtual_destructor : public __tof {};
+  
+__inherit If T is a (possibly cv-qualified) type with a virtual destructor
+then inherits from __true_type, otherwise inherits from __false_type.
+
+__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 (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.
+
+__header ` #include <boost/type_traits/has_virtual_destructor.hpp>` or ` #include <boost/type_traits.hpp>`
+
+[endsect]
+

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

@@ -0,0 +1,691 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Background and Tutorial</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.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>
+<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="../../../../../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/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">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_typetraits.background"></a><a class="link" href="background.html" title="Background and Tutorial">Background and Tutorial</a>
+</h2></div></div></div>
+<p>
+      The following is an updated version of the article "C++ Type traits"
+      by John Maddock and Steve Cleary that appeared in the October 2000 issue of
+      <a href="http://www.ddj.com" target="_top">Dr Dobb's Journal</a>.
+    </p>
+<p>
+      Generic programming (writing code which works with any data type meeting a
+      set of requirements) has become the method of choice for providing reusable
+      code. However, there are times in generic programming when "generic"
+      just isn't good enough - sometimes the differences between types are too large
+      for an efficient generic implementation. This is when the traits technique
+      becomes important - by encapsulating those properties that need to be considered
+      on a type by type basis inside a traits class, we can minimize the amount of
+      code that has to differ from one type to another, and maximize the amount of
+      generic code.
+    </p>
+<p>
+      Consider an example: when working with character strings, one common operation
+      is to determine the length of a null terminated string. Clearly it's possible
+      to write generic code that can do this, but it turns out that there are much
+      more efficient methods available: for example, the C library functions <code class="computeroutput"><span class="identifier">strlen</span></code> and <code class="computeroutput"><span class="identifier">wcslen</span></code>
+      are usually written in assembler, and with suitable hardware support can be
+      considerably faster than a generic version written in C++. The authors of the
+      C++ standard library realized this, and abstracted the properties of <code class="computeroutput"><span class="keyword">char</span></code> and <code class="computeroutput"><span class="keyword">wchar_t</span></code>
+      into the class <code class="computeroutput"><span class="identifier">char_traits</span></code>.
+      Generic code that works with character strings can simply use <code class="computeroutput"><span class="identifier">char_traits</span><span class="special">&lt;&gt;::</span><span class="identifier">length</span></code> to determine the length of a null
+      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>
+<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
+      example of a collection of type specific properties wrapped up in a single
+      class - what Nathan Myers termed a <span class="emphasis"><em>baggage class</em></span><a class="link" href="background.html#background.references">[1]</a>. In the Boost type-traits library,
+      we<a class="link" href="background.html#background.references">[2]</a> have written 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 <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
+      are appropriate for that case.
+    </p>
+<p>
+      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 <code class="computeroutput"><span class="identifier">type</span></code>
+      that is the result of the transformation. All of the type-traits classes are
+      defined inside namespace <code class="computeroutput"><span class="identifier">boost</span></code>;
+      for brevity, namespace-qualification is omitted in most of the code samples
+      given.
+    </p>
+<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
+      to give a full implementation here - see the source code in the Boost library
+      for the full details - however, most of the implementation is fairly repetitive
+      anyway, so here we will just give you a flavor for how some of the classes
+      are implemented. Beginning with possibly the simplest class in the library,
+      <code class="computeroutput"><span class="identifier">is_void</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> inherits
+      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>
+<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">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>
+      Here we define a primary version of the template class <code class="computeroutput"><a class="link" href="reference/is_void.html" title="is_void">is_void</a></code>,
+      and provide a full-specialization when <code class="computeroutput"><span class="identifier">T</span></code>
+      is <code class="computeroutput"><span class="keyword">void</span></code>. While full specialization
+      of a template class is an important technique, sometimes we need a solution
+      that is halfway between a fully generic solution, and a full specialization.
+      This is exactly the situation for which the standards committee defined partial
+      template-class specialization. As an example, consider the class <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>:
+      here we needed a primary version that handles all the cases where T is not
+      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>
+<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">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>
+      The syntax for partial specialization is somewhat arcane and could easily occupy
+      an article in its own right; like full specialization, in order to write a
+      partial specialization for a class, you must first declare the primary template.
+      The partial specialization contains an extra &lt;...&gt; after the class name
+      that contains the partial specialization parameters; these define the types
+      that will bind to that partial specialization rather than the default template.
+      The rules for what can appear in a partial specialization are somewhat convoluted,
+      but as a rule of thumb if you can legally write two function overloads of the
+      form:
+    </p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span><span class="special">);</span>
+<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="identifier">U</span><span class="special">);</span>
+</pre>
+<p>
+      Then you can also write a partial specialization of the form:
+    </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>
+<span class="keyword">class</span> <span class="identifier">c</span><span class="special">{</span> <span class="comment">/*details*/</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">&gt;</span>
+<span class="keyword">class</span> <span class="identifier">c</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;{</span> <span class="comment">/*details*/</span> <span class="special">};</span>
+</pre>
+<p>
+      This rule is by no means foolproof, but it is reasonably simple to remember
+      and close enough to the actual rule to be useful for everyday use.
+    </p>
+<p>
+      As a more complex example of partial specialization consider the class <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>. This
+      class defines a single typedef-member <code class="computeroutput"><span class="identifier">type</span></code>
+      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>
+<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">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>
+<p>
+      The aim of <code class="computeroutput"><a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a></code>
+      is this: imagine a generic algorithm that is passed an array type as a template
+      parameter, <code class="computeroutput"><a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a></code>
+      provides a means of determining the underlying type of the array. For example
+      <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">4</span><span class="special">][</span><span class="number">5</span><span class="special">]&gt;::</span><span class="identifier">type</span></code> would evaluate to the type <code class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">5</span><span class="special">]</span></code>. This example also shows that the number of
+      template parameters in a partial specialization does not have to match the
+      number in the default template. However, the number of parameters that appear
+      after the class name do have to match the number and type of the parameters
+      in the default template.
+    </p>
+<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
+      library algorithm copy:
+    </p>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Iter1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Iter2</span><span class="special">&gt;</span>
+<span class="identifier">Iter2</span> <span class="identifier">copy</span><span class="special">(</span><span class="identifier">Iter1</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">Iter1</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">Iter2</span> <span class="identifier">out</span><span class="special">);</span>
+</pre>
+<p>
+      Obviously, there's no problem writing a generic version of copy that works
+      for all iterator types <code class="computeroutput"><span class="identifier">Iter1</span></code>
+      and <code class="computeroutput"><span class="identifier">Iter2</span></code>; however, there are
+      some circumstances when the copy operation can best be performed by a call
+      to <code class="computeroutput"><span class="identifier">memcpy</span></code>. In order to implement
+      copy in terms of <code class="computeroutput"><span class="identifier">memcpy</span></code> all
+      of the following conditions need to be met:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" 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 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
+      assignment operator. The type-traits library provides a class <code class="computeroutput"><a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a></code>,
+      such that <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is true only if T has a trivial assignment
+      operator. This class "just works" for scalar types, but has to be
+      explicitly specialised for class/struct types that also happen to have a trivial
+      assignment operator. In other words if <a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a>
+      gives the wrong answer, it will give the "safe" wrong answer - that
+      trivial assignment is not allowable.
+    </p>
+<p>
+      The code for an optimized version of copy that uses <code class="computeroutput"><span class="identifier">memcpy</span></code>
+      where appropriate is given in <a class="link" href="examples/copy.html" title="An Optimized Version of std::copy">the
+      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_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>
+<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
+      is the root of all evil" <a class="link" href="background.html#background.references">[4]</a>.
+      So the question must be asked: was our optimization premature? To put this
+      in perspective the timings for our version of copy compared a conventional
+      generic copy<a class="link" href="background.html#background.references">[5]</a> are shown in table
+      1.
+    </p>
+<p>
+      Clearly the optimization makes a difference in this case; but, to be fair,
+      the timings are loaded to exclude cache miss effects - without this accurate
+      comparison between algorithms becomes difficult. However, perhaps we can add
+      a couple of caveats to the premature optimization rule:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" 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="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>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+              <p>
+                Version
+              </p>
+            </th>
+<th>
+              <p>
+                T
+              </p>
+            </th>
+<th>
+              <p>
+                Time
+              </p>
+            </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+              <p>
+                "Optimized" copy
+              </p>
+            </td>
+<td>
+              <p>
+                char
+              </p>
+            </td>
+<td>
+              <p>
+                0.99
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                Conventional copy
+              </p>
+            </td>
+<td>
+              <p>
+                char
+              </p>
+            </td>
+<td>
+              <p>
+                8.07
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                "Optimized" copy
+              </p>
+            </td>
+<td>
+              <p>
+                int
+              </p>
+            </td>
+<td>
+              <p>
+                2.52
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                Conventional copy
+              </p>
+            </td>
+<td>
+              <p>
+                int
+              </p>
+            </td>
+<td>
+              <p>
+                8.02
+              </p>
+            </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<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
+      decisions at compile-time. Another important usage of type traits is to allow
+      code to compile that otherwise would not do so unless excessive partial specialization
+      is used. This is possible by delegating partial specialization to the type
+      traits classes. Our example for this form of usage is a pair that can hold
+      references <a class="link" href="background.html#background.references">[6]</a>.
+    </p>
+<p>
+      First, let us examine the definition of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code>, omitting
+      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>
+<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>
+
+<span class="identifier">T1</span> <span class="identifier">first</span><span class="special">;</span>
+<span class="identifier">T2</span> <span class="identifier">second</span><span class="special">;</span>
+
+<span class="identifier">pair</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T1</span> <span class="special">&amp;</span> <span class="identifier">nfirst</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T2</span> <span class="special">&amp;</span> <span class="identifier">nsecond</span><span class="special">)</span>
+<span class="special">:</span><span class="identifier">first</span><span class="special">(</span><span class="identifier">nfirst</span><span class="special">),</span> <span class="identifier">second</span><span class="special">(</span><span class="identifier">nsecond</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="special">};</span>
+</pre>
+<p>
+      Now, this "pair" cannot hold references as it currently stands, because
+      the constructor would require taking a reference to a reference, which is currently
+      illegal <a class="link" href="background.html#background.references">[7]</a>. Let us consider what
+      the constructor's parameters would have to be in order to allow "pair"
+      to hold non-reference types, references, and constant references:
+    </p>
+<div class="table">
+<a name="boost_typetraits.background.required_constructor_argument_types"></a><p class="title"><b>Table 1.2. Required Constructor Argument Types</b></p>
+<div class="table-contents"><table class="table" summary="Required Constructor Argument Types">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<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>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+              <p>
+                T
+              </p>
+            </td>
+<td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                T &amp;
+              </p>
+            </td>
+<td>
+              <p>
+                T &amp;
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
+<td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break"><p>
+      A little familiarity with the type traits classes allows us to construct a
+      single mapping that allows us to determine the type of parameter from the type
+      of the contained class. The type traits classes provide a transformation <a class="link" href="reference/add_reference.html" title="add_reference">add_reference</a>, which
+      adds a reference to its type, unless it is already a reference.
+    </p>
+<div class="table">
+<a name="boost_typetraits.background.using_add_reference_to_synthesize_the_correct_constructor_type"></a><p class="title"><b>Table 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>
+<col>
+</colgroup>
+<thead><tr>
+<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>
+<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>
+<td>
+              <p>
+                const T
+              </p>
+            </td>
+<td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                T &amp;
+              </p>
+            </td>
+<td>
+              <p>
+                T &amp; [8]
+              </p>
+            </td>
+<td>
+              <p>
+                T &amp;
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
+<td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
+<td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break"><p>
+      This allows us to build a primary template definition for <code class="computeroutput"><span class="identifier">pair</span></code>
+      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>
+<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>
+
+<span class="identifier">T1</span> <span class="identifier">first</span><span class="special">;</span>
+<span class="identifier">T2</span> <span class="identifier">second</span><span class="special">;</span>
+
+<span class="identifier">pair</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><a class="link" href="reference/add_reference.html" title="add_reference">add_reference</a><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> <span class="identifier">nfirst</span><span class="special">,</span>
+      <span class="identifier">boost</span><span class="special">::</span><a class="link" href="reference/add_reference.html" title="add_reference">add_reference</a><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">T2</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">nsecond</span><span class="special">)</span>
+<span class="special">:</span><span class="identifier">first</span><span class="special">(</span><span class="identifier">nfirst</span><span class="special">),</span> <span class="identifier">second</span><span class="special">(</span><span class="identifier">nsecond</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="special">};</span>
+</pre>
+<p>
+      Add back in the standard comparison operators, default constructor, and template
+      copy constructor (which are all the same), and you have a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code> that
+      can hold reference types!
+    </p>
+<p>
+      This same extension could have been done using partial template specialization
+      of <code class="computeroutput"><span class="identifier">pair</span></code>, but to specialize
+      <code class="computeroutput"><span class="identifier">pair</span></code> in this way would require
+      three partial specializations, plus the primary template. Type traits allows
+      us to define a single primary template that adjusts itself auto-magically to
+      any of these partial specializations, instead of a brute-force partial specialization
+      approach. Using type traits in this fashion allows programmers to delegate
+      partial specialization to the type traits classes, resulting in code that is
+      easier to maintain and easier to understand.
+    </p>
+<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
+      type-traits are all about. A more complete listing of the available classes
+      are in the boost documentation, along with further examples using type traits.
+      Templates have enabled C++ uses to take the advantage of the code reuse that
+      generic programming brings; hopefully this article has shown that generic programming
+      does not have to sink to the lowest common denominator, and that templates
+      can be optimal as well as generic.
+    </p>
+<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>
+<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 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 © 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>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="intro.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="category.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/category.html

@@ -0,0 +1,67 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Type Traits by Category</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.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>
+<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="../../../../../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/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">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_typetraits.category"></a><a class="link" href="category.html" title="Type Traits by Category">Type Traits by Category</a>
+</h2></div></div></div>
+<div class="toc"><dl 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
+        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
+        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
+      Transform One Type to Another</a></span></dt>
+<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
+      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 © 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>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="background.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="category/value_traits.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/category/alignment.html

@@ -0,0 +1,63 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Synthesizing Types with Specific Alignments</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.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">
+</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="../../../../../../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/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">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.category.alignment"></a><a class="link" href="alignment.html" title="Synthesizing Types with Specific Alignments">Synthesizing Types
+      with Specific Alignments</a>
+</h3></div></div></div>
+<p>
+        Some low level memory management routines need to synthesize a POD type with
+        specific alignment properties. The template <code class="computeroutput"><a class="link" href="../reference/type_with_alignment.html" title="type_with_alignment">type_with_alignment</a></code>
+        finds the smallest type with a specified alignment, while template <code class="computeroutput"><a class="link" href="../reference/aligned_storage.html" title="aligned_storage">aligned_storage</a></code>
+        creates a type with a specific size and alignment.
+      </p>
+<p>
+        <span class="bold"><strong>Synopsis</strong></span>
+      </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../reference/type_with_alignment.html" title="type_with_alignment">type_with_alignment</a><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Size</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../reference/aligned_storage.html" title="aligned_storage">aligned_storage</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 © 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>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="transform.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="function.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/category/function.html

@@ -0,0 +1,60 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Decomposing Function Types</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.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">
+</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="../../../../../../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/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">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.category.function"></a><a class="link" href="function.html" title="Decomposing Function Types">Decomposing Function
+      Types</a>
+</h3></div></div></div>
+<p>
+        The class template <a class="link" href="../reference/function_traits.html" title="function_traits">function_traits</a>
+        extracts information from function types (see also <a class="link" href="../reference/is_function.html" title="is_function">is_function</a>).
+        This traits class allows you to tell how many arguments a function takes,
+        what those argument types are, and what the return type is.
+      </p>
+<p>
+        <span class="bold"><strong>Synopsis</strong></span>
+      </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../reference/function_traits.html" title="function_traits">function_traits</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 © 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>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="alignment.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../user_defined.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/category/transform.html

@@ -0,0 +1,129 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Type Traits that Transform One Type to Another</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../category.html" title="Type Traits by Category">
+<link rel="prev" href="value_traits/operators.html" title="Operator Type Traits">
+<link rel="next" href="alignment.html" title="Synthesizing Types with Specific Alignments">
+</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="../../../../../../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/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">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.category.transform"></a><a class="link" href="transform.html" title="Type Traits that Transform One Type to Another">Type Traits that
+      Transform One Type to Another</a>
+</h3></div></div></div>
+<p>
+        The following templates transform one type to another, based upon some well-defined
+        rule. Each template has a single member called <code class="computeroutput"><span class="identifier">type</span></code>
+        that is the result of applying the transformation to the template argument
+        <code class="computeroutput"><span class="identifier">T</span></code>.
+      </p>
+<p>
+        <span class="bold"><strong>Synopsis:</strong></span>
+      </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/add_const.html" title="add_const">add_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/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>
+
+<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/floating_point_promotion.html" title="floating_point_promotion">floating_point_promotion</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/integral_promotion.html" title="integral_promotion">integral_promotion</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/make_signed.html" title="make_signed">make_signed</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/make_unsigned.html" title="make_unsigned">make_unsigned</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/promote.html" title="promote">promote</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/remove_all_extents.html" title="remove_all_extents">remove_all_extents</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/remove_const.html" title="remove_const">remove_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/remove_cv.html" title="remove_cv">remove_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/remove_extent.html" title="remove_extent">remove_extent</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/remove_pointer.html" title="remove_pointer">remove_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/remove_reference.html" title="remove_reference">remove_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/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>
+</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 © 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>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="value_traits/operators.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="alignment.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/category/value_traits.html

@@ -0,0 +1,68 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Type Traits that Describe the Properties of a Type</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.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">
+</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="../../../../../../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/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">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.category.value_traits"></a><a class="link" href="value_traits.html" title="Type Traits that Describe the Properties of a Type">Type Traits that
+      Describe the Properties of a Type</a>
+</h3></div></div></div>
+<div class="toc"><dl 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
+        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
+        traits classes all inherit from <a class="link" href="../reference/integral_constant.html" title="integral_constant">integral_constant</a>,
+        and are used to access some numerical property of a type. Often this is a
+        simple true or false Boolean value, but in a few cases may be some other
+        integer value (for example when dealing with type alignments, or array bounds:
+        see <code class="computeroutput"><a class="link" href="../reference/alignment_of.html" title="alignment_of">alignment_of</a></code>,
+        <code class="computeroutput"><a class="link" href="../reference/rank.html" title="rank">rank</a></code>
+        and <code class="computeroutput"><a class="link" href="../reference/extent.html" title="extent">extent</a></code>).
+      </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 © 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>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../category.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="value_traits/primary.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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

@@ -0,0 +1,137 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Categorizing a Type</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.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">
+</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="../../../../../../../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/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">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_typetraits.category.value_traits.primary"></a><a class="link" href="primary.html" title="Categorizing a Type">Categorizing
+        a Type</a>
+</h4></div></div></div>
+<p>
+          These traits identify what "kind" of type some type <code class="computeroutput"><span class="identifier">T</span></code> is. These are split into two groups:
+          primary traits which are all mutually exclusive, and composite traits that
+          are compositions of one or more primary traits.
+        </p>
+<p>
+          For any given type, exactly one primary type trait will inherit from <a class="link" href="../../reference/integral_constant.html" title="integral_constant">true_type</a>,
+          and all the others will inherit from <a class="link" href="../../reference/integral_constant.html" title="integral_constant">false_type</a>,
+          in other words these traits are mutually exclusive.
+        </p>
+<p>
+          This means that <code class="computeroutput"><a class="link" href="../../reference/is_integral.html" title="is_integral">is_integral</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
+          and <code class="computeroutput"><a class="link" href="../../reference/is_floating_point.html" title="is_floating_point">is_floating_point</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
+          will only ever be true for built-in types; if you want to check for a user-defined
+          class type that behaves "as if" it is an integral or floating
+          point type, then use the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span>
+          <span class="keyword">template</span></code> instead.
+        </p>
+<p>
+          <span class="bold"><strong>Synopsis:</strong></span>
+        </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_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>
+<p>
+          The following traits are made up of the union of one or more type categorizations.
+          A type may belong to more than one of these categories, in addition to
+          one of the primary categories.
+        </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_arithmetic.html" title="is_arithmetic">is_arithmetic</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_compound.html" title="is_compound">is_compound</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_fundamental.html" title="is_fundamental">is_fundamental</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_pointer.html" title="is_member_pointer">is_member_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_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 © 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>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../value_traits.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="properties.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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

@@ -0,0 +1,156 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>General Type Properties</title>
+<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.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">
+</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="../../../../../../../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/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">
+<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>
+</h4></div></div></div>
+<p>
+          The following templates describe the general properties of a type.
+        </p>
+<p>
+          <span class="bold"><strong>Synopsis:</strong></span>
+        </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/alignment_of.html" title="alignment_of">alignment_of</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_new_operator.html" title="has_new_operator">has_new_operator</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_assign.html" title="has_nothrow_assign">has_nothrow_assign</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_constructor.html" title="has_nothrow_constructor">has_nothrow_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_constructor.html" title="has_nothrow_constructor">has_nothrow_default_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_copy.html" title="has_nothrow_copy">has_nothrow_copy</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_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>
+
+<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_constructor.html" title="has_trivial_constructor">has_trivial_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_trivial_constructor.html" title="has_trivial_constructor">has_trivial_default_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_trivial_copy.html" title="has_trivial_copy">has_trivial_copy</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_copy.html" title="has_trivial_copy">has_trivial_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_trivial_destructor.html" title="has_trivial_destructor">has_trivial_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_virtual_destructor.html" title="has_virtual_destructor">has_virtual_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/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>
+
+<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_pod.html" title="is_pod">is_pod</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_polymorphic.html" title="is_polymorphic">is_polymorphic</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_signed.html" title="is_signed">is_signed</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_unsigned.html" title="is_unsigned">is_unsigned</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_volatile.html" title="is_volatile">is_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">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="number">0</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../../reference/extent.html" title="extent">extent</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/rank.html" title="rank">rank</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 © 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>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="primary.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="relate.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>