Disabled OS X builds because they are slow on Travis CI.

Fix -Wextra-semi clang warnings

.travis.yml

@@ -0,0 +1,361 @@
+# Copyright 2016, 2017, 2018 Peter Dimov
+# Copyright 2019 Andrey Semashev
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+# gcc, Linux
+    - os: linux
+      dist: trusty
+      compiler: gcc-4.4
+      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: gcc-4.6
+      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: gcc-4.7
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      compiler: gcc-4.8
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      compiler: gcc-4.9
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      compiler: gcc-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      compiler: gcc-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      compiler: gcc-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: xenial
+      compiler: gcc-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: bionic
+      compiler: gcc-9
+      env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-9
+          sources:
+            - sourceline: "ppa:ubuntu-toolchain-r/test"
+
+# clang, Linux
+    - os: linux
+      dist: trusty
+      compiler: clang-3.4
+      env: TOOLSET=clang COMPILER=clang++-3.4 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.4
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.4 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: trusty
+      compiler: clang-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.5 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: trusty
+      compiler: clang-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+            - libstdc++-5-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.6 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: trusty
+      compiler: clang-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+            - libstdc++-5-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.7 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+            - libstdc++-6-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-3.8 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+            - libstdc++-6-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-3.9 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-4
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+            - libstdc++-6-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-4.0 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-5
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+            - libstdc++-7-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-5.0 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-6
+      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+            - libstdc++-8-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-6.0 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-7
+      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - clang-7
+            - libstdc++-8-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-7 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-8
+      env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - clang-8
+            - libstdc++-8-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-8 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-9
+      env: TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - clang-9
+            - libstdc++-9-dev
+          sources:
+            - sourceline: "ppa:ubuntu-toolchain-r/test"
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+    - os: linux
+      dist: xenial
+      compiler: clang-libc++
+      env: TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11,14,17 CXXFLAGS="-stdlib=libc++" LINKFLAGS="-stdlib=libc++"
+      addons:
+        apt:
+          packages:
+            - clang-9
+            - libc++-9-dev
+            - libc++abi-9-dev
+          sources:
+            - sourceline: "ppa:ubuntu-toolchain-r/test"
+            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main"
+              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
+
+# clang, OS X
+# Disabled because OS X builds are slow on Travis CI
+#    - os: osx
+#      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+#      osx_image: xcode9.4
+#
+#    - os: osx
+#      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+#      osx_image: xcode10.3
+#
+#    - os: osx
+#      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,17
+#      osx_image: xcode11.2
+
+install:
+  - GIT_FETCH_JOBS=8
+  - BOOST_BRANCH=develop
+  - if [ "$TRAVIS_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
+  - cd ..
+  - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule init tools/build
+  - git submodule init tools/boostdep
+  - git submodule init tools/boost_install
+  - git submodule init libs/headers
+  - git submodule init libs/config
+  - git submodule update --jobs $GIT_FETCH_JOBS
+  - cp -r $TRAVIS_BUILD_DIR/* libs/detail
+  - python tools/boostdep/depinst/depinst.py --git_args "--jobs $GIT_FETCH_JOBS" detail
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - BUILD_JOBS=`(nproc || sysctl -n hw.ncpu) 2> /dev/null`
+  - ./b2 -j $BUILD_JOBS libs/detail/test toolset=$TOOLSET cxxstd=$CXXSTD ${CXXFLAGS:+cxxflags="$CXXFLAGS"} ${LINKFLAGS:+linkflags="$LINKFLAGS"}
+
+notifications:
+  email:
+    on_success: always

CMakeLists.txt

@@ -0,0 +1,25 @@
+# Copyright 2018 Peter Dimov
+# Copyright 2018 Andrey Semashev
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
+
+# Partial (add_subdirectory only) and experimental CMake support
+# Subject to change; please do not rely on the contents of this file yet.
+
+cmake_minimum_required(VERSION 3.5)
+
+project(BoostDetail LANGUAGES CXX)
+
+add_library(boost_detail INTERFACE)
+add_library(Boost::detail ALIAS boost_detail)
+
+target_include_directories(boost_detail INTERFACE include)
+
+target_link_libraries(boost_detail
+    INTERFACE
+        Boost::config
+        Boost::core
+        Boost::preprocessor
+        Boost::static_assert
+        Boost::type_traits
+)

doc/build.jam

@@ -0,0 +1,36 @@
+# Copyright Rene Rivera 2016
+# 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)
+
+using quickbook ;
+using boostbook ;
+
+xml detail : detail.qbk ;
+
+install images : [ glob $(BOOST_ROOT)/doc/src/images/*.png ] : <location>html/images ;
+explicit images ;
+install callouts : [ glob $(BOOST_ROOT)/doc/src/images/callouts/*.png ] : <location>html/images/callouts ;
+explicit callouts ;
+install css : [ glob $(BOOST_ROOT)/doc/src/*.css ] : <location>html ;
+explicit css ;
+
+boostbook standalone
+    :
+        detail
+    :
+        <xsl:param>boost.root=../../../..
+        <xsl:param>generate.section.toc.level=3
+        <xsl:param>chunk.section.depth=2
+        #<xsl:param>chunk.first.sections=1
+    
+        <dependency>images
+        <dependency>callouts
+        <dependency>css
+    ;
+
+alias boostdoc ;
+explicit boostdoc ;
+
+alias boostrelease : standalone ;
+explicit boostrelease ;

doc/detail.qbk

@@ -0,0 +1,19 @@
+[article Detail
+    [quickbook 1.7]
+    [version 1.0]
+    [copyright 2016 Rene Rivera]
+    [purpose Internal support utilities for Boost C++ Libraries.]
+    [license
+        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])
+    ]
+    [source-mode c++]
+]
+
+[section Introduction]
+
+This library contains a set of header only utilities used internally by
+Boost C++ Libraries to facilitate their implementation.
+
+[endsect]

doc/html/boostbook.css

@@ -0,0 +1,716 @@
+
+/*=============================================================================
+Copyright (c) 2004 Joel de Guzman
+http://spirit.sourceforge.net/
+
+Copyright 2013 Niall Douglas additions for colors and alignment.
+Copyright 2013 Paul A. Bristow additions for more colors and alignments.
+
+Distributed under the Boost Software License, Version 1.0. (See accompany-
+ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+
+/*=============================================================================
+Body defaults
+=============================================================================*/
+
+    body
+    {
+        margin: 1em;
+        font-family: sans-serif;
+    }
+
+/*=============================================================================
+Paragraphs
+=============================================================================*/
+
+    p
+    {
+        text-align: left;
+        font-size: 10pt;
+        line-height: 1.15;
+    }
+
+/*=============================================================================
+Program listings
+=============================================================================*/
+
+    /* Code on paragraphs */
+    p tt.computeroutput
+    {
+        font-size: 9pt;
+    }
+
+    pre.synopsis
+    {
+        font-size: 9pt;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+    }
+
+    .programlisting,
+    .screen
+    {
+        font-size: 9pt;
+        display: block;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+    }
+
+    /* Program listings in tables don't get borders */
+    td .programlisting,
+    td .screen
+    {
+        margin: 0pc 0pc 0pc 0pc;
+        padding: 0pc 0pc 0pc 0pc;
+    }
+
+/*=============================================================================
+Headings
+=============================================================================*/
+
+    h1, h2, h3, h4, h5, h6
+    {
+        text-align: left;
+        margin: 1em 0em 0.5em 0em;
+        font-weight: bold;
+    }
+
+    h1 { font-size: 140%; }
+    h2 { font-weight: bold; font-size: 140%; }
+    h3 { font-weight: bold; font-size: 130%; }
+    h4 { font-weight: bold; font-size: 120%; }
+    h5 { font-weight: normal; font-style: italic; font-size: 110%; }
+    h6 { font-weight: normal; font-style: italic; font-size: 100%; }
+
+    /* Top page titles */
+    title,
+    h1.title,
+    h2.title
+    h3.title,
+    h4.title,
+    h5.title,
+    h6.title,
+    .refentrytitle
+    {
+        font-weight: bold;
+        margin-bottom: 1pc;
+    }
+
+    h1.title { font-size: 140% }
+    h2.title { font-size: 140% }
+    h3.title { font-size: 130% }
+    h4.title { font-size: 120% }
+    h5.title { font-size: 110% }
+    h6.title { font-size: 100% }
+
+    .section h1
+    {
+        margin: 0em 0em 0.5em 0em;
+        font-size: 140%;
+    }
+
+    .section h2 { font-size: 140% }
+    .section h3 { font-size: 130% }
+    .section h4 { font-size: 120% }
+    .section h5 { font-size: 110% }
+    .section h6 { font-size: 100% }
+
+    /* Code on titles */
+    h1 tt.computeroutput { font-size: 140% }
+    h2 tt.computeroutput { font-size: 140% }
+    h3 tt.computeroutput { font-size: 130% }
+    h4 tt.computeroutput { font-size: 130% }
+    h5 tt.computeroutput { font-size: 130% }
+    h6 tt.computeroutput { font-size: 130% }
+
+
+/*=============================================================================
+Author
+=============================================================================*/
+
+    h3.author
+    {
+        font-size: 100%
+    }
+
+/*=============================================================================
+Lists
+=============================================================================*/
+
+    li
+    {
+        font-size: 10pt;
+        line-height: 1.3;
+    }
+
+    /* Unordered lists */
+    ul
+    {
+        text-align: left;
+    }
+
+    /* Ordered lists */
+    ol
+    {
+        text-align: left;
+    }
+
+/*=============================================================================
+Links
+=============================================================================*/
+
+    a
+    {
+        text-decoration: none; /* no underline */
+    }
+
+    a:hover
+    {
+        text-decoration: underline;
+    }
+
+/*=============================================================================
+Spirit style navigation
+=============================================================================*/
+
+    .spirit-nav
+    {
+        text-align: right;
+    }
+
+    .spirit-nav a
+    {
+        color: white;
+        padding-left: 0.5em;
+    }
+
+    .spirit-nav img
+    {
+        border-width: 0px;
+    }
+
+/*=============================================================================
+Copyright footer
+=============================================================================*/
+    .copyright-footer
+    {
+        text-align: right;
+        font-size: 70%;
+    }
+
+    .copyright-footer p
+    {
+        text-align: right;
+        font-size: 80%;
+    }
+
+/*=============================================================================
+Table of contents
+=============================================================================*/
+
+    div.toc
+    {
+       margin: 1pc 4% 0pc 4%;
+       padding: 0.1pc 1pc 0.1pc 1pc;
+       font-size: 80%;
+       line-height: 1.15;
+    }
+
+    .boost-toc
+    {
+       float: right;
+       padding: 0.5pc;
+    }
+
+    /* Code on toc */
+    .toc .computeroutput { font-size: 120% }
+
+    /* No margin on nested menus */
+
+    .toc dl dl { margin: 0; }
+
+/*=============================================================================
+Tables
+=============================================================================*/
+
+    .table-title,
+    div.table p.title
+    {
+        margin-left: 4%;
+        padding-right: 0.5em;
+        padding-left: 0.5em;
+    }
+
+    .informaltable table,
+    .table table
+    {
+        width: 92%;
+        margin-left: 4%;
+        margin-right: 4%;
+    }
+
+    div.informaltable table,
+    div.table table
+    {
+        padding: 4px;
+    }
+
+    /* Table Cells */
+    div.informaltable table tr td,
+    div.table table tr td
+    {
+        padding: 0.5em;
+        text-align: left;
+        font-size: 9pt;
+    }
+
+    div.informaltable table tr th,
+    div.table table tr th
+    {
+        padding: 0.5em 0.5em 0.5em 0.5em;
+        border: 1pt solid white;
+        font-size: 80%;
+    }
+
+    table.simplelist
+    {
+        width: auto !important;
+        margin: 0em !important;
+        padding: 0em !important;
+        border: none !important;
+    }
+    table.simplelist td
+    {
+        margin: 0em !important;
+        padding: 0em !important;
+        text-align: left !important;
+        font-size: 9pt !important;
+        border: none !important;
+    }
+
+/*=============================================================================
+Suppress margins in tables
+=============================================================================*/
+
+    table th > *:first-child,
+    table td > *:first-child
+    {
+        margin-top: 0;
+    }
+
+    table th > *:last-child,
+    table td > *:last-child
+    {
+        margin-bottom: 0;
+    }
+
+/*=============================================================================
+Blurbs
+=============================================================================*/
+
+    div.note,
+    div.tip,
+    div.important,
+    div.caution,
+    div.warning,
+    p.blurb
+    {
+        font-size: 9pt; /* A little bit smaller than the main text */
+        line-height: 1.2;
+        display: block;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+    }
+
+    p.blurb img
+    {
+        padding: 1pt;
+    }
+
+/*=============================================================================
+Variable Lists
+=============================================================================*/
+
+    div.variablelist
+    {
+        margin: 1em 0;
+    }
+
+    /* Make the terms in definition lists bold */
+    div.variablelist dl dt,
+    span.term
+    {
+        font-weight: bold;
+        font-size: 10pt;
+    }
+
+    div.variablelist table tbody tr td
+    {
+        text-align: left;
+        vertical-align: top;
+        padding: 0em 2em 0em 0em;
+        font-size: 10pt;
+        margin: 0em 0em 0.5em 0em;
+        line-height: 1;
+    }
+
+    div.variablelist dl dt
+    {
+        margin-bottom: 0.2em;
+    }
+
+    div.variablelist dl dd
+    {
+        margin: 0em 0em 0.5em 2em;
+        font-size: 10pt;
+    }
+
+    div.variablelist table tbody tr td p,
+    div.variablelist dl dd p
+    {
+        margin: 0em 0em 0.5em 0em;
+        line-height: 1;
+    }
+
+/*=============================================================================
+Misc
+=============================================================================*/
+
+    /* Title of books and articles in bibliographies */
+    span.title
+    {
+        font-style: italic;
+    }
+
+    span.underline
+    {
+        text-decoration: underline;
+    }
+
+    span.strikethrough
+    {
+        text-decoration: line-through;
+    }
+
+    /* Copyright, Legal Notice */
+    div div.legalnotice p
+    {
+        text-align: left
+    }
+
+/*=============================================================================
+Colors
+=============================================================================*/
+
+    @media screen
+    {
+        body {
+            background-color: #FFFFFF;
+            color: #000000;
+        }
+
+    /* Syntax Highlighting */
+        .keyword { color: #0000AA; }
+        .identifier { color: #000000; }
+        .special { color: #707070; }
+        .preprocessor { color: #402080; }
+        .char { color: teal; }
+        .comment { color: #800000; }
+        .string { color: teal; }
+        .number { color: teal; }
+        .white_bkd { background-color: #FFFFFF; }
+        .dk_grey_bkd { background-color: #999999; }
+
+    /* Links */
+        a, a .keyword, a .identifier, a .special, a .preprocessor
+        a .char, a .comment, a .string, a .number
+        {
+            color: #005a9c;
+        }
+
+        a:visited, a:visited .keyword, a:visited .identifier,
+        a:visited .special, a:visited .preprocessor a:visited .char,
+        a:visited .comment, a:visited .string, a:visited .number
+        {
+            color: #9c5a9c;
+        }
+
+        h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
+        h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
+        h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
+        {
+            text-decoration: none; /* no underline */
+            color: #000000;
+        }
+
+    /* Copyright, Legal Notice */
+        .copyright
+        {
+            color: #666666;
+            font-size: small;
+        }
+
+        div div.legalnotice p
+        {
+            color: #666666;
+        }
+
+    /* Program listing */
+        pre.synopsis
+        {
+            border: 1px solid #DCDCDC;
+        }
+
+        .programlisting,
+        .screen
+        {
+            border: 1px solid #DCDCDC;
+        }
+
+        td .programlisting,
+        td .screen
+        {
+            border: 0px solid #DCDCDC;
+        }
+
+    /* Blurbs */
+        div.note,
+        div.tip,
+        div.important,
+        div.caution,
+        div.warning,
+        p.blurb
+        {
+            border: 1px solid #DCDCDC;
+        }
+
+    /* Table of contents */
+        div.toc
+        {
+            border: 1px solid #DCDCDC;
+        }
+
+    /* Tables */
+        div.informaltable table tr td,
+        div.table table tr td
+        {
+            border: 1px solid #DCDCDC;
+        }
+
+        div.informaltable table tr th,
+        div.table table tr th
+        {
+            background-color: #F0F0F0;
+            border: 1px solid #DCDCDC;
+        }
+
+        .copyright-footer
+        {
+            color: #8F8F8F;
+        }
+
+    /* Misc */
+        span.highlight
+        {
+            color: #00A000;
+        }
+    }
+
+    @media print
+    {
+    /* Links */
+        a
+        {
+            color: black;
+        }
+
+        a:visited
+        {
+            color: black;
+        }
+
+        .spirit-nav
+        {
+            display: none;
+        }
+
+    /* Program listing */
+        pre.synopsis
+        {
+            border: 1px solid gray;
+        }
+
+        .programlisting,
+        .screen
+        {
+            border: 1px solid gray;
+        }
+
+        td .programlisting,
+        td .screen
+        {
+            border: 0px solid #DCDCDC;
+        }
+
+    /* Table of contents */
+        div.toc
+        {
+            border: 1px solid gray;
+        }
+
+        .informaltable table,
+        .table table
+        {
+            border: 1px solid gray;
+            border-collapse: collapse;
+        }
+
+    /* Tables */
+        div.informaltable table tr td,
+        div.table table tr td
+        {
+            border: 1px solid gray;
+        }
+
+        div.informaltable table tr th,
+        div.table table tr th
+        {
+            border: 1px solid gray;
+        }
+
+        table.simplelist tr td
+        {
+            border: none !important;
+        }
+
+    /* Misc */
+        span.highlight
+        {
+            font-weight: bold;
+        }
+    }
+
+/*=============================================================================
+Images
+=============================================================================*/
+
+    span.inlinemediaobject img
+    {
+        vertical-align: middle;
+    }
+
+/*==============================================================================
+Super and Subscript: style so that line spacing isn't effected, see
+http://www.adobe.com/cfusion/communityengine/index.cfm?event=showdetails&productId=1&postId=5341
+==============================================================================*/
+
+sup,
+sub {
+height: 0;
+line-height: 1;
+vertical-align: baseline;
+position: relative;
+
+}
+
+/* For internet explorer: */
+
+* html sup,
+* html sub {
+vertical-align: bottom;
+}
+
+sup {
+bottom: 1ex;
+}
+
+sub {
+top: .5ex;
+}
+
+/*==============================================================================
+Indexes: pretty much the same as the TOC.
+==============================================================================*/
+
+    .index
+    {
+       font-size: 80%;
+       padding-top: 0px;
+       padding-bottom: 0px;
+       margin-top: 0px;
+       margin-bottom: 0px;
+       margin-left: 0px;
+    }
+
+    .index ul
+    {
+       padding-left: 3em;
+    }
+
+    .index p
+    {
+       padding: 2px;
+       margin: 2px;
+    }
+
+    .index-entry-level-0
+    {
+        font-weight: bold;
+    }
+
+    .index em
+    {
+        font-weight: bold;
+    }
+
+
+/*==============================================================================
+Alignment and coloring use 'role' feature, available from Quickbook 1.6 up.
+Added from Niall Douglas for role color and alignment.
+http://article.gmane.org/gmane.comp.lib.boost.devel/243318
+*/
+
+/* Add text alignment (see http://www.w3schools.com/cssref/pr_text_text-align.asp) */
+span.aligncenter
+{
+  display: inline-block; width: 100%; text-align: center;
+}
+span.alignright
+{
+  display: inline-block; width: 100%; text-align: right;
+}
+/* alignleft is the default. */
+span.alignleft
+{
+  display: inline-block; width: 100%; text-align: left;
+}
+
+/* alignjustify stretches the word spacing so that each line has equal width
+within a chosen fraction of page width (here arbitrarily 20%).
+*Not* useful inside table items as the column width remains the total string width.
+Nor very useful, except to temporarily restrict the width.
+*/
+span.alignjustify
+{
+  display: inline-block; width: 20%; text-align: justify;
+}
+
+/* Text colors.
+Names at http://www.w3.org/TR/2002/WD-css3-color-20020219/ 4.3. X11 color keywords.
+Quickbook Usage: [role red Some red text]
+
+*/
+span.red { inline-block; color: red; }
+span.green { color: green; }
+span.lime { color: #00FF00; }
+span.blue { color: blue; }
+span.navy { color: navy; }
+span.yellow { color: yellow; }
+span.magenta { color: magenta; }
+span.indigo { color: #4B0082; }
+span.cyan { color: cyan; }
+span.purple { color: purple; }
+span.gold { color: gold; }
+span.silver { color: silver; } /* lighter gray */
+span.gray { color: #808080; } /* light gray */

doc/html/docutils.css

@@ -0,0 +1,275 @@
+/*
+:Author: David Goodger
+:Contact: goodger@python.org
+:Date: $Date$
+:Revision: $Revision$
+:Copyright: This stylesheet has been placed in the public domain.
+
+Default cascading style sheet for the HTML output of Docutils.
+
+See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to
+customize this style sheet.
+*/
+
+/* used to remove borders from tables and images */
+.borderless, table.borderless td, table.borderless th {
+  border: 0 }
+
+table.borderless td, table.borderless th {
+  /* Override padding for "table.docutils td" with "! important".
+     The right padding separates the table cells. */
+  padding: 0 0.5em 0 0 ! important }
+
+.first {
+  /* Override more specific margin styles with "! important". */
+  margin-top: 0 ! important }
+
+.last, .with-subtitle {
+  margin-bottom: 0 ! important }
+
+.hidden {
+  display: none }
+
+a.toc-backref {
+  text-decoration: none ;
+  color: black }
+
+blockquote.epigraph {
+  margin: 2em 5em ; }
+
+dl.docutils dd {
+  margin-bottom: 0.5em }
+
+/* Uncomment (and remove this text!) to get bold-faced definition list terms
+dl.docutils dt {
+  font-weight: bold }
+*/
+
+div.abstract {
+  margin: 2em 5em }
+
+div.abstract p.topic-title {
+  font-weight: bold ;
+  text-align: center }
+
+div.admonition, div.attention, div.caution, div.danger, div.error,
+div.hint, div.important, div.note, div.tip, div.warning {
+  margin: 2em ;
+  border: medium outset ;
+  padding: 1em }
+
+div.admonition p.admonition-title, div.hint p.admonition-title,
+div.important p.admonition-title, div.note p.admonition-title,
+div.tip p.admonition-title {
+  font-weight: bold ;
+  font-family: sans-serif }
+
+div.attention p.admonition-title, div.caution p.admonition-title,
+div.danger p.admonition-title, div.error p.admonition-title,
+div.warning p.admonition-title {
+  color: red ;
+  font-weight: bold ;
+  font-family: sans-serif }
+
+/* Uncomment (and remove this text!) to get reduced vertical space in
+   compound paragraphs.
+div.compound .compound-first, div.compound .compound-middle {
+  margin-bottom: 0.5em }
+
+div.compound .compound-last, div.compound .compound-middle {
+  margin-top: 0.5em }
+*/
+
+div.dedication {
+  margin: 2em 5em ;
+  text-align: center ;
+  font-style: italic }
+
+div.dedication p.topic-title {
+  font-weight: bold ;
+  font-style: normal }
+
+div.figure {
+  margin-left: 2em ;
+  margin-right: 2em }
+
+div.footer, div.header {
+  clear: both;
+  font-size: smaller }
+
+div.line-block {
+  display: block ;
+  margin-top: 1em ;
+  margin-bottom: 1em }
+
+div.line-block div.line-block {
+  margin-top: 0 ;
+  margin-bottom: 0 ;
+  margin-left: 1.5em }
+
+div.sidebar {
+  margin-left: 1em ;
+  border: medium outset ;
+  padding: 1em ;
+  background-color: #ffffee ;
+  width: 40% ;
+  float: right ;
+  clear: right }
+
+div.sidebar p.rubric {
+  font-family: sans-serif ;
+  font-size: medium }
+
+div.system-messages {
+  margin: 5em }
+
+div.system-messages h1 {
+  color: red }
+
+div.system-message {
+  border: medium outset ;
+  padding: 1em }
+
+div.system-message p.system-message-title {
+  color: red ;
+  font-weight: bold }
+
+div.topic {
+  margin: 2em }
+
+h1.section-subtitle, h2.section-subtitle, h3.section-subtitle,
+h4.section-subtitle, h5.section-subtitle, h6.section-subtitle {
+  margin-top: 0.4em }
+
+h1.title {
+  text-align: center }
+
+h2.subtitle {
+  text-align: center }
+
+hr.docutils {
+  width: 75% }
+
+img.align-left {
+  clear: left }
+
+img.align-right {
+  clear: right }
+
+ol.simple, ul.simple {
+  margin-bottom: 1em }
+
+ol.arabic {
+  list-style: decimal }
+
+ol.loweralpha {
+  list-style: lower-alpha }
+
+ol.upperalpha {
+  list-style: upper-alpha }
+
+ol.lowerroman {
+  list-style: lower-roman }
+
+ol.upperroman {
+  list-style: upper-roman }
+
+p.attribution {
+  text-align: right ;
+  margin-left: 50% }
+
+p.caption {
+  font-style: italic }
+
+p.credits {
+  font-style: italic ;
+  font-size: smaller }
+
+p.label {
+  white-space: nowrap }
+
+p.rubric {
+  font-weight: bold ;
+  font-size: larger ;
+  color: maroon ;
+  text-align: center }
+
+p.sidebar-title {
+  font-family: sans-serif ;
+  font-weight: bold ;
+  font-size: larger }
+
+p.sidebar-subtitle {
+  font-family: sans-serif ;
+  font-weight: bold }
+
+p.topic-title {
+  font-weight: bold }
+
+pre.address {
+  margin-bottom: 0 ;
+  margin-top: 0 ;
+  font-family: serif ;
+  font-size: 100% }
+
+pre.literal-block, pre.doctest-block {
+  margin-left: 2em ;
+  margin-right: 2em }
+
+span.classifier {
+  font-family: sans-serif ;
+  font-style: oblique }
+
+span.classifier-delimiter {
+  font-family: sans-serif ;
+  font-weight: bold }
+
+span.interpreted {
+  font-family: sans-serif }
+
+span.option {
+  white-space: nowrap }
+
+span.pre {
+  white-space: pre }
+
+span.problematic {
+  color: red }
+
+span.section-subtitle {
+  /* font-size relative to parent (h1..h6 element) */
+  font-size: 80% }
+
+table.citation {
+  border-left: solid 1px gray;
+  margin-left: 1px }
+
+table.docinfo {
+  margin: 2em 4em }
+
+table.docutils {
+  margin-top: 0.5em ;
+  margin-bottom: 0.5em }
+
+table.footnote {
+  border-left: solid 1px black;
+  margin-left: 1px }
+
+table.docutils td, table.docutils th,
+table.docinfo td, table.docinfo th {
+  padding-left: 0.5em ;
+  padding-right: 0.5em ;
+  vertical-align: top }
+
+table.docutils th.field-name, table.docinfo th.docinfo-name {
+  font-weight: bold ;
+  text-align: left ;
+  white-space: nowrap ;
+  padding-left: 0 }
+
+h1 tt.docutils, h2 tt.docutils, h3 tt.docutils,
+h4 tt.docutils, h5 tt.docutils, h6 tt.docutils {
+  font-size: 100% }
+
+ul.auto-toc {
+  list-style-type: none }

doc/html/index.html

@@ -0,0 +1,56 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Detail 1.0</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="Detail 1.0">
+</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"></div>
+<div class="article">
+<div class="titlepage">
+<div>
+<div><h2 class="title">
+<a name="detail"></a>Detail 1.0</h2></div>
+<div><p class="copyright">Copyright &#169; 2016 Rene Rivera</p></div>
+<div><div class="legalnotice">
+<a name="detail.legal"></a><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></div>
+</div>
+<hr>
+</div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<dl class="toc"><dt><span class="section"><a href="index.html#detail.introduction">Introduction</a></span></dt></dl>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="detail.introduction"></a><a class="link" href="index.html#detail.introduction" title="Introduction">Introduction</a>
+</h2></div></div></div>
+<p>
+      This library contains a set of header only utilities used internally by Boost
+      C++ Libraries to facilitate their implementation.
+    </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"><p><small>Last revised: June 21, 2016 at 03:48:00 GMT</small></p></td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"></div>
+</body>
+</html>

doc/html/minimal.css

@@ -0,0 +1,23 @@
+/*
+
+  <20> Copyright Beman Dawes, 2007
+
+  Distributed under the Boost Software License, Version 1.0.
+  See www.boost.org/LICENSE_1_0.txt
+  
+*/
+
+body  {
+        font-family: sans-serif;
+        margin: 1em;
+        max-width : 8.5in;
+      }
+
+table { margin: 0.5em; }
+
+pre   { background-color:#D7EEFF }
+
+ins   { background-color:#A0FFA0 }
+del   { background-color:#FFA0A0 }
+
+/*** end ***/

doc/html/reference.css

@@ -0,0 +1,11 @@
+/*============================================================================
+    Copyright 2003-2004 Douglas Gregor
+    Distributed under the Boost Software License, Version 1.0. (See accompany-
+    ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+============================================================================*/
+
+PRE.synopsis { 
+  background-color: #e0ffff;
+  border: thin solid blue;
+  padding: 1em
+}

include/boost/blank.hpp

@@ -20,7 +20,7 @@
 #include "boost/detail/templated_streams.hpp"
 #endif // BOOST_NO_IOSTREAM
 
-#include "boost/mpl/bool.hpp"
+#include "boost/type_traits/integral_constant.hpp"
 #include "boost/type_traits/is_empty.hpp"
 #include "boost/type_traits/is_pod.hpp"
 #include "boost/type_traits/is_stateless.hpp"
@@ -36,19 +36,19 @@ struct blank
 
 template <>
 struct is_pod< blank >
-    : mpl::true_
+    : boost::true_type
 {
 };
 
 template <>
 struct is_empty< blank >
-    : mpl::true_
+    : boost::true_type
 {
 };
 
 template <>
 struct is_stateless< blank >
-    : mpl::true_
+    : boost::true_type
 {
 };
 

include/boost/detail/allocator_utilities.hpp

@@ -11,7 +11,7 @@
 
 #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
 #include <boost/detail/workaround.hpp>
-#include <boost/mpl/eval_if.hpp>
+#include <boost/detail/select_type.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <cstddef>
 #include <memory>
@@ -44,7 +44,7 @@ public:
 
   typedef Type value_type;
 
-  partial_std_allocator_wrapper(){};
+  partial_std_allocator_wrapper(){}
 
   template<typename Other>
   partial_std_allocator_wrapper(const partial_std_allocator_wrapper<Other>&){}
@@ -52,7 +52,7 @@ public:
   partial_std_allocator_wrapper(const std::allocator<Type>& x):
     std::allocator<Type>(x)
   {
-  };
+  }
 
 #if defined(BOOST_DINKUMWARE_STDLIB)
   /* Dinkumware guys didn't provide a means to call allocate() without
@@ -121,8 +121,13 @@ struct rebinder
   template<typename Type>
   struct result
   {
-      typedef typename Allocator::BOOST_NESTED_TEMPLATE 
+#ifdef BOOST_NO_CXX11_ALLOCATOR
+      typedef typename Allocator::BOOST_NESTED_TEMPLATE
           rebind<Type>::other other;
+#else
+      typedef typename std::allocator_traits<Allocator>::BOOST_NESTED_TEMPLATE
+          rebind_alloc<Type> other;
+#endif
   };
 };
 
@@ -137,11 +142,12 @@ struct compliant_allocator_rebind_to
 
 template<typename Allocator,typename Type>
 struct rebind_to:
-  mpl::eval_if_c<
-    is_partial_std_allocator<Allocator>::value,
+  boost::detail::if_true<
+    is_partial_std_allocator<Allocator>::value
+  >::template then<
     partial_std_allocator_rebind_to<Allocator,Type>,
     compliant_allocator_rebind_to<Allocator,Type>
-  >
+  >::type
 {
 };
 
@@ -159,7 +165,7 @@ void construct(void* p,const Type& t)
  */
 
 #pragma warning(push)
-#pragma warning(disable:4100)  
+#pragma warning(disable:4100)
 #endif
 
 template<typename Type>

include/boost/detail/bitmask.hpp

@@ -6,42 +6,53 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 
 //  Usage:  enum foo { a=1, b=2, c=4 };
-//          BOOST_BITMASK( foo );
+//          BOOST_BITMASK( foo )
 //
 //          void f( foo arg );
 //          ...
 //          f( a | c );
+//
+//  See [bitmask.types] in the C++ standard for the formal specification
 
 #ifndef BOOST_BITMASK_HPP
 #define BOOST_BITMASK_HPP
 
+#include <boost/config.hpp>
 #include <boost/cstdint.hpp>
 
 #define BOOST_BITMASK(Bitmask)                                            \
                                                                           \
-  inline Bitmask operator| (Bitmask x , Bitmask y )                       \
+  inline BOOST_CONSTEXPR Bitmask operator| (Bitmask x , Bitmask y )       \
   { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x)     \
       | static_cast<boost::int_least32_t>(y)); }                          \
                                                                           \
-  inline Bitmask operator& (Bitmask x , Bitmask y )                       \
+  inline BOOST_CONSTEXPR Bitmask operator& (Bitmask x , Bitmask y )       \
   { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x)     \
       & static_cast<boost::int_least32_t>(y)); }                          \
                                                                           \
-  inline Bitmask operator^ (Bitmask x , Bitmask y )                       \
+  inline BOOST_CONSTEXPR Bitmask operator^ (Bitmask x , Bitmask y )       \
   { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x)     \
       ^ static_cast<boost::int_least32_t>(y)); }                          \
                                                                           \
-  inline Bitmask operator~ (Bitmask x )                                   \
+  inline BOOST_CONSTEXPR Bitmask operator~ (Bitmask x )                   \
   { return static_cast<Bitmask>(~static_cast<boost::int_least32_t>(x)); } \
                                                                           \
-  inline Bitmask & operator&=(Bitmask & x , Bitmask y)                    \
+  inline Bitmask & operator&=(Bitmask& x , Bitmask y)                     \
   { x = x & y ; return x ; }                                              \
                                                                           \
-  inline Bitmask & operator|=(Bitmask & x , Bitmask y)                    \
+  inline Bitmask & operator|=(Bitmask& x , Bitmask y)                     \
   { x = x | y ; return x ; }                                              \
                                                                           \
-  inline Bitmask & operator^=(Bitmask & x , Bitmask y)                    \
-  { x = x ^ y ; return x ; }                                              
+  inline Bitmask & operator^=(Bitmask& x , Bitmask y)                     \
+  { x = x ^ y ; return x ; }                                              \
+                                                                          \
+  /* Boost extensions to [bitmask.types] */                               \
+                                                                          \
+  inline BOOST_CONSTEXPR bool operator!(Bitmask x)                        \
+  { return !static_cast<int>(x); }                                        \
+                                                                          \
+  inline BOOST_CONSTEXPR bool bitmask_set(Bitmask x)                      \
+  { return !!x; }
 
 #endif // BOOST_BITMASK_HPP
 

include/boost/detail/indirect_traits.hpp

@@ -4,6 +4,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 #ifndef INDIRECT_TRAITS_DWA2002131_HPP
 # define INDIRECT_TRAITS_DWA2002131_HPP
+# include <boost/type_traits/integral_constant.hpp>
 # include <boost/type_traits/is_function.hpp>
 # include <boost/type_traits/is_reference.hpp>
 # include <boost/type_traits/is_pointer.hpp>
@@ -17,13 +18,7 @@
 # include <boost/type_traits/remove_pointer.hpp>
 
 # include <boost/detail/workaround.hpp>
-
-# include <boost/mpl/eval_if.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/mpl/and.hpp>
-# include <boost/mpl/not.hpp>
-# include <boost/mpl/aux_/lambda_support.hpp>
+# include <boost/detail/select_type.hpp>
 
 
 namespace boost { namespace detail {
@@ -31,24 +26,24 @@ namespace boost { namespace detail {
 namespace indirect_traits {
 
 template <class T>
-struct is_reference_to_const : mpl::false_
+struct is_reference_to_const : boost::false_type
 {
 };
 
 template <class T>
-struct is_reference_to_const<T const&> : mpl::true_
+struct is_reference_to_const<T const&> : boost::true_type
 {
 };
 
 #   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
 template<class T>
-struct is_reference_to_const<T const volatile&> : mpl::true_
+struct is_reference_to_const<T const volatile&> : boost::true_type
 {
 };
-#   endif 
+#   endif
 
 template <class T>
-struct is_reference_to_function : mpl::false_
+struct is_reference_to_function : boost::false_type
 {
 };
 
@@ -58,7 +53,7 @@ struct is_reference_to_function<T&> : is_function<T>
 };
 
 template <class T>
-struct is_pointer_to_function : mpl::false_
+struct is_pointer_to_function : boost::false_type
 {
 };
 
@@ -70,7 +65,7 @@ struct is_pointer_to_function<T*> : is_function<T>
 };
 
 template <class T>
-struct is_reference_to_member_function_pointer_impl : mpl::false_
+struct is_reference_to_member_function_pointer_impl : boost::false_type
 {
 };
 
@@ -85,18 +80,17 @@ template <class T>
 struct is_reference_to_member_function_pointer
     : is_reference_to_member_function_pointer_impl<T>
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
 };
 
 template <class T>
 struct is_reference_to_function_pointer_aux
-    : mpl::and_<
-          is_reference<T>
-        , is_pointer_to_function<
+    : boost::integral_constant<bool,
+          is_reference<T>::value &&
+          is_pointer_to_function<
               typename remove_cv<
                   typename remove_reference<T>::type
               >::type
-          >
+          >::value
       >
 {
     // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those
@@ -104,94 +98,91 @@ struct is_reference_to_function_pointer_aux
 
 template <class T>
 struct is_reference_to_function_pointer
-    : mpl::if_<
-          is_reference_to_function<T>
-        , mpl::false_
+    : boost::detail::if_true<
+          is_reference_to_function<T>::value
+      >::template then<
+          boost::false_type
         , is_reference_to_function_pointer_aux<T>
-     >::type
+      >::type
 {
 };
 
 template <class T>
 struct is_reference_to_non_const
-    : mpl::and_<
-          is_reference<T>
-        , mpl::not_<
-             is_reference_to_const<T>
-          >
+    : boost::integral_constant<bool,
+          is_reference<T>::value &&
+          !is_reference_to_const<T>::value
       >
 {
 };
 
 template <class T>
-struct is_reference_to_volatile : mpl::false_
+struct is_reference_to_volatile : boost::false_type
 {
 };
 
 template <class T>
-struct is_reference_to_volatile<T volatile&> : mpl::true_
+struct is_reference_to_volatile<T volatile&> : boost::true_type
 {
 };
 
 #   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
 template <class T>
-struct is_reference_to_volatile<T const volatile&> : mpl::true_
+struct is_reference_to_volatile<T const volatile&> : boost::true_type
 {
 };
-#   endif 
+#   endif
 
 
 template <class T>
-struct is_reference_to_pointer : mpl::false_
+struct is_reference_to_pointer : boost::false_type
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T*&> : mpl::true_
+struct is_reference_to_pointer<T*&> : boost::true_type
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T* const&> : mpl::true_
+struct is_reference_to_pointer<T* const&> : boost::true_type
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T* volatile&> : mpl::true_
+struct is_reference_to_pointer<T* volatile&> : boost::true_type
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T* const volatile&> : mpl::true_
+struct is_reference_to_pointer<T* const volatile&> : boost::true_type
 {
 };
 
 template <class T>
 struct is_reference_to_class
-    : mpl::and_<
-          is_reference<T>
-        , is_class<
+    : boost::integral_constant<bool,
+          is_reference<T>::value &&
+          is_class<
               typename remove_cv<
                   typename remove_reference<T>::type
               >::type
-          >
+          >::value
       >
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
 };
 
 template <class T>
 struct is_pointer_to_class
-    : mpl::and_<
-          is_pointer<T>
-        , is_class<
+    : boost::integral_constant<bool,
+          is_pointer<T>::value &&
+          is_class<
               typename remove_cv<
                   typename remove_pointer<T>::type
               >::type
-          >
+          >::value
       >
 {
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T))
 };
 
 

include/boost/detail/is_incrementable.hpp

@@ -4,16 +4,11 @@
 #ifndef IS_INCREMENTABLE_DWA200415_HPP
 # define IS_INCREMENTABLE_DWA200415_HPP
 
-# include <boost/type_traits/detail/template_arity_spec.hpp>
+# include <boost/type_traits/integral_constant.hpp>
 # include <boost/type_traits/remove_cv.hpp>
-# include <boost/mpl/aux_/lambda_support.hpp>
-# include <boost/mpl/bool.hpp>
 # include <boost/detail/workaround.hpp>
 
-// Must be the last include
-# include <boost/type_traits/detail/bool_trait_def.hpp>
-
-namespace boost { namespace detail { 
+namespace boost { namespace detail {
 
 // is_incrementable<T> metafunction
 //
@@ -27,7 +22,7 @@ namespace is_incrementable_
   // a type returned from operator++ when no increment is found in the
   // type's own namespace
   struct tag {};
-  
+
   // any soaks up implicit conversions and makes the following
   // operator++ less-preferred than any other such operator that
   // might be found via ADL.
@@ -35,7 +30,7 @@ namespace is_incrementable_
 
   // This is a last-resort operator++ for when none other is found
 # if BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
-  
+
 }
 
 namespace is_incrementable_2
@@ -47,33 +42,33 @@ using namespace is_incrementable_2;
 
 namespace is_incrementable_
 {
-  
+
 # else
-  
+
   tag operator++(any const&);
   tag operator++(any const&,int);
-  
-# endif 
+
+# endif
 
 # if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) 
 #  define BOOST_comma(a,b) (a)
-# else 
+# else
   // In case an operator++ is found that returns void, we'll use ++x,0
-  tag operator,(tag,int);  
+  tag operator,(tag,int);
 #  define BOOST_comma(a,b) (a,b)
-# endif 
+# endif
 
 # if defined(BOOST_MSVC)
 #  pragma warning(push)
 #  pragma warning(disable:4913) // Warning about operator,
-# endif 
+# endif
 
   // two check overloads help us identify which operator++ was picked
   char (& check_(tag) )[2];
-  
+
   template <class T>
   char check_(T const&);
-  
+
 
   template <class T>
   struct impl
@@ -99,33 +94,26 @@ namespace is_incrementable_
 
 # if defined(BOOST_MSVC)
 #  pragma warning(pop)
-# endif 
+# endif
 
 }
 
 # undef BOOST_comma
 
-template<typename T> 
-struct is_incrementable 
-BOOST_TT_AUX_BOOL_C_BASE(::boost::detail::is_incrementable_::impl<T>::value)
-{ 
-    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::boost::detail::is_incrementable_::impl<T>::value)
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_incrementable,(T))
+template<typename T>
+struct is_incrementable :
+    public boost::integral_constant<bool, boost::detail::is_incrementable_::impl<T>::value>
+{
 };
 
-template<typename T> 
-struct is_postfix_incrementable 
-BOOST_TT_AUX_BOOL_C_BASE(::boost::detail::is_incrementable_::postfix_impl<T>::value)
-{ 
-    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(::boost::detail::is_incrementable_::postfix_impl<T>::value)
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_postfix_incrementable,(T))
+template<typename T>
+struct is_postfix_incrementable :
+    public boost::integral_constant<bool, boost::detail::is_incrementable_::postfix_impl<T>::value>
+{
 };
 
 } // namespace detail
 
-BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::boost::detail::is_incrementable)
-BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::boost::detail::is_postfix_incrementable)
-
 } // namespace boost
 
 # include <boost/type_traits/detail/bool_trait_undef.hpp>

include/boost/detail/is_xxx.hpp

@@ -5,13 +5,13 @@
 # define BOOST_DETAIL_IS_XXX_DWA20051011_HPP
 
 # include <boost/config.hpp>
-# include <boost/mpl/bool.hpp>
+# include <boost/type_traits/integral_constant.hpp>
 # include <boost/preprocessor/enum_params.hpp>
 
 
 #  define BOOST_DETAIL_IS_XXX_DEF(name, qualified_name, nargs)  \
 template <class T>                                              \
-struct is_##name : mpl::false_                                  \
+struct is_##name : boost::false_type                            \
 {                                                               \
 };                                                              \
                                                                 \
@@ -19,7 +19,7 @@ template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class T) >          \
 struct is_##name<                                               \
    qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, T) >        \
 >                                                               \
-   : mpl::true_                                                 \
+   : boost::true_type                                           \
 {                                                               \
 };
 

include/boost/detail/numeric_traits.hpp

@@ -56,65 +56,39 @@
 // 21 Jan 2001 - Created (David Abrahams)
 
 #ifndef BOOST_NUMERIC_TRAITS_HPP_DWA20001901
-# define BOOST_NUMERIC_TRAITS_HPP_DWA20001901
+#define BOOST_NUMERIC_TRAITS_HPP_DWA20001901
 
-# include <boost/config.hpp>
-# include <boost/cstdint.hpp>
-# include <boost/static_assert.hpp>
-# include <boost/type_traits.hpp>
-# include <boost/detail/select_type.hpp>
-# include <boost/limits.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/limits.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/type_traits/conditional.hpp>
+#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#endif
 
 namespace boost { namespace detail {
 
-  // Template class is_signed -- determine whether a numeric type is signed
-  // Requires that T is constructable from the literals -1 and 0.  Compile-time
-  // error results if that requirement is not met (and thus signedness is not
-  // likely to have meaning for that type).
-  template <class Number>
-  struct is_signed
-  {
-#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
-    BOOST_STATIC_CONSTANT(bool, value = (Number(-1) < Number(0)));
-#else
-    BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<Number>::is_signed);
-#endif
-  };
-
-# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
   // digit_traits - compute the number of digits in a built-in integer
   // type. Needed for implementations on which numeric_limits is not specialized
-  // for intmax_t (e.g. VC6).
-  template <bool is_specialized> struct digit_traits_select;
-
-  // numeric_limits is specialized; just select that version of digits
-  template <> struct digit_traits_select<true>
+  // for some integer types, like __int128 in libstdc++ (gcc).
+  template <class T, bool IsSpecialized = std::numeric_limits<T>::is_specialized>
+  struct digit_traits
   {
-      template <class T> struct traits
-      {
-          BOOST_STATIC_CONSTANT(int, digits = std::numeric_limits<T>::digits);
-      };
+      BOOST_STATIC_CONSTANT(int, digits = std::numeric_limits<T>::digits);
   };
 
   // numeric_limits is not specialized; compute digits from sizeof(T)
-  template <> struct digit_traits_select<false>
+  template <class T>
+  struct digit_traits<T, false>
   {
-      template <class T> struct traits
-      {
-          BOOST_STATIC_CONSTANT(int, digits = (
-              sizeof(T) * std::numeric_limits<unsigned char>::digits
-              - (is_signed<T>::value ? 1 : 0))
-              );
-      };
-  };
-
-  // here's the "usable" template
-  template <class T> struct digit_traits
-  {
-      typedef digit_traits_select<
-                ::std::numeric_limits<T>::is_specialized> selector;
-      typedef typename selector::template traits<T> traits;
-      BOOST_STATIC_CONSTANT(int, digits = traits::digits);
+      BOOST_STATIC_CONSTANT(int, digits = (
+          sizeof(T) * std::numeric_limits<unsigned char>::digits
+          - (boost::is_signed<T>::value ? 1 : 0))
+          );
   };
 #endif
 
@@ -124,44 +98,48 @@ namespace boost { namespace detail {
   template <class Integer>
   struct integer_traits
   {
-# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
    private:
       typedef Integer integer_type;
       typedef std::numeric_limits<integer_type> x;
    public:
-      typedef typename
-      if_true<(int(x::is_signed)
-              && (!int(x::is_bounded)
-                 // digits is the number of no-sign bits
-                  || (int(x::digits) + 1 >= digit_traits<boost::intmax_t>::digits)))>::template then<
+      typedef typename boost::conditional<
+        (int(x::is_signed)
+          && (!int(x::is_bounded)
+             // digits is the number of no-sign bits
+             || (int(x::digits) + 1 >= digit_traits<boost::intmax_t>::digits))),
         Integer,
-          
-      typename if_true<(int(x::digits) + 1 < digit_traits<signed int>::digits)>::template then<
-        signed int,
 
-      typename if_true<(int(x::digits) + 1 < digit_traits<signed long>::digits)>::template then<
-        signed long,
+        typename boost::conditional<
+          (int(x::digits) + 1 < digit_traits<signed int>::digits),
+          signed int,
 
-   // else
-        intmax_t
-      >::type>::type>::type difference_type;
+          typename boost::conditional<
+            (int(x::digits) + 1 < digit_traits<signed long>::digits),
+            signed long,
+            boost::intmax_t
+          >::type
+        >::type
+      >::type difference_type;
 #else
       BOOST_STATIC_ASSERT(boost::is_integral<Integer>::value);
 
-      typedef typename
-      if_true<(sizeof(Integer) >= sizeof(intmax_t))>::template then<
-               
-        typename if_true<(is_signed<Integer>::value)>::template then<
-          Integer,
-          intmax_t
-        >::type,
+      typedef typename boost::conditional<
+        (sizeof(Integer) >= sizeof(intmax_t)),
 
-        typename if_true<(sizeof(Integer) < sizeof(std::ptrdiff_t))>::template then<
+        boost::conditional<
+          (boost::is_signed<Integer>::value),
+          Integer,
+          boost::intmax_t
+        >,
+
+        boost::conditional<
+          (sizeof(Integer) < sizeof(std::ptrdiff_t)),
           std::ptrdiff_t,
-          intmax_t
-        >::type
-      >::type difference_type;
-# endif
+          boost::intmax_t
+        >
+      >::type::type difference_type;
+#endif
   };
 
   // Right now, only supports integers, but should be expanded.
@@ -172,7 +150,7 @@ namespace boost { namespace detail {
   };
 
   template <class Number>
-  typename numeric_traits<Number>::difference_type numeric_distance(Number x, Number y)
+  inline BOOST_CONSTEXPR typename numeric_traits<Number>::difference_type numeric_distance(Number x, Number y)
   {
       typedef typename numeric_traits<Number>::difference_type difference_type;
       return difference_type(y) - difference_type(x);

include/boost/detail/reference_content.hpp

@@ -15,15 +15,15 @@
 
 #include "boost/config.hpp"
 
-#   include "boost/mpl/bool.hpp"
+#   include "boost/type_traits/integral_constant.hpp"
 #   include "boost/type_traits/has_nothrow_copy.hpp"
 
-#include "boost/mpl/void.hpp"
-
 namespace boost {
 
 namespace detail {
 
+struct void_type {};
+
 ///////////////////////////////////////////////////////////////////////////////
 // (detail) class template reference_content
 //
@@ -71,7 +71,7 @@ public: // queries
 // Wraps with reference_content if specified type is reference.
 //
 
-template <typename T = mpl::void_> struct make_reference_content;
+template <typename T = void_type> struct make_reference_content;
 
 
 template <typename T>
@@ -88,7 +88,7 @@ struct make_reference_content< T& >
 
 
 template <>
-struct make_reference_content< mpl::void_ >
+struct make_reference_content< void_type >
 {
     template <typename T>
     struct apply
@@ -96,7 +96,7 @@ struct make_reference_content< mpl::void_ >
     {
     };
 
-    typedef mpl::void_ type;
+    typedef void_type type;
 };
 
 } // namespace detail
@@ -110,7 +110,7 @@ template <typename T>
 struct has_nothrow_copy<
       ::boost::detail::reference_content< T& >
     >
-    : mpl::true_
+    : boost::true_type
 {
 };
 

include/boost/detail/utf8_codecvt_facet.hpp

@@ -105,14 +105,16 @@ BOOST_UTF8_BEGIN_NAMESPACE
 //            See utf8_codecvt_facet.ipp for the implementation.              //
 //----------------------------------------------------------------------------//
 
+#ifndef BOOST_UTF8_DECL
+#define BOOST_UTF8_DECL
+#endif
 
 struct BOOST_UTF8_DECL utf8_codecvt_facet :
     public std::codecvt<wchar_t, char, std::mbstate_t>  
 {
 public:
-    explicit utf8_codecvt_facet(std::size_t no_locale_manage=0)
-        : std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage) 
-    {}
+    explicit utf8_codecvt_facet(std::size_t no_locale_manage=0);
+    virtual ~utf8_codecvt_facet();
 protected:
     virtual std::codecvt_base::result do_in(
         std::mbstate_t& state, 
@@ -177,7 +179,7 @@ protected:
     // How many char objects can I process to get <= max_limit
     // wchar_t objects?
     virtual int do_length(
-        const std::mbstate_t &,
+        std::mbstate_t &,
         const char * from,
         const char * from_end, 
         std::size_t max_limit
@@ -186,8 +188,10 @@ protected:
     throw()
 #endif
     ;
+
+    // Nonstandard override
     virtual int do_length(
-        std::mbstate_t & s,
+        const std::mbstate_t & s,
         const char * from,
         const char * from_end, 
         std::size_t max_limit
@@ -197,12 +201,13 @@ protected:
 #endif
     {
         return do_length(
-            const_cast<const std::mbstate_t &>(s),
+            const_cast<std::mbstate_t &>(s),
             from,
             from_end,
             max_limit
         );
     }
+
     // Largest possible value do_length(state,from,from_end,1) could return.
     virtual int do_max_length() const BOOST_NOEXCEPT_OR_NOTHROW {
         return 6; // largest UTF-8 encoding of a UCS-4 character

include/boost/detail/utf8_codecvt_facet.ipp

@@ -30,6 +30,15 @@ BOOST_UTF8_BEGIN_NAMESPACE
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // implementation for wchar_t
 
+utf8_codecvt_facet::utf8_codecvt_facet(
+    std::size_t no_locale_manage
+) :
+    std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
+{}
+
+utf8_codecvt_facet::~utf8_codecvt_facet()
+{}
+
 // Translate incoming UTF-8 into UCS-4
 std::codecvt_base::result utf8_codecvt_facet::do_in(
     std::mbstate_t& /*state*/, 
@@ -171,7 +180,7 @@ std::codecvt_base::result utf8_codecvt_facet::do_out(
 // How many char objects can I process to get <= max_limit
 // wchar_t objects?
 int utf8_codecvt_facet::do_length(
-    const std::mbstate_t &,
+    std::mbstate_t &,
     const char * from,
     const char * from_end, 
     std::size_t max_limit
@@ -198,11 +207,11 @@ int utf8_codecvt_facet::do_length(
         last_octet_count = (get_octet_count(*from_next));
         ++char_count;
     }
-    return static_cast<int>(from_next-from_end);
+    return static_cast<int>(from_next-from);
 }
 
 unsigned int utf8_codecvt_facet::get_octet_count(
-    unsigned char   lead_octet
+    unsigned char lead_octet
 ){
     // if the 0-bit (MSB) is 0, then 1 character
     if (lead_octet <= 0x7f) return 1;

index.html

@@ -0,0 +1,14 @@
+<!--
+Copyright 2016 Rene Rivera
+Distributed under the Boost Software License, Version 1.0. (See the accompanying
+file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt)
+-->
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=./doc/html/index.html">
+</head>
+<body>
+<p>Automatic redirection failed, please go to
+<a href="./doc/html/index.html">./doc/html/index.html</a>.</p>
+</body>
+</html>

meta/libraries.json

@@ -0,0 +1,27 @@
+{
+    "key": "detail",
+    "name": "Detail",
+    "status": "hidden",
+    "authors": [
+        "David Abrahams",
+        "Beman Dawes",
+        "Eric Friedman",
+        "Ronald Garcia",
+        "Howard Hinnant",
+        "Daniel James",
+        "Bryce Lelbach",
+        "Joaquin M Lopez Munoz",
+        "Jeremy Siek",
+        "Matthias Troyerk"
+    ],
+    "description": "This library contains a set of header only utilities used internally by Boost C++ Libraries to facilitate their implementation.",
+    "category": [
+        "Miscellaneous"
+    ],
+    "maintainers": [
+        "Beman Dawes <bdawes -at- acm.org>",
+        "Robert Ramey <ramey -at- rrsd.com>",
+        "Rene Rivera <grafikrobot -at- gmail.com>",
+        "Andrey Semashev <andrey.semashev -at- gmail.com>"
+    ]
+}

test/Jamfile

@@ -7,17 +7,26 @@
 
 build-project container_fwd ;
 
-project detail/test 
+project detail/test
   : requirements
     <toolset>clang:<cxxflags>-Wno-unused
     <toolset>clang:<cxxflags>-Wno-tautological-compare
     <toolset>clang:<cxxflags>-ftemplate-depth-300
     <toolset>gcc:<cxxflags>-ftemplate-depth-300
+    <toolset>gcc:<define>_STLP_DEBUG
+    <toolset>gcc:<define>_GLIBCXX_DEBUG
     <toolset>darwin:<cxxflags>-ftemplate-depth-300
   ;
 
-for tests in [ glob *.cpp ] {
-  run $(tests) : : : : $(tests:B) ;
-}
-
+# import rules for testing conditional on config file variables
+import ../../config/checks/config : requires ;
 
+run binary_search_test.cpp ;
+run blank_test.cpp ;
+run is_sorted_test.cpp ;
+run numeric_traits_test.cpp ;
+run is_xxx_test.cpp ;
+# run test_utf8_codecvt.cpp : : : [ requires std_wstreambuf ] ;
+run test_utf8_codecvt.cpp ;
+run allocator_utilities_test.cpp ;
+run reference_content_test.cpp ;

test/allocator_utilities_test.cpp

@@ -0,0 +1,40 @@
+
+// Copyright 2018 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/static_assert.hpp>
+#include <cassert>
+
+typedef std::allocator<int> std_int_allocator;
+typedef boost::detail::allocator::rebind_to<std_int_allocator, char>::type char_allocator;
+typedef boost::detail::allocator::rebind_to<char_allocator, int>::type int_allocator;
+typedef boost::detail::allocator::rebind_to<int_allocator, char>::type char_allocator2;
+
+int main() {
+    BOOST_STATIC_ASSERT((!boost::is_same<char_allocator, int_allocator>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<char_allocator, char_allocator2>::value));
+
+    // Check the constructors works okay
+    std_int_allocator a1;
+    char_allocator a2(a1);
+    char_allocator a2a(a2);
+    int_allocator a3(a2);
+
+    // Check allocate works okay
+    {
+        char_allocator::pointer p = a2.allocate(10);
+        assert(p);
+        a2.deallocate(p, 10);
+    }
+
+    // Try using the standalone construct/destroy
+    {
+        int_allocator::pointer p2 = a3.allocate(1);
+        boost::detail::allocator::construct(p2, 25);
+        assert(*p2 == 25);
+        boost::detail::allocator::destroy(p2);
+        a3.deallocate(p2, 1);
+    }
+}

test/binary_search_test.cpp

@@ -196,11 +196,12 @@ void test_loop(Sequence& x, Compare cmp, unsigned long test_count)
         std::size_t index = 0;
         std::size_t count = 0;
         unsigned last_value = 0;
+        (void)last_value;
         for (const_iterator p = start; p != finish; ++p)
         {
             if (p == l)
                 found_l = true;
-            
+
             if (p == u)
             {
                 assert(found_l);
@@ -210,7 +211,7 @@ void test_loop(Sequence& x, Compare cmp, unsigned long test_count)
             unsigned value = to_int(*p);
             assert(value >= last_value);
             last_value = value;
-            
+
             if (!found_l)
             {
                 ++index;
@@ -233,6 +234,7 @@ void test_loop(Sequence& x, Compare cmp, unsigned long test_count)
         assert(range.second == u);
 
         bool found = searches<Compare>::binary_search(start, finish, key, cmp);
+        (void)found;
         assert(found == (u != l));
         std::cout << "found " << count << " copies of " << key << " at index " << index << "\n";
     }
@@ -247,7 +249,7 @@ int main()
     test_loop(x, no_compare(), 25);
     std::cout << "=== testing random-access iterators with compare: ===\n";
     test_loop(x, cmp(), 25);
-    
+
     std::list<mystring> y;
     std::cout << "=== testing bidirectional iterators with <: ===\n";
     test_loop(y, no_compare(), 25);

test/blank_test.cpp

@@ -0,0 +1,32 @@
+
+// Copyright 2018 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/blank.hpp>
+#include <boost/static_assert.hpp>
+#include <cassert>
+
+#if !defined(BOOST_NO_IOSTREAM)
+#include <sstream>
+#endif
+
+int main() {
+    BOOST_STATIC_ASSERT((boost::is_pod<boost::blank>::value));
+    BOOST_STATIC_ASSERT((boost::is_empty<boost::blank>::value));
+    BOOST_STATIC_ASSERT((boost::is_stateless<boost::blank>::value));
+
+    boost::blank b1,b2;
+    assert(b1 == b2);
+    assert(b1 <= b2);
+    assert(b1 >= b2);
+    assert(!(b1 != b2));
+    assert(!(b1 < b2));
+    assert(!(b1 > b2));
+
+#if !defined(BOOST_NO_IOSTREAM)
+    std::stringstream s;
+    s << "(" << b1 << ")";
+    assert(s.str() == "()");
+#endif
+}

test/is_sorted_test.cpp

@@ -5,15 +5,17 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
-#include <ios>
+#include <iostream>
 #include <boost/config.hpp>
 #include <boost/array.hpp>
 #include <boost/detail/is_sorted.hpp>
 #include <boost/detail/lightweight_test.hpp>
 
 template<class T>
-struct tracking_less: std::binary_function <T, T, bool> {
+struct tracking_less {
   typedef bool result_type;
+  typedef T first_argument_type;
+  typedef T second_argument_type;
 
   #if defined(__PATHSCALE__)
   tracking_less (void) { }
@@ -27,8 +29,10 @@ struct tracking_less: std::binary_function <T, T, bool> {
 };
 
 template<class T>
-struct tracking_less_equal: std::binary_function <T, T, bool> {
+struct tracking_less_equal {
   typedef bool result_type;
+  typedef T first_argument_type;
+  typedef T second_argument_type;
 
   #if defined(__PATHSCALE__)
   tracking_less_equal (void) { }
@@ -42,8 +46,10 @@ struct tracking_less_equal: std::binary_function <T, T, bool> {
 };
 
 template<class T>
-struct tracking_greater: std::binary_function <T, T, bool> {
+struct tracking_greater {
   typedef bool result_type;
+  typedef T first_argument_type;
+  typedef T second_argument_type;
 
   #if defined(__PATHSCALE__)
   tracking_greater (void) { }
@@ -57,8 +63,10 @@ struct tracking_greater: std::binary_function <T, T, bool> {
 };
 
 template<class T>
-struct tracking_greater_equal: std::binary_function <T, T, bool> {
+struct tracking_greater_equal {
   typedef bool result_type;
+  typedef T first_argument_type;
+  typedef T second_argument_type;
 
   #if defined(__PATHSCALE__)
   tracking_greater_equal (void) { }
@@ -127,4 +135,3 @@ int main (void) {
 
   return report_errors();
 }
-

test/is_xxx_test.cpp

@@ -0,0 +1,23 @@
+
+// Copyright 2018 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/detail/is_xxx.hpp>
+#include <boost/static_assert.hpp>
+
+namespace is_xxx_test {
+    template <typename T> struct thing1 {};
+    template <typename T1, typename T2 = int> struct thing2 {};
+}
+
+BOOST_DETAIL_IS_XXX_DEF(thing1, is_xxx_test::thing1, 1);
+BOOST_DETAIL_IS_XXX_DEF(thing2, is_xxx_test::thing2, 2);
+
+BOOST_STATIC_ASSERT((is_thing1<is_xxx_test::thing1<int> >::value));
+BOOST_STATIC_ASSERT((!is_thing1<is_xxx_test::thing2<int> >::value));
+BOOST_STATIC_ASSERT((!is_thing2<is_xxx_test::thing1<int> >::value));
+BOOST_STATIC_ASSERT((is_thing2<is_xxx_test::thing2<int> >::value));
+BOOST_STATIC_ASSERT((is_thing2<is_xxx_test::thing2<int, float> >::value));
+
+int main() {}

test/numeric_traits_test.cpp

@@ -0,0 +1,416 @@
+//  (C) Copyright David Abrahams 2001.
+// 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)
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  1  Apr 2001 Fixes for ICL; use BOOST_STATIC_CONSTANT
+//  11 Feb 2001 Fixes for Borland (David Abrahams)
+//  23 Jan 2001 Added test for wchar_t (David Abrahams)
+//  23 Jan 2001 Now statically selecting a test for signed numbers to avoid
+//              warnings with fancy compilers. Added commentary and
+//              additional dumping of traits data for tested types (David
+//              Abrahams).
+//  21 Jan 2001 Initial version (David Abrahams)
+
+#include <boost/detail/numeric_traits.hpp>
+#include <cassert>
+#include <boost/type_traits/conditional.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/cstdint.hpp>
+#include <climits>
+#include <typeinfo>
+#include <iostream>
+#include <sstream>
+#include <string>
+#ifndef BOOST_NO_LIMITS
+#include <limits>
+#endif
+
+// =================================================================================
+// template class complement_traits<Number> --
+//
+//    statically computes the max and min for 1s and 2s-complement binary
+//    numbers. This helps on platforms without <limits> support. It also shows
+//    an example of a recursive template that works with MSVC!
+//
+
+template <unsigned size> struct complement; // forward
+
+// The template complement, below, does all the real work, using "poor man's
+// partial specialization". We need complement_traits_aux<> so that MSVC doesn't
+// complain about undefined min/max as we're trying to recursively define them.
+template <class Number, unsigned size>
+struct complement_traits_aux
+{
+    BOOST_STATIC_CONSTANT(Number, max = complement<size>::template traits<Number>::max);
+    BOOST_STATIC_CONSTANT(Number, min = complement<size>::template traits<Number>::min);
+};
+
+template <unsigned size>
+struct complement
+{
+    template <class Number>
+    struct traits
+    {
+     private:
+        // indirection through complement_traits_aux necessary to keep MSVC happy
+        typedef complement_traits_aux<Number, size - 1> prev;
+     public:
+#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
+        // GCC 4.0.2 ICEs on these C-style casts
+        BOOST_STATIC_CONSTANT(Number, max =
+                            Number((prev::max) << CHAR_BIT)
+                            + Number(UCHAR_MAX));
+        BOOST_STATIC_CONSTANT(Number, min = Number((prev::min) << CHAR_BIT));
+#else
+        // Avoid left shifting negative integers, use multiplication instead
+        BOOST_STATIC_CONSTANT(Number, shift = 1u << CHAR_BIT);
+        BOOST_STATIC_CONSTANT(Number, max =
+                            Number(Number(prev::max) * shift)
+                            + Number(UCHAR_MAX));
+        BOOST_STATIC_CONSTANT(Number, min = Number(Number(prev::min) * shift));
+#endif
+    };
+};
+
+// Template class complement_base<> -- defines values for min and max for
+// complement<1>, at the deepest level of recursion. Uses "poor man's partial
+// specialization" again.
+template <bool is_signed> struct complement_base;
+
+template <> struct complement_base<false>
+{
+    template <class Number>
+    struct values
+    {
+        BOOST_STATIC_CONSTANT(Number, min = 0);
+        BOOST_STATIC_CONSTANT(Number, max = UCHAR_MAX);
+    };
+};
+
+template <> struct complement_base<true>
+{
+    template <class Number>
+    struct values
+    {
+        BOOST_STATIC_CONSTANT(Number, min = SCHAR_MIN);
+        BOOST_STATIC_CONSTANT(Number, max = SCHAR_MAX);
+    };
+};
+
+// Base specialization of complement, puts an end to the recursion.
+template <>
+struct complement<1>
+{
+    template <class Number>
+    struct traits
+    {
+        BOOST_STATIC_CONSTANT(bool, is_signed = boost::is_signed<Number>::value);
+        BOOST_STATIC_CONSTANT(Number, min =
+                            complement_base<is_signed>::template values<Number>::min);
+        BOOST_STATIC_CONSTANT(Number, max =
+                            complement_base<is_signed>::template values<Number>::max);
+    };
+};
+
+// Now here's the "pretty" template you're intended to actually use.
+//   complement_traits<Number>::min, complement_traits<Number>::max are the
+//   minimum and maximum values of Number if Number is a built-in integer type.
+template <class Number>
+struct complement_traits
+{
+    BOOST_STATIC_CONSTANT(Number, max = (complement_traits_aux<Number, sizeof(Number)>::max));
+    BOOST_STATIC_CONSTANT(Number, min = (complement_traits_aux<Number, sizeof(Number)>::min));
+};
+
+// =================================================================================
+
+// Support for streaming various numeric types in exactly the format I want. I
+// needed this in addition to all the assertions so that I could see exactly
+// what was going on.
+//
+// Numbers go through a 2-stage conversion process (by default, though, no real
+// conversion).
+//
+template <class T> struct stream_as {
+    typedef T t1;
+    typedef T t2;
+};
+
+// char types first get converted to unsigned char, then to unsigned.
+template <> struct stream_as<char> {
+    typedef unsigned char t1;
+    typedef unsigned t2;
+};
+template <> struct stream_as<unsigned char> {
+    typedef unsigned char t1; typedef unsigned t2;
+};
+template <> struct stream_as<signed char>  {
+    typedef unsigned char t1; typedef unsigned t2;
+};
+
+#if defined(BOOST_MSVC_STD_ITERATOR) // No intmax streaming built-in
+
+// With this library implementation, __int64 and __uint64 get streamed as strings
+template <> struct stream_as<boost::uintmax_t> {
+    typedef std::string t1;
+    typedef std::string t2;
+};
+
+template <> struct stream_as<boost::intmax_t>  {
+    typedef std::string t1;
+    typedef std::string t2;
+};
+#endif
+
+// Standard promotion process for streaming
+template <class T> struct promote
+{
+    static typename stream_as<T>::t1 from(T x) {
+        typedef typename stream_as<T>::t1 t1;
+        return t1(x);
+    }
+};
+
+#if defined(BOOST_MSVC_STD_ITERATOR) // No intmax streaming built-in
+
+// On this platform, stream them as long/unsigned long if they fit.
+// Otherwise, write a string.
+template <> struct promote<boost::uintmax_t> {
+    std::string static from(const boost::uintmax_t x) {
+        if (x > ULONG_MAX)
+            return std::string("large unsigned value");
+        else {
+            std::ostringstream strm;
+            strm << (unsigned long)x;
+            return strm.str();
+        }
+    }
+};
+template <> struct promote<boost::intmax_t> {
+    std::string static from(const boost::intmax_t x) {
+        if (x > boost::intmax_t(ULONG_MAX))
+            return std::string("large positive signed value");
+        else if (x >= 0) {
+            std::ostringstream strm;
+            strm << (unsigned long)x;
+            return strm.str();
+        }
+
+        if (x < boost::intmax_t(LONG_MIN))
+            return std::string("large negative signed value");
+        else {
+            std::ostringstream strm;
+            strm << (long)x;
+            return strm.str();
+        }
+    }
+};
+#endif
+
+// This is the function which converts types to the form I want to stream them in.
+template <class T>
+typename stream_as<T>::t2 stream_number(T x)
+{
+    return promote<T>::from(x);
+}
+// =================================================================================
+
+//
+// Tests for built-in signed and unsigned types
+//
+
+// Tag types for selecting tests
+struct unsigned_tag {};
+struct signed_tag {};
+
+// Tests for unsigned numbers. The extra default Number parameter works around
+// an MSVC bug.
+template <class Number>
+void test_aux(unsigned_tag, Number*)
+{
+    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
+    BOOST_STATIC_ASSERT(!boost::is_signed<Number>::value);
+    BOOST_STATIC_ASSERT(
+        (sizeof(Number) < sizeof(boost::intmax_t))
+        | (boost::is_same<difference_type, boost::intmax_t>::value));
+
+#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
+    // GCC 4.0.2 ICEs on this C-style cases
+    BOOST_STATIC_ASSERT((complement_traits<Number>::max) > Number(0));
+    BOOST_STATIC_ASSERT((complement_traits<Number>::min) == Number(0));
+#else
+    // Force casting to Number here to work around the fact that it's an enum on MSVC
+    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::max) > Number(0));
+    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::min) == Number(0));
+#endif
+
+    const Number max = complement_traits<Number>::max;
+    const Number min = complement_traits<Number>::min;
+
+    const Number test_max = (sizeof(Number) < sizeof(boost::intmax_t))
+        ? max
+        : max / 2 - 1;
+
+    std::cout << std::hex << "(unsigned) min = " << stream_number(min) << ", max = "
+              << stream_number(max) << "..." << std::flush;
+    std::cout << "difference_type = " << typeid(difference_type).name() << "..."
+              << std::flush;
+
+    difference_type d1 = boost::detail::numeric_distance(Number(0), test_max);
+    difference_type d2 = boost::detail::numeric_distance(test_max, Number(0));
+
+    std::cout << "0->" << stream_number(test_max) << "==" << std::dec << stream_number(d1) << "; "
+              << std::hex << stream_number(test_max) << "->0==" << std::dec << stream_number(d2) << "..." << std::flush;
+
+    assert(d1 == difference_type(test_max));
+    assert(d2 == -difference_type(test_max));
+}
+
+// Tests for signed numbers. The extra default Number parameter works around an
+// MSVC bug.
+struct out_of_range_tag {};
+struct in_range_tag {};
+
+// This test morsel gets executed for numbers whose difference will always be
+// representable in intmax_t
+template <class Number>
+void signed_test(in_range_tag, Number*)
+{
+    BOOST_STATIC_ASSERT(boost::is_signed<Number>::value);
+    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
+    const Number max = complement_traits<Number>::max;
+    const Number min = complement_traits<Number>::min;
+
+    difference_type d1 = boost::detail::numeric_distance(min, max);
+    difference_type d2 = boost::detail::numeric_distance(max, min);
+
+    std::cout << stream_number(min) << "->" << stream_number(max) << "==";
+    std::cout << std::dec << stream_number(d1) << "; ";
+    std::cout << std::hex << stream_number(max) << "->" << stream_number(min)
+              << "==" << std::dec << stream_number(d2) << "..." << std::flush;
+    assert(d1 == difference_type(max) - difference_type(min));
+    assert(d2 == difference_type(min) - difference_type(max));
+}
+
+// This test morsel gets executed for numbers whose difference may exceed the
+// capacity of intmax_t.
+template <class Number>
+void signed_test(out_of_range_tag, Number*)
+{
+    BOOST_STATIC_ASSERT(boost::is_signed<Number>::value);
+    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
+    const Number max = complement_traits<Number>::max;
+    const Number min = complement_traits<Number>::min;
+
+    difference_type min_distance = complement_traits<difference_type>::min;
+    difference_type max_distance = complement_traits<difference_type>::max;
+
+    const Number n1 = Number(min + max_distance);
+    const Number n2 = Number(max + min_distance);
+    difference_type d1 = boost::detail::numeric_distance(min, n1);
+    difference_type d2 = boost::detail::numeric_distance(max, n2);
+
+    std::cout << stream_number(min) << "->" << stream_number(n1) << "==";
+    std::cout << std::dec << stream_number(d1) << "; ";
+    std::cout << std::hex << stream_number(max) << "->" << stream_number(n2)
+              << "==" << std::dec << stream_number(d2) << "..." << std::flush;
+    assert(d1 == max_distance);
+    assert(d2 == min_distance);
+}
+
+template <class Number>
+void test_aux(signed_tag, Number*)
+{
+    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
+    BOOST_STATIC_ASSERT(boost::is_signed<Number>::value);
+    BOOST_STATIC_ASSERT(
+        (sizeof(Number) < sizeof(boost::intmax_t))
+        | (boost::is_same<difference_type, Number>::value));
+
+#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
+    // GCC 4.0.2 ICEs on this cast
+    BOOST_STATIC_ASSERT((complement_traits<Number>::max) > Number(0));
+    BOOST_STATIC_ASSERT((complement_traits<Number>::min) < Number(0));
+#else
+    // Force casting to Number here to work around the fact that it's an enum on MSVC
+    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::max) > Number(0));
+    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::min) < Number(0));
+#endif
+    const Number max = complement_traits<Number>::max;
+    const Number min = complement_traits<Number>::min;
+
+    std::cout << std::hex << "min = " << stream_number(min) << ", max = "
+              << stream_number(max) << "..." << std::flush;
+    std::cout << "difference_type = " << typeid(difference_type).name() << "..."
+              << std::flush;
+
+    typedef typename boost::conditional<
+        (sizeof(Number) < sizeof(boost::intmax_t)),
+        in_range_tag,
+        out_of_range_tag
+    >::type range_tag;
+    signed_test<Number>(range_tag(), 0);
+}
+
+
+// Test for all numbers. The extra default Number parameter works around an MSVC
+// bug.
+template <class Number>
+void test(Number* = 0)
+{
+    std::cout << "testing " << typeid(Number).name() << ":\n"
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+              << "is_signed: " << (std::numeric_limits<Number>::is_signed ? "true\n" : "false\n")
+              << "is_bounded: " << (std::numeric_limits<Number>::is_bounded ? "true\n" : "false\n")
+              << "digits: " << std::numeric_limits<Number>::digits << "\n"
+#endif
+              << "..." << std::flush;
+
+    // factoring out difference_type for the assert below confused Borland :(
+    typedef boost::is_signed<
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+        typename
+#endif
+        boost::detail::numeric_traits<Number>::difference_type
+        > is_signed;
+    BOOST_STATIC_ASSERT(is_signed::value);
+
+    typedef typename boost::conditional<
+        boost::is_signed<Number>::value,
+        signed_tag,
+        unsigned_tag
+    >::type signedness;
+
+    test_aux<Number>(signedness(), 0);
+    std::cout << "passed" << std::endl;
+}
+
+int main()
+{
+    test<char>();
+    test<unsigned char>();
+    test<signed char>();
+    test<wchar_t>();
+    test<short>();
+    test<unsigned short>();
+    test<int>();
+    test<unsigned int>();
+    test<long>();
+    test<unsigned long>();
+#if defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_INTEGRAL_INT64_T)
+    test< ::boost::long_long_type>();
+    test< ::boost::ulong_long_type>();
+#elif defined(BOOST_MSVC)
+    // The problem of not having compile-time static class constants other than
+    // enums prevents this from working, since values get truncated.
+    // test<boost::uintmax_t>();
+    // test<boost::intmax_t>();
+#endif
+    return 0;
+}

test/reference_content_test.cpp

@@ -0,0 +1,16 @@
+
+// Copyright 2018 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/detail/reference_content.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+BOOST_STATIC_ASSERT((boost::is_same<int, boost::detail::make_reference_content<int>::type>::value));
+BOOST_STATIC_ASSERT((boost::is_same<boost::detail::reference_content<int&>, boost::detail::make_reference_content<int&>::type>::value));
+BOOST_STATIC_ASSERT((boost::is_same<int, boost::detail::make_reference_content<>::apply<int>::type>::value));
+BOOST_STATIC_ASSERT((boost::is_same<boost::detail::reference_content<int&>, boost::detail::make_reference_content<>::apply<int&>::type>::value));
+BOOST_STATIC_ASSERT((boost::has_nothrow_copy<boost::detail::make_reference_content<int&>::type>::value));
+
+int main() {}

test/test_utf8_codecvt.cpp

@@ -0,0 +1,302 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// test_utf8_codecvt.cpp
+
+// (C) Copyright 2002-4 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is 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)
+
+#include <algorithm> // std::copy
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <locale>
+#include <vector>
+#include <string>
+
+#include <cstddef> // size_t
+#include <cwchar>
+#include <boost/config.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+
+#define BOOST_UTF8_BEGIN_NAMESPACE namespace boost { namespace detail {
+#define BOOST_UTF8_END_NAMESPACE } }
+#include <boost/detail/utf8_codecvt_facet.hpp>
+#include <boost/detail/utf8_codecvt_facet.ipp>
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ 
+    using ::size_t; 
+    using ::wcslen;
+#if !defined(UNDER_CE) && !defined(__PGIC__) 
+    using ::w_int;
+#endif
+} // namespace std
+#endif
+
+// Note: copied from boost/iostreams/char_traits.hpp
+//
+// Dinkumware that comes with QNX Momentics 6.3.0, 4.0.2, incorrectly defines
+// the EOF and WEOF macros to not std:: qualify the wint_t type (and so does
+// Sun C++ 5.8 + STLport 4). Fix by placing the def in this scope.
+// NOTE: Use BOOST_WORKAROUND?
+#if (defined(__QNX__) && defined(BOOST_DINKUMWARE_STDLIB))  \
+    || defined(__SUNPRO_CC)
+    using ::std::wint_t;
+#endif
+
+#include <boost/core/lightweight_test.hpp>
+
+template<std::size_t s>
+struct test_data
+{
+    static unsigned char utf8_encoding[];
+    static wchar_t wchar_encoding[];
+};
+
+template<>
+unsigned char test_data<2>::utf8_encoding[] = {
+    0x01,
+    0x7f,
+    0xc2, 0x80,
+    0xdf, 0xbf,
+    0xe0, 0xa0, 0x80,
+    0xe7, 0xbf, 0xbf
+};
+
+template<>
+wchar_t test_data<2>::wchar_encoding[] = {
+    0x0001,
+    0x007f,
+    0x0080,
+    0x07ff,
+    0x0800,
+    0x7fff
+};
+
+template<>
+unsigned char test_data<4>::utf8_encoding[] = {
+    0x01,
+    0x7f,
+    0xc2, 0x80,
+    0xdf, 0xbf,
+    0xe0, 0xa0, 0x80,
+    0xef, 0xbf, 0xbf,
+    0xf0, 0x90, 0x80, 0x80,
+    0xf4, 0x8f, 0xbf, 0xbf,
+    /* codecvt implementations for clang and gcc don't handle more than 21 bits and
+     * return eof accordlingly.  So don't test the whole 32 range
+     */
+    /*
+    0xf7, 0xbf, 0xbf, 0xbf,
+    0xf8, 0x88, 0x80, 0x80, 0x80,
+    0xfb, 0xbf, 0xbf, 0xbf, 0xbf,
+    0xfc, 0x84, 0x80, 0x80, 0x80, 0x80,
+    0xfd, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf
+    */
+};
+
+template<>
+wchar_t test_data<4>::wchar_encoding[] = {
+    (wchar_t)0x00000001,
+    (wchar_t)0x0000007f,
+    (wchar_t)0x00000080,
+    (wchar_t)0x000007ff,
+    (wchar_t)0x00000800,
+    (wchar_t)0x0000ffff,
+    (wchar_t)0x00010000,
+    (wchar_t)0x0010ffff,
+    /* codecvt implementations for clang and gcc don't handle more than 21 bits and
+     * return eof accordlingly.  So don't test the whole 32 range
+     */
+    /*
+    (wchar_t)0x001fffff,
+    (wchar_t)0x00200000,
+    (wchar_t)0x03ffffff,
+    (wchar_t)0x04000000,
+    (wchar_t)0x7fffffff
+    */
+};
+
+int
+test_main(int /* argc */, char * /* argv */[]) {
+    std::locale utf8_locale
+        = std::locale(
+            std::locale::classic(),
+            new boost::detail::utf8_codecvt_facet
+        );
+
+    typedef char utf8_t;
+    // define test data compatible with the wchar_t implementation
+    // as either ucs-2 or ucs-4 depending on the compiler/library.
+    typedef test_data<sizeof(wchar_t)> td;
+
+    // Send our test UTF-8 data to file
+    {
+        std::ofstream ofs;
+        ofs.open("test.dat");
+        std::copy(
+            td::utf8_encoding,
+            td::utf8_encoding + sizeof(td::utf8_encoding) / sizeof(unsigned char),
+            std::ostream_iterator<utf8_t>(ofs)
+        );
+    }
+
+    // Read the test data back in, converting to UCS-4 on the way in
+    std::vector<wchar_t> from_file;
+    {
+        std::wifstream ifs;
+        ifs.imbue(utf8_locale);
+        ifs.open("test.dat");
+
+        std::wint_t item = 0;
+        // note can't use normal vector from iterator constructor because
+        // dinkumware doesn't have it.
+        for(;;){
+            item = ifs.get();
+            if(item == WEOF)
+                break;
+            //ifs >> item;
+            //if(ifs.eof())
+            //    break;
+            from_file.push_back(item);
+        }
+    }
+
+    BOOST_TEST(std::equal(from_file.begin(), from_file.end(), td::wchar_encoding));
+  
+    // Send the UCS4_data back out, converting to UTF-8
+    {
+        std::wofstream ofs;
+        ofs.imbue(utf8_locale);
+        ofs.open("test2.dat");
+        std::copy(
+            from_file.begin(),
+            from_file.end(),
+            std::ostream_iterator<wchar_t, wchar_t>(ofs)
+        );
+    }
+
+    // Make sure that both files are the same
+    {
+        typedef std::istream_iterator<utf8_t> is_iter;
+        is_iter end_iter;
+
+        std::ifstream ifs1("test.dat");
+        is_iter it1(ifs1);
+        std::vector<utf8_t> data1;
+        std::copy(it1, end_iter, std::back_inserter(data1));
+
+        std::ifstream ifs2("test2.dat");
+        is_iter it2(ifs2);
+        std::vector<utf8_t> data2;
+        std::copy(it2, end_iter, std::back_inserter(data2));
+
+        BOOST_TEST(data1 == data2);
+    }
+
+    // some libraries have trouble that only shows up with longer strings
+    
+    const wchar_t * test3_data = L"\
+    <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
+    <!DOCTYPE boost_serialization>\
+    <boost_serialization signature=\"serialization::archive\" version=\"3\">\
+    <a class_id=\"0\" tracking_level=\"0\">\
+        <b>1</b>\
+        <f>96953204</f>\
+        <g>177129195</g>\
+        <l>1</l>\
+        <m>5627</m>\
+        <n>23010</n>\
+        <o>7419</o>\
+        <p>16212</p>\
+        <q>4086</q>\
+        <r>2749</r>\
+        <c>-33</c>\
+        <s>124</s>\
+        <t>28</t>\
+        <u>32225</u>\
+        <v>17543</v>\
+        <w>0.84431422</w>\
+        <x>1.0170664757130923</x>\
+        <y>tjbx</y>\
+        <z>cuwjentqpkejp</z>\
+    </a>\
+    </boost_serialization>\
+    ";
+    
+    // Send the UCS4_data back out, converting to UTF-8
+    std::size_t l = std::wcslen(test3_data);
+    {
+        std::wofstream ofs;
+        ofs.imbue(utf8_locale);
+        ofs.open("test3.dat");
+        std::copy(
+            test3_data,
+            test3_data + l,
+            std::ostream_iterator<wchar_t, wchar_t>(ofs)
+        );
+    }
+
+    // Make sure that both files are the same
+    {
+        std::wifstream ifs;
+        ifs.imbue(utf8_locale);
+        ifs.open("test3.dat");
+        ifs >> std::noskipws;
+        BOOST_TEST(
+            std::equal(
+                test3_data,
+                test3_data + l,
+                std::istream_iterator<wchar_t, wchar_t>(ifs)
+            )
+        );
+    }
+
+    // Test length calculation
+    {
+        std::codecvt<wchar_t, char, std::mbstate_t> const& fac = std::use_facet< std::codecvt<wchar_t, char, std::mbstate_t> >(utf8_locale);
+        std::mbstate_t mbs = std::mbstate_t();
+        const int utf8_len = sizeof(td::utf8_encoding) / sizeof(*td::utf8_encoding);
+        int res = fac.length(mbs, reinterpret_cast< const char* >(td::utf8_encoding), reinterpret_cast< const char* >(td::utf8_encoding + utf8_len), ~static_cast< std::size_t >(0u));
+        BOOST_TEST_EQ(utf8_len, res);
+    }
+
+    // Test that length calculation detects character boundaries
+    {
+        std::codecvt<wchar_t, char, std::mbstate_t> const& fac = std::use_facet< std::codecvt<wchar_t, char, std::mbstate_t> >(utf8_locale);
+        std::mbstate_t mbs = std::mbstate_t();
+        // The first 5 bytes of utf8_encoding contain 3 complete UTF-8 characters (taking 4 bytes in total) and 1 byte of an incomplete character.
+        // This last byte should not be accounted by length().
+        const int input_len = 5;
+        const int utf8_len = 4;
+        int res = fac.length(mbs, reinterpret_cast< const char* >(td::utf8_encoding), reinterpret_cast< const char* >(td::utf8_encoding + input_len), ~static_cast< std::size_t >(0u));
+        BOOST_TEST_EQ(utf8_len, res);
+    }
+
+    return EXIT_SUCCESS;
+}
+
+int
+main(int argc, char * argv[]){
+
+    int retval = 1;
+    BOOST_TRY{
+        retval = test_main(argc, argv);
+    }
+    #ifndef BOOST_NO_EXCEPTION_STD_NAMESPACE
+        BOOST_CATCH(const std::exception & e){
+            BOOST_ERROR(e.what());
+        }
+    #endif
+    BOOST_CATCH(...){
+        BOOST_ERROR("failed with uncaught exception:");
+    }
+    BOOST_CATCH_END
+
+    int error_count = boost::report_errors();
+    if(error_count > 0)
+        retval = error_count;
+    return retval;
+}
+