v2, v3, integration branch

[SVN r62649]

.travis.yml

@@ -1,386 +0,0 @@
-# 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"
-
-    - os: linux
-      dist: bionic
-      compiler: gcc-10
-      env: TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,17,20
-      addons:
-        apt:
-          packages:
-            - g++-10
-          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-10
-      env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20
-      addons:
-        apt:
-          packages:
-            - clang-10
-            - libstdc++-9-dev
-          sources:
-            - sourceline: "ppa:ubuntu-toolchain-r/test"
-            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main"
-              key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
-
-    - os: linux
-      dist: xenial
-      compiler: clang-libc++
-      env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20 CXXFLAGS="-stdlib=libc++" LINKFLAGS="-stdlib=libc++"
-      addons:
-        apt:
-          packages:
-            - clang-10
-            - libc++-10-dev
-            - libc++abi-10-dev
-          sources:
-            - sourceline: "ppa:ubuntu-toolchain-r/test"
-            - sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 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

@@ -1,25 +0,0 @@
-# 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

@@ -1,36 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-[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

@@ -1,716 +0,0 @@
-
-/*=============================================================================
-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

@@ -1,275 +0,0 @@
-/*
-: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

@@ -1,56 +0,0 @@
-<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

@@ -1,23 +0,0 @@
-/*
-
-  <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

@@ -1,11 +0,0 @@
-/*============================================================================
-    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/type_traits/integral_constant.hpp"
+#include "boost/mpl/bool.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 >
-    : boost::true_type
+    : mpl::true_
 {
 };
 
 template <>
 struct is_empty< blank >
-    : boost::true_type
+    : mpl::true_
 {
 };
 
 template <>
 struct is_stateless< blank >
-    : boost::true_type
+    : mpl::true_
 {
 };
 

include/boost/detail/allocator_utilities.hpp

@@ -1,4 +1,4 @@
-/* Copyright 2003-2013 Joaquin M Lopez Munoz.
+/* Copyright 2003-2009 Joaquin M Lopez Munoz.
  * 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)
@@ -11,7 +11,8 @@
 
 #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
 #include <boost/detail/workaround.hpp>
-#include <boost/detail/select_type.hpp>
+#include <boost/mpl/aux_/msvc_never_true.hpp>
+#include <boost/mpl/eval_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <cstddef>
 #include <memory>
@@ -44,7 +45,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 +53,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
@@ -115,21 +116,40 @@ struct partial_std_allocator_rebind_to
 
 /* rebind operation in all other cases */
 
+#if BOOST_WORKAROUND(BOOST_MSVC,<1300)
+/* Workaround for a problem in MSVC with dependent template typedefs
+ * when doing rebinding of allocators.
+ * Modeled after <boost/mpl/aux_/msvc_dtw.hpp> (thanks, Aleksey!)
+ */
+
+template<typename Allocator>
+struct rebinder
+{
+  template<bool> struct fake_allocator:Allocator{};
+  template<> struct fake_allocator<true>
+  {
+    template<typename Type> struct rebind{};
+  };
+
+  template<typename Type>
+  struct result:
+    fake_allocator<mpl::aux::msvc_never_true<Allocator>::value>::
+      template rebind<Type>
+  {
+  };
+};
+#else
 template<typename Allocator>
 struct rebinder
 {
   template<typename Type>
   struct result
   {
-#ifdef BOOST_NO_CXX11_ALLOCATOR
-      typedef typename Allocator::BOOST_NESTED_TEMPLATE
+      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
   };
 };
+#endif
 
 template<typename Allocator,typename Type>
 struct compliant_allocator_rebind_to
@@ -142,12 +162,11 @@ struct compliant_allocator_rebind_to
 
 template<typename Allocator,typename Type>
 struct rebind_to:
-  boost::detail::if_true<
-    is_partial_std_allocator<Allocator>::value
-  >::template then<
+  mpl::eval_if_c<
+    is_partial_std_allocator<Allocator>::value,
     partial_std_allocator_rebind_to<Allocator,Type>,
     compliant_allocator_rebind_to<Allocator,Type>
-  >::type
+  >
 {
 };
 
@@ -165,7 +184,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/binary_search.hpp

@@ -1,11 +1,11 @@
-// Copyright (c)  2000 David Abrahams.
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// Copyright (c)  2000 David Abrahams. 
+// 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)
-//
+// 
 // Copyright (c) 1994
 // Hewlett-Packard Company
-//
+// 
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
@@ -13,10 +13,10 @@
 // in supporting documentation.  Hewlett-Packard Company makes no
 // representations about the suitability of this software for any
 // purpose.  It is provided "as is" without express or implied warranty.
-//
+// 
 // Copyright (c) 1996
 // Silicon Graphics Computer Systems, Inc.
-//
+// 
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee,
 // provided that the above copyright notice appear in all copies and
@@ -24,22 +24,22 @@
 // in supporting documentation.  Silicon Graphics makes no
 // representations about the suitability of this software for any
 // purpose.  It is provided "as is" without express or implied warranty.
-//
+// 
 #ifndef BINARY_SEARCH_DWA_122600_H_
 # define BINARY_SEARCH_DWA_122600_H_
 
+# include <boost/detail/iterator.hpp>
 # include <utility>
-# include <iterator>
 
 namespace boost { namespace detail {
 
 template <class ForwardIter, class Tp>
 ForwardIter lower_bound(ForwardIter first, ForwardIter last,
-                             const Tp& val)
+                             const Tp& val) 
 {
-    typedef std::iterator_traits<ForwardIter> traits;
-
-    typename traits::difference_type len = std::distance(first, last);
+    typedef detail::iterator_traits<ForwardIter> traits;
+    
+    typename traits::difference_type len = boost::detail::distance(first, last);
     typename traits::difference_type half;
     ForwardIter middle;
 
@@ -62,9 +62,9 @@ template <class ForwardIter, class Tp, class Compare>
 ForwardIter lower_bound(ForwardIter first, ForwardIter last,
                               const Tp& val, Compare comp)
 {
-  typedef std::iterator_traits<ForwardIter> traits;
+  typedef detail::iterator_traits<ForwardIter> traits;
 
-  typename traits::difference_type len = std::distance(first, last);
+  typename traits::difference_type len = boost::detail::distance(first, last);
   typename traits::difference_type half;
   ForwardIter middle;
 
@@ -87,9 +87,9 @@ template <class ForwardIter, class Tp>
 ForwardIter upper_bound(ForwardIter first, ForwardIter last,
                            const Tp& val)
 {
-  typedef std::iterator_traits<ForwardIter> traits;
+  typedef detail::iterator_traits<ForwardIter> traits;
 
-  typename traits::difference_type len = std::distance(first, last);
+  typename traits::difference_type len = boost::detail::distance(first, last);
   typename traits::difference_type half;
   ForwardIter middle;
 
@@ -112,9 +112,9 @@ template <class ForwardIter, class Tp, class Compare>
 ForwardIter upper_bound(ForwardIter first, ForwardIter last,
                            const Tp& val, Compare comp)
 {
-  typedef std::iterator_traits<ForwardIter> traits;
+  typedef detail::iterator_traits<ForwardIter> traits;
 
-  typename traits::difference_type len = std::distance(first, last);
+  typename traits::difference_type len = boost::detail::distance(first, last);
   typename traits::difference_type half;
   ForwardIter middle;
 
@@ -137,9 +137,9 @@ template <class ForwardIter, class Tp>
 std::pair<ForwardIter, ForwardIter>
 equal_range(ForwardIter first, ForwardIter last, const Tp& val)
 {
-  typedef std::iterator_traits<ForwardIter> traits;
+  typedef detail::iterator_traits<ForwardIter> traits;
 
-  typename traits::difference_type len = std::distance(first, last);
+  typename traits::difference_type len = boost::detail::distance(first, last);
   typename traits::difference_type half;
   ForwardIter middle, left, right;
 
@@ -169,9 +169,9 @@ std::pair<ForwardIter, ForwardIter>
 equal_range(ForwardIter first, ForwardIter last, const Tp& val,
               Compare comp)
 {
-  typedef std::iterator_traits<ForwardIter> traits;
+  typedef detail::iterator_traits<ForwardIter> traits;
 
-  typename traits::difference_type len = std::distance(first, last);
+  typename traits::difference_type len = boost::detail::distance(first, last);
   typename traits::difference_type half;
   ForwardIter middle, left, right;
 
@@ -194,7 +194,7 @@ equal_range(ForwardIter first, ForwardIter last, const Tp& val,
     }
   }
   return std::pair<ForwardIter, ForwardIter>(first, first);
-}
+}           
 
 template <class ForwardIter, class Tp>
 bool binary_search(ForwardIter first, ForwardIter last,

include/boost/detail/bitmask.hpp

@@ -1,58 +0,0 @@
-//  boost/detail/bitmask.hpp  ------------------------------------------------//
-
-//  Copyright Beman Dawes 2006
-
-//  Distributed under the Boost Software License, Version 1.0
-//  http://www.boost.org/LICENSE_1_0.txt
-
-//  Usage:  enum foo { a=1, b=2, c=4 };
-//          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 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 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 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 BOOST_CONSTEXPR Bitmask operator~ (Bitmask x )                   \
-  { return static_cast<Bitmask>(~static_cast<boost::int_least32_t>(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 ; }                                              \
-                                                                          \
-  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/catch_exceptions.hpp

@@ -20,14 +20,17 @@
 //  to reduce coupling to other boost libraries.
 #include <string>             // for string
 #include <new>                // for bad_alloc
-#include <ostream>            // for ostream
 #include <typeinfo>           // for bad_cast, bad_typeid
 #include <exception>          // for exception, bad_exception
 #include <stdexcept>          // for std exception hierarchy
-#include <boost/config.hpp>
 #include <boost/cstdlib.hpp>  // for exit codes
+# if __GNUC__ != 2 || __GNUC_MINOR__ > 96
+#   include <ostream>         // for ostream
+# else
+#   include <iostream> // workaround GNU missing ostream header
+# endif
 
-# if defined(BOOST_BORLANDC) && (__BORLANDC__ <= 0x0551)
+# if defined(__BORLANDC__) && (__BORLANDC__ <= 0x0551)
 #   define BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT 
 # endif
 

include/boost/detail/container_fwd.hpp

@@ -1,92 +1,24 @@
 
-// Copyright 2005-2011 Daniel James.
+// Copyright 2005-2008 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)
 
-// Note: if you change this include guard, you also need to change
-// container_fwd_compile_fail.cpp
 #if !defined(BOOST_DETAIL_CONTAINER_FWD_HPP)
 #define BOOST_DETAIL_CONTAINER_FWD_HPP
 
-#if defined(_MSC_VER) && \
-    !defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 
-////////////////////////////////////////////////////////////////////////////////
-//                                                                            //
-// Define BOOST_DETAIL_NO_CONTAINER_FWD if you don't want this header to      //
-// forward declare standard containers.                                       //
-//                                                                            //
-// BOOST_DETAIL_CONTAINER_FWD to make it foward declare containers even if it //
-// normally doesn't.                                                          //
-//                                                                            //
-// BOOST_DETAIL_NO_CONTAINER_FWD overrides BOOST_DETAIL_CONTAINER_FWD.        //
-//                                                                            //
-////////////////////////////////////////////////////////////////////////////////
-
-#if !defined(BOOST_DETAIL_NO_CONTAINER_FWD)
-#  if defined(BOOST_DETAIL_CONTAINER_FWD)
-     // Force forward declarations.
-#  elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
-     // STLport
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
-#  elif defined(__LIBCOMO__)
-     // Comeau STL:
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
-#  elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
-     // Rogue Wave library:
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
-#  elif defined(_LIBCPP_VERSION)
-     // libc++
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
-#  elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
-     // GNU libstdc++ 3
-     //
-     // Disable forwarding for all recent versions, as the library has a
-     // versioned namespace mode, and I don't know how to detect it.
-#    if __GLIBCXX__ >= 20070513 \
-        || defined(_GLIBCXX_DEBUG) \
-        || defined(_GLIBCXX_PARALLEL) \
-        || defined(_GLIBCXX_PROFILE)
-#      define BOOST_DETAIL_NO_CONTAINER_FWD
-#    else
-#      if defined(__GLIBCXX__) && __GLIBCXX__ >= 20040530
-#        define BOOST_CONTAINER_FWD_COMPLEX_STRUCT
-#      endif
-#    endif
-#  elif defined(__STL_CONFIG_H)
-     // generic SGI STL
-     //
-     // Forward declaration seems to be okay, but it has a couple of odd
-     // implementations.
-#    define BOOST_CONTAINER_FWD_BAD_BITSET
-#    if !defined(__STL_NON_TYPE_TMPL_PARAM_BUG)
-#      define BOOST_CONTAINER_FWD_BAD_DEQUE
-#     endif
-#  elif defined(__MSL_CPP__)
-     // MSL standard lib:
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
-#  elif defined(__IBMCPP__)
-     // The default VACPP std lib, forward declaration seems to be fine.
-#  elif defined(MSIPL_COMPILE_H)
-     // Modena C++ standard library
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
-#  elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
-     // Dinkumware Library (this has to appear after any possible replacement
-     // libraries)
-#  else
-#    define BOOST_DETAIL_NO_CONTAINER_FWD
-#  endif
-#endif
-
-#if !defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
-
-#if defined(BOOST_DETAIL_NO_CONTAINER_FWD) && \
-    !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
+#if defined(BOOST_DETAIL_NO_CONTAINER_FWD) \
+    || ((defined(__GLIBCPP__) || defined(__GLIBCXX__)) \
+        && (defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL))) \
+    || BOOST_WORKAROUND(__BORLANDC__, > 0x551) \
+    || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x842)) \
+    || (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
 
 #include <deque>
 #include <list>
@@ -101,6 +33,17 @@
 
 #include <cstddef>
 
+#if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) && \
+        defined(__STL_CONFIG_H)
+
+#define BOOST_CONTAINER_FWD_BAD_BITSET
+
+#if !defined(__STL_NON_TYPE_TMPL_PARAM_BUG)
+#define BOOST_CONTAINER_FWD_BAD_DEQUE
+#endif
+
+#endif
+
 #if defined(BOOST_CONTAINER_FWD_BAD_DEQUE)
 #include <deque>
 #endif
@@ -119,14 +62,18 @@ namespace std
     template <class T> class allocator;
     template <class charT, class traits, class Allocator> class basic_string;
 
-    template <class charT> struct char_traits;
-
-#if defined(BOOST_CONTAINER_FWD_COMPLEX_STRUCT)
-    template <class T> struct complex;
+#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+    template <class charT> struct string_char_traits;
 #else
-    template <class T> class complex;
+    template <class charT> struct char_traits;
 #endif
 
+    template <class T> class complex;
+}
+
+// gcc 3.4 and greater
+namespace std
+{
 #if !defined(BOOST_CONTAINER_FWD_BAD_DEQUE)
     template <class T, class Allocator> class deque;
 #endif
@@ -149,9 +96,6 @@ namespace std
 #pragma warning(pop)
 #endif
 
-#endif // BOOST_DETAIL_NO_CONTAINER_FWD &&
-       // !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
-
-#endif // BOOST_DETAIL_TEST_CONFIG_ONLY
+#endif
 
 #endif

include/boost/detail/endian.hpp

@@ -0,0 +1,76 @@
+// Copyright 2005 Caleb Epstein
+// Copyright 2006 John Maddock
+// Copyright 2010 Rene Rivera
+// 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)
+
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/*
+ * Copyright notice reproduced from <boost/detail/limits.hpp>, from
+ * which this code was originally taken.
+ *
+ * Modified by Caleb Epstein to use <endian.h> with GNU libc and to
+ * defined the BOOST_ENDIAN macro.
+ */
+
+#ifndef BOOST_DETAIL_ENDIAN_HPP
+#define BOOST_DETAIL_ENDIAN_HPP
+
+// GNU libc offers the helpful header <endian.h> which defines
+// __BYTE_ORDER
+
+#if defined (__GLIBC__)
+# include <endian.h>
+# if (__BYTE_ORDER == __LITTLE_ENDIAN)
+#  define BOOST_LITTLE_ENDIAN
+# elif (__BYTE_ORDER == __BIG_ENDIAN)
+#  define BOOST_BIG_ENDIAN
+# elif (__BYTE_ORDER == __PDP_ENDIAN)
+#  define BOOST_PDP_ENDIAN
+# else
+#  error Unknown machine endianness detected.
+# endif
+# define BOOST_BYTE_ORDER __BYTE_ORDER
+#elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN) || \
+    defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
+# define BOOST_BIG_ENDIAN
+# define BOOST_BYTE_ORDER 4321
+#elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN) || \
+    defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
+# define BOOST_LITTLE_ENDIAN
+# define BOOST_BYTE_ORDER 1234
+#elif defined(__sparc) || defined(__sparc__) \
+   || defined(_POWER) || defined(__powerpc__) \
+   || defined(__ppc__) || defined(__hpux) || defined(__hppa) \
+   || defined(_MIPSEB) || defined(_POWER) \
+   || defined(__s390__)
+# define BOOST_BIG_ENDIAN
+# define BOOST_BYTE_ORDER 4321
+#elif defined(__i386__) || defined(__alpha__) \
+   || defined(__ia64) || defined(__ia64__) \
+   || defined(_M_IX86) || defined(_M_IA64) \
+   || defined(_M_ALPHA) || defined(__amd64) \
+   || defined(__amd64__) || defined(_M_AMD64) \
+   || defined(__x86_64) || defined(__x86_64__) \
+   || defined(_M_X64) || defined(__bfin__)
+
+# define BOOST_LITTLE_ENDIAN
+# define BOOST_BYTE_ORDER 1234
+#else
+# error The file boost/detail/endian.hpp needs to be set up for your CPU type.
+#endif
+
+
+#endif

include/boost/detail/fenv.hpp

@@ -1,101 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2010      Bryce Lelbach
-
-    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/config.hpp>
-
-#if defined(BOOST_NO_FENV_H)
-  #error This platform does not have a floating point environment
-#endif
-
-#if !defined(BOOST_DETAIL_FENV_HPP)
-#define BOOST_DETAIL_FENV_HPP
-
-/* If we're using clang + glibc, we have to get hacky.
- * See http://llvm.org/bugs/show_bug.cgi?id=6907 */
-#if defined(__clang__)       &&  (__clang_major__ < 3) &&    \
-    defined(__GNU_LIBRARY__) && /* up to version 5 */ \
-    defined(__GLIBC__) &&         /* version 6 + */ \
-    !defined(_FENV_H)
-  #define _FENV_H
-
-  #include <features.h>
-  #include <bits/fenv.h>
-
-  extern "C" {
-    extern int fegetexceptflag (fexcept_t*, int) __THROW;
-    extern int fesetexceptflag (__const fexcept_t*, int) __THROW;
-    extern int feclearexcept (int) __THROW;
-    extern int feraiseexcept (int) __THROW;
-    extern int fetestexcept (int) __THROW;
-    extern int fegetround (void) __THROW;
-    extern int fesetround (int) __THROW;
-    extern int fegetenv (fenv_t*) __THROW;
-    extern int fesetenv (__const fenv_t*) __THROW;
-    extern int feupdateenv (__const fenv_t*) __THROW;
-    extern int feholdexcept (fenv_t*) __THROW;
-
-    #ifdef __USE_GNU
-      extern int feenableexcept (int) __THROW;
-      extern int fedisableexcept (int) __THROW;
-      extern int fegetexcept (void) __THROW;
-    #endif
-  }
-
-  namespace std { namespace tr1 {
-    using ::fenv_t;
-    using ::fexcept_t;
-    using ::fegetexceptflag;
-    using ::fesetexceptflag;
-    using ::feclearexcept;
-    using ::feraiseexcept;
-    using ::fetestexcept;
-    using ::fegetround;
-    using ::fesetround;
-    using ::fegetenv;
-    using ::fesetenv;
-    using ::feupdateenv;
-    using ::feholdexcept;
-  } }
-
-#elif defined(__MINGW32__) && defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 408
-
-  // MinGW (32-bit) has a bug in mingw32/bits/c++config.h, it does not define _GLIBCXX_HAVE_FENV_H,
-  // which prevents the C fenv.h header contents to be included in the C++ wrapper header fenv.h. This is at least
-  // the case with gcc 4.8.1 packages tested so far, up to 4.8.1-4. Note that there is no issue with
-  // MinGW-w64.
-  // To work around the bug we avoid including the C++ wrapper header and include the C header directly
-  // and import all relevant symbols into std:: ourselves.
-
-  #include <../include/fenv.h>
-
-  namespace std {
-    using ::fenv_t;
-    using ::fexcept_t;
-    using ::fegetexceptflag;
-    using ::fesetexceptflag;
-    using ::feclearexcept;
-    using ::feraiseexcept;
-    using ::fetestexcept;
-    using ::fegetround;
-    using ::fesetround;
-    using ::fegetenv;
-    using ::fesetenv;
-    using ::feupdateenv;
-    using ::feholdexcept;
-  }
-
-#else /* if we're not using GNU's C stdlib, fenv.h should work with clang */
-
-  #if defined(__SUNPRO_CC) /* lol suncc */
-    #include <stdio.h>
-  #endif
-
-  #include <fenv.h>
-
-#endif
-
-#endif /* BOOST_DETAIL_FENV_HPP */

include/boost/detail/identifier.hpp

@@ -57,7 +57,9 @@ namespace boost
       identifier()                             {}
       explicit identifier( value_type v )      : m_value(v) {}
 
+  #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300  // 1300 == VC++ 7.0 bug workaround
     private:
+  #endif
       T m_value;
     };
 

include/boost/detail/indirect_traits.hpp

@@ -4,7 +4,6 @@
 // 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,33 +16,44 @@
 # include <boost/type_traits/remove_reference.hpp>
 # include <boost/type_traits/remove_pointer.hpp>
 
+# include <boost/type_traits/detail/ice_and.hpp>
 # include <boost/detail/workaround.hpp>
-# include <boost/detail/select_type.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>
+
+#  ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#   include <boost/detail/is_function_ref_tester.hpp>
+#  endif 
 
 namespace boost { namespace detail {
 
 namespace indirect_traits {
 
+#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T>
-struct is_reference_to_const : boost::false_type
+struct is_reference_to_const : mpl::false_
 {
 };
 
 template <class T>
-struct is_reference_to_const<T const&> : boost::true_type
+struct is_reference_to_const<T const&> : mpl::true_
 {
 };
 
 #   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
 template<class T>
-struct is_reference_to_const<T const volatile&> : boost::true_type
+struct is_reference_to_const<T const volatile&> : mpl::true_
 {
 };
-#   endif
+#   endif 
 
 template <class T>
-struct is_reference_to_function : boost::false_type
+struct is_reference_to_function : mpl::false_
 {
 };
 
@@ -53,7 +63,7 @@ struct is_reference_to_function<T&> : is_function<T>
 };
 
 template <class T>
-struct is_pointer_to_function : boost::false_type
+struct is_pointer_to_function : mpl::false_
 {
 };
 
@@ -65,7 +75,7 @@ struct is_pointer_to_function<T*> : is_function<T>
 };
 
 template <class T>
-struct is_reference_to_member_function_pointer_impl : boost::false_type
+struct is_reference_to_member_function_pointer_impl : mpl::false_
 {
 };
 
@@ -80,17 +90,18 @@ 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
-    : boost::integral_constant<bool,
-          is_reference<T>::value &&
-          is_pointer_to_function<
+    : mpl::and_<
+          is_reference<T>
+        , 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
@@ -98,93 +109,374 @@ struct is_reference_to_function_pointer_aux
 
 template <class T>
 struct is_reference_to_function_pointer
-    : boost::detail::if_true<
-          is_reference_to_function<T>::value
-      >::template then<
-          boost::false_type
+    : mpl::if_<
+          is_reference_to_function<T>
+        , mpl::false_
         , is_reference_to_function_pointer_aux<T>
-      >::type
+     >::type
 {
 };
 
 template <class T>
 struct is_reference_to_non_const
-    : boost::integral_constant<bool,
-          is_reference<T>::value &&
-          !is_reference_to_const<T>::value
+    : mpl::and_<
+          is_reference<T>
+        , mpl::not_<
+             is_reference_to_const<T>
+          >
       >
 {
 };
 
 template <class T>
-struct is_reference_to_volatile : boost::false_type
+struct is_reference_to_volatile : mpl::false_
 {
 };
 
 template <class T>
-struct is_reference_to_volatile<T volatile&> : boost::true_type
+struct is_reference_to_volatile<T volatile&> : mpl::true_
 {
 };
 
 #   if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround
 template <class T>
-struct is_reference_to_volatile<T const volatile&> : boost::true_type
+struct is_reference_to_volatile<T const volatile&> : mpl::true_
 {
 };
-#   endif
+#   endif 
 
 
 template <class T>
-struct is_reference_to_pointer : boost::false_type
+struct is_reference_to_pointer : mpl::false_
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T*&> : boost::true_type
+struct is_reference_to_pointer<T*&> : mpl::true_
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T* const&> : boost::true_type
+struct is_reference_to_pointer<T* const&> : mpl::true_
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T* volatile&> : boost::true_type
+struct is_reference_to_pointer<T* volatile&> : mpl::true_
 {
 };
 
 template <class T>
-struct is_reference_to_pointer<T* const volatile&> : boost::true_type
+struct is_reference_to_pointer<T* const volatile&> : mpl::true_
 {
 };
 
 template <class T>
 struct is_reference_to_class
-    : boost::integral_constant<bool,
-          is_reference<T>::value &&
-          is_class<
+    : mpl::and_<
+          is_reference<T>
+        , 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
-    : boost::integral_constant<bool,
-          is_pointer<T>::value &&
-          is_class<
+    : mpl::and_<
+          is_pointer<T>
+        , is_class<
               typename remove_cv<
                   typename remove_pointer<T>::type
               >::type
-          >::value
+          >
       >
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T))
+};
+
+#  else
+
+using namespace boost::detail::is_function_ref_tester_;
+
+typedef char (&inner_yes_type)[3];
+typedef char (&inner_no_type)[2];
+typedef char (&outer_no_type)[1];
+
+template <typename V>
+struct is_const_help
+{
+    typedef typename mpl::if_<
+          is_const<V>
+        , inner_yes_type
+        , inner_no_type
+        >::type type;
+};
+
+template <typename V>
+struct is_volatile_help
+{
+    typedef typename mpl::if_<
+          is_volatile<V>
+        , inner_yes_type
+        , inner_no_type
+        >::type type;
+};
+
+template <typename V>
+struct is_pointer_help
+{
+    typedef typename mpl::if_<
+          is_pointer<V>
+        , inner_yes_type
+        , inner_no_type
+        >::type type;
+};
+
+template <typename V>
+struct is_class_help
+{
+    typedef typename mpl::if_<
+          is_class<V>
+        , inner_yes_type
+        , inner_no_type
+        >::type type;
+};
+
+template <class T>
+struct is_reference_to_function_aux
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value = sizeof(detail::is_function_ref_tester(t,0)) == sizeof(::boost::type_traits::yes_type));
+    typedef mpl::bool_<value> type;
+ };
+
+template <class T>
+struct is_reference_to_function
+    : mpl::if_<is_reference<T>, is_reference_to_function_aux<T>, mpl::bool_<false> >::type
 {
 };
 
+template <class T>
+struct is_pointer_to_function_aux
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type));
+    typedef mpl::bool_<value> type;
+};
+
+template <class T>
+struct is_pointer_to_function
+    : mpl::if_<is_pointer<T>, is_pointer_to_function_aux<T>, mpl::bool_<false> >::type
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_function,(T))
+};
+
+struct false_helper1
+{
+    template <class T>
+    struct apply : mpl::false_
+    {
+    };
+};
+
+template <typename V>
+typename is_const_help<V>::type reference_to_const_helper(V&);    
+outer_no_type
+reference_to_const_helper(...);
+
+struct true_helper1
+{
+    template <class T>
+    struct apply
+    {
+        static T t;
+        BOOST_STATIC_CONSTANT(
+            bool, value
+            = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type));
+        typedef mpl::bool_<value> type;
+    };
+};
+
+template <bool ref = true>
+struct is_reference_to_const_helper1 : true_helper1
+{
+};
+
+template <>
+struct is_reference_to_const_helper1<false> : false_helper1
+{
+};
+
+
+template <class T>
+struct is_reference_to_const
+    : is_reference_to_const_helper1<is_reference<T>::value>::template apply<T>
+{
+};
+
+
+template <bool ref = true>
+struct is_reference_to_non_const_helper1
+{
+    template <class T>
+    struct apply
+    {
+        static T t;
+        BOOST_STATIC_CONSTANT(
+            bool, value
+            = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type));
+        
+        typedef mpl::bool_<value> type;
+    };
+};
+
+template <>
+struct is_reference_to_non_const_helper1<false> : false_helper1
+{
+};
+
+
+template <class T>
+struct is_reference_to_non_const
+    : is_reference_to_non_const_helper1<is_reference<T>::value>::template apply<T>
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_non_const,(T))
+};
+
+
+template <typename V>
+typename is_volatile_help<V>::type reference_to_volatile_helper(V&);    
+outer_no_type
+reference_to_volatile_helper(...);
+
+template <bool ref = true>
+struct is_reference_to_volatile_helper1
+{
+    template <class T>
+    struct apply
+    {
+        static T t;
+        BOOST_STATIC_CONSTANT(
+            bool, value
+            = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type));
+        typedef mpl::bool_<value> type;
+    };
+};
+
+template <>
+struct is_reference_to_volatile_helper1<false> : false_helper1
+{
+};
+
+
+template <class T>
+struct is_reference_to_volatile
+    : is_reference_to_volatile_helper1<is_reference<T>::value>::template apply<T>
+{
+};
+
+template <typename V>
+typename is_pointer_help<V>::type reference_to_pointer_helper(V&);
+outer_no_type reference_to_pointer_helper(...);
+
+template <class T>
+struct reference_to_pointer_impl
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = (sizeof((reference_to_pointer_helper)(t)) == sizeof(inner_yes_type))
+        );
+    
+    typedef mpl::bool_<value> type;
+};
+    
+template <class T>
+struct is_reference_to_pointer
+  : mpl::eval_if<is_reference<T>, reference_to_pointer_impl<T>, mpl::false_>::type
+{   
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_pointer,(T))
+};
+
+template <class T>
+struct is_reference_to_function_pointer
+  : mpl::eval_if<is_reference<T>, is_pointer_to_function_aux<T>, mpl::false_>::type
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T))
+};
+
+
+template <class T>
+struct is_member_function_pointer_help
+    : mpl::if_<is_member_function_pointer<T>, inner_yes_type, inner_no_type>
+{};
+
+template <typename V>
+typename is_member_function_pointer_help<V>::type member_function_pointer_helper(V&);
+outer_no_type member_function_pointer_helper(...);
+
+template <class T>
+struct is_pointer_to_member_function_aux
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = sizeof((member_function_pointer_helper)(t)) == sizeof(inner_yes_type));
+    typedef mpl::bool_<value> type;
+};
+
+template <class T>
+struct is_reference_to_member_function_pointer
+    : mpl::if_<
+        is_reference<T>
+        , is_pointer_to_member_function_aux<T>
+        , mpl::bool_<false>
+     >::type
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
+};
+
+template <typename V>
+typename is_class_help<V>::type reference_to_class_helper(V const volatile&);
+outer_no_type reference_to_class_helper(...);
+
+template <class T>
+struct is_reference_to_class
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = (is_reference<T>::value
+           & (sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type)))
+        );
+    typedef mpl::bool_<value> type;
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
+};
+
+template <typename V>
+typename is_class_help<V>::type pointer_to_class_helper(V const volatile*);
+outer_no_type pointer_to_class_helper(...);
+
+template <class T>
+struct is_pointer_to_class
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = (is_pointer<T>::value
+           && sizeof(pointer_to_class_helper(t)) == sizeof(inner_yes_type))
+        );
+    typedef mpl::bool_<value> type;
+};
+#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
 
 }
 

include/boost/detail/interlocked.hpp

@@ -0,0 +1,152 @@
+#ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
+#define BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/detail/interlocked.hpp
+//
+//  Copyright 2005 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/config.hpp>
+
+#if defined( BOOST_USE_WINDOWS_H )
+
+# include <windows.h>
+
+# define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement
+# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement
+# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
+# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange
+# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
+# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER InterlockedCompareExchangePointer
+# define BOOST_INTERLOCKED_EXCHANGE_POINTER InterlockedExchangePointer
+
+#elif defined(_WIN32_WCE)
+
+// under Windows CE we still have old-style Interlocked* functions
+
+extern "C" long __cdecl InterlockedIncrement( long* );
+extern "C" long __cdecl InterlockedDecrement( long* );
+extern "C" long __cdecl InterlockedCompareExchange( long*, long, long );
+extern "C" long __cdecl InterlockedExchange( long*, long );
+extern "C" long __cdecl InterlockedExchangeAdd( long*, long );
+
+# define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement
+# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement
+# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
+# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange
+# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
+
+# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
+    ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest),(long)(exchange),(long)(compare)))
+# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
+    ((void*)BOOST_INTERLOCKED_EXCHANGE((long*)(dest),(long)(exchange)))
+
+#elif defined( BOOST_MSVC ) || defined( BOOST_INTEL_WIN )
+
+#if defined( __CLRCALL_PURE_OR_CDECL )
+
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedIncrement( long volatile * );
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedDecrement( long volatile * );
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedCompareExchange( long volatile *, long, long );
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchange( long volatile *, long );
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchangeAdd( long volatile *, long );
+
+#else
+
+extern "C" long __cdecl _InterlockedIncrement( long volatile * );
+extern "C" long __cdecl _InterlockedDecrement( long volatile * );
+extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long );
+extern "C" long __cdecl _InterlockedExchange( long volatile *, long );
+extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long );
+
+#endif
+
+# pragma intrinsic( _InterlockedIncrement )
+# pragma intrinsic( _InterlockedDecrement )
+# pragma intrinsic( _InterlockedCompareExchange )
+# pragma intrinsic( _InterlockedExchange )
+# pragma intrinsic( _InterlockedExchangeAdd )
+
+# if defined(_M_IA64) || defined(_M_AMD64)
+
+extern "C" void* __cdecl _InterlockedCompareExchangePointer( void* volatile *, void*, void* );
+extern "C" void* __cdecl _InterlockedExchangePointer( void* volatile *, void* );
+
+#  pragma intrinsic( _InterlockedCompareExchangePointer )
+#  pragma intrinsic( _InterlockedExchangePointer )
+
+#  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER _InterlockedCompareExchangePointer
+#  define BOOST_INTERLOCKED_EXCHANGE_POINTER _InterlockedExchangePointer
+
+# else
+
+#  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
+    ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
+#  define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
+    ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
+
+# endif
+
+# define BOOST_INTERLOCKED_INCREMENT _InterlockedIncrement
+# define BOOST_INTERLOCKED_DECREMENT _InterlockedDecrement
+# define BOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
+# define BOOST_INTERLOCKED_EXCHANGE _InterlockedExchange
+# define BOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
+
+#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
+
+namespace boost
+{
+
+namespace detail
+{
+
+extern "C" __declspec(dllimport) long __stdcall InterlockedIncrement( long volatile * );
+extern "C" __declspec(dllimport) long __stdcall InterlockedDecrement( long volatile * );
+extern "C" __declspec(dllimport) long __stdcall InterlockedCompareExchange( long volatile *, long, long );
+extern "C" __declspec(dllimport) long __stdcall InterlockedExchange( long volatile *, long );
+extern "C" __declspec(dllimport) long __stdcall InterlockedExchangeAdd( long volatile *, long );
+
+# if defined(_M_IA64) || defined(_M_AMD64)
+extern "C" __declspec(dllimport) void* __stdcall InterlockedCompareExchangePointer( void* volatile *, void*, void* );
+extern "C" __declspec(dllimport) void* __stdcall InterlockedExchangePointer( void* volatile *, void* );
+# endif
+
+} // namespace detail
+
+} // namespace boost
+
+# define BOOST_INTERLOCKED_INCREMENT ::boost::detail::InterlockedIncrement
+# define BOOST_INTERLOCKED_DECREMENT ::boost::detail::InterlockedDecrement
+# define BOOST_INTERLOCKED_COMPARE_EXCHANGE ::boost::detail::InterlockedCompareExchange
+# define BOOST_INTERLOCKED_EXCHANGE ::boost::detail::InterlockedExchange
+# define BOOST_INTERLOCKED_EXCHANGE_ADD ::boost::detail::InterlockedExchangeAdd
+
+# if defined(_M_IA64) || defined(_M_AMD64)
+#  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER ::boost::detail::InterlockedCompareExchangePointer
+#  define BOOST_INTERLOCKED_EXCHANGE_POINTER ::boost::detail::InterlockedExchangePointer
+# else
+#  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
+    ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
+#  define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
+    ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
+# endif
+
+#else
+
+# error "Interlocked intrinsics not available"
+
+#endif
+
+#endif // #ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED

include/boost/detail/is_function_ref_tester.hpp

@@ -0,0 +1,135 @@
+
+// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, 
+// Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000.  
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+#ifndef BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
+#define BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
+
+#include "boost/type_traits/detail/yes_no_type.hpp"
+#include "boost/type_traits/config.hpp"
+
+#if defined(BOOST_TT_PREPROCESSING_MODE)
+#   include "boost/preprocessor/iterate.hpp"
+#   include "boost/preprocessor/enum_params.hpp"
+#   include "boost/preprocessor/comma_if.hpp"
+#endif
+
+namespace boost {
+namespace detail {
+namespace is_function_ref_tester_ {
+
+template <class T>
+boost::type_traits::no_type BOOST_TT_DECL is_function_ref_tester(T& ...);
+
+#if !defined(BOOST_TT_PREPROCESSING_MODE)
+// preprocessor-generated part, don't edit by hand!
+
+template <class R>
+boost::type_traits::yes_type is_function_ref_tester(R (&)(), int);
+
+template <class R,class T0 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0), int);
+
+template <class R,class T0,class T1 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1), int);
+
+template <class R,class T0,class T1,class T2 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2), int);
+
+template <class R,class T0,class T1,class T2,class T3 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23), int);
+
+template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24 >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24), int);
+
+#else
+
+#define BOOST_PP_ITERATION_PARAMS_1 \
+    (3, (0, 25, "boost/type_traits/detail/is_function_ref_tester.hpp"))
+#include BOOST_PP_ITERATE()
+
+#endif // BOOST_TT_PREPROCESSING_MODE
+
+} // namespace detail
+} // namespace python
+} // namespace boost
+
+#endif // BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
+
+///// iteration
+
+#else
+#define i BOOST_PP_FRAME_ITERATION(1)
+
+template <class R BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i,class T) >
+boost::type_traits::yes_type is_function_ref_tester(R (&)(BOOST_PP_ENUM_PARAMS(i,T)), int);
+
+#undef i
+#endif // BOOST_PP_IS_ITERATING

include/boost/detail/is_incrementable.hpp

@@ -4,11 +4,16 @@
 #ifndef IS_INCREMENTABLE_DWA200415_HPP
 # define IS_INCREMENTABLE_DWA200415_HPP
 
-# include <boost/type_traits/integral_constant.hpp>
+# include <boost/type_traits/detail/template_arity_spec.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>
 
-namespace boost { namespace detail {
+// Must be the last include
+# include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost { namespace detail { 
 
 // is_incrementable<T> metafunction
 //
@@ -22,7 +27,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.
@@ -30,7 +35,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
@@ -42,33 +47,34 @@ 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)) 
+# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \
+    || BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
 #  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];
-
+  char (& check(tag) )[2];
+  
   template <class T>
-  char check_(T const&);
-
+  char check(T const&);
+  
 
   template <class T>
   struct impl
@@ -77,7 +83,7 @@ namespace is_incrementable_
 
       BOOST_STATIC_CONSTANT(
           bool
-        , value = sizeof(is_incrementable_::check_(BOOST_comma(++x,0))) == 1
+        , value = sizeof(is_incrementable_::check(BOOST_comma(++x,0))) == 1
       );
   };
 
@@ -88,32 +94,39 @@ namespace is_incrementable_
 
       BOOST_STATIC_CONSTANT(
           bool
-        , value = sizeof(is_incrementable_::check_(BOOST_comma(x++,0))) == 1
+        , value = sizeof(is_incrementable_::check(BOOST_comma(x++,0))) == 1
       );
   };
 
 # if defined(BOOST_MSVC)
 #  pragma warning(pop)
-# endif
+# endif 
 
 }
 
 # undef BOOST_comma
 
-template<typename T>
-struct is_incrementable :
-    public boost::integral_constant<bool, boost::detail::is_incrementable_::impl<T>::value>
-{
+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_postfix_incrementable :
-    public boost::integral_constant<bool, boost::detail::is_incrementable_::postfix_impl<T>::value>
-{
+template<typename T> 
+struct is_postfix_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_::postfix_impl<T>::value)
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_postfix_incrementable,(T))
 };
 
 } // 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_sorted.hpp

@@ -1,55 +0,0 @@
-/*==============================================================================
-    Copyright (c) 2010-2011 Bryce Lelbach
-
-    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)
-==============================================================================*/
-
-#ifndef BOOST_DETAIL_SORTED_HPP
-#define BOOST_DETAIL_SORTED_HPP
-
-#include <iterator>
-#include <functional>
-
-namespace boost {
-namespace detail {
-
-template<class Iterator, class Comp>
-inline Iterator is_sorted_until (Iterator first, Iterator last, Comp c) {
-  if (first == last)
-    return last;
-
-  Iterator it = first; ++it;
-
-  for (; it != last; first = it, ++it)
-    if (c(*it, *first))
-      return it;
-
-  return it;
-}
-
-template<class Iterator>
-inline Iterator is_sorted_until (Iterator first, Iterator last) {
-  typedef typename std::iterator_traits<Iterator>::value_type
-    value_type;
-
-  typedef std::less<value_type> c;
-
-  return ::boost::detail::is_sorted_until(first, last, c());
-}
-
-template<class Iterator, class Comp>
-inline bool is_sorted (Iterator first, Iterator last, Comp c) {
-  return ::boost::detail::is_sorted_until(first, last, c) == last;
-}
-
-template<class Iterator>
-inline bool is_sorted (Iterator first, Iterator last) {
-  return ::boost::detail::is_sorted_until(first, last) == last;
-}
-
-} // detail
-} // boost
-
-#endif // BOOST_DETAIL_SORTED_HPP
-

include/boost/detail/is_xxx.hpp

@@ -5,13 +5,46 @@
 # define BOOST_DETAIL_IS_XXX_DWA20051011_HPP
 
 # include <boost/config.hpp>
-# include <boost/type_traits/integral_constant.hpp>
+# include <boost/mpl/bool.hpp>
 # include <boost/preprocessor/enum_params.hpp>
 
+# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+# include <boost/type_traits/is_reference.hpp>
+# include <boost/type_traits/add_reference.hpp>
+
+#  define BOOST_DETAIL_IS_XXX_DEF(name, qualified_name, nargs)          \
+template <class X_>                                                     \
+struct is_##name                                                        \
+{                                                                       \
+    typedef char yes;                                                   \
+    typedef char (&no)[2];                                              \
+                                                                        \
+    static typename add_reference<X_>::type dummy;                      \
+                                                                        \
+    struct helpers                                                      \
+    {                                                                   \
+        template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class U) >          \
+        static yes test(                                                \
+           qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, U) >&, int  \
+        );                                                              \
+                                                                        \
+        template <class U>                                              \
+        static no test(U&, ...);                                        \
+    };                                                                  \
+                                                                        \
+    BOOST_STATIC_CONSTANT(                                              \
+        bool, value                                                     \
+        = !is_reference<X_>::value                                      \
+        & (sizeof(helpers::test(dummy, 0)) == sizeof(yes)));            \
+                                                                        \
+    typedef mpl::bool_<value> type;                                     \
+};
+
+# else
 
 #  define BOOST_DETAIL_IS_XXX_DEF(name, qualified_name, nargs)  \
 template <class T>                                              \
-struct is_##name : boost::false_type                            \
+struct is_##name : mpl::false_                                  \
 {                                                               \
 };                                                              \
                                                                 \
@@ -19,9 +52,10 @@ template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class T) >          \
 struct is_##name<                                               \
    qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, T) >        \
 >                                                               \
-   : boost::true_type                                           \
+   : mpl::true_                                                 \
 {                                                               \
 };
 
+# endif
 
 #endif // BOOST_DETAIL_IS_XXX_DWA20051011_HPP

include/boost/detail/iterator.hpp

@@ -0,0 +1,494 @@
+// (C) Copyright David Abrahams 2002.
+// 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)
+
+// Boost versions of
+//
+//    std::iterator_traits<>::iterator_category
+//    std::iterator_traits<>::difference_type
+//    std::distance()
+//
+// ...for all compilers and iterators
+//
+// Additionally, if X is a pointer
+//    std::iterator_traits<X>::pointer
+
+// Otherwise, if partial specialization is supported or X is not a pointer
+//    std::iterator_traits<X>::value_type
+//    std::iterator_traits<X>::pointer
+//    std::iterator_traits<X>::reference
+//
+// See http://www.boost.org for most recent version including documentation.
+
+// Revision History
+// 04 Mar 2001 - More attempted fixes for Intel C++ (David Abrahams)
+// 03 Mar 2001 - Put all implementation into namespace
+//               boost::detail::iterator_traits_. Some progress made on fixes
+//               for Intel compiler. (David Abrahams)
+// 02 Mar 2001 - Changed BOOST_MSVC to BOOST_MSVC_STD_ITERATOR in a few
+//               places. (Jeremy Siek)
+// 19 Feb 2001 - Improved workarounds for stock MSVC6; use yes_type and
+//               no_type from type_traits.hpp; stopped trying to remove_cv
+//               before detecting is_pointer, in honor of the new type_traits
+//               semantics. (David Abrahams)
+// 13 Feb 2001 - Make it work with nearly all standard-conforming iterators
+//               under raw VC6. The one category remaining which will fail is
+//               that of iterators derived from std::iterator but not
+//               boost::iterator and which redefine difference_type.
+// 11 Feb 2001 - Clean away code which can never be used (David Abrahams)
+// 09 Feb 2001 - Always have a definition for each traits member, even if it
+//               can't be properly deduced. These will be incomplete types in
+//               some cases (undefined<void>), but it helps suppress MSVC errors
+//               elsewhere (David Abrahams)
+// 07 Feb 2001 - Support for more of the traits members where possible, making
+//               this useful as a replacement for std::iterator_traits<T> when
+//               used as a default template parameter.
+// 06 Feb 2001 - Removed useless #includes of standard library headers
+//               (David Abrahams)
+
+#ifndef ITERATOR_DWA122600_HPP_
+# define ITERATOR_DWA122600_HPP_
+
+# include <boost/config.hpp>
+# include <iterator>
+
+// STLPort 4.0 and betas have a bug when debugging is enabled and there is no
+// partial specialization: instead of an iterator_category typedef, the standard
+// container iterators have _Iterator_category.
+//
+// Also, whether debugging is enabled or not, there is a broken specialization
+// of std::iterator<output_iterator_tag,void,void,void,void> which has no
+// typedefs but iterator_category.
+# if defined(__SGI_STL_PORT)
+
+#  if (__SGI_STL_PORT <= 0x410) && !defined(__STL_CLASS_PARTIAL_SPECIALIZATION) && defined(__STL_DEBUG)
+#   define BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
+#  endif
+
+#  define BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
+
+# endif // STLPort <= 4.1b4 && no partial specialization
+
+# if !defined(BOOST_NO_STD_ITERATOR_TRAITS)             \
+  && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+  && !defined(BOOST_MSVC_STD_ITERATOR)
+    
+namespace boost { namespace detail {
+
+// Define a new template so it can be specialized
+template <class Iterator>
+struct iterator_traits
+    : std::iterator_traits<Iterator>
+{};
+using std::distance;
+
+}} // namespace boost::detail
+
+# else
+
+#  if  !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)  \
+    && !defined(BOOST_MSVC_STD_ITERATOR)
+
+// This is the case where everything conforms except BOOST_NO_STD_ITERATOR_TRAITS
+
+namespace boost { namespace detail {
+
+// Rogue Wave Standard Library fools itself into thinking partial
+// specialization is missing on some platforms (e.g. Sun), so fails to
+// supply iterator_traits!
+template <class Iterator>
+struct iterator_traits
+{
+    typedef typename Iterator::value_type value_type;
+    typedef typename Iterator::reference reference;
+    typedef typename Iterator::pointer pointer;
+    typedef typename Iterator::difference_type difference_type;
+    typedef typename Iterator::iterator_category iterator_category;
+};
+
+template <class T>
+struct iterator_traits<T*>
+{
+    typedef T value_type;
+    typedef T& reference;
+    typedef T* pointer;
+    typedef std::ptrdiff_t difference_type;
+    typedef std::random_access_iterator_tag iterator_category;
+};
+
+template <class T>
+struct iterator_traits<T const*>
+{
+    typedef T value_type;
+    typedef T const& reference;
+    typedef T const* pointer;
+    typedef std::ptrdiff_t difference_type;
+    typedef std::random_access_iterator_tag iterator_category;
+};
+
+}} // namespace boost::detail
+
+#  else
+
+# include <boost/type_traits/remove_const.hpp>
+# include <boost/type_traits/detail/yes_no_type.hpp>
+# include <boost/type_traits/is_pointer.hpp>
+
+# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#  include <boost/type_traits/is_same.hpp>
+#  include <boost/type_traits/remove_pointer.hpp>
+# endif
+# ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
+#  include <boost/type_traits/is_base_and_derived.hpp>
+# endif
+
+# include <boost/mpl/if.hpp>
+# include <boost/mpl/has_xxx.hpp>
+# include <cstddef>
+
+// should be the last #include
+# include "boost/type_traits/detail/bool_trait_def.hpp"
+
+namespace boost { namespace detail {
+
+BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(pointer)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(difference_type)
+BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator_category)
+
+// is_mutable_iterator --
+//
+//   A metafunction returning true iff T is a mutable iterator type
+//   with a nested value_type. Will only work portably with iterators
+//   whose operator* returns a reference, but that seems to be OK for
+//   the iterators supplied by Dinkumware. Some input iterators may
+//   compile-time if they arrive here, and if the compiler is strict
+//   about not taking the address of an rvalue.
+
+// This one detects ordinary mutable iterators - the result of
+// operator* is convertible to the value_type.
+template <class T>
+type_traits::yes_type is_mutable_iterator_helper(T const*, BOOST_DEDUCED_TYPENAME T::value_type*);
+
+// Since you can't take the address of an rvalue, the guts of
+// is_mutable_iterator_impl will fail if we use &*t directly.  This
+// makes sure we can still work with non-lvalue iterators.
+template <class T> T* mutable_iterator_lvalue_helper(T& x);
+int mutable_iterator_lvalue_helper(...);
+
+
+// This one detects output iterators such as ostream_iterator which
+// return references to themselves.
+template <class T>
+type_traits::yes_type is_mutable_iterator_helper(T const*, T const*);
+
+type_traits::no_type is_mutable_iterator_helper(...);
+
+template <class T>
+struct is_mutable_iterator_impl
+{
+    static T t;
+    
+    BOOST_STATIC_CONSTANT(
+        bool, value = sizeof(
+            detail::is_mutable_iterator_helper(
+                (T*)0
+              , mutable_iterator_lvalue_helper(*t) // like &*t
+            ))
+        == sizeof(type_traits::yes_type)
+    );
+};
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(
+    is_mutable_iterator,T,::boost::detail::is_mutable_iterator_impl<T>::value)
+
+
+// is_full_iterator_traits --
+//
+//   A metafunction returning true iff T has all the requisite nested
+//   types to satisfy the requirements for a fully-conforming
+//   iterator_traits implementation.
+template <class T>
+struct is_full_iterator_traits_impl
+{
+    enum { value = 
+           has_value_type<T>::value 
+           & has_reference<T>::value 
+           & has_pointer<T>::value 
+           & has_difference_type<T>::value
+           & has_iterator_category<T>::value
+    };
+};
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(
+    is_full_iterator_traits,T,::boost::detail::is_full_iterator_traits_impl<T>::value)
+
+
+#   ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
+BOOST_MPL_HAS_XXX_TRAIT_DEF(_Iterator_category)
+    
+// is_stlport_40_debug_iterator --
+//
+//   A metafunction returning true iff T has all the requisite nested
+//   types to satisfy the requirements of an STLPort 4.0 debug iterator
+//   iterator_traits implementation.
+template <class T>
+struct is_stlport_40_debug_iterator_impl
+{
+    enum { value = 
+           has_value_type<T>::value 
+           & has_reference<T>::value 
+           & has_pointer<T>::value 
+           & has_difference_type<T>::value
+           & has__Iterator_category<T>::value
+    };
+};
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(
+    is_stlport_40_debug_iterator,T,::boost::detail::is_stlport_40_debug_iterator_impl<T>::value)
+
+template <class T>
+struct stlport_40_debug_iterator_traits
+{
+    typedef typename T::value_type value_type;
+    typedef typename T::reference reference;
+    typedef typename T::pointer pointer;
+    typedef typename T::difference_type difference_type;
+    typedef typename T::_Iterator_category iterator_category;
+};
+#   endif // BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF 
+
+template <class T> struct pointer_iterator_traits;
+
+#   ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <class T>
+struct pointer_iterator_traits<T*>
+{
+    typedef typename remove_const<T>::type value_type;
+    typedef T* pointer;
+    typedef T& reference;
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef std::ptrdiff_t difference_type;
+};
+#   else
+
+// In case of no template partial specialization, and if T is a
+// pointer, iterator_traits<T>::value_type can still be computed.  For
+// some basic types, remove_pointer is manually defined in
+// type_traits/broken_compiler_spec.hpp. For others, do it yourself.
+
+template<class P> class please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee;
+
+template<class P>
+struct pointer_value_type
+  : mpl::if_<
+        is_same<P, typename remove_pointer<P>::type>
+      , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<P>
+      , typename remove_const<
+            typename remove_pointer<P>::type
+        >::type
+    >
+{
+};
+
+
+template<class P>
+struct pointer_reference
+  : mpl::if_<
+        is_same<P, typename remove_pointer<P>::type>
+      , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<P>
+      , typename remove_pointer<P>::type&
+    >
+{
+};
+
+template <class T>
+struct pointer_iterator_traits
+{
+    typedef T pointer;
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef std::ptrdiff_t difference_type;
+
+    typedef typename pointer_value_type<T>::type value_type;
+    typedef typename pointer_reference<T>::type reference;
+};
+
+#   endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+// We'll sort iterator types into one of these classifications, from which we
+// can determine the difference_type, pointer, reference, and value_type
+template <class Iterator>
+struct standard_iterator_traits
+{
+    typedef typename Iterator::difference_type difference_type;
+    typedef typename Iterator::value_type value_type;
+    typedef typename Iterator::pointer pointer;
+    typedef typename Iterator::reference reference;
+    typedef typename Iterator::iterator_category iterator_category;
+};
+
+template <class Iterator>
+struct msvc_stdlib_mutable_traits
+    : std::iterator_traits<Iterator>
+{
+    typedef typename std::iterator_traits<Iterator>::distance_type difference_type;
+    typedef typename std::iterator_traits<Iterator>::value_type* pointer;
+    typedef typename std::iterator_traits<Iterator>::value_type& reference;
+};
+
+template <class Iterator>
+struct msvc_stdlib_const_traits
+    : std::iterator_traits<Iterator>
+{
+    typedef typename std::iterator_traits<Iterator>::distance_type difference_type;
+    typedef const typename std::iterator_traits<Iterator>::value_type* pointer;
+    typedef const typename std::iterator_traits<Iterator>::value_type& reference;
+};
+
+#   ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
+template <class Iterator>
+struct is_bad_output_iterator
+    : is_base_and_derived<
+        std::iterator<std::output_iterator_tag,void,void,void,void>
+        , Iterator>
+{
+};
+
+struct bad_output_iterator_traits
+{
+    typedef void value_type;
+    typedef void difference_type;
+    typedef std::output_iterator_tag iterator_category;
+    typedef void pointer;
+    typedef void reference;
+};
+#   endif
+
+// If we're looking at an MSVC6 (old Dinkumware) ``standard''
+// iterator, this will generate an appropriate traits class. 
+template <class Iterator>
+struct msvc_stdlib_iterator_traits
+    : mpl::if_<
+       is_mutable_iterator<Iterator>
+       , msvc_stdlib_mutable_traits<Iterator>
+       , msvc_stdlib_const_traits<Iterator>
+      >::type
+{};
+
+template <class Iterator>
+struct non_pointer_iterator_traits
+    : mpl::if_<
+        // if the iterator contains all the right nested types...
+        is_full_iterator_traits<Iterator>
+        // Use a standard iterator_traits implementation
+        , standard_iterator_traits<Iterator>
+#   ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
+        // Check for STLPort 4.0 broken _Iterator_category type
+        , mpl::if_<
+             is_stlport_40_debug_iterator<Iterator>
+             , stlport_40_debug_iterator_traits<Iterator>
+#   endif
+        // Otherwise, assume it's a Dinkum iterator
+        , msvc_stdlib_iterator_traits<Iterator>
+#   ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
+        >::type
+#   endif 
+    >::type
+{
+};
+
+template <class Iterator>
+struct iterator_traits_aux
+    : mpl::if_<
+        is_pointer<Iterator>
+        , pointer_iterator_traits<Iterator>
+        , non_pointer_iterator_traits<Iterator>
+    >::type
+{
+};
+
+template <class Iterator>
+struct iterator_traits
+{
+    // Explicit forwarding from base class needed to keep MSVC6 happy
+    // under some circumstances.
+ private:
+#   ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
+    typedef 
+    typename mpl::if_<
+        is_bad_output_iterator<Iterator>
+        , bad_output_iterator_traits
+        , iterator_traits_aux<Iterator>
+    >::type base;
+#   else
+    typedef iterator_traits_aux<Iterator> base;
+#   endif
+ public:
+    typedef typename base::value_type value_type;
+    typedef typename base::pointer pointer;
+    typedef typename base::reference reference;
+    typedef typename base::difference_type difference_type;
+    typedef typename base::iterator_category iterator_category;
+};
+
+// This specialization cuts off ETI (Early Template Instantiation) for MSVC.
+template <> struct iterator_traits<int>
+{
+    typedef int value_type;
+    typedef int pointer;
+    typedef int reference;
+    typedef int difference_type;
+    typedef int iterator_category;
+};
+
+}} // namespace boost::detail
+
+#  endif // workarounds
+
+namespace boost { namespace detail {
+
+namespace iterator_traits_
+{
+  template <class Iterator, class Difference>
+  struct distance_select
+  {
+      static Difference execute(Iterator i1, const Iterator i2, ...)
+      {
+          Difference result = 0;
+          while (i1 != i2)
+          {
+              ++i1;
+              ++result;
+          }
+          return result;
+      }
+
+      static Difference execute(Iterator i1, const Iterator i2, std::random_access_iterator_tag*)
+      {
+          return i2 - i1;
+      }
+  };
+} // namespace boost::detail::iterator_traits_
+
+template <class Iterator>
+inline typename iterator_traits<Iterator>::difference_type
+distance(Iterator first, Iterator last)
+{
+    typedef typename iterator_traits<Iterator>::difference_type diff_t;
+    typedef typename ::boost::detail::iterator_traits<Iterator>::iterator_category iterator_category;
+    
+    return iterator_traits_::distance_select<Iterator,diff_t>::execute(
+        first, last, (iterator_category*)0);
+}
+
+}}
+
+# endif
+
+
+# undef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
+# undef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
+
+#endif // ITERATOR_DWA122600_HPP_

include/boost/detail/lightweight_main.hpp

@@ -1,36 +0,0 @@
-//  boost/detail/lightweight_main.hpp  -------------------------------------------------//
-
-//  Copyright Beman Dawes 2010
-
-//  Distributed under the Boost Software License, Version 1.0.
-//  See http://www.boost.org/LICENSE_1_0.txt
-
-#include <iostream>
-#include <exception>
-
-//--------------------------------------------------------------------------------------//
-//                                                                                      //
-//                exception reporting main() that calls cpp_main()                      //
-//                                                                                      //
-//--------------------------------------------------------------------------------------//
-
-int cpp_main(int argc, char* argv[]);
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    return cpp_main(argc, argv);
-  }
-
-  catch (const std::exception& ex)
-  {
-    std::cout
-    << "\nERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR\n"
-    << "\n****************************** std::exception *****************************\n"
-    << ex.what()
-    << "\n***************************************************************************\n"
-    << std::endl;
-  }
-  return 1;
-}

include/boost/detail/lightweight_test.hpp

@@ -0,0 +1,91 @@
+#ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED
+#define BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/detail/lightweight_test.hpp - lightweight test library
+//
+//  Copyright (c) 2002, 2009 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+//
+//  BOOST_TEST(expression)
+//  BOOST_ERROR(message)
+//  BOOST_TEST_EQ(expr1, expr2)
+//
+//  int boost::report_errors()
+//
+
+#include <boost/current_function.hpp>
+#include <iostream>
+
+namespace boost
+{
+
+namespace detail
+{
+
+inline int & test_errors()
+{
+    static int x = 0;
+    return x;
+}
+
+inline void test_failed_impl(char const * expr, char const * file, int line, char const * function)
+{
+    std::cerr << file << "(" << line << "): test '" << expr << "' failed in function '" << function << "'" << std::endl;
+    ++test_errors();
+}
+
+inline void error_impl(char const * msg, char const * file, int line, char const * function)
+{
+    std::cerr << file << "(" << line << "): " << msg << " in function '" << function << "'" << std::endl;
+    ++test_errors();
+}
+
+template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2, char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t == u )
+    {
+    }
+    else
+    {
+        std::cerr << file << "(" << line << "): test '" << expr1 << " == " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << t << "' != '" << u << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+} // namespace detail
+
+inline int report_errors()
+{
+    int errors = detail::test_errors();
+
+    if( errors == 0 )
+    {
+        std::cerr << "No errors detected." << std::endl;
+        return 0;
+    }
+    else
+    {
+        std::cerr << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
+        return 1;
+    }
+}
+
+} // namespace boost
+
+#define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION))
+#define BOOST_ERROR(msg) ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION)
+#define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+
+#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED

include/boost/detail/lightweight_test_report.hpp

@@ -1,56 +0,0 @@
-//  boost/detail/lightweight_test_reporter.hpp  ----------------------------------------//
-
-//  Copyright Beman Dawes 2014
-
-//  Distributed under the Boost Software License, Version 1.0.
-//  See http://www.boost.org/LICENSE_1_0.txt
-
-//--------------------------------------------------------------------------------------//
-//                                                                                      //
-//                         Configuration reporting cpp_main()                           //
-//                                                                                      //
-//  Displays configuration information, then returns test_main(argc, argv), which       //
-//  must be supplied by the user.                                                       //
-//                                                                                      //
-//  Note: cpp_main(argc, argv) is called from a try block in main(), which is           //
-//  supplied by <boost/detail/lightweight_main.hpp> as is a catch block that reports    //
-//  std::exception what().                                                              //
-//                                                                                      //
-//--------------------------------------------------------------------------------------//
-
-#include <boost/config.hpp>
-#include <boost/version.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/detail/lightweight_main.hpp>
-#include <iostream>
-
-int test_main(int argc, char* argv[]);
-
-int cpp_main(int argc, char* argv[])
-{
-  std::cout << BOOST_COMPILER
-#ifdef __GNUC__
-            << ", __GXX_EXPERIMENTAL_CXX0X__ "
-# ifdef __GXX_EXPERIMENTAL_CXX0X__
-              "defined"
-# else
-              "not defined"
-# endif
-#endif
-            << "\n"
-            << BOOST_STDLIB << "\n"
-            << BOOST_PLATFORM << "\n"
-            << "Boost version " << BOOST_VERSION / 100000 << '.'
-            << BOOST_VERSION / 100 % 1000 << '.' << BOOST_VERSION % 100 << "\n";
-
-  std::cout << "Command line: ";
-  for (int a = 0; a < argc; ++a)
-  {
-    std::cout << argv[a];
-    if (a != argc - 1)
-      std::cout << ' ';
-  }
-  std::cout << std::endl;
-
-  return test_main(argc, argv);
-}

include/boost/detail/lightweight_thread.hpp

@@ -0,0 +1,135 @@
+#ifndef BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED
+#define BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  boost/detail/lightweight_thread.hpp
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2008 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <memory>
+#include <cerrno>
+
+// pthread_create, pthread_join
+
+#if defined( BOOST_HAS_PTHREADS )
+
+#include <pthread.h>
+
+#else
+
+#include <windows.h>
+#include <process.h>
+
+typedef HANDLE pthread_t;
+
+int pthread_create( pthread_t * thread, void const *, unsigned (__stdcall * start_routine) (void*), void* arg )
+{
+    HANDLE h = (HANDLE)_beginthreadex( 0, 0, start_routine, arg, 0, 0 );
+
+    if( h != 0 )
+    {
+        *thread = h;
+        return 0;
+    }
+    else
+    {
+        return EAGAIN;
+    }
+}
+
+int pthread_join( pthread_t thread, void ** /*value_ptr*/ )
+{
+    ::WaitForSingleObject( thread, INFINITE );
+    ::CloseHandle( thread );
+    return 0;
+}
+
+#endif
+
+// template<class F> int lw_thread_create( pthread_t & pt, F f );
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lw_abstract_thread
+{
+public:
+
+    virtual ~lw_abstract_thread() {}
+    virtual void run() = 0;
+};
+
+#if defined( BOOST_HAS_PTHREADS )
+
+extern "C" void * lw_thread_routine( void * pv )
+{
+    std::auto_ptr<lw_abstract_thread> pt( static_cast<lw_abstract_thread *>( pv ) );
+
+    pt->run();
+
+    return 0;
+}
+
+#else
+
+unsigned __stdcall lw_thread_routine( void * pv )
+{
+    std::auto_ptr<lw_abstract_thread> pt( static_cast<lw_abstract_thread *>( pv ) );
+
+    pt->run();
+
+    return 0;
+}
+
+#endif
+
+template<class F> class lw_thread_impl: public lw_abstract_thread
+{
+public:
+
+    explicit lw_thread_impl( F f ): f_( f )
+    {
+    }
+
+    void run()
+    {
+        f_();
+    }
+
+private:
+
+    F f_;
+};
+
+template<class F> int lw_thread_create( pthread_t & pt, F f )
+{
+    std::auto_ptr<lw_abstract_thread> p( new lw_thread_impl<F>( f ) );
+
+    int r = pthread_create( &pt, 0, lw_thread_routine, p.get() );
+
+    if( r == 0 )
+    {
+        p.release();
+    }
+
+    return r;
+}
+
+} // namespace detail
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED

include/boost/detail/named_template_params.hpp

@@ -11,10 +11,9 @@
 #ifndef BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP
 #define BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP
 
-#include <boost/config.hpp>
 #include <boost/type_traits/conversion_traits.hpp>
 #include <boost/type_traits/composite_traits.hpp> // for is_reference
-#if defined(BOOST_BORLANDC)
+#if defined(__BORLANDC__)
 #include <boost/type_traits/ice.hpp>
 #endif
 
@@ -58,7 +57,7 @@ namespace boost {
       };
     };
 
-#if defined(BOOST_BORLANDC)
+#if defined(__BORLANDC__)
     template <class UseDefault>
     struct choose_arg_or_default { typedef choose_arg type; };
     template <>
@@ -76,7 +75,7 @@ namespace boost {
     
     template <class Arg, class DefaultGen, class Base, class Traits>
     class resolve_default {
-#if defined(BOOST_BORLANDC)
+#if defined(__BORLANDC__)
       typedef typename choose_arg_or_default<typename is_default<Arg>::type>::type Selector;
 #else
       // This usually works for Borland, but I'm seeing weird errors in

include/boost/detail/no_exceptions_support.hpp

@@ -0,0 +1,87 @@
+#ifndef BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_
+#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+//----------------------------------------------------------------------
+// (C) Copyright 2004 Pavel Vozenilek.
+// 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)
+//
+//
+// This file contains helper macros used when exception support may be
+// disabled (as indicated by macro BOOST_NO_EXCEPTIONS).
+//
+// Before picking up these macros you may consider using RAII techniques
+// to deal with exceptions - their syntax can be always the same with 
+// or without exception support enabled.
+//
+
+/* Example of use:
+
+void foo() {
+  BOOST_TRY {
+    ...
+  } BOOST_CATCH(const std::bad_alloc&) {
+      ...
+      BOOST_RETHROW
+  } BOOST_CATCH(const std::exception& e) {
+      ...
+  }
+  BOOST_CATCH_END
+}
+
+With exception support enabled it will expand into:
+
+void foo() {
+  { try {
+    ...
+  } catch (const std::bad_alloc&) {
+      ...
+      throw;
+  } catch (const std::exception& e) {
+      ...
+  }
+  }
+}
+
+With exception support disabled it will expand into:
+
+void foo() {
+  { if(true) {
+    ...
+  } else if (false) {
+      ...
+  } else if (false)  {
+      ...
+  }
+  }
+}
+*/
+//----------------------------------------------------------------------
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if !(defined BOOST_NO_EXCEPTIONS)
+#    define BOOST_TRY { try
+#    define BOOST_CATCH(x) catch(x)
+#    define BOOST_RETHROW throw;
+#    define BOOST_CATCH_END }
+#else
+#    if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#        define BOOST_TRY { if ("")
+#        define BOOST_CATCH(x) else if (!"")
+#    else
+#        define BOOST_TRY { if (true)
+#        define BOOST_CATCH(x) else if (false)
+#    endif
+#    define BOOST_RETHROW
+#    define BOOST_CATCH_END }
+#endif
+
+
+#endif 

include/boost/detail/numeric_traits.hpp

@@ -56,39 +56,65 @@
 // 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 <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
+# 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>
 
 namespace boost { namespace detail {
 
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+  // 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) || defined(BOOST_MSVC) && BOOST_MSVC <= 1300
+    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
   // digit_traits - compute the number of digits in a built-in integer
   // type. Needed for implementations on which numeric_limits is not specialized
-  // for some integer types, like __int128 in libstdc++ (gcc).
-  template <class T, bool IsSpecialized = std::numeric_limits<T>::is_specialized>
-  struct digit_traits
+  // 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>
   {
-      BOOST_STATIC_CONSTANT(int, digits = std::numeric_limits<T>::digits);
+      template <class T> struct traits
+      {
+          BOOST_STATIC_CONSTANT(int, digits = std::numeric_limits<T>::digits);
+      };
   };
 
   // numeric_limits is not specialized; compute digits from sizeof(T)
-  template <class T>
-  struct digit_traits<T, false>
+  template <> struct digit_traits_select<false>
   {
-      BOOST_STATIC_CONSTANT(int, digits = (
-          sizeof(T) * std::numeric_limits<unsigned char>::digits
-          - (boost::is_signed<T>::value ? 1 : 0))
-          );
+      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);
   };
 #endif
 
@@ -98,48 +124,53 @@ 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;
+#   if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
+      // for some reason, MSVC asserts when it shouldn't unless we make these
+      // local definitions
+      BOOST_STATIC_CONSTANT(bool, is_integer = x::is_integer);
+      BOOST_STATIC_CONSTANT(bool, is_specialized = x::is_specialized);
+      
+      BOOST_STATIC_ASSERT(is_integer);
+      BOOST_STATIC_ASSERT(is_specialized);
+#   endif
    public:
-      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))),
+      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<
         Integer,
+          
+      typename if_true<(int(x::digits) + 1 < digit_traits<signed int>::digits)>::template then<
+        signed int,
 
-        typename boost::conditional<
-          (int(x::digits) + 1 < digit_traits<signed int>::digits),
-          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 long>::digits),
-            signed long,
-            boost::intmax_t
-          >::type
-        >::type
-      >::type difference_type;
+   // else
+        intmax_t
+      >::type>::type>::type difference_type;
 #else
       BOOST_STATIC_ASSERT(boost::is_integral<Integer>::value);
 
-      typedef typename boost::conditional<
-        (sizeof(Integer) >= sizeof(intmax_t)),
-
-        boost::conditional<
-          (boost::is_signed<Integer>::value),
+      typedef typename
+      if_true<(sizeof(Integer) >= sizeof(intmax_t))>::template then<
+               
+        typename if_true<(is_signed<Integer>::value)>::template then<
           Integer,
-          boost::intmax_t
-        >,
+          intmax_t
+        >::type,
 
-        boost::conditional<
-          (sizeof(Integer) < sizeof(std::ptrdiff_t)),
+        typename if_true<(sizeof(Integer) < sizeof(std::ptrdiff_t))>::template then<
           std::ptrdiff_t,
-          boost::intmax_t
-        >
-      >::type::type difference_type;
-#endif
+          intmax_t
+        >::type
+      >::type difference_type;
+# endif
   };
 
   // Right now, only supports integers, but should be expanded.
@@ -150,7 +181,7 @@ namespace boost { namespace detail {
   };
 
   template <class Number>
-  inline BOOST_CONSTEXPR typename numeric_traits<Number>::difference_type numeric_distance(Number x, Number y)
+  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/quick_allocator.hpp

@@ -0,0 +1,23 @@
+#ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED
+#define BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  detail/quick_allocator.hpp
+//
+//  Copyright (c) 2003 David Abrahams
+//  Copyright (c) 2003 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+//
+
+#include <boost/smart_ptr/detail/quick_allocator.hpp>
+
+#endif  // #ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED

include/boost/detail/reference_content.hpp

@@ -15,15 +15,20 @@
 
 #include "boost/config.hpp"
 
-#   include "boost/type_traits/integral_constant.hpp"
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#   include "boost/mpl/bool.hpp"
 #   include "boost/type_traits/has_nothrow_copy.hpp"
+#else
+#   include "boost/mpl/if.hpp"
+#   include "boost/type_traits/is_reference.hpp"
+#endif
+
+#include "boost/mpl/void.hpp"
 
 namespace boost {
 
 namespace detail {
 
-struct void_type {};
-
 ///////////////////////////////////////////////////////////////////////////////
 // (detail) class template reference_content
 //
@@ -71,8 +76,9 @@ public: // queries
 // Wraps with reference_content if specified type is reference.
 //
 
-template <typename T = void_type> struct make_reference_content;
+template <typename T = mpl::void_> struct make_reference_content;
 
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
 template <typename T>
 struct make_reference_content
@@ -86,9 +92,22 @@ struct make_reference_content< T& >
     typedef reference_content<T&> type;
 };
 
+#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template <typename T>
+struct make_reference_content
+    : mpl::if_<
+          is_reference<T>
+        , reference_content<T>
+        , T
+        >
+{
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
 
 template <>
-struct make_reference_content< void_type >
+struct make_reference_content< mpl::void_ >
 {
     template <typename T>
     struct apply
@@ -96,7 +115,7 @@ struct make_reference_content< void_type >
     {
     };
 
-    typedef void_type type;
+    typedef mpl::void_ type;
 };
 
 } // namespace detail
@@ -105,15 +124,17 @@ struct make_reference_content< void_type >
 // reference_content<T&> type traits specializations
 //
 
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
 template <typename T>
 struct has_nothrow_copy<
       ::boost::detail::reference_content< T& >
     >
-    : boost::true_type
+    : mpl::true_
 {
 };
 
+#endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
 } // namespace boost
 

include/boost/detail/scoped_enum_emulation.hpp

@@ -0,0 +1,56 @@
+//  scoped_enum_emulation.hpp  ---------------------------------------------------------//
+
+//  Copyright Beman Dawes, 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Generates C++0x scoped enums if the feature is present, otherwise emulates C++0x
+//  scoped enums with C++03 namespaces and enums. The Boost.Config BOOST_NO_SCOPED_ENUMS
+//  macro is used to detect feature support.
+//
+//  See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf for a
+//  description of the scoped enum feature. Note that the committee changed the name
+//  from strongly typed enum to scoped enum.  
+//
+//  Caution: only the syntax is emulated; the semantics are not emulated and
+//  the syntax emulation doesn't include being able to specify the underlying
+//  representation type.
+//
+//  The emulation is via struct rather than namespace to allow use within classes.
+//  Thanks to Andrey Semashev for pointing that out.
+//
+//  Helpful comments and suggestions were also made by Kjell Elster, Phil Endecott,
+//  Joel Falcou, Mathias Gaunard, Felipe Magno de Almeida, Matt Calabrese, Vincente
+//  Botet, and Daniel James. 
+//
+//  Sample usage:
+//
+//     BOOST_SCOPED_ENUM_START(algae) { green, red, cyan }; BOOST_SCOPED_ENUM_END
+//     ...
+//     BOOST_SCOPED_ENUM(algae) sample( algae::red );
+//     void foo( BOOST_SCOPED_ENUM(algae) color );
+//     ...
+//     sample = algae::green;
+//     foo( algae::cyan );
+
+#ifndef BOOST_SCOPED_ENUM_EMULATION_HPP
+#define BOOST_SCOPED_ENUM_EMULATION_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_SCOPED_ENUMS
+
+# define BOOST_SCOPED_ENUM_START(name) struct name { enum enum_type
+# define BOOST_SCOPED_ENUM_END };
+# define BOOST_SCOPED_ENUM(name) name::enum_type
+
+#else
+
+# define BOOST_SCOPED_ENUM_START(name) enum class name
+# define BOOST_SCOPED_ENUM_END
+# define BOOST_SCOPED_ENUM(name) name
+
+#endif
+
+#endif  // BOOST_SCOPED_ENUM_EMULATION_HPP

include/boost/detail/utf8_codecvt_facet.hpp

@@ -14,7 +14,7 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // utf8_codecvt_facet.hpp
 
-// This header defines class utf8_codecvt_facet, derived from 
+// This header defines class utf8_codecvt_facet, derived fro 
 // std::codecvt<wchar_t, char>, which can be used to convert utf8 data in
 // files into wchar_t strings in the application.
 //
@@ -28,13 +28,12 @@
 //   This seems inconvenient, and asking a user to link to an unrevieved 
 //   library is strange. 
 // Until the above points are fixed, a library which wants to use utf8 must:
-// - include this header in one of it's headers or sources
-// - include the corresponding boost/detail/utf8_codecvt_facet.ipp file in one
-//   of its sources
+// - include this header from one of it's headers or sources
+// - include the corresponding .cpp file from one of the sources
 // - before including either file, the library must define
 //   - BOOST_UTF8_BEGIN_NAMESPACE to the namespace declaration that must be used
 //   - BOOST_UTF8_END_NAMESPACE to the code to close the previous namespace
-//     declaration.
+//   - declaration.
 //   - BOOST_UTF8_DECL -- to the code which must be used for all 'exportable'
 //     symbols.
 //
@@ -43,7 +42,7 @@
 //             namespace boost { namespace program_options {
 //    #define BOOST_UTF8_END_NAMESPACE }}
 //    #define BOOST_UTF8_DECL BOOST_PROGRAM_OPTIONS_DECL
-//    #include <boost/detail/utf8_codecvt_facet.ipp>
+//    #include "../../detail/utf8/utf8_codecvt.cpp"
 //
 // Essentially, each library will have its own copy of utf8 code, in
 // different namespaces. 
@@ -93,28 +92,24 @@ namespace std {
 }
 #endif
 
+#if !defined(__MSL_CPP__) && !defined(__LIBCOMO__)
+    #define BOOST_CODECVT_DO_LENGTH_CONST const
+#else
+    #define BOOST_CODECVT_DO_LENGTH_CONST
+#endif
+
 // maximum lenght of a multibyte string
 #define MB_LENGTH_MAX 8
 
 BOOST_UTF8_BEGIN_NAMESPACE
 
-//----------------------------------------------------------------------------//
-//                                                                            //
-//                          utf8_codecvt_facet                                //
-//                                                                            //
-//            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);
-    virtual ~utf8_codecvt_facet();
+    explicit utf8_codecvt_facet(std::size_t no_locale_manage=0)
+        : std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage) 
+    {}
 protected:
     virtual std::codecvt_base::result do_in(
         std::mbstate_t& state, 
@@ -127,13 +122,9 @@ protected:
     ) const;
 
     virtual std::codecvt_base::result do_out(
-        std::mbstate_t & state,
-        const wchar_t * from,
-        const wchar_t * from_end,
-        const wchar_t*  & from_next,
-        char * to,
-        char * to_end,
-        char * & to_next
+        std::mbstate_t & state, const wchar_t * from,
+        const wchar_t * from_end, const wchar_t*  & from_next,
+        char * to, char * to_end, char * & to_next
     ) const;
 
     bool invalid_continuing_octet(unsigned char octet_1) const {
@@ -146,19 +137,17 @@ protected:
     }
 
     // continuing octets = octets except for the leading octet
-    static unsigned int get_cont_octet_count(unsigned char lead_octet) {
+    static unsigned int get_cont_octet_count(unsigned   char lead_octet) {
         return get_octet_count(lead_octet) - 1;
     }
 
-    static unsigned int get_octet_count(unsigned char lead_octet);
+    static unsigned int get_octet_count(unsigned char   lead_octet);
 
     // How many "continuing octets" will be needed for this word
     // ==   total octets - 1.
     int get_cont_octet_out_count(wchar_t word) const ;
 
-    virtual bool do_always_noconv() const BOOST_NOEXCEPT_OR_NOTHROW {
-        return false;
-    }
+    virtual bool do_always_noconv() const throw() { return false; }
 
     // UTF-8 isn't really stateful since we rewind on partial conversions
     virtual std::codecvt_base::result do_unshift(
@@ -166,12 +155,13 @@ protected:
         char * from,
         char * /*to*/,
         char * & next
-    ) const {
+    ) const 
+    {
         next = from;
         return ok;
     }
 
-    virtual int do_encoding() const BOOST_NOEXCEPT_OR_NOTHROW {
+    virtual int do_encoding() const throw() {
         const int variable_byte_external_encoding=0;
         return variable_byte_external_encoding;
     }
@@ -179,37 +169,18 @@ protected:
     // How many char objects can I process to get <= max_limit
     // wchar_t objects?
     virtual int do_length(
-        std::mbstate_t &,
+        BOOST_CODECVT_DO_LENGTH_CONST std::mbstate_t &,
         const char * from,
         const char * from_end, 
         std::size_t max_limit
-    ) const
 #if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
-    throw()
+        ) const throw();
+#else
+        ) const;
 #endif
-    ;
-
-    // Nonstandard override
-    virtual int do_length(
-        const std::mbstate_t & s,
-        const char * from,
-        const char * from_end, 
-        std::size_t max_limit
-    ) const
-#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
-    throw()
-#endif
-    {
-        return do_length(
-            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 {
+    virtual int do_max_length() const throw () {
         return 6; // largest UTF-8 encoding of a UCS-4 character
     }
 };

include/boost/indirect_reference.hpp

@@ -0,0 +1,43 @@
+#ifndef INDIRECT_REFERENCE_DWA200415_HPP
+# define INDIRECT_REFERENCE_DWA200415_HPP
+
+//
+// Copyright David Abrahams 2004. 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)
+//
+// typename indirect_reference<P>::type provides the type of *p.
+//
+// http://www.boost.org/libs/iterator/doc/pointee.html
+//
+
+# include <boost/detail/is_incrementable.hpp>
+# include <boost/iterator/iterator_traits.hpp>
+# include <boost/type_traits/remove_cv.hpp>
+# include <boost/mpl/eval_if.hpp>
+# include <boost/pointee.hpp>
+
+namespace boost { 
+
+namespace detail
+{
+  template <class P>
+  struct smart_ptr_reference
+  {
+      typedef typename boost::pointee<P>::type& type;
+  };
+}
+
+template <class P>
+struct indirect_reference
+  : mpl::eval_if<
+        detail::is_incrementable<P>
+      , iterator_reference<P>
+      , detail::smart_ptr_reference<P>
+    >
+{
+};
+  
+} // namespace boost
+
+#endif // INDIRECT_REFERENCE_DWA200415_HPP

include/boost/non_type.hpp

@@ -0,0 +1,27 @@
+// -------------------------------------
+//
+//           (C) Copyright Gennaro Prota 2003.
+//
+// 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)
+//
+// ------------------------------------------------------
+
+#ifndef BOOST_NON_TYPE_HPP_GP_20030417
+#define BOOST_NON_TYPE_HPP_GP_20030417
+
+
+namespace boost {
+
+  // Just a simple "envelope" for non-type template parameters. Useful
+  // to work around some MSVC deficiencies.
+
+ template <typename T, T n>
+ struct non_type { };
+
+
+}
+
+
+#endif // include guard

include/boost/pending/cstddef.hpp

@@ -0,0 +1,16 @@
+// -*- C++ -*- forwarding header.
+//  (C) Copyright Jeremy Siek 2004 
+//  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)
+
+#ifndef BOOST_CSTDDEF_HPP
+#define BOOST_CSTDDEF_HPP
+
+#if defined(__sgi) && !defined(__GNUC__)
+# include <stddef.h>
+#else
+# include <cstddef>
+#endif
+
+#endif

include/boost/pending/integer_log2.hpp

@@ -0,0 +1,112 @@
+// -----------------------------------------------------------
+// integer_log2.hpp
+//
+//   Gives the integer part of the logarithm, in base 2, of a
+// given number. Behavior is undefined if the argument is <= 0.
+//
+//         Copyright (c) 2003-2004, 2008 Gennaro Prota
+//
+// 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)
+//
+// -----------------------------------------------------------
+
+#ifndef BOOST_INTEGER_LOG2_HPP_GP_20030301
+#define BOOST_INTEGER_LOG2_HPP_GP_20030301
+
+#include <assert.h>
+#ifdef __BORLANDC__
+#include <climits>
+#endif
+#include "boost/limits.hpp"
+#include "boost/config.hpp"
+
+
+namespace boost {
+ namespace detail {
+
+  template <typename T>
+  int integer_log2_impl(T x, int n) {
+
+      int result = 0;
+
+      while (x != 1) {
+
+          const T t = static_cast<T>(x >> n);
+          if (t) {
+              result += n;
+              x = t;
+          }
+          n /= 2;
+
+      }
+
+      return result;
+  }
+
+
+
+  // helper to find the maximum power of two
+  // less than p (more involved than necessary,
+  // to avoid PTS)
+  //
+  template <int p, int n>
+  struct max_pow2_less {
+
+      enum { c = 2*n < p };
+
+      BOOST_STATIC_CONSTANT(int, value =
+          c ? (max_pow2_less< c*p, 2*c*n>::value) : n);
+
+  };
+
+  template <>
+  struct max_pow2_less<0, 0> {
+
+      BOOST_STATIC_CONSTANT(int, value = 0);
+  };
+
+  // this template is here just for Borland :(
+  // we could simply rely on numeric_limits but sometimes
+  // Borland tries to use numeric_limits<const T>, because
+  // of its usual const-related problems in argument deduction
+  // - gps
+  template <typename T>
+  struct width {
+
+#ifdef __BORLANDC__
+      BOOST_STATIC_CONSTANT(int, value = sizeof(T) * CHAR_BIT);
+#else
+      BOOST_STATIC_CONSTANT(int, value = (std::numeric_limits<T>::digits));
+#endif
+
+  };
+
+ } // detail
+
+
+ // ---------
+ // integer_log2
+ // ---------------
+ //
+ template <typename T>
+ int integer_log2(T x) {
+
+     assert(x > 0);
+
+     const int n = detail::max_pow2_less<
+                     detail::width<T> :: value, 4
+                   > :: value;
+
+     return detail::integer_log2_impl(x, n);
+
+ }
+
+
+
+}
+
+
+
+#endif // include guard

include/boost/type.hpp

@@ -0,0 +1,18 @@
+// (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)
+
+#ifndef BOOST_TYPE_DWA20010120_HPP
+# define BOOST_TYPE_DWA20010120_HPP
+
+namespace boost {
+
+  // Just a simple "type envelope". Useful in various contexts, mostly to work
+  // around some MSVC deficiencies.
+  template <class T>
+  struct type {};
+
+}
+
+#endif // BOOST_TYPE_DWA20010120_HPP

include/boost/visit_each.hpp

@@ -0,0 +1,29 @@
+// Boost.Signals library
+
+// Copyright Douglas Gregor 2001-2003. 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)
+
+// For more information, see http://www.boost.org/libs/signals
+
+#ifndef BOOST_VISIT_EACH_HPP
+#define BOOST_VISIT_EACH_HPP
+
+#include <boost/config.hpp>
+
+namespace boost {
+  template<typename Visitor, typename T>
+  inline void visit_each(Visitor& visitor, const T& t, long)
+  {
+    visitor(t);
+  }
+
+  template<typename Visitor, typename T>
+  inline void visit_each(Visitor& visitor, const T& t)
+  {
+    visit_each(visitor, t, 0);
+  }
+}
+
+#endif // BOOST_VISIT_EACH_HPP

index.html

@@ -1,14 +0,0 @@
-<!--
-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

@@ -1,27 +0,0 @@
-{
-    "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

@@ -1,33 +0,0 @@
-################################################################*# Jam #*#######
-#   Copyright (C) 2010 Bryce Lelbach
-#
-#   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)
-################################################################################
-
-build-project container_fwd ;
-
-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
-    # Do not enable libstdc++ debug mode because of gcc 10.1 bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=95289
-    # <toolset>gcc:<define>_GLIBCXX_DEBUG
-    <toolset>darwin:<cxxflags>-ftemplate-depth-300
-  ;
-
-# 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

@@ -1,46 +0,0 @@
-
-// 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 <boost/core/allocator_access.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <memory>
-
-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
-    {
-        boost::allocator_pointer<char_allocator>::type p = a2.allocate(10);
-        BOOST_TEST(!!p);
-        a2.deallocate(p, 10);
-    }
-
-    // Try using the standalone construct/destroy
-    {
-        boost::allocator_pointer<int_allocator>::type p2 = a3.allocate(1);
-        boost::detail::allocator::construct(p2, 25);
-        BOOST_TEST(*p2 == 25);
-        boost::detail::allocator::destroy(p2);
-        a3.deallocate(p2, 1);
-    }
-
-    return boost::report_errors();
-}

test/binary_search_test.cpp

@@ -1,264 +0,0 @@
-// (C) Copyright David Abrahams 2000.
-// 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/binary_search.hpp>
-#include <vector>
-#include <string>
-#include <memory>
-#include <climits>
-#include <iostream>
-#include <cstddef>
-#include <stdlib.h> // for rand(). Would use cstdlib but VC6.4 doesn't put it in std::
-#include <list>
-#include <utility>
-#include <algorithm>
-#include <boost/detail/workaround.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-#if defined(__SGI_STL_PORT) ? defined(__SGI_STL_OWN_IOSTREAMS) : (!defined(__GNUC__) || __GNUC__ > 2)
-# define USE_SSTREAM
-#endif
-
-#ifdef USE_SSTREAM
-# include <sstream>
-#else
-# include <strstream>
-#endif
-
-namespace {
-
-// In order to get ADL to find the comparison operators defined below, they have
-struct mystring : std::string
-{
-    typedef std::string base;
-
-    mystring(std::string const& x)
-        : base(x) {}
-};
-
-typedef std::vector<mystring> string_vector;
-
-const std::size_t sequence_length = 1000;
-
-unsigned random_number()
-{
-    return static_cast<unsigned>(::rand()) % sequence_length;
-}
-
-# ifndef USE_SSTREAM
-class unfreezer {
- public:
-    unfreezer(std::ostrstream& s) : m_stream(s) {}
-    ~unfreezer() { m_stream.freeze(false); }
- private:
-    std::ostrstream& m_stream;
-};
-# endif
-
-template <class T>
-void push_back_random_number_string(T& seq)
-{
-    unsigned value = random_number();
-# if defined(__SGI_STL_PORT) ? defined(__SGI_STL_OWN_IOSTREAMS) : (!defined(__GNUC__) || __GNUC__ > 2)
-    std::ostringstream s;
-    s << value;
-    seq.push_back(s.str());
-# else
-    std::ostrstream s;
-    auto unfreezer unfreeze(s);
-    s << value << char(0);
-    seq.push_back(std::string(s.str()));
-# endif
-}
-
-inline unsigned to_int(unsigned x) { return x; }
-inline unsigned to_int(const std::string& x) { return atoi(x.c_str()); }
-
-struct cmp
-{
-    template <class A1, class A2>
-    inline bool operator()(const A1& a1, const A2& a2) const
-    {
-        return to_int(a1) < to_int(a2);
-    }
-};
-
-inline bool operator<(const mystring& x, const unsigned y)
-{
-    return to_int(x) < y;
-}
-
-inline bool operator<(const unsigned y, const mystring& x)
-{
-    return y < to_int(x);
-}
-
-template <class T>
-void sort_by_value(T& x);
-
-template <class T>
-void sort_by_value_(T& v, long)
-{
-    std::sort(v.begin(), v.end(), cmp());
-}
-
-template <class T>
-void random_sorted_sequence(T& seq)
-{
-    seq.clear();
-    for (std::size_t i = 0; i < sequence_length; ++i)
-    {
-        push_back_random_number_string(seq);
-    }
-    sort_by_value(seq);
-}
-
-template <class T, class A>
-void sort_by_value_(std::list<T,A>& l, int)
-{
-# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) && !defined(__SGI_STL_PORT)
-// VC6's standard lib doesn't have a template member function for list::sort()
-    std::vector<T> seq;
-    seq.reserve(sequence_length);
-    std::copy(l.begin(), l.end(), std::back_inserter(seq));
-    sort_by_value(seq);
-    std::copy(seq.begin(), seq.end(), l.begin());
-# else
-    l.sort(cmp());
-# endif
-}
-
-template <class T>
-void sort_by_value(T& x)
-{
-    (sort_by_value_)(x, 1);
-}
-
-// A way to select the comparisons with/without a Compare parameter for testing.
-template <class Compare> struct searches
-{
-    template <class Iterator, class Key>
-    static Iterator lower_bound(Iterator start, Iterator finish, Key key, Compare cmp)
-        { return boost::detail::lower_bound(start, finish, key, cmp); }
-
-    template <class Iterator, class Key>
-    static Iterator upper_bound(Iterator start, Iterator finish, Key key, Compare cmp)
-        { return boost::detail::upper_bound(start, finish, key, cmp); }
-
-    template <class Iterator, class Key>
-    static std::pair<Iterator, Iterator> equal_range(Iterator start, Iterator finish, Key key, Compare cmp)
-        { return boost::detail::equal_range(start, finish, key, cmp); }
-
-    template <class Iterator, class Key>
-    static bool binary_search(Iterator start, Iterator finish, Key key, Compare cmp)
-        { return boost::detail::binary_search(start, finish, key, cmp); }
-};
-
-struct no_compare {};
-
-template <> struct searches<no_compare>
-{
-    template <class Iterator, class Key>
-    static Iterator lower_bound(Iterator start, Iterator finish, Key key, no_compare)
-        { return boost::detail::lower_bound(start, finish, key); }
-
-    template <class Iterator, class Key>
-    static Iterator upper_bound(Iterator start, Iterator finish, Key key, no_compare)
-        { return boost::detail::upper_bound(start, finish, key); }
-
-    template <class Iterator, class Key>
-    static std::pair<Iterator, Iterator> equal_range(Iterator start, Iterator finish, Key key, no_compare)
-        { return boost::detail::equal_range(start, finish, key); }
-
-    template <class Iterator, class Key>
-    static bool binary_search(Iterator start, Iterator finish, Key key, no_compare)
-        { return boost::detail::binary_search(start, finish, key); }
-};
-
-template <class Sequence, class Compare>
-void test_loop(Sequence& x, Compare cmp, unsigned long test_count)
-{
-    typedef typename Sequence::const_iterator const_iterator;
-
-    for (unsigned long i = 0; i < test_count; ++i)
-    {
-        random_sorted_sequence(x);
-        const const_iterator start = x.begin();
-        const const_iterator finish = x.end();
-
-        unsigned key = random_number();
-        const const_iterator l = searches<Compare>::lower_bound(start, finish, key, cmp);
-        const const_iterator u = searches<Compare>::upper_bound(start, finish, key, cmp);
-
-        bool found_l = false;
-        bool found_u = false;
-        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)
-            {
-                BOOST_TEST(found_l);
-                found_u = true;
-            }
-
-            unsigned value = to_int(*p);
-            BOOST_TEST(value >= last_value);
-            last_value = value;
-
-            if (!found_l)
-            {
-                ++index;
-                BOOST_TEST(to_int(*p) < key);
-            }
-            else if (!found_u)
-            {
-                ++count;
-                BOOST_TEST(to_int(*p) == key);
-            }
-            else
-            {
-                BOOST_TEST(to_int(*p) > key);
-            }
-        }
-        BOOST_TEST(found_l || l == finish);
-        BOOST_TEST(found_u || u == finish);
-
-        std::pair<const_iterator, const_iterator>
-            range = searches<Compare>::equal_range(start, finish, key, cmp);
-        BOOST_TEST(range.first == l);
-        BOOST_TEST(range.second == u);
-
-        bool found = searches<Compare>::binary_search(start, finish, key, cmp);
-        (void)found;
-        BOOST_TEST(found == (u != l));
-        std::cout << "found " << count << " copies of " << key << " at index " << index << "\n";
-    }
-}
-
-}
-
-int main()
-{
-    string_vector x;
-    std::cout << "=== testing random-access iterators with <: ===\n";
-    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);
-    std::cout << "=== testing bidirectional iterators with compare: ===\n";
-    test_loop(y, cmp(), 25);
-    std::cerr << "******TEST PASSED******\n";
-
-    return boost::report_errors();
-}

test/blank_test.cpp

@@ -1,37 +0,0 @@
-
-// 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 <boost/core/lightweight_test.hpp>
-#include <boost/type_traits/is_pod.hpp>
-#include <boost/type_traits/is_empty.hpp>
-#include <boost/type_traits/is_stateless.hpp>
-#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;
-    BOOST_TEST(b1 == b2);
-    BOOST_TEST(b1 <= b2);
-    BOOST_TEST(b1 >= b2);
-    BOOST_TEST(!(b1 != b2));
-    BOOST_TEST(!(b1 < b2));
-    BOOST_TEST(!(b1 > b2));
-
-#if !defined(BOOST_NO_IOSTREAM)
-    std::stringstream s;
-    s << "(" << b1 << ")";
-    BOOST_TEST(s.str() == "()");
-#endif
-
-    return boost::report_errors();
-}

test/container_fwd/Jamfile

@@ -1,39 +0,0 @@
-
-# Copyright 2011 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)
-
-import testing ;
-
-project detail/test/container_fwd
-  : requirements
-        <warnings>all
-        <toolset>intel:<warnings>on
-        <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion"
-        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion"
-        <toolset>clang:<cxxflags>"-pedantic -Wextra -Wmismatched-tags"
-        <warnings-as-errors>on
-  ;
-
-run container_no_fwd_test.cpp ;
-run container_fwd_test.cpp : : : : container_fwd ;
-run container_fwd_test.cpp : :
-    : <define>_STLP_DEBUG <define>_GLIBCXX_DEBUG
-    : container_fwd_debug ;
-
-# The 'correctly_disable' tests fail if forward declaring standard types
-# could work, but is currently not being done. Unfortunately, this if often
-# the case - but we can't detect it, so the tests fail and there's not much
-# we can do. There are also problems because some compilers don't support
-# the debug version of their libraries. So I felt it was best to stop these
-# tests from running in a normal test run..
-
-compile-fail correctly_disable_fail.cpp
-    : <warnings-as-errors>off
-    : correctly_disable ;
-compile-fail correctly_disable_fail.cpp
-    : <warnings-as-errors>off <define>_STLP_DEBUG <define>_GLIBCXX_DEBUG
-    : correctly_disable_debug ;
-
-explicit correctly_disable ;
-explicit correctly_disable_debug ;

test/container_fwd/container_fwd_test.cpp

@@ -1,112 +0,0 @@
-
-// Copyright 2005-2009 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/container_fwd.hpp>
-
-#if BOOST_WORKAROUND(__GNUC__, < 3) && \
-    !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-template <class charT, class Allocator>
-static void test(
-    std::basic_string<charT, std::string_char_traits<charT>, Allocator> const&)
-{
-}
-#else
-template <class charT, class Allocator>
-static void test(
-    std::basic_string<charT, std::char_traits<charT>, Allocator> const&)
-{
-}
-#endif
-    
-template <class T, class Allocator>
-static void test(std::deque<T, Allocator> const&)
-{
-}
-
-template <class T, class Allocator>
-static void test(std::list<T, Allocator> const&)
-{
-}
-
-template <class T, class Allocator>
-static void test(std::vector<T, Allocator> const&)
-{
-}
-
-template <class Key, class T, class Compare, class Allocator>
-static void test(std::map<Key, T, Compare, Allocator> const&)
-{
-}
-
-template <class Key, class T, class Compare, class Allocator>
-static void test(std::multimap<Key, T, Compare, Allocator> const&)
-{
-}
-
-template <class Key, class Compare, class Allocator>
-static void test(std::set<Key, Compare, Allocator> const&)
-{
-}
-
-template <class Key, class Compare, class Allocator>
-static void test(std::multiset<Key, Compare, Allocator> const&)
-{
-}
-
-template <std::size_t N>
-static void test(std::bitset<N> const&)
-{
-}
-
-template <class T>
-static void test(std::complex<T> const&)
-{
-}
-
-template <class X, class Y>
-static void test(std::pair<X, Y> const&)
-{
-}
-
-#include <deque>
-#include <list>
-#include <vector>
-#include <map>
-#include <set>
-#include <bitset>
-#include <string>
-#include <complex>
-#include <utility>
-
-int main()
-{
-    std::deque<int> x1;
-    std::list<std::string> x2;
-    std::vector<float> x3;
-    std::vector<bool> x4;
-    std::map<int, int> x5;
-    std::multimap<float, int*> x6;
-    std::set<std::string> x7;
-    std::multiset<std::vector<int> > x8;
-    std::bitset<10> x9;
-    std::string x10;
-    std::complex<double> x11;
-    std::pair<std::list<int>, char***> x12;
-
-    test(x1);
-    test(x2);
-    test(x3);
-    test(x4);
-    test(x5);
-    test(x6);
-    test(x7);
-    test(x8);
-    test(x9);
-    test(x10);
-    test(x11);
-    test(x12);
-
-    return 0;
-}

test/container_fwd/container_no_fwd_test.cpp

@@ -1,14 +0,0 @@
-
-// Copyright 2010 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)
-
-#define BOOST_DETAIL_NO_CONTAINER_FWD
-
-#include <boost/detail/container_fwd.hpp>
-
-int main()
-{
-    std::set<int> x;
-    std::vector<std::string> y;
-}

test/container_fwd/correctly_disable_fail.cpp

@@ -1,43 +0,0 @@
-
-// Copyright 2011 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)
-
-// This tests if container forwarding is correctly disabled. If it isn't
-// disabled it causes a compile error (which causes the test to pass).
-// If it is disabled it tries container forwarding. If it doesn't work
-// then there will be a compile error, indicating that it is correctly
-// disabled. But if there isn't a compile error that indicates that
-// container forwarding might work.
-//
-// Since this test only tries std::vector, it might get it wrong but I didn't
-// want it to fail because of some incompatibility with a trickier class.
-
-#define BOOST_DETAIL_TEST_CONFIG_ONLY
-#include <boost/detail/container_fwd.hpp>
-
-#if !defined(BOOST_DETAIL_NO_CONTAINER_FWD)
-#error "Failing in order to pass test"
-#else
-#define BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD
-
-#undef BOOST_DETAIL_CONTAINER_FWD_HPP
-#undef BOOST_DETAIL_TEST_CONFIG_ONLY
-
-#include <boost/detail/container_fwd.hpp>
-
-template <class T, class Allocator>
-void test(std::vector<T, Allocator> const&)
-{
-}
-
-#include <vector>
-
-int main ()
-{
-    std::vector<int> x;
-    test(x);
-}
-
-#endif
-

test/is_sorted_test.cpp

@@ -1,137 +0,0 @@
-/*==============================================================================
-    Copyright (c) 2010-2011 Bryce Lelbach
-
-    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_sorted.hpp>
-#include <iostream>
-#include <boost/config.hpp>
-#include <boost/array.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-template<class T>
-struct tracking_less {
-  typedef bool result_type;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-
-  #if defined(__PATHSCALE__)
-  tracking_less (void) { }
-  ~tracking_less (void) { }
-  #endif
-
-  bool operator() (T const& x, T const& y) const {
-    std::cout << x << " < " << y << " == " << (x < y) << "\n"; 
-    return x < y;
-  }
-};
-
-template<class T>
-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) { }
-  ~tracking_less_equal (void) { }
-  #endif
-
-  bool operator() (T const& x, T const& y) const {
-    std::cout << x << " <= " << y << " == " << (x <= y) << "\n"; 
-    return x <= y;
-  }
-};
-
-template<class T>
-struct tracking_greater {
-  typedef bool result_type;
-  typedef T first_argument_type;
-  typedef T second_argument_type;
-
-  #if defined(__PATHSCALE__)
-  tracking_greater (void) { }
-  ~tracking_greater (void) { }
-  #endif
-
-  bool operator() (T const& x, T const& y) const {
-    std::cout << x << " > " << y << " == " << (x > y) << "\n"; 
-    return x > y;
-  }
-};
-
-template<class T>
-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) { }
-  ~tracking_greater_equal (void) { }
-  #endif
-
-  bool operator() (T const& x, T const& y) const {
-    std::cout << x << " >= " << y << " == " << (x >= y) << "\n"; 
-    return x >= y;
-  }
-};
-
-
-int main (void) {
-  #define IS_SORTED ::boost::detail::is_sorted
-  #define IS_SORTED_UNTIL ::boost::detail::is_sorted_until
-  using boost::array;
-  using boost::report_errors;
-
-  std::cout << std::boolalpha;
-
-  array<int, 10> a = { { 0, 1, 2,  3,  4, 5, 6,  7,  8,   9  } };
-  array<int, 10> b = { { 0, 1, 1,  2,  5, 8, 13, 34, 55,  89 } };
-  array<int, 10> c = { { 0, 1, -1, 2, -3, 5, -8, 13, -21, 34 } };
-
-  tracking_less<int> lt;
-  tracking_less_equal<int> lte;
-  tracking_greater<int> gt;
-  tracking_greater_equal<int> gte;
-
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(a.begin(), a.end()),          a.end());
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(a.begin(), a.end(), lt),      a.end());
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(a.begin(), a.end(), lte),     a.end());
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(a.rbegin(), a.rend(), gt).base(),   a.rend().base());
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(a.rbegin(), a.rend(), gte).base(),  a.rend().base());
-
-  BOOST_TEST_EQ(IS_SORTED(a.begin(), a.end()),        true);
-  BOOST_TEST_EQ(IS_SORTED(a.begin(), a.end(), lt),    true);
-  BOOST_TEST_EQ(IS_SORTED(a.begin(), a.end(), lte),   true);
-  BOOST_TEST_EQ(IS_SORTED(a.rbegin(), a.rend(), gt),  true);
-  BOOST_TEST_EQ(IS_SORTED(a.rbegin(), a.rend(), gte), true);
-
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(b.begin(), b.end()),          b.end());
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(b.begin(), b.end(), lt),      b.end());
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(b.begin(), b.end(), lte),     &b[2]);
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(b.rbegin(), b.rend(), gt).base(),   b.rend().base());
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(b.rbegin(), b.rend(), gte).base(),  &b[2]);
-
-  BOOST_TEST_EQ(IS_SORTED(b.begin(), b.end()),        true);
-  BOOST_TEST_EQ(IS_SORTED(b.begin(), b.end(), lt),    true);
-  BOOST_TEST_EQ(IS_SORTED(b.begin(), b.end(), lte),   false);
-  BOOST_TEST_EQ(IS_SORTED(b.rbegin(), b.rend(), gt),  true);
-  BOOST_TEST_EQ(IS_SORTED(b.rbegin(), b.rend(), gte), false);
-
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(c.begin(), c.end()),          &c[2]);
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(c.begin(), c.end(), lt),      &c[2]);
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(c.begin(), c.end(), lte),     &c[2]);
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(c.rbegin(), c.rend(), gt).base(),   &c[8]);
-  BOOST_TEST_EQ(IS_SORTED_UNTIL(c.rbegin(), c.rend(), gte).base(),  &c[8]);
-
-  BOOST_TEST_EQ(IS_SORTED(c.begin(), c.end()),        false);
-  BOOST_TEST_EQ(IS_SORTED(c.begin(), c.end(), lt),    false);
-  BOOST_TEST_EQ(IS_SORTED(c.begin(), c.end(), lte),   false);
-  BOOST_TEST_EQ(IS_SORTED(c.rbegin(), c.rend(), gt),  false);
-  BOOST_TEST_EQ(IS_SORTED(c.rbegin(), c.rend(), gte), false);
-
-  return report_errors();
-}

test/is_xxx_test.cpp

@@ -1,23 +0,0 @@
-
-// 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

@@ -1,422 +0,0 @@
-//  (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;
-};
-
-// C++20 ostream has deleted operator<< for wchar_t
-template <> struct stream_as<wchar_t> {
-    typedef unsigned int t1;
-    typedef unsigned int 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

@@ -1,16 +0,0 @@
-
-// 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

@@ -1,302 +0,0 @@
-/////////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;
-}
-

utf8_codecvt_facet.cpp

@@ -1,5 +1,5 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// utf8_codecvt_facet.ipp
+// utf8_codecvt_facet.cpp
 
 // Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
 // Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). 
@@ -30,15 +30,6 @@ 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*/, 
@@ -180,13 +171,14 @@ 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(
-    std::mbstate_t &,
+    BOOST_CODECVT_DO_LENGTH_CONST std::mbstate_t &,
     const char * from,
     const char * from_end, 
     std::size_t max_limit
-) const
 #if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
-        throw()
+) const throw()
+#else
+) const
 #endif
 { 
     // RG - this code is confusing!  I need a better way to express it.
@@ -207,11 +199,11 @@ int utf8_codecvt_facet::do_length(
         last_octet_count = (get_octet_count(*from_next));
         ++char_count;
     }
-    return static_cast<int>(from_next-from);
+    return static_cast<int>(from_next-from_end);
 }
 
 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;
@@ -225,9 +217,9 @@ unsigned int utf8_codecvt_facet::get_octet_count(
     else if (0xf8 <= lead_octet && lead_octet <= 0xfb) return 5;
     else return 6;
 }
+BOOST_UTF8_END_NAMESPACE
 
-namespace detail {
-
+namespace {
 template<std::size_t s>
 int get_cont_octet_out_count_impl(wchar_t word){
     if (word < 0x80) {
@@ -278,14 +270,15 @@ int get_cont_octet_out_count_impl<4>(wchar_t word){
 #endif
 }
 
-} // namespace detail
+} // namespace anonymous
 
+BOOST_UTF8_BEGIN_NAMESPACE
 // How many "continuing octets" will be needed for this word
 // ==   total octets - 1.
 int utf8_codecvt_facet::get_cont_octet_out_count(
     wchar_t word
 ) const {
-    return detail::get_cont_octet_out_count_impl<sizeof(wchar_t)>(word);
+    return get_cont_octet_out_count_impl<sizeof(wchar_t)>(word);
 }
 BOOST_UTF8_END_NAMESPACE