Fix eol-style and mime-types

[SVN r7564]

.travis.yml

@@ -1,250 +0,0 @@
-# Copyright 2016, 2017 Peter Dimov
-# 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
-
-python: "2.7"
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
-
-    - os: linux
-      compiler: g++-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
-      compiler: g++-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
-      compiler: g++-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
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-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: trusty
-      compiler: g++-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: trusty
-      compiler: g++-8
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
-
-    - os: linux
-      compiler: clang++-3.5
-      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - clang-3.5
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.5
-
-    - os: linux
-      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
-            - llvm-toolchain-precise-3.6
-
-    - os: linux
-      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
-            - llvm-toolchain-precise-3.7
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-            - libstdc++-5-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.9
-            - libstdc++-5-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.9
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-            - libstdc++-5-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-5.0
-      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-            - libstdc++-5-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
-
-    - os: linux
-      compiler: clang++-6.0
-      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-            - libstdc++-5-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
-
-    - os: linux
-      compiler: clang++-7
-      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - clang-7
-            - libstdc++-5-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-7
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-
-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/boost_install
-  - git submodule init libs/headers
-  - git submodule init libs/assert
-  - git submodule init libs/config
-  - git submodule init libs/core
-  - git submodule init libs/preprocessor
-  - git submodule init libs/static_assert
-  - git submodule init libs/throw_exception
-  - git submodule init libs/type_traits
-  - git submodule init libs/container_hash
-  - git submodule init libs/integer
-  - git submodule init libs/detail
-  - git submodule update --jobs $GIT_FETCH_JOBS
-  - cp -r $TRAVIS_BUILD_DIR/* libs/utility
-  - ./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/utility/test toolset=$TOOLSET cxxstd=$CXXSTD
-
-notifications:
-  email:
-    on_success: always

Assignable.html

@@ -1,109 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-<head>
-  <meta http-equiv="Content-Language" content="en-us">
-  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
-
-  <title>Assignable</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
-"#FF0000">
-  <img src="../../boost.png" alt="C++ Boost" width="277" height=
-  "86"><br clear="none">
-
-  <h1>Assignable</h1>
-
-  <h3>Description</h3>
-
-  <p>A type is Assignable if it is possible to assign one object of the type
-  to another object of that type.</p>
-
-  <h3>Notation</h3>
-
-  <table summary="">
-    <tr>
-      <td valign="top"><tt>T</tt></td>
-
-      <td valign="top">is type that is a model of Assignable</td>
-    </tr>
-
-    <tr>
-      <td valign="top"><tt>t</tt></td>
-
-      <td valign="top">is an object of type <tt>T</tt></td>
-    </tr>
-
-    <tr>
-      <td valign="top"><tt>u</tt></td>
-
-      <td valign="top">is an object of type <tt>T</tt> or possibly <tt>const
-      T</tt></td>
-    </tr>
-  </table>
-
-  <h3>Definitions</h3>
-
-  <h3>Valid expressions</h3>
-
-  <table border summary="">
-    <tr>
-      <th>Name</th>
-
-      <th>Expression</th>
-
-      <th>Return type</th>
-
-      <th>Semantics</th>
-    </tr>
-
-    <tr>
-      <td valign="top">Assignment</td>
-
-      <td valign="top"><tt>t = u</tt></td>
-
-      <td valign="top"><tt>T&amp;</tt></td>
-
-      <td valign="top"><tt>t</tt> is equivalent to <tt>u</tt></td>
-    </tr>
-  </table>
-
-  <h3>Models</h3>
-
-  <ul>
-    <li><tt>int</tt></li>
-
-    <li><tt>std::pair</tt></li>
-  </ul>
-
-  <h3>See also</h3>
-
-  <p><a href=
-  "http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>
-  and <a href="./CopyConstructible.html">CopyConstructible</a><br></p>
-  <hr>
-
-  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
-  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
-  height="31" width="88"></a></p>
-
-  <p>Revised 
-  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05 December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
-
-  <table summary="">
-    <tr valign="top">
-      <td nowrap><i>Copyright &copy; 2000</i></td>
-
-      <td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
-      Notre Dame (<a href=
-      "mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
-    </tr>
-  </table>
-
-  <p><i>Distributed under the Boost Software License, Version 1.0. (See
-  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
-  copy at <a href=
-  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
-</body>
-</html>

Buffer.html

@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title>Buffer Concept</title>
+  </head>
+  <body>
+    <h1><img src="../../c++boost.gif" alt="C++ Boost" width="277" height="86" /><br />Buffer Concept</h1>
+    <p>A Buffer is something in which items can be put and removed.  The Buffer <em>concept</em> has very few requirements.  It does not require any particular ordering of how the items are stored or in what order they will appear when removed, however, there is typically some sort of ordering policy.</p>
+
+    <h3>Notation</h3>
+    <ul>
+      <li><tt>B</tt> is a type that models <tt>Buffer</tt>.</li>
+      <li><tt>T</tt> is the value type of <tt>B</tt>.</li>
+      <li><tt>t</tt> is an object of type <tt>T</tt>.</li>
+    </ul>
+
+    <h3>Members</h3>
+    <p>For a type to model the Buffer concept it must have the following members.</p>
+
+    <table border="1">
+      <tr>
+        <th>Member</th>
+        <th>Description</th>
+      </tr>
+      <tr valign="top">
+        <td><tt>value_type</tt></td>
+        <td>The type of object stored in the Buffer.  The value type must be <a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>size_type</tt></td>
+        <td>An unsigned integral type for representing the number of objects in the Buffer.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>void push(const T&amp; t)</tt></td>
+        <td>Inserts <tt>t</tt> into the Buffer.  <tt>size()</tt> will be incremented by one.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>void pop()</tt></td>
+        <td>Removes an object from the Buffer.  <tt>size()</tt> will be decremented by one.  Precondition: <tt>empty()</tt> is <tt>false</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>T&amp; top()</tt></td>
+        <td>Returns a mutable reference to some object in the Buffer.  Precondition: <tt>empty()</tt> is <tt>false</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>const T&amp; top() const</tt></td>
+        <td>Returns a const reference to some object in the Buffer.  Precondition: <tt>empty()</tt> is <tt>false</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>void size() const</tt></td>
+        <td>Returns the number of objects in the Buffer.  Invariant: <tt>size() &gt;= 0</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>bool empty() const</tt></td>
+        <td>Equivalent to <tt>b.size() == 0</tt>.</td>
+      </tr>
+    </table>
+
+    <h3>Complexity Guarantees</h3>
+    <ul>
+      <li><tt>push()</tt>, <tt>pop()</tt>, and <tt>size()</tt> must be at most linear time complexity in the size of the Generalized Queue.</li>
+      <li><tt>top()</tt> and <tt>empty()</tt> must be amortized constant time.</li>
+    </ul>
+
+    <h3>Models</h3>
+    <ul>
+      <li><a href="http://www.sgi.com/tech/stl/stack.html"><tt>std::stack</tt></a></li>
+      <li><a href="./queue.html"><tt>boost::queue</tt></a></li>
+      <li><a href="../pri_queue/doc/mutable_queue.html"><tt>boost::mutable_queue</tt></a></li>
+      <li><a href="../pri_queue/doc/fibonacci_heap.html"><tt>boost::fibonacci_heap</tt></a></li>
+      <li><a href="../pri_queue/doc/fenced_priority_queue.html"><tt>boost::fenced_priority_queue</tt></a></li>
+    </ul>
+
+    <hr />
+    <table border="0">
+      <tr valign="top">
+        <td>Copyright &copy; 2004</td>
+        <td><a href="../../people/jeremy_siek.htm">Jeremy Siek</a>, Univ. of Notre Dame (<a href="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</td>
+      </tr>
+    </table>
+    <p>Use, modification, and distribution are subject to the Boost Software License, Version 1.0 at <a href="../../LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a></p>
+  </body>
+</html> 
+

CMakeLists.txt

@@ -1,27 +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(BoostUtility LANGUAGES CXX)
-
-add_library(boost_utility INTERFACE)
-add_library(Boost::utility ALIAS boost_utility)
-
-target_include_directories(boost_utility INTERFACE include)
-
-target_link_libraries(boost_utility
-    INTERFACE
-        Boost::config
-        Boost::container_hash
-        Boost::core
-        Boost::preprocessor
-        Boost::static_assert
-        Boost::throw_exception
-        Boost::type_traits
-)

Collection.html

@@ -1,534 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-<head>
-  <meta http-equiv="Content-Language" content="en-us">
-  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
-
-  <title>Collection</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
-"#FF0000">
-  <h1><img src="../../boost.png" alt="boost logo" width="277" align="middle"
-  height="86"><br>
-  Collection</h1>
-
-  <h3>Description</h3>
-
-  <p>A Collection is a <i>concept</i> similar to the STL <a href=
-  "http://www.sgi.com/tech/stl/Container.html">Container</a> concept. A
-  Collection provides iterators for accessing a range of elements and
-  provides information about the number of elements in the Collection.
-  However, a Collection has fewer requirements than a Container. The
-  motivation for the Collection concept is that there are many useful
-  Container-like types that do not meet the full requirements of Container,
-  and many algorithms that can be written with this reduced set of
-  requirements. To summarize the reduction in requirements:</p>
-
-  <ul>
-    <li>It is not required to "own" its elements: the lifetime of an element
-    in a Collection does not have to match the lifetime of the Collection
-    object, though the lifetime of the element should cover the lifetime of
-    the Collection object.</li>
-
-    <li>The semantics of copying a Collection object is not defined (it could
-    be a deep or shallow copy or not even support copying).</li>
-
-    <li>The associated reference type of a Collection does not have to be a
-    real C++ reference.</li>
-  </ul>Because of the reduced requirements, some care must be taken when
-  writing code that is meant to be generic for all Collection types. In
-  particular, a Collection object should be passed by-reference since
-  assumptions can not be made about the behaviour of the copy constructor.
-
-  <h3>Associated types</h3>
-
-  <table border summary="">
-    <tr>
-      <td valign="top">Value type</td>
-
-      <td valign="top"><tt>X::value_type</tt></td>
-
-      <td valign="top">The type of the object stored in a Collection. If the
-      Collection is <i>mutable</i> then the value type must be <a href=
-      "http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>. Otherwise
-      the value type must be <a href=
-      "./CopyConstructible.html">CopyConstructible</a>.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Iterator type</td>
-
-      <td valign="top"><tt>X::iterator</tt></td>
-
-      <td valign="top">The type of iterator used to iterate through a
-      Collection's elements. The iterator's value type is expected to be the
-      Collection's value type. A conversion from the iterator type to the
-      const iterator type must exist. The iterator type must be an <a href=
-      "http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Const iterator type</td>
-
-      <td valign="top"><tt>X::const_iterator</tt></td>
-
-      <td valign="top">A type of iterator that may be used to examine, but
-      not to modify, a Collection's elements.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Reference type</td>
-
-      <td valign="top"><tt>X::reference</tt></td>
-
-      <td valign="top">A type that behaves like a reference to the
-      Collection's value type. <a href="#n1">[1]</a></td>
-    </tr>
-
-    <tr>
-      <td valign="top">Const reference type</td>
-
-      <td valign="top"><tt>X::const_reference</tt></td>
-
-      <td valign="top">A type that behaves like a const reference to the
-      Collection's value type.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Pointer type</td>
-
-      <td valign="top"><tt>X::pointer</tt></td>
-
-      <td valign="top">A type that behaves as a pointer to the Collection's
-      value type.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Distance type</td>
-
-      <td valign="top"><tt>X::difference_type</tt></td>
-
-      <td valign="top">A signed integral type used to represent the distance
-      between two of the Collection's iterators. This type must be the same
-      as the iterator's distance type.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Size type</td>
-
-      <td valign="top"><tt>X::size_type</tt></td>
-
-      <td valign="top">An unsigned integral type that can represent any
-      nonnegative value of the Collection's distance type.</td>
-    </tr>
-  </table>
-
-  <h3>Notation</h3>
-
-  <table summary="">
-    <tr>
-      <td valign="top"><tt>X</tt></td>
-
-      <td valign="top">A type that is a model of Collection.</td>
-    </tr>
-
-    <tr>
-      <td valign="top"><tt>a</tt>, <tt>b</tt></td>
-
-      <td valign="top">Object of type <tt>X</tt>.</td>
-    </tr>
-
-    <tr>
-      <td valign="top"><tt>T</tt></td>
-
-      <td valign="top">The value type of <tt>X</tt>.</td>
-    </tr>
-  </table>
-
-  <h3>Valid expressions</h3>
-
-  <p>The following expressions must be valid.</p>
-
-  <table border summary="">
-    <tr>
-      <th>Name</th>
-
-      <th>Expression</th>
-
-      <th>Return type</th>
-    </tr>
-
-    <tr>
-      <td valign="top">Beginning of range</td>
-
-      <td valign="top"><tt>a.begin()</tt></td>
-
-      <td valign="top"><tt>iterator</tt> if <tt>a</tt> is mutable,
-      <tt>const_iterator</tt> otherwise</td>
-    </tr>
-
-    <tr>
-      <td valign="top">End of range</td>
-
-      <td valign="top"><tt>a.end()</tt></td>
-
-      <td valign="top"><tt>iterator</tt> if <tt>a</tt> is mutable,
-      <tt>const_iterator</tt> otherwise</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Size</td>
-
-      <td valign="top"><tt>a.size()</tt></td>
-
-      <td valign="top"><tt>size_type</tt></td>
-    </tr><!--
-<TR>
-<TD VAlign=top>
-Maximum size
-</TD>
-<TD VAlign=top>
-<tt>a.max_size()</tt>
-</TD>
-<TD VAlign=top>
-<tt>size_type</tt>
-</TD>
-</TR>
--->
-
-    <tr>
-      <td valign="top">Empty Collection</td>
-
-      <td valign="top"><tt>a.empty()</tt></td>
-
-      <td valign="top">Convertible to <tt>bool</tt></td>
-    </tr>
-
-    <tr>
-      <td valign="top">Swap</td>
-
-      <td valign="top"><tt>a.swap(b)</tt></td>
-
-      <td valign="top"><tt>void</tt></td>
-    </tr>
-  </table>
-
-  <h3>Expression semantics</h3>
-
-  <table border summary="">
-    <tr>
-      <th>Name</th>
-
-      <th>Expression</th>
-
-      <th>Semantics</th>
-
-      <th>Postcondition</th>
-    </tr>
-
-    <tr>
-      <td valign="top">Beginning of range</td>
-
-      <td valign="top"><tt>a.begin()</tt></td>
-
-      <td valign="top">Returns an iterator pointing to the first element in
-      the Collection.</td>
-
-      <td valign="top"><tt>a.begin()</tt> is either dereferenceable or
-      past-the-end. It is past-the-end if and only if <tt>a.size() ==
-      0</tt>.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">End of range</td>
-
-      <td valign="top"><tt>a.end()</tt></td>
-
-      <td valign="top">Returns an iterator pointing one past the last element
-      in the Collection.</td>
-
-      <td valign="top"><tt>a.end()</tt> is past-the-end.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Size</td>
-
-      <td valign="top"><tt>a.size()</tt></td>
-
-      <td valign="top">Returns the size of the Collection, that is, its
-      number of elements.</td>
-
-      <td valign="top"><tt>a.size() &gt;= 0</tt></td>
-    </tr><!--
-<TR>
-<TD VAlign=top>
-Maximum size
-</TD>
-<TD VAlign=top>
-<tt>a.max_size()</tt>
-</TD>
-<TD VAlign=top>
-&nbsp;
-</TD>
-<TD VAlign=top>
-Returns the largest size that this Collection can ever have. <A href="#8">[8]</A>
-</TD>
-<TD VAlign=top>
-<tt>a.max_size() &gt;= 0 &amp;&amp; a.max_size() &gt;= a.size()</tt>
-</TD>
-</TR>
- -->
-
-    <tr>
-      <td valign="top">Empty Collection</td>
-
-      <td valign="top"><tt>a.empty()</tt></td>
-
-      <td valign="top">Equivalent to <tt>a.size() == 0</tt>. (But possibly
-      faster.)</td>
-
-      <td valign="top">&nbsp;</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Swap</td>
-
-      <td valign="top"><tt>a.swap(b)</tt></td>
-
-      <td valign="top">Equivalent to <tt>swap(a,b)</tt></td>
-
-      <td valign="top">&nbsp;</td>
-    </tr>
-  </table>
-
-  <h3>Complexity guarantees</h3>
-
-  <p><tt>begin()</tt> and <tt>end()</tt> are amortized constant time.</p>
-
-  <p><tt>size()</tt> is at most linear in the Collection's size.
-  <tt>empty()</tt> is amortized constant time.</p>
-
-  <p><tt>swap()</tt> is at most linear in the size of the two
-  collections.</p>
-
-  <h3>Invariants</h3>
-
-  <table border summary="">
-    <tr>
-      <td valign="top">Valid range</td>
-
-      <td valign="top">For any Collection <tt>a</tt>, <tt>[a.begin(),
-      a.end())</tt> is a valid range.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Range size</td>
-
-      <td valign="top"><tt>a.size()</tt> is equal to the distance from
-      <tt>a.begin()</tt> to <tt>a.end()</tt>.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Completeness</td>
-
-      <td valign="top">An algorithm that iterates through the range
-      <tt>[a.begin(), a.end())</tt> will pass through every element of
-      <tt>a</tt>.</td>
-    </tr>
-  </table>
-
-  <h3>Models</h3>
-
-  <ul>
-    <li><tt>array</tt></li>
-
-    <li><tt>array_ptr</tt></li>
-
-    <li><tt>vector&lt;bool&gt;</tt></li>
-  </ul>
-
-  <h3>Collection Refinements</h3>
-
-  <p>There are quite a few concepts that refine the Collection concept,
-  similar to the concepts that refine the Container concept. Here is a brief
-  overview of the refining concepts.</p>
-
-  <h4>ForwardCollection</h4>
-
-  <p>The elements are arranged in some order that does not change
-  spontaneously from one iteration to the next. As a result, a
-  ForwardCollection is <a href=
-  "http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a>
-  and <a href=
-  "http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</a>.
-  In addition, the iterator type of a ForwardCollection is a
-  MultiPassInputIterator which is just an InputIterator with the added
-  requirements that the iterator can be used to make multiple passes through
-  a range, and that if <tt>it1 == it2</tt> and <tt>it1</tt> is
-  dereferenceable then <tt>++it1 == ++it2</tt>. The ForwardCollection also
-  has a <tt>front()</tt> method.</p>
-
-  <table border summary="">
-    <tr>
-      <th>Name</th>
-
-      <th>Expression</th>
-
-      <th>Return type</th>
-
-      <th>Semantics</th>
-    </tr>
-
-    <tr>
-      <td valign="top">Front</td>
-
-      <td valign="top"><tt>a.front()</tt></td>
-
-      <td valign="top"><tt>reference</tt> if <tt>a</tt> is mutable,<br>
-      <tt>const_reference</tt> otherwise.</td>
-
-      <td valign="top">Equivalent to <tt>*(a.begin())</tt>.</td>
-    </tr>
-  </table>
-
-  <h4>ReversibleCollection</h4>
-
-  <p>The container provides access to iterators that traverse in both
-  directions (forward and reverse). The iterator type must meet all of the
-  requirements of <a href=
-  "http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>
-  except that the reference type does not have to be a real C++ reference.
-  The ReversibleCollection adds the following requirements to those of
-  ForwardCollection.</p>
-
-  <table border summary="">
-    <tr>
-      <th>Name</th>
-
-      <th>Expression</th>
-
-      <th>Return type</th>
-
-      <th>Semantics</th>
-    </tr>
-
-    <tr>
-      <td valign="top">Beginning of range</td>
-
-      <td valign="top"><tt>a.rbegin()</tt></td>
-
-      <td valign="top"><tt>reverse_iterator</tt> if <tt>a</tt> is mutable,
-      <tt>const_reverse_iterator</tt> otherwise.</td>
-
-      <td valign="top">Equivalent to
-      <tt>X::reverse_iterator(a.end())</tt>.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">End of range</td>
-
-      <td valign="top"><tt>a.rend()</tt></td>
-
-      <td valign="top"><tt>reverse_iterator</tt> if <tt>a</tt> is mutable,
-      <tt>const_reverse_iterator</tt> otherwise.</td>
-
-      <td valign="top">Equivalent to
-      <tt>X::reverse_iterator(a.begin())</tt>.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Back</td>
-
-      <td valign="top"><tt>a.back()</tt></td>
-
-      <td valign="top"><tt>reference</tt> if <tt>a</tt> is mutable,<br>
-      <tt>const_reference</tt> otherwise.</td>
-
-      <td valign="top">Equivalent to <tt>*(--a.end())</tt>.</td>
-    </tr>
-  </table>
-
-  <h4>SequentialCollection</h4>
-
-  <p>The elements are arranged in a strict linear order. No extra methods are
-  required.</p>
-
-  <h4>RandomAccessCollection</h4>
-
-  <p>The iterators of a RandomAccessCollection satisfy all of the
-  requirements of <a href=
-  "http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>
-  except that the reference type does not have to be a real C++ reference. In
-  addition, a RandomAccessCollection provides an element access operator.</p>
-
-  <table border summary="">
-    <tr>
-      <th>Name</th>
-
-      <th>Expression</th>
-
-      <th>Return type</th>
-
-      <th>Semantics</th>
-    </tr>
-
-    <tr>
-      <td valign="top">Element Access</td>
-
-      <td valign="top"><tt>a[n]</tt></td>
-
-      <td valign="top"><tt>reference</tt> if <tt>a</tt> is mutable,
-      <tt>const_reference</tt> otherwise.</td>
-
-      <td valign="top">Returns the nth element of the Collection. <tt>n</tt>
-      must be convertible to <tt>size_type</tt>. Precondition: <tt>0 &lt;= n
-      &lt; a.size()</tt>.</td>
-    </tr>
-  </table>
-
-  <h3>Notes</h3>
-
-  <p><a name="n1" id="n1">[1]</a> The reference type does not have to be a
-  real C++ reference. The requirements of the reference type depend on the
-  context within which the Collection is being used. Specifically it depends
-  on the requirements the context places on the value type of the Collection.
-  The reference type of the Collection must meet the same requirements as the
-  value type. In addition, the reference objects must be equivalent to the
-  value type objects in the collection (which is trivially true if they are
-  the same object). Also, in a mutable Collection, an assignment to the
-  reference object must result in an assignment to the object in the
-  Collection (again, which is trivially true if they are the same object, but
-  non-trivial if the reference type is a proxy class).</p>
-
-  <h3>See also</h3>
-
-  <p><a href=
-  "http://www.sgi.com/tech/stl/Container.html">Container</a><br></p>
-  <hr>
-
-  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
-  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
-  height="31" width="88"></a></p>
-
-  <p>Revised 
-  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
-  December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
-
-  <table summary="">
-    <tr valign="top">
-      <td nowrap><i>Copyright &copy; 2000</i></td>
-
-      <td><i><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy
-      Siek</a>, Univ.of Notre Dame and C++ Library &amp; Compiler Group/SGI
-      (<a href="mailto:jsiek@engr.sgi.com">jsiek@engr.sgi.com</a>)</i></td>
-    </tr>
-  </table>
-
-  <p><i>Distributed under the Boost Software License, Version 1.0. (See
-  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
-  copy at <a href=
-  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
-</body>
-</html>

CopyConstructible.html

@@ -1,185 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-<head>
-  <meta http-equiv="Content-Language" content="en-us">
-  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
-
-  <title>Copy Constructible</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
-"#FF0000">
-  <img src="../../boost.png" alt="C++ Boost" width="277" height=
-  "86"><br clear="none">
-
-  <h1>Copy Constructible</h1>
-
-  <h3>Description</h3>
-
-  <p>A type is Copy Constructible if it is possible to copy objects of that
-  type.</p>
-
-  <h3>Notation</h3>
-
-  <table summary="">
-    <tr>
-      <td valign="top"><tt>T</tt></td>
-
-      <td valign="top">is type that is a model of Copy Constructible</td>
-    </tr>
-
-    <tr>
-      <td valign="top"><tt>t</tt></td>
-
-      <td valign="top">is an object of type <tt>T</tt></td>
-    </tr>
-
-    <tr>
-      <td valign="top"><tt>u</tt></td>
-
-      <td valign="top">is an object of type <tt>const T</tt></td>
-    </tr>
-  </table>
-
-  <h3>Definitions</h3>
-
-  <h3>Valid expressions</h3>
-
-  <table border summary="">
-    <tr>
-      <th>Name</th>
-
-      <th>Expression</th>
-
-      <th>Return type</th>
-
-      <th>Semantics</th>
-    </tr>
-
-    <tr>
-      <td valign="top">Copy constructor</td>
-
-      <td valign="top"><tt>T(t)</tt></td>
-
-      <td valign="top"><tt>T</tt></td>
-
-      <td valign="top"><tt>t</tt> is equivalent to <tt>T(t)</tt></td>
-    </tr>
-
-    <tr>
-      <td valign="top">Copy constructor</td>
-
-      <td valign="top">
-        <pre>
-T(u)
-</pre>
-      </td>
-
-      <td valign="top"><tt>T</tt></td>
-
-      <td valign="top"><tt>u</tt> is equivalent to <tt>T(u)</tt></td>
-    </tr>
-
-    <tr>
-      <td valign="top">Destructor</td>
-
-      <td valign="top">
-        <pre>
-t.~T()
-</pre>
-      </td>
-
-      <td valign="top"><tt>T</tt></td>
-
-      <td valign="top">&nbsp;</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Address Operator</td>
-
-      <td valign="top">
-        <pre>
-&amp;t
-</pre>
-      </td>
-
-      <td valign="top"><tt>T*</tt></td>
-
-      <td valign="top">denotes the address of <tt>t</tt></td>
-    </tr>
-
-    <tr>
-      <td valign="top">Address Operator</td>
-
-      <td valign="top">
-        <pre>
-&amp;u
-</pre>
-      </td>
-
-      <td valign="top"><tt>T*</tt></td>
-
-      <td valign="top">denotes the address of <tt>u</tt></td>
-    </tr>
-  </table>
-
-  <h3>Models</h3>
-
-  <ul>
-    <li><tt>int</tt></li>
-
-    <li><tt>std::pair</tt></li>
-  </ul>
-
-  <h3>Concept Checking Class</h3>
-  <pre>
-  template &lt;class T&gt;
-  struct CopyConstructibleConcept
-  {
-    void constraints() {
-      T a(b);            // require copy constructor
-      T* ptr = &amp;a;       // require address of operator
-      const_constraints(a);
-      ignore_unused_variable_warning(ptr);
-    }
-    void const_constraints(const T&amp; a) {
-      T c(a);            // require const copy constructor
-      const T* ptr = &amp;a; // require const address of operator
-      ignore_unused_variable_warning(c);
-      ignore_unused_variable_warning(ptr);
-    }
-    T b;
-  };
-</pre>
-
-  <h3>See also</h3>
-
-  <p><a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default
-  Constructible</a> and <a href="./Assignable.html">Assignable</a><br></p>
-  <hr>
-
-  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
-  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
-  height="31" width="88"></a></p>
-
-  <p>Revised 
-  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
-  December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
-
-  <table summary="">
-    <tr valign="top">
-      <td nowrap><i>Copyright &copy; 2000</i></td>
-
-      <td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
-      Notre Dame (<a href=
-      "mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
-    </tr>
-  </table>
-
-  <p><i>Distributed under the Boost Software License, Version 1.0. (See
-  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
-  copy at <a href=
-  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
-</body>
-</html>

LessThanComparable.html

@@ -1,210 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-<!--
-  == Copyright (c) 1996-1999
-  == 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 appears 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 (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 appears in all copies and
-  == that both that copyright notice and this permission notice appear
-  == 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.
-  ==
-  -->
-
-<head>
-  <meta http-equiv="Content-Language" content="en-us">
-  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
-
-  <title>LessThanComparable</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
-"#FF0000">
-  <img src="../../boost.png" alt="C++ Boost" width="277" height=
-  "86"><br clear="none">
-
-  <h1>LessThanComparable</h1>
-
-  <h3>Description</h3>
-
-  <p>A type is LessThanComparable if it is ordered: it must be possible to
-  compare two objects of that type using <tt>operator&lt;</tt>, and
-  <tt>operator&lt;</tt> must be a strict weak ordering relation.</p>
-
-  <h3>Refinement of</h3>
-
-  <h3>Associated types</h3>
-
-  <h3>Notation</h3>
-
-  <table summary="">
-    <tr>
-      <td valign="top"><tt>X</tt></td>
-
-      <td valign="top">A type that is a model of LessThanComparable</td>
-    </tr>
-
-    <tr>
-      <td valign="top"><tt>x</tt>, <tt>y</tt>, <tt>z</tt></td>
-
-      <td valign="top">Object of type <tt>X</tt></td>
-    </tr>
-  </table>
-
-  <h3>Definitions</h3>
-
-  <p>Consider the relation <tt>!(x &lt; y) &amp;&amp; !(y &lt; x)</tt>. If
-  this relation is transitive (that is, if <tt>!(x &lt; y) &amp;&amp; !(y
-  &lt; x) &amp;&amp; !(y &lt; z) &amp;&amp; !(z &lt; y)</tt> implies <tt>!(x
-  &lt; z) &amp;&amp; !(z &lt; x)</tt>), then it satisfies the mathematical
-  definition of an equivalence relation. In this case, <tt>operator&lt;</tt>
-  is a <i>strict weak ordering</i>.</p>
-
-  <p>If <tt>operator&lt;</tt> is a strict weak ordering, and if each
-  equivalence class has only a single element, then <tt>operator&lt;</tt> is
-  a <i>total ordering</i>.</p>
-
-  <h3>Valid expressions</h3>
-
-  <table border summary="">
-    <tr>
-      <th>Name</th>
-
-      <th>Expression</th>
-
-      <th>Type requirements</th>
-
-      <th>Return type</th>
-    </tr>
-
-    <tr>
-      <td valign="top">Less</td>
-
-      <td valign="top"><tt>x &lt; y</tt></td>
-
-      <td valign="top">&nbsp;</td>
-
-      <td valign="top">Convertible to <tt>bool</tt></td>
-    </tr>
-  </table>
-
-  <h3>Expression semantics</h3>
-
-  <table border summary="">
-    <tr>
-      <th>Name</th>
-
-      <th>Expression</th>
-
-      <th>Precondition</th>
-
-      <th>Semantics</th>
-
-      <th>Postcondition</th>
-    </tr>
-
-    <tr>
-      <td valign="top">Less</td>
-
-      <td valign="top"><tt>x &lt; y</tt></td>
-
-      <td valign="top"><tt>x</tt> and <tt>y</tt> are in the domain of
-      <tt>&lt;</tt></td>
-
-      <td valign="top">&nbsp;</td>
-    </tr>
-  </table>
-
-  <h3>Complexity guarantees</h3>
-
-  <h3>Invariants</h3>
-
-  <table border summary="">
-    <tr>
-      <td valign="top">Irreflexivity</td>
-
-      <td valign="top"><tt>x &lt; x</tt> must be false.</td>
-    </tr>
-
-    <tr>
-      <td valign="top">Antisymmetry</td>
-
-      <td valign="top"><tt>x &lt; y</tt> implies !(y &lt; x) <a href=
-      "#n2">[2]</a></td>
-    </tr>
-
-    <tr>
-      <td valign="top">Transitivity</td>
-
-      <td valign="top"><tt>x &lt; y</tt> and <tt>y &lt; z</tt> implies <tt>x
-      &lt; z</tt> <a href="#n3">[3]</a></td>
-    </tr>
-  </table>
-
-  <h3>Models</h3>
-
-  <ul>
-    <li>int</li>
-  </ul>
-
-  <h3>Notes</h3>
-
-  <p><a name="n1" id="n1">[1]</a> Only <tt>operator&lt;</tt> is fundamental;
-  the other inequality operators are essentially syntactic sugar.</p>
-
-  <p><a name="n2" id="n2">[2]</a> Antisymmetry is a theorem, not an axiom: it
-  follows from irreflexivity and transitivity.</p>
-
-  <p><a name="n3" id="n3">[3]</a> Because of irreflexivity and transitivity,
-  <tt>operator&lt;</tt> always satisfies the definition of a <i>partial
-  ordering</i>. The definition of a <i>strict weak ordering</i> is stricter,
-  and the definition of a <i>total ordering</i> is stricter still.</p>
-
-  <h3>See also</h3>
-
-  <p><a href=
-  "http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a>,
-  <a href=
-  "http://www.sgi.com/tech/stl/StrictWeakOrdering.html">StrictWeakOrdering</a><br>
-  </p>
-  <hr>
-
-  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
-  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
-  height="31" width="88"></a></p>
-
-  <p>Revised 
-  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
-  December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
-
-  <table summary="">
-    <tr valign="top">
-      <td nowrap><i>Copyright &copy; 2000</i></td>
-
-      <td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
-      Notre Dame (<a href=
-      "mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
-    </tr>
-  </table>
-
-  <p><i>Distributed under the Boost Software License, Version 1.0. (See
-  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
-  copy at <a href=
-  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
-</body>
-</html>

MultiPassInputIterator.html

@@ -1,95 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-<head>
-  <meta http-equiv="Content-Language" content="en-us">
-  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
-
-  <title>MultiPassInputIterator</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
-"#FF0000">
-  <img src="../../boost.png" alt="C++ Boost" width="277" height=
-  "86"><br clear="none">
-
-  <h2><a name="concept:MultiPassInputIterator" id=
-  "concept:MultiPassInputIterator"></a> Multi-Pass Input Iterator</h2>
-
-  <p>This concept is a refinement of <a href=
-  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>, adding
-  the requirements that the iterator can be used to make multiple passes
-  through a range, and that if <tt>it1 == it2</tt> and <tt>it1</tt> is
-  dereferenceable then <tt>++it1 == ++it2</tt>. The Multi-Pass Input Iterator
-  is very similar to the <a href=
-  "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>.
-  The only difference is that a <a href=
-  "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>
-  requires the <tt>reference</tt> type to be <tt>value_type&amp;</tt>,
-  whereas MultiPassInputIterator is like <a href=
-  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> in that
-  the <tt>reference</tt> type merely has to be convertible to
-  <tt>value_type</tt>.</p>
-
-  <h3>Design Notes</h3>
-
-  <p>comments by Valentin Bonnard:</p>
-
-  <p>I think that introducing Multi-Pass Input Iterator isn't the right
-  solution. Do you also want to define Multi-Pass Bidirectionnal Iterator and
-  Multi-Pass Random Access Iterator ? I don't, definitly. It only confuses
-  the issue. The problem lies into the existing hierarchy of iterators, which
-  mixes movabillity, modifiabillity and lvalue-ness, and these are clearly
-  independant.</p>
-
-  <p>The terms Forward, Bidirectionnal and Random Access are about
-  movabillity and shouldn't be used to mean anything else. In a completly
-  orthogonal way, iterators can be immutable, mutable, or neither. Lvalueness
-  of iterators is also orthogonal with immutabillity. With these clean
-  concepts, your Multi-Pass Input Iterator is just called a Forward
-  Iterator.</p>
-
-  <p>Other translations are:<br>
-  std::Forward Iterator -&gt; ForwardIterator &amp; Lvalue Iterator<br>
-  std::Bidirectionnal Iterator -&gt; Bidirectionnal Iterator &amp; Lvalue
-  Iterator<br>
-  std::Random Access Iterator -&gt; Random Access Iterator &amp; Lvalue
-  Iterator<br></p>
-
-  <p>Note that in practice the only operation not allowed on my Forward
-  Iterator which is allowed on std::Forward Iterator is <tt>&amp;*it</tt>. I
-  think that <tt>&amp;*</tt> is rarely needed in generic code.</p>
-
-  <p>reply by Jeremy Siek:</p>
-
-  <p>The above analysis by Valentin is right on. Of course, there is the
-  problem with backward compatibility. The current STL implementations are
-  based on the old definition of Forward Iterator. The right course of action
-  is to get Forward Iterator, etc. changed in the C++ standard. Once that is
-  done we can drop Multi-Pass Input Iterator.<br></p>
-  <hr>
-
-  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
-  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
-  height="31" width="88"></a></p>
-
-  <p>Revised 
-  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
-  December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
-
-  <table summary="">
-    <tr valign="top">
-      <td nowrap><i>Copyright &copy; 2000</i></td>
-
-      <td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
-      Notre Dame (<a href=
-      "mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
-    </tr>
-  </table>
-
-  <p><i>Distributed under the Boost Software License, Version 1.0. (See
-  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
-  copy at <a href=
-  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
-</body>
-</html>

OptionalPointee.html

@@ -1,159 +0,0 @@
-<HTML>
-<Head>
-<Title>OptionalPointee Concept</Title>
-</HEAD>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../boost.png" 
-     ALT="C++ Boost" width="277" height="86"> 
-<!--end header-->
-<BR Clear>
-<H1>Concept: OptionalPointee</H1>
-
-<h3>Description</h3>
-A type is a model of <i>OptionalPointee</i> if it points to (or refers to) a value 
-that may not exist. That is, if it has a <b>pointee</b> which might be <b>valid</b>
-(existent) or <b>invalid</b> (inexistent); and it is possible to test whether the 
-pointee is valid or not.
-This model does <u>not</u> imply pointer semantics: i.e., it does not imply shallow copy nor
-aliasing.
-<h3>Notation</h3>
-<Table>
-  <TR>
-    <TD VAlign=top> <tt>T</tt> </TD>
-    <TD VAlign=top> is a type that is a model of OptionalPointee</TD>
-  </TR>
-  <TR>
-    <TD VAlign=top> <tt>t</tt> </TD>
-    <TD VAlign=top> is an object of type <tt>T</tt> or possibly <tt>const T</tt></TD>
-  </tr>
-</table>
-<h3>Definitions</h3>
-<h3>Valid expressions</h3>
-<Table border>
-  <TR>
-    <TH> Name </TH>
-    <TH> Expression </TH>
-    <TH> Return type </TH>
-    <TH> Semantics </TH>
-  </TR>
-  <TR>
-    <TD VAlign=top>Value Access</TD>
-    <TD VAlign=top>&nbsp;<tt>*t</tt></TD>
-    <TD VAlign=top>&nbsp;<tt>T&amp;</tt></TD>
-    <TD VAlign=top>If the pointee is valid returns a reference to
-      the pointee.<br>
-      If the pointee is invalid the result is <i>undefined</i>.</TD>
-    <TD VAlign=top> </TD>
-  </TR>
-  <TR>
-    <TD VAlign=top>Value Access</TD>
-    <TD VAlign=top>&nbsp;<tt>t-><i>xyz</i></tt></TD>
-    <TD VAlign=top>&nbsp;<tt>T*</tt></TD>
-    <TD VAlign=top>If the pointee is valid returns a builtin pointer to the pointee.<br>
-      If the pointee is invalid the result is <i>undefined</i> (It might not even return NULL).<br>
-    </TD>
-    <TD VAlign=top> </TD>
-  </TR>
-  <TR>
-    <TD VAlign=top>Validity Test</TD>
-    <TD VAlign=top>&nbsp;<tt>bool(t)</tt></TD>
-    <TD VAlign=top>&nbsp;bool </TD>
-    <TD VAlign=top>If the pointee is valid returns true.<br>
-      If the pointee is invalid returns false.</TD>
-    <TD VAlign=top></TD>
-  </TR>
-  <TR>
-    <TD VAlign=top>Invalidity Test</TD>
-    <TD VAlign=top>&nbsp;<tt>!t</tt></TD>
-    <TD VAlign=top>&nbsp;bool </TD>
-    <TD VAlign=top>If the pointee is valid returns false.<br>
-      If the pointee is invalid returns true.</TD>
-    <TD VAlign=top></TD>
-  </TR>
-</table>
-
-
-<h3>Models</h3>
-
-<UL>
-  <LI><tt>pointers, both builtin and smart.</tt>
-  <LI><tt>boost::optional&lt;&gt;</tt>
-</UL>
-
-<HR>
-<h3>OptionalPointee and relational operations</h3>
-<p>This concept does not define any particular semantic for relational operations, therefore,
-a type which models this concept might have either shallow or deep relational semantics.<br>
-For instance, pointers, which are models of OptionalPointee, have shallow relational operators:
-comparisons of pointers do not involve comparisons of pointees.
-This makes sense for pointers because they have shallow copy semantics.<br>
-But boost::optional&lt;T&gt;, on the other hand, which is also a model of OptionalPointee, has
-deep-copy and deep-relational semantics.<br>
-If generic code is written for this concept, it is important not to use relational
-operators directly because the semantics might be different depending on the actual type.<br>
-Still, the concept itsef can be used to define <i>deep</i> relational tests that can
-be used in generic code with any type which models OptionalPointee:</p>
-<a name="equal"></a>
-<p><u>Equivalence relation:</u></p>
-<pre>template&lt;class OptionalPointee&gt;
-inline
-bool equal_pointees ( OptionalPointee const&amp; x, OptionalPointee const&amp; y )
-{
-  return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
-}
-template&lt;class OptionalPointee&gt;
-struct equal_pointees_t : std::binary_function&lt;OptionalPointee,OptionalPointee,bool&gt;
-{
-  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
-    { return equal_pointees(x,y) ; }
-} ;
-</pre>
-<p>The preceding generic function and function object have the following semantics:<br>
-If both <b>x</b> and <b>y</b> have valid pointees, it compares values via <code>(*x == *y)</code>.<br>
-If only one has a valid pointee, returns <code>false</code>.<br>
-If both have invalid pointees, returns <code>true</code>.</p>
-<a name="less"></a>
-<p><u>Less-than relation:</u></p>
-<pre>template&lt;class OptionalPointee&gt;
-inline
-bool less_pointees ( OptionalPointee const&amp; x, OptionalPointee const&amp; y )
-{
-  return !y ? false : ( !x ? true : (*x) < (*y) ) ;
-}
-template&lt;class OptionalPointee&gt;
-struct less_pointees_t : std::binary_function&lt;OptionalPointee,OptionalPointee,bool&gt;
-{
-  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
-    { return less_pointees(x,y) ; }
-} ;
-</pre>
-<p>The preceding generic function and function object have the following semantics:<br>
-If <b>y</b> has an invalid pointee, returns <code>false</code>.<br>
-Else, if <b>x</b> has an invalid pointee, returns <code>true</code>.<br>
-Else, ( <b>x</b> and <b>y</b> have valid pointees), compares values via <code>(*x &lt; 
-*y).</code></p>
-<p><br>
-All these functions and function 
-objects are is implemented in <a href="../../boost/utility/compare_pointees.hpp">compare_pointees.hpp</a></p>
-<p>Notice that OptionalPointee does not imply aliasing (and optional&lt;&gt; for instance does not alias);
-so direct usage of relational operators with the implied aliasing of shallow semantics
--as with pointers- should not be used with generic code written for this concept.</p>
-
-<h3>Acknowledgements</h3>
-<p>Based on the original concept developed by Augustus Saunders.
-
-<br>
-</p>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2003</TD><TD>
-<A HREF="mailto:fernando_cacciola@hotmail.com">Fernando Cacciola</A>
-</TD></TR></TABLE>
-
-<p>Distributed under the Boost Software License, Version 1.0. See
-<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
-
-</BODY>
-</HTML>

README.md

@@ -1,24 +0,0 @@
-# ![Boost.Utility](doc/logo.png)
-
-Boost.Utility, part of collection of the [Boost C++ Libraries](https://github.com/boostorg), provides a number of smaller components, too small to be called libraries in their own right. See the documentation for the list of components.
-
-### Directories
-
-* **doc** - Documentation sources
-* **include** - Interface headers of Boost.Utility
-* **test** - Boost.Utility unit tests
-
-### More information
-
-* [Documentation](https://boost.org/libs/utility)
-* [Report bugs](https://github.com/boostorg/utility/issues/new). Be sure to mention Boost version, Boost.Utility component, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
-* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).
-
-### Build status
-
-Master: [![Travis CI](https://travis-ci.org/boostorg/utility.svg?branch=master)](https://travis-ci.org/boostorg/utility)
-Develop: [![Travis CI](https://travis-ci.org/boostorg/utility.svg?branch=develop)](https://travis-ci.org/boostorg/utility)
-
-### License
-
-Distributed under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).

UpdatableBuffer.html

@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title>Updatable Buffer Concept</title>
+  </head>
+  <body>
+    <h1><img src="../../c++boost.gif" alt="C++ Boost" width="277" height="86" /><br />Updatable Buffer Concept</h1>
+    <p>An <tt>UpdatableBuffer</tt> is a special type of <a href="./Buffer.html">Buffer</a> that provides an update operation for when the <tt>Buffer</tt>'s ordering policy changes.</p>
+
+    <h3>Notation</h3>
+    <ul>
+      <li><tt>B</tt> is a type that models <tt>UpdatableBuffer</tt>.</li>
+      <li><tt>T</tt> is the value type of <tt>B</tt>.</li>
+      <li><tt>t</tt> is an object of type <tt>T</tt>.</li>
+    </ul>
+
+    <h3>Members</h3>
+    <p>For a type to model the <tt>UpdatableBuffer</tt> concept it must have the following members.</p>
+
+    <table border="1">
+      <tr>
+        <th>Member</th>
+        <th>Where Defined</th>
+        <th>Description</th>
+      </tr>
+      <tr valign="top">
+        <td><tt>value_type</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>The type of object stored in the Buffer.  The value type must be <a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>size_type</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>An unsigned integral type for representing the number of objects in the Buffer.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>void update(const T&amp; t)</tt></td>
+        <td><tt>UpdatableBuffer</tt></td>
+        <td>Revalidates this Updatable Buffer.  An Updatable Buffer is <em>invalidated</em> if its ordering policy changes with respect to <tt>t</tt> but its <em>internal structure</em> does not reflect that change.<br />Precondition: <tt>t</tt> is in the buffer.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>void push(const T&amp; t)</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>Inserts <tt>t</tt> into the Buffer.  <tt>size()</tt> will be incremented by one.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>void pop()</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>Removes an object from the Buffer.  <tt>size()</tt> will be decremented by one.<br />Precondition: <tt>empty()</tt> is <tt>false</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>T&amp; top()</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>Returns a mutable reference to some object in the Buffer.  Precondition: <tt>empty()</tt> is <tt>false</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>const T& top() const</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>Returns a const reference to some object in the Buffer.  Precondition: <tt>empty()</tt> is <tt>false</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>void size() const</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>Returns the number of objects in the Buffer.  Invariant: <tt>size() &gt;= 0</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>bool empty() const</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>Equivalent to <tt>b.size() == 0</tt>.</td>
+      </tr>
+    </table>
+
+    <h3>Complexity Guarantees</h3>
+    <ul>
+      <li><tt>push()</tt>, <tt>pop()</tt>, <tt>size()</tt>, and <tt>update()</tt> must be at most linear time complexity in the size of the Generalized Queue.</li>
+      <li><tt>top()</tt> and <tt>empty()</tt> must be amortized constant time.</li>
+    </ul>
+
+    <h3>Models</h3>
+    <ul>
+      <li><a href="../pri_queue/doc/mutable_queue.html"><tt>mutable_queue</tt></a></li>
+      <li><a href="../pri_queue/doc/fibonacci_heap.html"><tt>fibonacci_heap</tt></a></li>
+    </ul>
+
+    <hr />
+    <table border="0">
+      <tr valign="top">
+        <td>Copyright &copy; 2004</td>
+        <td><a href="../../people/jeremy_siek.htm">Jeremy Siek</a>, Univ. of Notre Dame (<a href="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</td>
+      </tr>
+    </table>
+    <p>Use, modification, and distribution are subject to the Boost Software License, Version 1.0 at <a href="../../LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a></p>
+  </body>
+</html> 
+

appveyor.yml

@@ -1,58 +0,0 @@
-# Copyright 2016-2019 Peter Dimov
-# 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)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-12.0,msvc-14.0
-      ADDRMD: 32,64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      ADDRMD: 32,64
-      CXXSTD: 14,17
-
-install:
-  - set GIT_FETCH_JOBS=8
-  - set BOOST_BRANCH=develop
-  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
-  - 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/boost_install
-  - git submodule init libs/headers
-  - git submodule init libs/assert
-  - git submodule init libs/config
-  - git submodule init libs/core
-  - git submodule init libs/preprocessor
-  - git submodule init libs/static_assert
-  - git submodule init libs/throw_exception
-  - git submodule init libs/type_traits
-  - git submodule init libs/container_hash
-  - git submodule init libs/integer
-  - git submodule init libs/detail
-  - git submodule update --jobs %GIT_FETCH_JOBS%
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\utility\
-  - cmd /c bootstrap
-  - b2 -d0 headers
-
-build: off
-
-test_script:
-  - PATH=%ADDPATH%%PATH%
-  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - b2 -j %NUMBER_OF_PROCESSORS% libs/utility/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release

build/Jamfile.v2

@@ -0,0 +1,13 @@
+
+project
+    :
+    : default-build debug
+    ;
+
+lib debug
+    : #sources
+      ../src/obj_id.cpp
+      ../src/object_tracked.cpp
+      ../src/trace_scope_stk.cpp
+    ;
+

call_traits.htm

@@ -1,755 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type"
-content="text/html; charset=iso-8859-1">
-<meta name="Template"
-content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>Call Traits</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
-vlink="#800080">
-
-<h1><img src="../../boost.png" width="276" height="86">Header
-&lt;<a href="../../boost/detail/call_traits.hpp">boost/call_traits.hpp</a>&gt;</h1>
-
-<p>All of the contents of &lt;boost/call_traits.hpp&gt; are
-defined inside namespace boost.</p>
-
-<p>The template class call_traits&lt;T&gt; encapsulates the
-&quot;best&quot; method to pass a parameter of some type T to or
-from a function, and consists of a collection of typedefs defined
-as in the table below. The purpose of call_traits is to ensure
-that problems like &quot;<a href="#refs">references to references</a>&quot;
-never occur, and that parameters are passed in the most efficient
-manner possible (see <a href="#examples">examples</a>). In each
-case if your existing practice is to use the type defined on the
-left, then replace it with the call_traits defined type on the
-right. </p>
-
-<p>Note that for compilers that do not support either partial
-specialization or member templates, no benefit will occur from
-using call_traits: the call_traits defined types will always be
-the same as the existing practice in this case. In addition if
-only member templates and not partial template specialisation is
-support by the compiler (for example Visual C++ 6) then
-call_traits can not be used with array types (although it can be
-used to solve the reference to reference problem).</p>
-
-<table border="0" cellpadding="7" cellspacing="1" width="797">
-    <tr>
-        <td valign="top" width="17%" bgcolor="#008080"><p
-        align="center">Existing practice</p>
-        </td>
-        <td valign="top" width="35%" bgcolor="#008080"><p
-        align="center">call_traits equivalent</p>
-        </td>
-        <td valign="top" width="32%" bgcolor="#008080"><p
-        align="center">Description</p>
-        </td>
-        <td valign="top" width="16%" bgcolor="#008080"><p
-        align="center">Notes</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%"><p align="center">T<br>
-        (return by value)</p>
-        </td>
-        <td valign="top" width="35%"><p align="center"><code>call_traits&lt;T&gt;::value_type</code></p>
-        </td>
-        <td valign="top" width="32%">Defines a type that
-        represents the &quot;value&quot; of type T. Use this for
-        functions that return by value, or possibly for stored
-        values of type T.</td>
-        <td valign="top" width="16%"><p align="center">2</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%"><p align="center">T&amp;<br>
-        (return value)</p>
-        </td>
-        <td valign="top" width="35%"><p align="center"><code>call_traits&lt;T&gt;::reference</code></p>
-        </td>
-        <td valign="top" width="32%">Defines a type that
-        represents a reference to type T. Use for functions that
-        would normally return a T&amp;.</td>
-        <td valign="top" width="16%"><p align="center">1</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%"><p align="center">const
-        T&amp;<br>
-        (return value)</p>
-        </td>
-        <td valign="top" width="35%"><p align="center"><code>call_traits&lt;T&gt;::const_reference</code></p>
-        </td>
-        <td valign="top" width="32%">Defines a type that
-        represents a constant reference to type T. Use for
-        functions that would normally return a const T&amp;.</td>
-        <td valign="top" width="16%"><p align="center">1</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%"><p align="center">const
-        T&amp;<br>
-        (function parameter)</p>
-        </td>
-        <td valign="top" width="35%"><p align="center"><code>call_traits&lt;T&gt;::param_type</code></p>
-        </td>
-        <td valign="top" width="32%">Defines a type that
-        represents the &quot;best&quot; way to pass a parameter
-        of type T to a function.</td>
-        <td valign="top" width="16%"><p align="center">1,3</p>
-        </td>
-    </tr>
-</table>
-
-<p>Notes:</p>
-
-<ol>
-    <li>If T is already reference type, then call_traits is
-        defined such that <a href="#refs">references to
-        references</a> do not occur (requires partial
-        specialization).</li>
-    <li>If T is an array type, then call_traits defines <code>value_type</code>
-        as a &quot;constant pointer to type&quot; rather than an
-        &quot;array of type&quot; (requires partial
-        specialization). Note that if you are using value_type as
-        a stored value then this will result in storing a &quot;constant
-        pointer to an array&quot; rather than the array itself.
-        This may or may not be a good thing depending upon what
-        you actually need (in other words take care!).</li>
-    <li>If T is a small built in type or a pointer, then <code>param_type</code>
-        is defined as <code>T const</code>, instead of <code>T
-        const&amp;</code>. This can improve the ability of the
-        compiler to optimize loops in the body of the function if
-        they depend upon the passed parameter, the semantics of
-        the passed parameter is otherwise unchanged (requires
-        partial specialization).</li>
-</ol>
-
-<p>&nbsp;</p>
-
-<h3>Copy constructibility</h3>
-
-<p>The following table defines which call_traits types can always
-be copy-constructed from which other types, those entries marked
-with a '?' are true only if and only if T is copy constructible:</p>
-
-<table border="0" cellpadding="7" cellspacing="1" width="766">
-    <tr>
-        <td valign="top" width="17%">&nbsp;</td>
-        <td valign="top" colspan="5" width="85%"
-        bgcolor="#008080"><p align="center">To:</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#008080">From:</td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">T</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">value_type</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">reference</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">const_reference</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">param_type</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0">T</td>
-        <td valign="top" width="17%"><p align="center">?</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">?</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0">value_type</td>
-        <td valign="top" width="17%"><p align="center">?</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">?</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">N</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">N</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0">reference</td>
-        <td valign="top" width="17%"><p align="center">?</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">?</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0">const_reference</td>
-        <td valign="top" width="17%"><p align="center">?</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">N</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">N</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0">param_type</td>
-        <td valign="top" width="17%"><p align="center">?</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">?</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">N</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">N</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-    </tr>
-</table>
-
-<p>&nbsp;</p>
-
-<p>If T is an assignable type the following assignments are
-possible:</p>
-
-<table border="0" cellpadding="7" cellspacing="1" width="766">
-    <tr>
-        <td valign="top" width="17%">&nbsp;</td>
-        <td valign="top" colspan="5" width="85%"
-        bgcolor="#008080"><p align="center">To:</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#008080">From:</td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">T</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">value_type</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">reference</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">const_reference</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">param_type</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0">T</td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0">value_type</td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0">reference</td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0">const_reference</td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0">param_type</td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">Y</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">-</p>
-        </td>
-    </tr>
-</table>
-
-<p>&nbsp;</p>
-
-<h3><a name="examples"></a>Examples</h3>
-
-<p>The following table shows the effect that call_traits has on
-various types, the table assumes that the compiler supports
-partial specialization: if it doesn't then all types behave in
-the same way as the entry for &quot;myclass&quot;, and
-call_traits can not be used with reference or array types.</p>
-
-<table border="0" cellpadding="7" cellspacing="1" width="766">
-    <tr>
-        <td valign="top" width="17%">&nbsp;</td>
-        <td valign="top" colspan="5" width="85%"
-        bgcolor="#008080"><p align="center">Call_traits type:</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#008080"><p
-        align="center">Original type T</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">value_type</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">reference</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">const_reference</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">param_type</p>
-        </td>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">Applies to:</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">myclass</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">myclass</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">myclass&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const
-        myclass&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">myclass
-        const&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">All user
-        defined types.</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">int</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">int</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">int&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const
-        int&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">int const</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">All small
-        built-in types.</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">int*</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">int*</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">int*&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">int*const&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">int* const</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">All
-        pointer types.</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">int&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">int&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">int&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const
-        int&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">int&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">All
-        reference types.</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">const int&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const
-        int&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const
-        int&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const
-        int&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const
-        int&amp;</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">All
-        constant-references.</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">int[3]</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const int*</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">int(&amp;)[3]</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const int(&amp;)[3]</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const int*
-        const</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">All array
-        types.</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
-        align="center">const int[3]</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const int*</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const int(&amp;)[3]</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const int(&amp;)[3]</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">const int*
-        const</p>
-        </td>
-        <td valign="top" width="17%"><p align="center">All
-        constant-array types.</p>
-        </td>
-    </tr>
-</table>
-
-<p>&nbsp;</p>
-
-<h4>Example 1:</h4>
-
-<p>The following class is a trivial class that stores some type T
-by value (see the <a href="test/call_traits_test.cpp">call_traits_test.cpp</a>
-file), the aim is to illustrate how each of the available
-call_traits typedefs may be used:</p>
-
-<pre>template &lt;class T&gt;
-struct contained
-{
-   // define our typedefs first, arrays are stored by value
-   // so value_type is not the same as result_type:
-   typedef typename boost::call_traits&lt;T&gt;::param_type       param_type;
-   typedef typename boost::call_traits&lt;T&gt;::reference        reference;
-   typedef typename boost::call_traits&lt;T&gt;::const_reference  const_reference;
-   typedef T                                                value_type;
-   typedef typename boost::call_traits&lt;T&gt;::value_type       result_type;
-
-   // stored value:
-   value_type v_;
-   
-   // constructors:
-   contained() {}
-   contained(param_type p) : v_(p){}
-   // return byval:
-   result_type value() { return v_; }
-   // return by_ref:
-   reference get() { return v_; }
-   const_reference const_get()const { return v_; }
-   // pass value:
-   void call(param_type p){}
-
-};</pre>
-
-<h4><a name="refs"></a>Example 2 (the reference to reference
-problem):</h4>
-
-<p>Consider the definition of std::binder1st:</p>
-
-<pre>template &lt;class Operation&gt; 
-class binder1st : 
-   public unary_function&lt;typename Operation::second_argument_type, typename Operation::result_type&gt; 
-{ 
-protected: 
-   Operation op; 
-   typename Operation::first_argument_type value; 
-public: 
-   binder1st(const Operation&amp; x, const typename Operation::first_argument_type&amp; y); 
-   typename Operation::result_type operator()(const typename Operation::second_argument_type&amp; x) const; 
-}; </pre>
-
-<p>Now consider what happens in the relatively common case that
-the functor takes its second argument as a reference, that
-implies that <code>Operation::second_argument_type</code> is a
-reference type, <code>operator()</code> will now end up taking a
-reference to a reference as an argument, and that is not
-currently legal. The solution here is to modify <code>operator()</code>
-to use call_traits:</p>
-
-<pre>typename Operation::result_type operator()(typename call_traits&lt;typename Operation::second_argument_type&gt;::param_type x) const;</pre>
-
-<p>Now in the case that <code>Operation::second_argument_type</code>
-is a reference type, the argument is passed as a reference, and
-the no &quot;reference to reference&quot; occurs.</p>
-
-<h4><a name="ex3"></a>Example 3 (the make_pair problem):</h4>
-
-<p>If we pass the name of an array as one (or both) arguments to <code>std::make_pair</code>,
-then template argument deduction deduces the passed parameter as
-&quot;const reference to array of T&quot;, this also applies to
-string literals (which are really array literals). Consequently
-instead of returning a pair of pointers, it tries to return a
-pair of arrays, and since an array type is not copy-constructible
-the code fails to compile. One solution is to explicitly cast the
-arguments to make_pair to pointers, but call_traits provides a
-better (i.e. automatic) solution (and one that works safely even
-in generic code where the cast might do the wrong thing):</p>
-
-<pre>template &lt;class T1, class T2&gt;
-std::pair&lt;
-   typename boost::call_traits&lt;T1&gt;::value_type, 
-   typename boost::call_traits&lt;T2&gt;::value_type&gt; 
-      make_pair(const T1&amp; t1, const T2&amp; t2)
-{
-   return std::pair&lt;
-      typename boost::call_traits&lt;T1&gt;::value_type, 
-      typename boost::call_traits&lt;T2&gt;::value_type&gt;(t1, t2);
-}</pre>
-
-<p>Here, the deduced argument types will be automatically
-degraded to pointers if the deduced types are arrays, similar
-situations occur in the standard binders and adapters: in
-principle in any function that &quot;wraps&quot; a temporary
-whose type is deduced. Note that the function arguments to
-make_pair are not expressed in terms of call_traits: doing so
-would prevent template argument deduction from functioning.</p>
-
-<h4><a name="ex4"></a>Example 4 (optimising fill):</h4>
-
-<p>The call_traits template will &quot;optimize&quot; the passing
-of a small built-in type as a function parameter, this mainly has
-an effect when the parameter is used within a loop body. In the
-following example (see <a
-href="../type_traits/examples/fill_example.cpp">fill_example.cpp</a>),
-a version of std::fill is optimized in two ways: if the type
-passed is a single byte built-in type then std::memset is used to
-effect the fill, otherwise a conventional C++ implemention is
-used, but with the passed parameter &quot;optimized&quot; using
-call_traits:</p>
-
-<pre>namespace detail{
-
-template &lt;bool opt&gt;
-struct filler
-{
-   template &lt;typename I, typename T&gt;
-   static void do_fill(I first, I last, typename boost::call_traits&lt;T&gt;::param_type val)
-   {
-      while(first != last)
-      {
-         *first = val;
-         ++first;
-      }
-   }
-};
-
-template &lt;&gt;
-struct filler&lt;true&gt;
-{
-   template &lt;typename I, typename T&gt;
-   static void do_fill(I first, I last, T val)
-   {
-      memset(first, val, last-first);
-   }
-};
-
-}
-
-template &lt;class I, class T&gt;
-inline void fill(I first, I last, const T&amp; val)
-{
-   enum{ can_opt = boost::is_pointer&lt;I&gt;::value
-                   &amp;&amp; boost::is_arithmetic&lt;T&gt;::value
-                   &amp;&amp; (sizeof(T) == 1) };
-   typedef detail::filler&lt;can_opt&gt; filler_t;
-   filler_t::template do_fill&lt;I,T&gt;(first, last, val);
-}</pre>
-
-<p>Footnote: the reason that this is &quot;optimal&quot; for
-small built-in types is that with the value passed as &quot;T
-const&quot; instead of &quot;const T&amp;&quot; the compiler is
-able to tell both that the value is constant and that it is free
-of aliases. With this information the compiler is able to cache
-the passed value in a register, unroll the loop, or use
-explicitly parallel instructions: if any of these are supported.
-Exactly how much mileage you will get from this depends upon your
-compiler - we could really use some accurate benchmarking
-software as part of boost for cases like this.</p>
-
-<p>Note that the function arguments to fill are not expressed in
-terms of call_traits: doing so would prevent template argument
-deduction from functioning. Instead fill acts as a &quot;thin
-wrapper&quot; that is there to perform template argument
-deduction, the compiler will optimise away the call to fill all
-together, replacing it with the call to filler&lt;&gt;::do_fill,
-which does use call_traits.</p>
-
-<h3>Rationale</h3>
-
-<p>The following notes are intended to briefly describe the
-rational behind choices made in call_traits.</p>
-
-<p>All user-defined types follow &quot;existing practice&quot;
-and need no comment.</p>
-
-<p>Small built-in types (what the standard calls fundamental
-types [3.9.1]) differ from existing practice only in the <i>param_type</i>
-typedef. In this case passing &quot;T const&quot; is compatible
-with existing practice, but may improve performance in some cases
-(see <a href="#ex4">Example 4</a>), in any case this should never
-be any worse than existing practice.</p>
-
-<p>Pointers follow the same rational as small built-in types.</p>
-
-<p>For reference types the rational follows <a href="#refs">Example
-2</a> - references to references are not allowed, so the
-call_traits members must be defined such that these problems do
-not occur. There is a proposal to modify the language such that
-&quot;a reference to a reference is a reference&quot; (issue #106,
-submitted by Bjarne Stroustrup), call_traits&lt;T&gt;::value_type
-and call_traits&lt;T&gt;::param_type both provide the same effect
-as that proposal, without the need for a language change (in
-other words it's a workaround).</p>
-
-<p>For array types, a function that takes an array as an argument
-will degrade the array type to a pointer type: this means that
-the type of the actual parameter is different from its declared
-type, something that can cause endless problems in template code
-that relies on the declared type of a parameter. For example:</p>
-
-<pre>template &lt;class T&gt;
-struct A
-{
-   void foo(T t);
-};</pre>
-
-<p><font face="Times New Roman">In this case if we instantiate
-A&lt;int[2]&gt; then the declared type of the parameter passed to
-member function foo is int[2], but it's actual type is const int*,
-if we try to use the type T within the function body, then there
-is a strong likelyhood that our code will not compile:</font></p>
-
-<pre>template &lt;class T&gt;
-void A&lt;T&gt;::foo(T t)
-{
-   T dup(t); // doesn't compile for case that T is an array.
-}</pre>
-
-<p>By using call_traits the degradation from array to pointer is
-explicit, and the type of the parameter is the same as it's
-declared type:</p>
-
-<pre>template &lt;class T&gt;
-struct A
-{
-   void foo(typename call_traits&lt;T&gt;::value_type t);
-};
-
-template &lt;class T&gt;
-void A&lt;T&gt;::foo(typename call_traits&lt;T&gt;::value_type t)
-{
-   typename call_traits&lt;T&gt;::value_type dup(t); // OK even if T is an array type.
-}</pre>
-
-<p>For value_type (return by value), again only a pointer may be
-returned, not a copy of the whole array, and again call_traits
-makes the degradation explicit. The value_type member is useful
-whenever an array must be explicitly degraded to a pointer - <a
-href="#ex3">Example 3</a> provides the test case (Footnote: the
-array specialisation for call_traits is the least well understood
-of all the call_traits specialisations, if the given semantics
-cause specific problems for you, or don't solve a particular
-array-related problem, then I would be interested to hear about
-it. Most people though will probably never need to use this
-specialisation).</p>
-
-<hr>
-
-<p>Revised 01 September 2000</p>
-
-   <p>
-      Copyright 2000 Steve Cleary, Beman Dawes, Howard
-      Hinnant and John Maddock. <br/>
-      Use, modification and distribution are subject to 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">
-         http://www.boost.org/LICENSE_1_0.txt
-      </a>).
-   </p>
-</body>
-</html>
-

checked_delete.html

@@ -1,15 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-<head>
-<meta http-equiv=refresh content="0; URL=../core/doc/html/core/checked_delete.html">
-<title>Automatic redirection</title>
-</head>
-<body>
-Automatic redirection failed, please go to
-<a href="../core/doc/html/core/checked_delete.html">checked_delete.html</a>.&nbsp;<hr>
-<p>© Copyright Beman Dawes, 2001</p>
-<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
-file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
-at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
-</body>
-</html>

compressed_pair.htm

@@ -1,16 +0,0 @@
-
-<!--
-Copyright 2014 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)
--->
-
-<html>
-<head>
-    <meta http-equiv="refresh" content="0; URL=doc/html/compressed_pair.html">
-</head>
-<body>
-Automatic redirection failed, please go to
-<a href="doc/html/compressed_pair.html">doc/html/compressed_pair.html</a>
-</body>
-</html>

doc/Jamfile.v2

@@ -1,140 +0,0 @@
-
-# Copyright John Maddock 2005. Use, modification, and distribution are
-# subject to the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-project : requirements
-        # Path for links to Boost:
-        <xsl:param>boost.root=../../../..
-
-        # Some general style settings:
-        <xsl:param>table.footnote.number.format=1
-        <xsl:param>footnote.number.format=1
-
-        # HTML options first:
-        # Use graphics not text for navigation:
-        <xsl:param>navig.graphics=1
-       # PDF Options:
-        # TOC Generation: this is needed for FOP-0.9 and later:
-        <xsl:param>fop1.extensions=0
-        <xsl:param>xep.extensions=1
-        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
-        <xsl:param>fop.extensions=0
-        # No indent on body text:
-        <xsl:param>body.start.indent=0pt
-        # Margin size:
-        <xsl:param>page.margin.inner=0.5in
-        # Margin size:
-        <xsl:param>page.margin.outer=0.5in
-        # Paper type = A4
-        <xsl:param>paper.type=A4
-        # Yes, we want graphics for admonishments:
-        <xsl:param>admon.graphics=1
-        # Set this one for PDF generation *only*:
-        # default pnd graphics are awful in PDF form,
-        # better use SVG's instead:
-        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
-        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
-        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/utility/doc/html
-;
-
-using quickbook ;
-
-path-constant boost-images : ../../../doc/src/images ;
-
-xml base_from_member : base_from_member.qbk ;
-boostbook standalone_base_from_member
-    :
-        base_from_member
-    :
-        # File name of HTML output:
-        <xsl:param>root.filename=base_from_member
-        # How far down we chunk nested sections, basically all of them:
-        <xsl:param>chunk.section.depth=0
-        # Don't put the first section on the same page as the TOC:
-        <xsl:param>chunk.first.sections=0
-        # How far down sections get TOC's
-        <xsl:param>toc.section.depth=1
-        # Max depth in each TOC:
-        <xsl:param>toc.max.depth=1
-        # How far down we go with TOC's
-        <xsl:param>generate.section.toc.level=1
-     ;
-
-xml compressed_pair : compressed_pair.qbk ;
-boostbook standalone_compressed_pair
-    :
-        compressed_pair
-    :
-        # File name of HTML output:
-        <xsl:param>root.filename=compressed_pair
-        # How far down we chunk nested sections, basically all of them:
-        <xsl:param>chunk.section.depth=0
-        # Don't put the first section on the same page as the TOC:
-        <xsl:param>chunk.first.sections=0
-        # How far down sections get TOC's
-        <xsl:param>toc.section.depth=1
-        # Max depth in each TOC:
-        <xsl:param>toc.max.depth=1
-        # How far down we go with TOC's
-        <xsl:param>generate.section.toc.level=1
-     ;
-
-xml declval : declval.qbk ;
-boostbook standalone_declval
-    :
-        declval
-    :
-        # File name of HTML output:
-        <xsl:param>root.filename=declval
-        # How far down we chunk nested sections, basically all of them:
-        <xsl:param>chunk.section.depth=0
-        # Don't put the first section on the same page as the TOC:
-        <xsl:param>chunk.first.sections=0
-        # How far down sections get TOC's
-        <xsl:param>toc.section.depth=1
-        # Max depth in each TOC:
-        <xsl:param>toc.max.depth=1
-        # How far down we go with TOC's
-        <xsl:param>generate.section.toc.level=1
-     ;
-
-xml ostream_string : ostream_string.qbk ;
-boostbook standalone_ostream_string
-    :
-        ostream_string
-    :
-        <xsl:param>root.filename=ostream_string
-        <xsl:param>chunk.section.depth=0
-        <xsl:param>chunk.first.sections=0
-        <xsl:param>toc.section.depth=1
-        <xsl:param>toc.max.depth=1
-        <xsl:param>generate.section.toc.level=1
-     ;
-
-xml string_ref : string_ref.qbk ;
-boostbook standalone_string_ref
-    :
-        string_ref
-    :
-        # File name of HTML output:
-        <xsl:param>root.filename=string_ref
-        # How far down we chunk nested sections, basically all of them:
-        <xsl:param>chunk.section.depth=0
-        # Don't put the first section on the same page as the TOC:
-        <xsl:param>chunk.first.sections=0
-        # How far down sections get TOC's
-        <xsl:param>toc.section.depth=1
-        # Max depth in each TOC:
-        <xsl:param>toc.max.depth=1
-        # How far down we go with TOC's
-        <xsl:param>generate.section.toc.level=1
-     ;
-
-###############################################################################
-alias boostdoc ;
-explicit boostdoc ;
-alias boostrelease :
-    standalone_base_from_member standalone_compressed_pair
-    standalone_declval standalone_ostream_string standalone_string_ref ;
-explicit boostrelease ;

doc/base_from_member.qbk

@@ -1,363 +0,0 @@
-[/
-  Copyright 2001, 2003, 2004, 2012 Daryle Walker.
-
-  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
-]
-
-[article Base_From_Member
-    [quickbook 1.5]
-    [authors [Walker, Daryle]]
-    [copyright 2001, 2003, 2004, 2012 Daryle Walker]
-    [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])
-    ]
-]
-
-[section Rationale]
-
-When developing a class, sometimes a base class needs to be initialized
-with a member of the current class. As a na\u00EFve example:
-
-    #include <streambuf>  /* for std::streambuf */
-    #include <ostream>    /* for std::ostream */
-
-    class fdoutbuf
-      : public std::streambuf
-    {
-    public:
-        explicit fdoutbuf( int fd );
-        //...
-    };
-
-    class fdostream
-      : public std::ostream
-    {
-    protected:
-        fdoutbuf buf;
-    public:
-        explicit fdostream( int fd )
-          : buf( fd ), std::ostream( &buf ) {}
-        //...
-    };
-
-This is undefined because C++'s initialization order mandates that the base
-class is initialized before the member it uses. [@http://www.moocat.org R.
-Samuel Klatchko] developed a way around this by using the initialization
-order in his favor. Base classes are intialized in order of declaration, so
-moving the desired member to another base class, that is initialized before
-the desired base class, can ensure proper initialization.
-
-A custom base class can be made for this idiom:
-
-    #include <streambuf>  /* for std::streambuf */
-    #include <ostream>    /* for std::ostream */
-
-    class fdoutbuf
-      : public std::streambuf
-    {
-    public:
-        explicit fdoutbuf( int fd );
-        //...
-    };
-
-    struct fdostream_pbase
-    {
-        fdoutbuf sbuffer;
-
-        explicit fdostream_pbase( int fd )
-          : sbuffer( fd ) {}
-    };
-
-    class fdostream
-      : private fdostream_pbase
-      , public std::ostream
-    {
-        typedef fdostream_pbase  pbase_type;
-        typedef std::ostream     base_type;
-
-    public:
-        explicit fdostream( int fd )
-          : pbase_type( fd ), base_type( &sbuffer ) {}
-        //...
-    };
-
-Other projects can use similar custom base classes. The technique is basic
-enough to make a template, with a sample template class in this library.
-The main template parameter is the type of the enclosed member. The
-template class has several (explicit) constructor member templates, which
-implicitly type the constructor arguments and pass them to the member. The
-template class uses implicit copy construction and assignment, cancelling
-them if the enclosed member is non-copyable.
-
-Manually coding a base class may be better if the construction and/or
-copying needs are too complex for the supplied template class, or if the
-compiler is not advanced enough to use it.
-
-Since base classes are unnamed, a class cannot have multiple (direct) base
-classes of the same type. The supplied template class has an extra template
-parameter, an integer, that exists solely to provide type differentiation.
-This parameter has a default value so a single use of a particular member
-type does not need to concern itself with the integer.
-
-[endsect]
-
-[section Synopsis]
-
-    #include <type_traits>  /* exposition only */
-
-    #ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY
-    #define BOOST_BASE_FROM_MEMBER_MAX_ARITY  10
-    #endif
-
-    template < typename MemberType, int UniqueID = 0 >
-    class boost::base_from_member
-    {
-    protected:
-        MemberType  member;
-
-    #if ``['C++11 is in use]``
-        template< typename ...T >
-        explicit constexpr   base_from_member( T&& ...x )
-         noexcept( std::is_nothrow_constructible<MemberType, T...>::value );
-    #else
-        base_from_member();
-
-        template< typename T1 >
-        explicit  base_from_member( T1 x1 );
-
-        template< typename T1, typename T2 >
-        base_from_member( T1 x1, T2 x2 );
-
-        //...
-
-        template< typename T1, typename T2, typename T3, typename T4,
-         typename T5, typename T6, typename T7, typename T8, typename T9,
-         typename T10 >
-        base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7,
-         T8 x8, T9 x9, T10 x10 );
-    #endif
-    };
-
-    template < typename MemberType, int UniqueID >
-    class base_from_member<MemberType&, UniqueID>
-    {
-    protected:
-        MemberType& member;
-
-        explicit constexpr base_from_member( MemberType& x )
-            noexcept;
-    };
-
-The class template has a first template parameter `MemberType` representing
-the type of the based-member. It has a last template parameter `UniqueID`,
-that is an `int`, to differentiate between multiple base classes that use
-the same based-member type. The last template parameter has a default value
-of zero if it is omitted. The class template has a protected data member
-called `member` that the derived class can use for later base classes (or
-itself).
-
-If the appropriate features of C++11 are present, there will be a single
-constructor template. It implements ['perfect forwarding] to the best
-constructor call of `member` (if any). The constructor template is marked
-both `constexpr` and `explicit`. The former will be ignored if the
-corresponding inner constructor call (of `member`) does not have the marker.
-The latter binds the other way; always taking effect, even when the inner
-constructor call does not have the marker. The constructor template
-propagates the `noexcept` status of the inner constructor call. (The
-constructor template has a trailing parameter with a default value that
-disables the template when its signature is too close to the signatures of
-the automatically-defined non-template copy- and/or move-constructors of
-`base_from_member`.)
-
-On earlier-standard compilers, there is a default constructor and several
-constructor member templates. These constructor templates can take as many
-arguments (currently up to ten) as possible and pass them to a constructor
-of the data member.
-
-A specialization for member references offers a single constructor taking
-a `MemberType&`, which is the only way to initialize a reference.
-
-Since C++ does not allow any way to explicitly state the template parameters
-of a templated constructor, make sure that the arguments are already close
-as possible to the actual type used in the data member's desired constructor.
-Explicit conversions may be necessary.
-
-The `BOOST_BASE_FROM_MEMBER_MAX_ARITY` macro constant specifies the maximum
-argument length for the constructor templates. The constant may be overridden
-if more (or less) argument configurations are needed. The constant may be
-read for code that is expandable like the class template and needs to
-maintain the same maximum size. (Example code would be a class that uses
-this class template as a base class for a member with a flexible set of
-constructors.) This constant is ignored when C++11 features are present.
-
-[endsect]
-
-[section Usage]
-
-With the starting example, the `fdoutbuf` sub-object needs to be
-encapsulated in a base class that is inheirited before `std::ostream`.
-
-    #include <boost/utility/base_from_member.hpp>
-
-    #include <streambuf>  // for std::streambuf
-    #include <ostream>    // for std::ostream
-
-    class fdoutbuf
-      : public std::streambuf
-    {
-    public:
-        explicit fdoutbuf( int fd );
-        //...
-    };
-
-    class fdostream
-      : private boost::base_from_member<fdoutbuf>
-      , public std::ostream
-    {
-        // Helper typedef's
-        typedef boost::base_from_member<fdoutbuf>  pbase_type;
-        typedef std::ostream                        base_type;
-
-    public:
-        explicit fdostream( int fd )
-          : pbase_type( fd ), base_type( &member ){}
-        //...
-    };
-
-The base-from-member idiom is an implementation detail, so it should not
-be visible to the clients (or any derived classes) of `fdostream`. Due to
-the initialization order, the `fdoutbuf` sub-object will get initialized
-before the `std::ostream` sub-object does, making the former sub-object
-safe to use in the latter sub-object's construction. Since the `fdoutbuf`
-sub-object of the final type is the only sub-object with the name `member`
-that name can be used unqualified within the final class.
-
-[endsect]
-
-[section Example]
-
-The base-from-member class templates should commonly involve only one
-base-from-member sub-object, usually for attaching a stream-buffer to an
-I/O stream. The next example demonstrates how to use multiple
-base-from-member sub-objects and the resulting qualification issues.
-
-    #include <boost/utility/base_from_member.hpp>
-
-    #include <cstddef>  /* for NULL */
-
-    struct an_int
-    {
-        int  y;
-
-        an_int( float yf );
-    };
-
-    class switcher
-    {
-    public:
-        switcher();
-        switcher( double, int * );
-        //...
-    };
-
-    class flow_regulator
-    {
-    public:
-        flow_regulator( switcher &, switcher & );
-        //...
-    };
-
-    template < unsigned Size >
-    class fan
-    {
-    public:
-        explicit fan( switcher );
-        //...
-    };
-
-    class system
-      : private boost::base_from_member<an_int>
-      , private boost::base_from_member<switcher>
-      , private boost::base_from_member<switcher, 1>
-      , private boost::base_from_member<switcher, 2>
-      , protected flow_regulator
-      , public fan<6>
-    {
-        // Helper typedef's
-        typedef boost::base_from_member<an_int>       pbase0_type;
-        typedef boost::base_from_member<switcher>     pbase1_type;
-        typedef boost::base_from_member<switcher, 1>  pbase2_type;
-        typedef boost::base_from_member<switcher, 2>  pbase3_type;
-
-        typedef flow_regulator  base1_type;
-        typedef fan<6>          base2_type;
-
-    public:
-        system( double x );
-        //...
-    };
-
-    system::system( double x )
-      : pbase0_type( 0.2 )
-      , pbase1_type()
-      , pbase2_type( -16, &this->pbase0_type::member.y )
-      , pbase3_type( x, static_cast<int *>(NULL) )
-      , base1_type( pbase3_type::member, pbase1_type::member )
-      , base2_type( pbase2_type::member )
-    {
-        //...
-    }
-
-The final class has multiple sub-objects with the name `member`, so any
-use of that name needs qualification by a name of the appropriate base
-type. (Using `typedef`s ease mentioning the base types.) However, the fix
-introduces a new problem when a pointer is needed. Using the address
-operator with a sub-object qualified with its class's name results in a
-pointer-to-member (here, having a type of `an_int boost::base_from_member<
-an_int, 0> :: *`) instead of a pointer to the member (having a type of
-`an_int *`). The new problem is fixed by qualifying the sub-object with
-`this->` and is needed just for pointers, and not for references or values.
-
-There are some argument conversions in the initialization. The constructor
-argument for `pbase0_type` is converted from `double` to `float`. The first
-constructor argument for `pbase2_type` is converted from `int` to `double`.
-The second constructor argument for `pbase3_type` is a special case of
-necessary conversion; all forms of the null-pointer literal in C++ (except
-`nullptr` from C++11) also look like compile-time integral expressions, so
-C++ always interprets such code as an integer when it has overloads that can
-take either an integer or a pointer. The last conversion is necessary for the
-compiler to call a constructor form with the exact pointer type used in
-`switcher`'s constructor. (If C++11's `nullptr` is used, it still needs a
-conversion if multiple pointer types can be accepted in a constructor call
-but `std::nullptr_t` cannot.)
-
-[endsect]
-
-[section Acknowledgments]
-
-* [@http://www.boost.org/people/ed_brey.htm Ed Brey] suggested some interface
-changes.
-
-* [@http://www.moocat.org R. Samuel Klatchko] ([@mailto:rsk@moocat.org
-rsk@moocat.org], [@mailto:rsk@brightmail.com rsk@brightmail.com]) invented
-the idiom of how to use a class member for initializing a base class.
-
-* [@http://www.boost.org/people/dietmar_kuehl.htm Dietmar Kuehl] popularized the
- base-from-member idiom in his [@http://www.informatik.uni-konstanz.de/~kuehl/c++/iostream/
-  IOStream example classes].
-
-* Jonathan Turkanis supplied an implementation of generating the constructor
-templates that can be controlled and automated with macros. The
-implementation uses the [@../../../preprocessor/index.html Preprocessor library].
-
-* [@http://www.boost.org/people/daryle_walker.html">Daryle Walker] started the
-library. Contributed the test file [@../../test/base_from_member_test.cpp
-base_from_member_test.cpp].
-
-[endsect]
-

doc/compressed_pair.qbk

@@ -1,99 +0,0 @@
-[/
-  Copyright 2000 Beman Dawes & John Maddock.
-
-  Distributed under the Boost Software License, Version 1.0.
-
-  See accompanying file LICENSE_1_0.txt
-  or copy at http://boost.org/LICENSE_1_0.txt
-]
-
-[article Compressed_Pair
-    [quickbook 1.5]
-    [authors [Cleary, Steve]]
-    [authors [Dawes, Beman]]
-    [authors [Hinnant, Howard]]
-    [authors [Maddock, John]]
-    [copyright 2000 Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock]
-    [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])
-    ]
-]
-
-[section Overview]
-
-All of the contents of `<boost/compressed_pair.hpp>` are defined inside
-`namespace boost`.
-
-The class `compressed_pair` is very similar to `std::pair`, but if either of
-the template arguments are empty classes, then the ['empty base-class
-optimisation] is applied to compress the size of the pair.
-
-[endsect]
-
-[section Synopsis]
-
-    template <class T1, class T2>
-    class compressed_pair
-    {
-    public:
-        typedef T1                                                 first_type;
-        typedef T2                                                 second_type;
-        typedef typename call_traits<first_type>::param_type       first_param_type;
-        typedef typename call_traits<second_type>::param_type      second_param_type;
-        typedef typename call_traits<first_type>::reference        first_reference;
-        typedef typename call_traits<second_type>::reference       second_reference;
-        typedef typename call_traits<first_type>::const_reference  first_const_reference;
-        typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-                 compressed_pair() : base() {}
-                 compressed_pair(first_param_type x, second_param_type y);
-        explicit compressed_pair(first_param_type x);
-        explicit compressed_pair(second_param_type y);
-
-        compressed_pair& operator=(const compressed_pair&);
-
-        first_reference       first();
-        first_const_reference first() const;
-
-        second_reference       second();
-        second_const_reference second() const;
-
-        void swap(compressed_pair& y);
-    };
-
-The two members of the pair can be accessed using the member functions
-`first()` and `second()`. Note that not all member functions can be
-instantiated for all template parameter types. In particular
-`compressed_pair` can be instantiated for reference and array types,
-however in these cases the range of constructors that can be used are
-limited. If types `T1` and `T2` are the same type, then there is only
-one version of the single-argument constructor, and this constructor
-initialises both values in the pair to the passed value.
-
-Note that if either member is a POD type, then that member is not
-zero-initialized by the `compressed_pair` default constructor: it's up
-to you to supply an initial value for these types if you want them to have
-a default value.
-
-Note that `compressed_pair` can not be instantiated if either of the
-template arguments is a union type, unless there is compiler support for
-`boost::is_union`, or if `boost::is_union` is specialised for the union
-type.
-
-Finally, a word of caution for Visual C++ 6 users: if either argument is an
-empty type, then assigning to that member will produce memory corruption,
-unless the empty type has a "do nothing" assignment operator defined. This
-is due to a bug in the way VC6 generates implicit assignment operators.
-
-[endsect]
-
-[section Acknowledgments]
-
-Based on contributions by Steve Cleary, Beman Dawes, Howard Hinnant and
-John Maddock.
-
-Maintained by [@mailto:john@johnmaddock.co.uk John Maddock].
-
-[endsect]

doc/declval.qbk

@@ -1,114 +0,0 @@
-[/
- / Copyright (c) 2008 Howard Hinnant
- / Copyright (c) 2009-20012 Vicente J. Botet Escriba
- /
- / 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)
- /]
-
-[article Declval
-    [quickbook 1.5]
-    [authors [Hinnant, Howard]]
-    [authors [Botet Escriba, Vicente J.]]
-    [copyright 2008 Howard Hinnant]
-    [copyright 2009-2012 Vicente J. Botet Escriba]
-    [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])
-    ]
-]
-
-[/===============]
-[section Overview]
-[/===============]
-
-The motivation for `declval` was introduced in [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2958.html#Value N2958: 
-Moving Swap Forward]. Here follows a rewording of this chapter.
-
-With the provision of decltype, late-specified return types, and default template-arguments for function templates a 
-new generation of SFINAE patterns will emerge to at least partially compensate the lack of concepts on the C++0x timescale. 
-Using this technique, it is sometimes necessary to obtain an object of a known type in a non-using context, e.g. given the declaration 
-
-  template<class T>
-  T&& declval(); // not used
-  
-as part of the function template declaration 
-
-  template<class To, class From>
-  decltype(static_cast<To>(declval<From>())) convert(From&&);
-  
-or as part of a class template definition 
-
-  template<class> class result_of;
-
-  template<class Fn, class... ArgTypes>
-  struct result_of<Fn(ArgTypes...)> 
-  {
-    typedef decltype(declval<Fn>()(declval<ArgTypes>()...)) type;
-  };
-  
-The role of the function template declval() is a transformation of a type T into a value without using or evaluating this function. 
-The name is supposed to direct the reader's attention to the fact that the expression `declval<T>()` is an lvalue if and only if 
-T is an lvalue-reference, otherwise an rvalue. To extend the domain of this function we can do a bit better by changing its declaration to 
-
-  template<class T>
-  typename std::add_rvalue_reference<T>::type declval(); // not used
-  
-which ensures that we can also use cv void as template parameter. The careful reader might have noticed that `declval()` 
-already exists under the name create() as part of the definition of the semantics of the type trait is_convertible in the C++0x standard. 
-
-The provision of a new library component that allows the production of values in unevaluated expressions is considered 
-important to realize constrained templates in C++0x where concepts are not available. 
-This extremely light-weight function is expected to be part of the daily tool-box of the C++0x programmer. 
-
-[endsect]
-
-
-[/=================]
-[section:reference Reference ]
-[/=================]
-
-`#include <boost/utility/declval.hpp>`
-
-    namespace boost {
-
-        template <typename T>
-        typename add_rvalue_reference<T>::type declval() noexcept; // as unevaluated operand
-
-    }  // namespace boost
-
-
-The library provides the function template declval to simplify the definition of expressions which occur as unevaluated operands.
-
-        template <typename T>
-        typename add_rvalue_reference<T>::type declval();
-
-[*Remarks:] If this function is used, the program is ill-formed.
-
-[*Remarks:] The template parameter T of declval may be an incomplete type.
-
-[*Example:]
-
-    template <class To, class From>
-    decltype(static_cast<To>(declval<From>())) convert(From&&);
-
-Declares a function template convert which only participates in overloading if the type From can be explicitly converted to type To. 
-
-[endsect]
-
-[/===============]
-[section History]
-[/===============]
-
-[heading boost 1.50]
-
-Fixes:
-
-* [@http://svn.boost.org/trac/boost/ticket/6570 #6570] Adding noexcept to boost::declval.
-
-[endsect]
-
-
-
-

doc/enable_if.html

@@ -0,0 +1,417 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
+            "http://www.w3.org/TR/REC-html40/loose.dtd">
+<HTML>
+<HEAD><TITLE>enable_if</TITLE>
+
+<META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<META name="GENERATOR" content="hevea 1.06">
+</HEAD>
+<BODY >
+<!--HEVEA command line is: hevea -nosymb -noiso -pedantic -v enable_if_docs_for_boost.tex -->
+<!--HTMLHEAD-->
+<!--ENDHTML-->
+<!--PREFIX <ARG ></ARG>-->
+<!--CUT DEF section 1 -->
+<BR>
+<BR>
+
+
+<h1>
+<img border="0" src="c++boost.gif" align="center" width="277" height="86">enable_if</h1>
+<BR>
+<BR>
+Copyright 2003 Jaakko J&auml;rvi, Jeremiah Willcock, Andrew Lumsdaine.<BR>
+<BR>
+<!--TOC section Introduction-->
+
+<H2><A NAME="htoc1">1</A>&nbsp;&nbsp;Introduction</H2><!--SEC END -->
+
+<A NAME="introduction"></A>
+The <TT>enable_if</TT> family of templates is a set of tools to allow a function template or a class template specialization 
+to include or exclude itself from a set of matching functions or specializations
+based on properties of its template arguments. 
+For example, one can define function templates that
+are only enabled for, and thus only match, an arbitrary set of types
+defined by a traits class. The <TT>enable_if</TT> templates can also be
+applied to enable class template specializations. Applications of
+<TT>enable_if</TT> are discussed in length
+in&nbsp;[<A HREF="#jarvi:03:cuj_arbitrary_overloading"><CITE>1</CITE></A>] and&nbsp;[<A HREF="#jarvi:03:c++typeclasses"><CITE>2</CITE></A>].<BR>
+<BR>
+<!--TOC subsection Synopsis-->
+
+<H3><A NAME="htoc2">1.1</A>&nbsp;&nbsp;Synopsis</H3><!--SEC END -->
+
+<A NAME="sec:synopsis"></A>
+<PRE>
+namespace boost {
+  template &lt;class Cond, class T = void&gt; struct enable_if;
+  template &lt;class Cond, class T = void&gt; struct disable_if;
+  template &lt;class Cond, class T&gt; struct lazy_enable_if;
+  template &lt;class Cond, class T&gt; struct lazy_disable_if;
+
+  template &lt;bool B, class T = void&gt; struct enable_if_c;
+  template &lt;bool B, class T = void&gt; struct disable_if_c;
+  template &lt;bool B, class T&gt; struct lazy_enable_if_c;
+  template &lt;bool B, class T&gt; struct lazy_disable_if_c;
+}
+</PRE>
+<!--TOC subsection Background-->
+
+<H3><A NAME="htoc3">1.2</A>&nbsp;&nbsp;Background</H3><!--SEC END -->
+
+<A NAME="sec:background"></A>
+Sensible operation of template function overloading in C++ relies
+on the <EM>SFINAE</EM> (substitution-failure-is-not-an-error)
+principle&nbsp;[<A HREF="#vandevoorde2002:templates"><CITE>3</CITE></A>]: if an invalid argument
+or return type is formed during the instantiation of a function
+template, the instantiation is removed from the overload resolution
+set instead of causing a compilation error. The following example, 
+taken from&nbsp;[<A HREF="#jarvi:03:cuj_arbitrary_overloading"><CITE>1</CITE></A>],
+demonstrates why this is important:
+<PRE>
+
+int negate(int i) { return -i; }
+
+template &lt;class F&gt;
+typename F::result_type negate(const F&amp; f) { return -f(); }
+
+</PRE>
+Suppose the compiler encounters the call <TT>negate(1)</TT>. The first
+definition is obviously a better match, but the compiler must
+nevertheless consider (and instantiate the prototypes) of both
+definitions to find this out. Instantiating the latter definition with
+<TT>F</TT> as <TT>int</TT> would result in:
+<PRE>
+
+int::result_type negate(const int&amp;);
+
+</PRE>
+where the return type is invalid. If this was an error, adding an unrelated function template 
+(that was never called) could break otherwise valid code.
+Due to the SFINAE principle the above example is not, however, erroneous. 
+The latter definition of <TT>negate</TT> is simply removed from the overload resolution set.<BR>
+<BR>
+The <TT>enable_if</TT> templates are tools for controlled creation of the SFINAE
+conditions.<BR>
+<BR>
+<!--TOC section The <TT>enable_if</TT> templates-->
+
+<H2><A NAME="htoc4">2</A>&nbsp;&nbsp;The <TT>enable_if</TT> templates</H2><!--SEC END -->
+
+<A NAME="enable_if"></A>
+The names of the <TT>enable_if</TT> templates have three parts: an optional <TT>lazy_</TT> tag, 
+either <TT>enable_if</TT> or <TT>disable_if</TT>, and an optional <TT>_c</TT> tag.
+All eight combinations of these parts are supported.
+The meaning of the <TT>lazy_</TT> tag is described in Section&nbsp;<A HREF="#sec:enable_if_lazy">3.3</A>.
+The second part of the name indicates whether a true condition argument should 
+enable or disable the current overload.
+The third part of the name indicates whether the condition argument is a <TT>bool</TT> value 
+(<TT>_c</TT> suffix), or a type containing a static <TT>bool</TT> constant named <TT>value</TT> (no suffix).
+The latter version interoperates with Boost.MPL. <BR>
+<BR>
+The definitions of <TT>enable_if_c</TT> and <TT>enable_if</TT> are as follows (we use <TT>enable_if</TT> templates 
+unqualified but they are in the <TT>boost</TT> namespace).
+<PRE>
+
+template &lt;bool B, class T = void&gt;
+struct enable_if_c {
+  typedef T type;
+};
+
+template &lt;class T&gt;
+struct enable_if_c&lt;false, T&gt; {};
+
+template &lt;class Cond, class T = void&gt;
+struct enable_if : public enable_if_c&lt;Cond::value, T&gt; {};
+
+</PRE>
+An instantiation of the <TT>enable_if_c</TT> template with the parameter
+<TT>B</TT> as <TT>true</TT> contains a member type <TT>type</TT>, defined
+to be <TT>T</TT>. If <TT>B</TT> is
+<TT>false</TT>, no such member is defined. Thus 
+<TT>enable_if_c&lt;B, T&gt;::type</TT> is either a valid or an invalid type
+expression, depending on the value of <TT>B</TT>.
+When valid, <TT>enable_if_c&lt;B, T&gt;::type</TT> equals <TT>T</TT>.
+The <TT>enable_if_c</TT> template can thus be used for controlling when functions are considered for
+overload resolution and when they are not. 
+For example, the following function is defined for all arithmetic types (according to the
+classification of the <A HREF="http://www.boost.org/libs/type_traits">Boost type_traits library</A>):
+<PRE>
+
+template &lt;class T&gt;
+typename enable_if_c&lt;boost::is_arithmetic&lt;T&gt;::value, T&gt;::type 
+foo(T t) { return t; }
+
+</PRE>
+The <TT>disable_if_c</TT> template is provided as well, and has the
+same functionality as <TT>enable_if_c</TT> except for the negated condition. The following
+function is enabled for all non-arithmetic types.
+<PRE>
+
+template &lt;class T&gt;
+typename disable_if_c&lt;boost::is_arithmetic&lt;T&gt;::value, T&gt;::type 
+bar(T t) { return t; }
+
+</PRE>
+For easier syntax in some cases and interoperation with Boost.MPL we provide versions of
+the <TT>enable_if</TT> templates taking any type with a <TT>bool</TT> member constant named 
+<TT>value</TT> as the condition argument.
+The MPL <TT>bool_</TT>, <TT>and_</TT>, <TT>or_</TT>, and <TT>not_</TT> templates are likely to be 
+useful for creating such types. Also, the traits classes in the Boost.Type_traits library 
+follow this convention. 
+For example, the above example function <TT>foo</TT> can be alternatively written as:
+<PRE>
+
+template &lt;class T&gt;
+typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
+foo(T t) { return t; }
+
+</PRE>
+<!--TOC section Using <TT>enable_if</TT>-->
+
+<H2><A NAME="htoc5">3</A>&nbsp;&nbsp;Using <TT>enable_if</TT></H2><!--SEC END -->
+
+<A NAME="sec:using_enable_if"></A>
+The <TT>enable_if</TT> templates are defined in
+<TT>boost/utility/enable_if.hpp</TT>, which is included by <TT>boost/utility.hpp</TT>.<BR>
+<BR>
+The <TT>enable_if</TT> template can be used either as the return type, or as an 
+extra argument. For example, the <TT>foo</TT> function in the previous section could also be written
+as:
+<PRE>
+
+template &lt;class T&gt;
+T foo(T t, typename enable_if&lt;boost::is_arithmetic&lt;T&gt; &gt;::type* dummy = 0); 
+
+</PRE>Hence, an extra parameter of type <TT>void*</TT> is added, but it is given 
+a default value to keep the parameter hidden from client code.
+Note that the second template argument was not given to <TT>enable_if</TT>, as the default 
+<TT>void</TT> gives the desired behavior.<BR>
+<BR>
+Whether to write the enabler as an argument or within the return type is
+largely a matter of taste, but for certain functions, only one
+alternative is possible:
+<UL><LI>
+Operators have a fixed number of arguments, thus <TT>enable_if</TT> must be used in the return type.
+<LI>Constructors and destructors do not have a return type; an extra argument is the only option.
+<LI>There does not seem to be a way to specify an enabler for a conversion operator. Converting constructors,
+however, can have enablers as extra default arguments.
+</UL>
+<!--TOC subsection Enabling template class specializations-->
+
+<H3><A NAME="htoc6">3.1</A>&nbsp;&nbsp;Enabling template class specializations</H3><!--SEC END -->
+
+<A NAME="sec:enable_if_classes"></A>
+Class template specializations can be enabled or disabled with <TT>enable_if</TT>.
+One extra template parameter needs to be added for the enabler expressions.
+This parameter has the default value <TT>void</TT>.
+For example:
+<PRE>
+
+template &lt;class T, class Enable = void&gt; 
+class A { ... };
+
+template &lt;class T&gt;
+class A&lt;T, typename enable_if&lt;is_integral&lt;T&gt; &gt;::type&gt; { ... };
+
+template &lt;class T&gt;
+class A&lt;T, typename enable_if&lt;is_float&lt;T&gt; &gt;::type&gt; { ... };
+
+</PRE>Instantiating <TT>A</TT> with any integral type matches the first specialization,
+whereas any floating point type matches the second one. All other types
+match the primary template.
+The condition can be any compile-time boolean expression that depends on the 
+template arguments of the class.
+Note that again, the second argument to <TT>enable_if</TT> is not needed; the default (<TT>void</TT>) 
+is the correct value.<BR>
+<BR>
+<!--TOC subsection Overlapping enabler conditions-->
+
+<H3><A NAME="htoc7">3.2</A>&nbsp;&nbsp;Overlapping enabler conditions</H3><!--SEC END -->
+
+<A NAME="sec:overlapping_conditions"></A>
+Once the compiler has examined the enabling conditions and included the
+function into the overload resolution set, normal C++ overload resolution 
+rules are used to select the best matching function.
+In particular, there is no ordering between enabling conditions.
+Function templates with enabling conditions that are not mutually exclusive can 
+lead to ambiguities. For example:
+<PRE>
+
+template &lt;class T&gt;
+typename enable_if&lt;boost::is_integral&lt;T&gt;, void&gt;::type 
+foo(T t) {}
+
+template &lt;class T&gt;
+typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, void&gt;::type 
+foo(T t) {}
+
+</PRE>
+All integral types are also arithmetic. Therefore, say, for the call <TT>foo(1)</TT>,
+both conditions are true and both functions are thus in the overload resolution set.
+They are both equally good matches and thus ambiguous.
+Of course, more than one enabling condition can be simultaneously true as long as 
+other arguments disambiguate the functions.<BR>
+<BR>
+The above discussion applies to using <TT>enable_if</TT> in class template
+partial specializations as well.<BR>
+<BR>
+<!--TOC subsection Lazy <TT>enable_if</TT>-->
+
+<H3><A NAME="htoc8">3.3</A>&nbsp;&nbsp;Lazy <TT>enable_if</TT></H3><!--SEC END -->
+
+<A NAME="sec:enable_if_lazy"></A>
+In some cases it is necessary to avoid instantiating part of a
+function signature unless an enabling condition is true. For example:
+<PRE>
+
+template &lt;class T, class U&gt; class mult_traits;
+
+template &lt;class T, class U&gt;
+typename enable_if&lt;is_multipliable&lt;T, U&gt;, typename mult_traits&lt;T, U&gt;::type&gt;::type
+operator*(const T&amp; t, const U&amp; u) { ... }
+
+</PRE>Assume the class template <TT>mult_traits</TT> is a traits class defining 
+the resulting type of a multiplication operator. The <TT>is_multipliable</TT> traits
+class specifies for which types to enable the operator. Whenever
+<TT>is_multipliable&lt;A, B&gt;::value</TT> is <TT>true</TT> for some types <TT>A</TT> and <TT>B</TT>,
+then <TT>mult_traits&lt;A, B&gt;::type</TT> is defined.<BR>
+<BR>
+Now, trying to invoke (some other overload) of <TT>operator*</TT> with, say, operand types <TT>C</TT> and <TT>D</TT> 
+for which <TT>is_multipliable&lt;C, D&gt;::value</TT> is <TT>false</TT> 
+and <TT>mult_traits&lt;C, D&gt;::type</TT> is not defined is an error on some compilers. 
+The SFINAE principle is not applied because
+the invalid type occurs as an argument to another template. The <TT>lazy_enable_if</TT> 
+and <TT>lazy_disable_if</TT> templates (and their <TT>_c</TT> versions) can be used in such
+situations:
+<PRE>
+
+template&lt;class T, class U&gt;
+typename lazy_enable_if&lt;is_multipliable&lt;T, U&gt;, mult_traits&lt;T, U&gt; &gt;::type
+operator*(const T&amp; t, const U&amp; u) { ... }
+
+</PRE>The second argument of <TT>lazy_enable_if</TT> must be a class type
+that defines a nested type named <TT>type</TT> whenever the first
+parameter (the condition) is true.<BR>
+<BR>
+<!--TOC paragraph Note-->
+
+<H5>Note</H5><!--SEC END -->
+
+Referring to one member type or static constant in a traits class
+causes all of the members (type and static constant) of that
+specialization to be instantiated. Therefore, if your traits classes
+can sometimes contain invalid types, you should use two distinct
+templates for describing the conditions and the type mappings. In the
+above example, <TT>is_multipliable&lt;T, U&gt;::value</TT> defines when
+<TT>mult_traits&lt;T, U&gt;::type</TT> is valid.<BR>
+<BR>
+<!--TOC subsection Compiler workarounds-->
+
+<H3><A NAME="htoc9">3.4</A>&nbsp;&nbsp;Compiler workarounds</H3><!--SEC END -->
+
+<A NAME="sec:workarounds"></A>
+Some compilers flag functions as ambiguous if the only distinguishing factor is a different 
+condition in an enabler (even though the functions could never be ambiguous). For example,
+some compilers (e.g. GCC 3.2) diagnose the following two functions as ambiguous:
+<PRE>
+
+template &lt;class T&gt;
+typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
+foo(T t);
+
+template &lt;class T&gt;
+typename disable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
+foo(T t);
+
+</PRE>Two workarounds can be applied:
+<UL><LI>
+Use an extra dummy parameter which disambiguates the functions. Use a default value for
+it to hide the parameter from the caller. For example:
+<PRE>
+
+template &lt;class T&gt; struct dummy { dummy(int) {} };
+
+template &lt;class T&gt;
+typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
+foo(T t, dummy&lt;0&gt; = 0);
+
+template &lt;class T&gt;
+typename disable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
+foo(T t, dummy&lt;1&gt; = 0);
+</PRE><BR>
+<BR>
+<LI>Define the functions in different namespaces and bring them into a common
+namespace with <TT>using</TT> declarations:
+<PRE>
+
+namespace A {
+  template &lt;class T&gt;
+  typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
+  foo(T t);
+}
+
+namespace B {
+  template &lt;class T&gt;
+  typename disable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
+  foo(T t);
+}
+
+using A::foo;
+using B::foo;
+
+</PRE>
+Note that the second workaround above cannot be used for member
+templates. On the other hand, operators do not accept extra arguments,
+which makes the first workaround unusable. As the net effect,
+neither of the workarounds are of assistance for templated operators that
+need to be defined as member functions (assignment and
+subscript operators).
+</UL>
+<!--TOC section Acknowledgements-->
+
+<H2><A NAME="htoc10">4</A>&nbsp;&nbsp;Acknowledgements</H2><!--SEC END -->
+
+We are grateful to Howard Hinnant, Jason Shirk, Paul Mensonides, and Richard
+Smith whose findings have influenced the library.<BR>
+<BR>
+<!--TOC section References-->
+
+<H2>References</H2><!--SEC END -->
+<DL COMPACT=compact><DT><A NAME="jarvi:03:cuj_arbitrary_overloading"><FONT COLOR=purple>[1]</FONT></A><DD>
+Jaakko J&auml;rvi, Jeremiah Willcock, Howard Hinnant, and Andrew Lumsdaine.
+Function overloading based on arbitrary properties of types.
+<EM>C/C++ Users Journal</EM>, 21(6):25--32, June 2003.<BR>
+<BR>
+<DT><A NAME="jarvi:03:c++typeclasses"><FONT COLOR=purple>[2]</FONT></A><DD>
+Jaakko J&auml;rvi, Jeremiah Willcock, and Andrew Lumsdaine.
+Concept-controlled polymorphism.
+In Frank Pfennig and Yannis Smaragdakis, editors, <EM>Generative
+ Programming and Component Engineering</EM>, volume 2830 of <EM>LNCS</EM>, pages
+ 228--244. Springer Verlag, September 2003.<BR>
+<BR>
+<DT><A NAME="vandevoorde2002:templates"><FONT COLOR=purple>[3]</FONT></A><DD>
+David Vandevoorde and Nicolai&nbsp;M. Josuttis.
+<EM>C++ Templates: The Complete Guide</EM>.
+Addison-Wesley, 2002.</DL>
+
+
+
+
+
+<hr></hr>
+
+<B>Contributed by:</B> <BR>
+Jaakko J&auml;rvi, Jeremiah Willcock and Andrew Lumsdaine<BR>
+<EM>{jajarvi|jewillco|lums}@osl.iu.edu</EM><BR>
+Indiana University<BR>
+Open Systems Lab
+<!--HTMLFOOT-->
+<!--ENDHTML-->
+<!--FOOTER-->
+<HR SIZE=2>
+<BLOCKQUOTE><EM>This document was translated from L<sup>A</sup>T<sub>E</sub>X by
+</EM><A HREF="http://pauillac.inria.fr/~maranget/hevea/index.html"><EM>H<FONT SIZE=2><sup>E</sup></FONT>V<FONT SIZE=2><sup>E</sup></FONT>A</EM></A><EM>.
+</EM></BLOCKQUOTE>
+</BODY>
+</HTML>

doc/lexicographic.html

@@ -0,0 +1,302 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 
+"http://www.w3.org/TR/html4/strict.dtd">
+<html>
+<head>
+
+<!-- TODO: 
+	- lambda interaction
+-->
+
+        <title>Boost.Utility - lexicographic documentation</title>
+        <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+</head>
+<body bgcolor="#ffffff">
+	<h1>
+	<img border="0" src="../../../c++boost.gif" align="center" alt="c++ boost"> 
+	Utility - Lexicographic
+	</h1>
+	
+	<p>
+	The class <code>boost::lexicographic</code> provides an easy way 
+	to avoid complex and errorprone if-else cascades to do lexicographic
+	comparisions on certain different criteria. The class is in the header
+	<a href="../../../boost/utility/lexicographic.hpp"
+	>boost/utility/lexicographic.hpp</a> and depends on no others headers. 
+	The test code is in 
+	<a href="../../../libs/utility/test/lexicographic_test.cpp"
+        >lexicographic_test.cpp</a>.
+	</p>
+
+	<h2>Contents</h2>
+	<ul>
+		<li><a href="#introduction">Introduction</a></li>
+		<li><a href="#examples">Examples</a></li>
+		<li><a href="#synopsis">Synopsis</a></li>
+		<li><a href="#members">Members</a></li>
+		<li><a href="#free_functions">Free Functions</a></li>
+		<li><a href="#credits">Credits</a></li>
+	</ul>
+
+	<h2><a name="introduction">Introduction</a></h2>
+	<p>	
+	Often one has to write comparisions which give an ordering between
+	various kinds of data. When they look in a certain 
+	specified order at one relation between two data items at a time and 
+	result in a lexicographic comparision of all these relations the 
+	programmer often has to write long if-else cascades. These cascades
+	are often complex and difficult to maintain. The class 
+	<code>boost::lexicographic</code> helps in this scenario. Its constructor
+	and function call operator takes two data items which need to be
+	compared as arguments and performs to comparision. The order in which
+	the function call operators are called determine the lexicographic order
+	of the relations. Since the result of all further comparisions might not
+	be needed after a certain step, they are not executed.<br>
+	The logic of the class assumes an ascending order as implied by the 
+	<code>operator &lt;</code>. If a descending order needs to be obtained
+	one can just switch the order of the arguments. Additionally, both the
+	constructor and the function call operator provide also a three argument
+	form which takes a functor for comparisions as a third argument.
+ 	</p>
+	
+	<h3>Relation to <code>std::lexicographic_compare</code></h3>
+	<p>
+	The standard C++ algorithm <code>std::lexicographic_compare</code>
+	does essentially the same thing but in a different situation. It compares
+	sequences of data items of equal type. Whereas <code>boost::lexicographic</code>
+	compares individual data items of different type, and every comparison
+	must be specified explicitly by using the function call operator of the class.
+	</p>
+
+	<h3>Relation to if-else-cascades</h3>
+	<p>
+	<b>Advantages</b><br>
+	<ul>
+		<li>The order of comparisons can easily be changed.
+		<li>Single comparisons can be added or removed in one line.
+		<li>Comparisons can be split up to be computed partly in one 
+			function and partly in another by using 
+			<code>boost::lexicographic</code> as a functor.
+		<li>It documents the code in a better fashion and expresses
+			the users intention directly.
+		<li>If the comparison arguments do not need computation, there is in
+			theory no performance overhead.   
+	</ul>
+	<b>Disadvantages</b><br>
+	<ul>
+		<li>There is no short-circuiting. All arguments will be 
+	evaluated, also if
+	an earlier comparison step already gave the final result. As long as the
+	arguments are trivial there should be no performance overhead. The only 
+	way to avoid evaluation of arguments is to place every comparison step
+	in an if-statement like:
+<blockquote>
+<pre>boost::lexicographic cmp (complex_computation (a), complex_computation (b));
+if (cmp.result () == lexicographic::equivalent) 
+{
+	cmp (complex_computation (c), complex_computation (d));
+	if (cmp.result () == lexicographic::equivalent)
+	{
+		cmp (complex_computation (e), complex_computation (f));
+	}
+}
+// do something with cmp
+</pre>
+</blockquote>
+	But this construct eats up many of the advantages of using 
+	<code>boost::lexicographic</code>.
+		<li>
+	The performance of using <code>boost::lexicographic</code>, besides 
+	the lack of short-circuiting, is not negligible.
+	Tests with gcc 3.2.2 showed, that the algorithmic overhead
+	is about 40% in comparison to according to if-else-cascades.
+	Additionally gcc failed to inline everything properly, so that the 
+	resulting performance overhead was about a factor two.
+	</ul>
+	</p>
+
+	<h2><a name="examples">Examples</a></h2>
+	<p>
+	An example usage are special sorting operators, such as the lexicographic
+	ordering of tuples:
+<blockquote>
+<pre>struct position
+{
+    double x, y, z;
+};
+
+bool operator &lt; (position const &amp;p1, position const &amp;p2)
+{
+    return boost::lexicographic (p1.x, p2.x)
+                                (p1.y, p2.y)
+                                (p1.z, p2.z);
+}</pre>
+</blockquote>
+	An alternative form of writing this without <code>boost::lexicographic</code>
+	would be this:
+<blockquote>
+<pre>bool operator &lt; (position const &amp;p1, position const &amp;p2)
+{
+    if (p1.x == p2.x)
+        if (p1.y == p2.y)
+            return p1.z &lt; p2.z;
+        else
+            return p1.y &lt; p2.y;
+    else
+        return p1.x &lt; p2.x;
+}</pre>
+</blockquote>
+	It is also easy to use different functor such as a case insensitive
+	comparision function object in the next example.
+<blockquote>
+<pre>struct person
+{
+    std::string firstname, lastname;
+};
+
+bool operator &lt; (person const &amp;p1, person const &amp;p2)
+{
+    return boost::lexicographic
+        (p1.lastname, p2.lastname, cmp_case_insensitive)
+        (p1.firstname, p2.firstname, cmp_case_insensitive);
+}</pre>
+</blockquote>
+	</p>
+
+	<h2><a name="synopsis">Synopsis</a></h2>
+	<blockquote>
+<pre>namespace boost
+{
+
+  class lexicographic
+  {
+    public:
+      enum result_type { minus = -1, equivalent, plus };
+
+      template &lt;typename T1, typename T2&gt;
+      lexicographic (T1 const &amp;a, T2 const &b);
+      
+      template &lt;typename T1, typename T2, typename Cmp&gt;
+      lexicographic (T1 const &amp;a, T2 const &b, Cmp cmp);
+
+      template &lt;typename T1, typename T2&gt;
+      lexicographic &amp;operator () (T1 const &a, T2 const &b);
+
+      template &lt;typename T1, typename T2, typename Cmp&gt;
+      lexicographic &amp;operator () (T1 const &a, T2 const &b, Cmp cmp);
+
+      result_type result () const;
+      operator <i>unspecified_bool_type</i> () const;
+  };
+
+  bool operator == (lexicographic l1, lexicographic l2);
+  bool operator != (lexicographic l1, lexicographic l2);
+
+}</pre>
+	</blockquote>
+	
+	<h2><a name="members">Members</a></h2>
+	<h3>result_type</h3>
+	<code>enum result_type { minus = -1, equivalent = 0, plus = +1 };</code>
+	<blockquote><p>
+		Defines the result type of the class. It is kept as internal state
+		and is returned by <code>result ()</code>.
+		The integer representation of it is equivalent to the one
+		returned by <code>std::strcmp</code>. 
+		<ul>
+			<li><code>minus</code> - the sequence of the first arguments 
+				of constructor and function call operators
+				is lexicographically less than the according 
+				sequence of the second arguments.
+			<li><code>equivalent</code> - all elements of the sequences
+				of the first and the second arguments are identical.
+			<li><code>plus</code> - the sequence of the first arguments 
+				of constructor and function call operators
+				is lexicographically greater than the according 
+				sequence of the second arguments.
+		</ul>
+        </p></blockquote>
+
+	<h3>constructors</h3>
+	<code>template &lt;typename T1, typename T2&gt;<br>
+	lexicographic (T1 const &amp;a, T2 const &b);</code>
+	<blockquote><p>
+		Constructs new object and does the first comparision 
+		step between <code>a</code> and <code>b</code>. It uses 
+		<code>operator &lt;</code> for comparisions.
+	</p></blockquote>
+
+	<code>template &lt;typename T1, typename T2, typename Cmp&gt;<br>
+	lexicographic (T1 const &amp;a, T2 const &b, Cmp cmp);</code>
+	<blockquote><p>
+	        Constructs new object and does the first comparision 
+                step between <code>a</code> and <code>b</code>. It uses 
+                <code>cmp</code> for comparisions.
+        </p></blockquote>   
+
+	<h3>function call operators</h3>
+	<code>template &lt;typename T1, typename T2&gt;<br>
+	lexicographic &amp;operator () (T1 const &a, T2 const &b);</code>
+        <blockquote><p>
+                Does next comparision step on object between <code>a</code> 
+		and <code>b</code>. It uses <code>operator &lt;</code> for 
+		comparisions.
+        </p></blockquote>
+	
+	<code>template &lt;typename T1, typename T2, typename Cmp&gt;<br>
+	lexicographic &amp;operator () (T1 const &a, T2 const &b, Cmp cmp);</code>
+        <blockquote><p>
+                Does next comparision step on object between <code>a</code> 
+		and <code>b</code>. It uses <code>cmp</code> for 
+		comparisions.
+        </p></blockquote>
+
+	<h3>result</h3>
+	<code>result_type result () const;</code>
+	<blockquote><p>
+		Gives result of already done comparision steps.
+	</p></blockquote>
+	
+	<h3>conversions</h3>
+	<code>operator <i>unspecified_bool_type</i> () const;</code>
+	<blockquote><p>
+		This conversion operator allows objects to be used in boolean 
+		contexts, like <code>if (lexicographic (a, b)) {}</code>. The 
+		actual target type is typically a pointer to a member function, 
+		avoiding many of the implicit conversion pitfalls.<br>
+		It evaluates to <code>true</code> if <code>result () == minus</code>,
+		otherwise to <code>false</code>.
+	</p></blockquote>
+
+	<h2><a name="free_functions">Free Functions</a></h2>
+	<h3>comparision</h3>
+	<code>bool operator == (lexicographic l1, lexicographic l2);</code>
+	<blockquote><p>
+		Returns <code>l1.result () == l2.result ()</code>.
+		That means it returns <code>true</code> if both
+		objects are in the same state.
+	</p></blockquote>
+  
+	<code>bool operator != (lexicographic l1, lexicographic l2);</code>
+	<blockquote><p>
+		Returns <code>l1.result () != l2.result ()</code>.
+		That means it returns <code>true</code> if the two  
+		objects are in the a different state.
+	</p></blockquote>
+
+	<h2><a name="credits">Credits</a></h2>
+	<p>
+	The author of <code>boost::lexicographic</code> is Jan Langer (jan@langernetz.de).
+	Ideas and suggestions from Steve Cleary, David Abrahams, Gennaro Proata, Paul Bristow, Daniel Frey, Daryle Walker and Brian McNamara were used.
+	</p>
+	<hr>
+	<p>
+	October 5, 2003<br>
+	<br>
+	© Copyright Jan Langer 2003<br>
+	Use, modification, and distribution is subject to the Boost Software 
+	License, Version 1.0. (See accompanying file 
+	<a href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at 
+	<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
+	</p>
+</body>
+</html>

doc/logo.svg

@@ -1,539 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:xlink="http://www.w3.org/1999/xlink"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="744.09448819"
-   height="1052.3622047"
-   id="svg6858"
-   version="1.1"
-   inkscape:version="0.48.4 r9939"
-   sodipodi:docname="utility.svg">
-  <defs
-     id="defs6860">
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient4453-7-8-6-7-3-5"
-       id="linearGradient10687-2-5"
-       gradientUnits="userSpaceOnUse"
-       x1="753.02301"
-       y1="3132.0801"
-       x2="1146.25"
-       y2="3132.0801" />
-    <linearGradient
-       id="linearGradient4453-7-8-6-7-3-5">
-      <stop
-         style="stop-color:#aac4dd;stop-opacity:1;"
-         offset="0"
-         id="stop4455-61-8-7-1-2-8" />
-      <stop
-         style="stop-color:#c2dbe9;stop-opacity:1;"
-         offset="1"
-         id="stop4457-4-1-9-1-12-1" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient4453-7-8-6-7-3-5"
-       id="linearGradient10685-2-2"
-       gradientUnits="userSpaceOnUse"
-       x1="753.02301"
-       y1="3132.0801"
-       x2="1146.25"
-       y2="3132.0801" />
-    <linearGradient
-       id="linearGradient6749">
-      <stop
-         style="stop-color:#aac4dd;stop-opacity:1;"
-         offset="0"
-         id="stop6751" />
-      <stop
-         style="stop-color:#c2dbe9;stop-opacity:1;"
-         offset="1"
-         id="stop6753" />
-    </linearGradient>
-    <clipPath
-       clipPathUnits="userSpaceOnUse"
-       id="clipPath3387-3-6-4-2-8-4">
-      <path
-         inkscape:connector-curvature="0"
-         d="m 862.109,3289.75 -109.086,-190.45 69.122,-124.42 164.511,-0.47 c 0,0 111.044,188.28 116.564,197.63 7.66,0 43.03,0 43.03,0 l -67.03,117.71 -217.111,0 z"
-         id="path3389-2-0-7-7-8-9" />
-    </clipPath>
-    <linearGradient
-       y2="3132.0801"
-       x2="1146.25"
-       y1="3132.0801"
-       x1="753.02301"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4492-8-8"
-       xlink:href="#linearGradient4453-7-8-6-7-3-5"
-       inkscape:collect="always" />
-    <linearGradient
-       id="linearGradient6758">
-      <stop
-         style="stop-color:#aac4dd;stop-opacity:1;"
-         offset="0"
-         id="stop6760" />
-      <stop
-         style="stop-color:#c2dbe9;stop-opacity:1;"
-         offset="1"
-         id="stop6762" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient4453-7-8-6-7-3-5"
-       id="linearGradient10691-7-8"
-       gradientUnits="userSpaceOnUse"
-       x1="1026.6899"
-       y1="2937.73"
-       x2="1463.14"
-       y2="2937.73" />
-    <linearGradient
-       id="linearGradient6765">
-      <stop
-         style="stop-color:#aac4dd;stop-opacity:1;"
-         offset="0"
-         id="stop6767" />
-      <stop
-         style="stop-color:#c2dbe9;stop-opacity:1;"
-         offset="1"
-         id="stop6769" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient4453-7-8-6-7-3-5"
-       id="linearGradient10689-4-2"
-       gradientUnits="userSpaceOnUse"
-       x1="1026.6899"
-       y1="2937.73"
-       x2="1463.14"
-       y2="2937.73" />
-    <linearGradient
-       id="linearGradient6772">
-      <stop
-         style="stop-color:#aac4dd;stop-opacity:1;"
-         offset="0"
-         id="stop6774" />
-      <stop
-         style="stop-color:#c2dbe9;stop-opacity:1;"
-         offset="1"
-         id="stop6776" />
-    </linearGradient>
-    <clipPath
-       clipPathUnits="userSpaceOnUse"
-       id="clipPath3369-1-5-6-1-0-7">
-      <path
-         inkscape:connector-curvature="0"
-         d="m 1131.64,3128.5 -104.95,-181.12 116.38,-200.42 208.05,0.94 112.02,191.63 -112.08,188.97 -219.42,0 z"
-         id="path3371-89-4-1-6-0-1" />
-    </clipPath>
-    <linearGradient
-       y2="2937.73"
-       x2="1463.14"
-       y1="2937.73"
-       x1="1026.6899"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4498-5-7"
-       xlink:href="#linearGradient4453-7-8-6-7-3-5"
-       inkscape:collect="always" />
-    <linearGradient
-       id="linearGradient6781">
-      <stop
-         style="stop-color:#aac4dd;stop-opacity:1;"
-         offset="0"
-         id="stop6783" />
-      <stop
-         style="stop-color:#c2dbe9;stop-opacity:1;"
-         offset="1"
-         id="stop6785" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient4459-1-2-8-9-9-5"
-       id="linearGradient10695-9-9"
-       gradientUnits="userSpaceOnUse"
-       x1="646.55499"
-       y1="2736.25"
-       x2="1088.27"
-       y2="2736.25" />
-    <linearGradient
-       id="linearGradient4459-1-2-8-9-9-5">
-      <stop
-         id="stop4461-2-1-5-2-5-0"
-         offset="0"
-         style="stop-color:#839bc2;stop-opacity:1;" />
-      <stop
-         id="stop4463-3-2-8-7-30-3"
-         offset="1"
-         style="stop-color:#9fb6d4;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient4459-1-2-8-9-9-5"
-       id="linearGradient10693-9-4"
-       gradientUnits="userSpaceOnUse"
-       x1="646.55499"
-       y1="2736.25"
-       x2="1088.27"
-       y2="2736.25" />
-    <linearGradient
-       id="linearGradient6792">
-      <stop
-         id="stop6794"
-         offset="0"
-         style="stop-color:#839bc2;stop-opacity:1;" />
-      <stop
-         id="stop6796"
-         offset="1"
-         style="stop-color:#9fb6d4;stop-opacity:1;" />
-    </linearGradient>
-    <clipPath
-       clipPathUnits="userSpaceOnUse"
-       id="clipPath3351-4-7-3-5-95-0">
-      <path
-         inkscape:connector-curvature="0"
-         d="m 757.242,2926.25 -110.687,-189.11 110.656,-190.89 219.437,0 111.622,189.1 -111.59,190.9 -219.438,0 z"
-         id="path3353-1-9-3-4-1-1" />
-    </clipPath>
-    <linearGradient
-       y2="2736.25"
-       x2="1088.27"
-       y1="2736.25"
-       x1="646.55499"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4510-1-5"
-       xlink:href="#linearGradient4459-1-2-8-9-9-5"
-       inkscape:collect="always" />
-    <linearGradient
-       id="linearGradient6801">
-      <stop
-         id="stop6803"
-         offset="0"
-         style="stop-color:#839bc2;stop-opacity:1;" />
-      <stop
-         id="stop6805"
-         offset="1"
-         style="stop-color:#9fb6d4;stop-opacity:1;" />
-    </linearGradient>
-    <radialGradient
-       inkscape:collect="always"
-       xlink:href="#radialGradient3327-8-4-8-0-2-4"
-       id="radialGradient10699-1-3"
-       gradientUnits="userSpaceOnUse"
-       cx="997.46997"
-       cy="2896.25"
-       fx="997.46997"
-       fy="2896.25"
-       r="583.73999" />
-    <radialGradient
-       fx="0"
-       fy="0"
-       cx="0"
-       cy="0"
-       r="1"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(58.375,0,0,-58.375,99.75,289.625)"
-       spreadMethod="pad"
-       id="radialGradient3327-8-4-8-0-2-4">
-      <stop
-         style="stop-opacity:1;stop-color:#aeaeb3"
-         offset="0"
-         id="stop3329-7-0-1-0-33-2" />
-      <stop
-         style="stop-opacity:1;stop-color:#ffffff"
-         offset="0.949438"
-         id="stop3331-4-3-0-0-97-3" />
-      <stop
-         style="stop-opacity:1;stop-color:#ffffff"
-         offset="1"
-         id="stop3333-2-4-9-7-2-2" />
-    </radialGradient>
-    <radialGradient
-       r="583.73999"
-       fy="2896.25"
-       fx="997.46997"
-       cy="2896.25"
-       cx="997.46997"
-       gradientUnits="userSpaceOnUse"
-       id="radialGradient13050"
-       xlink:href="#radialGradient3327-8-4-8-0-2-4"
-       inkscape:collect="always" />
-    <radialGradient
-       fx="0"
-       fy="0"
-       cx="0"
-       cy="0"
-       r="1"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(58.375,0,0,-58.375,99.75,289.625)"
-       spreadMethod="pad"
-       id="radialGradient6813">
-      <stop
-         style="stop-opacity:1;stop-color:#aeaeb3"
-         offset="0"
-         id="stop6815" />
-      <stop
-         style="stop-opacity:1;stop-color:#ffffff"
-         offset="0.949438"
-         id="stop6817" />
-      <stop
-         style="stop-opacity:1;stop-color:#ffffff"
-         offset="1"
-         id="stop6819" />
-    </radialGradient>
-    <clipPath
-       clipPathUnits="userSpaceOnUse"
-       id="clipPath3323-7-2-4-5-3-4">
-      <path
-         inkscape:connector-curvature="0"
-         d="m 997.469,2312.51 c -322.379,0 -583.739,261.36 -583.739,583.74 0,322.38 261.36,583.74 583.739,583.74 322.381,0 583.741,-261.36 583.741,-583.74 0,-322.38 -261.36,-583.74 -583.741,-583.74"
-         id="path3325-9-2-9-5-04-9" />
-    </clipPath>
-    <radialGradient
-       r="583.73999"
-       fy="2896.25"
-       fx="997.46997"
-       cy="2896.25"
-       cx="997.46997"
-       gradientUnits="userSpaceOnUse"
-       id="radialGradient4516-8-2"
-       xlink:href="#radialGradient3327-8-4-8-0-2-4"
-       inkscape:collect="always" />
-    <radialGradient
-       fx="0"
-       fy="0"
-       cx="0"
-       cy="0"
-       r="1"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(58.375,0,0,-58.375,99.75,289.625)"
-       spreadMethod="pad"
-       id="radialGradient6824">
-      <stop
-         style="stop-opacity:1;stop-color:#aeaeb3"
-         offset="0"
-         id="stop6826" />
-      <stop
-         style="stop-opacity:1;stop-color:#ffffff"
-         offset="0.949438"
-         id="stop6828" />
-      <stop
-         style="stop-opacity:1;stop-color:#ffffff"
-         offset="1"
-         id="stop6830" />
-    </radialGradient>
-    <radialGradient
-       r="583.73999"
-       fy="2896.25"
-       fx="997.46997"
-       cy="2896.25"
-       cx="997.46997"
-       gradientUnits="userSpaceOnUse"
-       id="radialGradient6856"
-       xlink:href="#radialGradient3327-8-4-8-0-2-4"
-       inkscape:collect="always" />
-  </defs>
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="1.4"
-     inkscape:cx="234.05635"
-     inkscape:cy="581.46313"
-     inkscape:document-units="px"
-     inkscape:current-layer="layer1"
-     showgrid="false"
-     inkscape:window-width="1680"
-     inkscape:window-height="982"
-     inkscape:window-x="-8"
-     inkscape:window-y="-8"
-     inkscape:window-maximized="1">
-    <inkscape:grid
-       type="xygrid"
-       id="grid3066" />
-  </sodipodi:namedview>
-  <metadata
-     id="metadata6863">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title />
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1">
-    <g
-       id="g3319-1-2-5-1-4-4"
-       transform="matrix(0.10419818,0,0,-0.10419818,137.10955,897.00327)"
-       style="fill:url(#radialGradient10699-1-3);fill-opacity:1"
-       inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
-       inkscape:export-xdpi="63.625523"
-       inkscape:export-ydpi="63.625523">
-      <g
-         clip-path="url(#clipPath3323-7-2-4-5-3-4)"
-         id="g3321-9-2-7-4-3-9"
-         style="fill:url(#radialGradient6856);fill-opacity:1">
-        <path
-           id="path3335-8-7-3-8-92-0"
-           style="fill:url(#radialGradient4516-8-2);fill-opacity:1;fill-rule:nonzero;stroke:none"
-           d="m 997.469,2312.51 c -322.379,0 -583.739,261.36 -583.739,583.74 0,322.38 261.36,583.74 583.739,583.74 322.381,0 583.741,-261.36 583.741,-583.74 0,-322.38 -261.36,-583.74 -583.741,-583.74"
-           inkscape:connector-curvature="0" />
-      </g>
-    </g>
-    <g
-       id="g3347-6-8-3-7-4-4"
-       transform="matrix(0.125,0,0,-0.125,112.08304,959.82207)"
-       style="fill:url(#linearGradient10695-9-9);fill-opacity:1"
-       inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
-       inkscape:export-xdpi="63.625523"
-       inkscape:export-ydpi="63.625523">
-      <g
-         clip-path="url(#clipPath3351-4-7-3-5-95-0)"
-         id="g3349-5-5-4-7-9-4"
-         style="fill:url(#linearGradient10693-9-4);fill-opacity:1">
-        <path
-           id="path3361-0-8-2-9-0-9"
-           style="fill:url(#linearGradient4510-1-5);fill-opacity:1;fill-rule:nonzero;stroke:none"
-           d="m 757.242,2926.25 -110.687,-189.11 110.656,-190.89 219.437,0 111.622,189.1 -111.59,190.9 -219.438,0"
-           inkscape:connector-curvature="0" />
-      </g>
-    </g>
-    <path
-       id="path3363-6-9-0-1-5-8"
-       style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
-       d="m 194.34816,617.68335 13.106,-22.3925 25.99649,0 13.21487,22.60874 -13.21487,22.39125 -25.99649,0 -13.106,-22.60749 z m 40.53761,-24.8925 -28.86524,0 -0.72412,1.23749 -13.106,22.39251 -0.73575,1.25625 0.73087,1.26 13.106,22.60744 0.72263,1.24634 28.86374,0 0.72512,-1.22884 13.215,-22.39119 0.74625,-1.265 -0.74,-1.26751 -13.21537,-22.60875 -0.72313,-1.23874"
-       inkscape:connector-curvature="0"
-       inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
-       inkscape:export-xdpi="63.625523"
-       inkscape:export-ydpi="63.625523" />
-    <g
-       id="g3365-0-4-1-9-7-5"
-       transform="matrix(0.125,0,0,-0.125,112.08304,959.82207)"
-       style="fill:url(#linearGradient10691-7-8);fill-opacity:1"
-       inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
-       inkscape:export-xdpi="63.625523"
-       inkscape:export-ydpi="63.625523">
-      <g
-         clip-path="url(#clipPath3369-1-5-6-1-0-7)"
-         id="g3367-2-4-2-8-4-3"
-         style="fill:url(#linearGradient10689-4-2);fill-opacity:1">
-        <path
-           id="path3379-4-6-7-6-7-2"
-           style="fill:url(#linearGradient4498-5-7);fill-opacity:1;fill-rule:nonzero;stroke:none"
-           d="m 1131.64,3128.5 -104.95,-181.12 116.38,-200.42 208.05,0.94 112.02,191.63 -112.08,188.97 -219.42,0"
-           inkscape:connector-curvature="0" />
-      </g>
-    </g>
-    <path
-       id="path3381-6-8-0-0-66-3"
-       style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
-       d="m 241.86427,591.39959 12.3925,-21.38999 25.99625,0 13.27125,22.37625 -13.27125,22.7025 -24.56875,0.11 -13.82,-23.79876 z m 39.8125,-23.88999 -28.86125,0 -0.7225,1.24625 -12.3925,21.39 -0.72625,1.255 0.7275,1.25374 13.82,23.79876 0.7275,1.25125 1.44625,-0.006 24.56875,-0.11 1.4275,-0.006 0.72,-1.2325 13.27125,-22.7025 0.7425,-1.27 -0.75125,-1.26625 -13.27125,-22.37625 -0.72625,-1.225"
-       inkscape:connector-curvature="0"
-       inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
-       inkscape:export-xdpi="63.625523"
-       inkscape:export-ydpi="63.625523" />
-    <g
-       id="g3383-5-5-2-2-3-0"
-       transform="matrix(0.125,0,0,-0.125,112.08304,959.82207)"
-       style="fill:url(#linearGradient10687-2-5);fill-opacity:1"
-       inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
-       inkscape:export-xdpi="63.625523"
-       inkscape:export-ydpi="63.625523">
-      <g
-         clip-path="url(#clipPath3387-3-6-4-2-8-4)"
-         id="g3385-0-6-4-8-0-1"
-         style="fill:url(#linearGradient10685-2-2);fill-opacity:1">
-        <path
-           id="path3397-9-6-1-6-9-7"
-           style="fill:url(#linearGradient4492-8-8);fill-opacity:1;fill-rule:nonzero;stroke:none"
-           d="m 862.109,3289.75 -109.086,-190.45 69.122,-124.42 164.511,-0.47 c 0,0 111.044,188.28 116.564,197.63 7.66,0 43.03,0 43.03,0 l -67.03,117.71 -217.111,0"
-           inkscape:connector-curvature="0" />
-      </g>
-    </g>
-    <path
-       id="path3399-6-7-3-2-0-1"
-       style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
-       d="m 207.64603,572.41959 12.92424,-22.56624 25.68775,0 6.95625,12.21375 -3.94375,0 -14.56837,24.7025 -19.11525,-0.055 -7.94087,-14.295 z m 40.06574,-25.06624 -28.59012,0 -0.71975,1.2575 -12.92537,22.56625 -0.70112,1.22375 0.68512,1.23249 7.94137,14.295 0.71087,1.2825 1.46638,0.004 19.11525,0.055 1.43212,0.004 0.729,-1.23375 13.84375,-23.47249 6.81625,0 -2.12875,-3.7375 -6.95625,-12.21375 -0.71875,-1.2625"
-       inkscape:connector-curvature="0"
-       inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
-       inkscape:export-xdpi="63.625523"
-       inkscape:export-ydpi="63.625523" />
-    <g
-       transform="matrix(1.25,0,0,-1.25,105.02062,972.84257)"
-       id="g3465-0-8-9"
-       inkscape:export-filename="C:\Users\Adam\Desktop\bg_logo1.png"
-       inkscape:export-xdpi="63.625523"
-       inkscape:export-ydpi="63.625523">
-      <text
-         id="text3467-9-0-8"
-         transform="matrix(1,0,-0.17627963,-1,0,0)"
-         x="116.98372"
-         y="-267.77499"
-         style="font-size:11.81779194px">
-        <tspan
-           sodipodi:role="line"
-           style="font-size:46.39999771px;font-variant:normal;font-weight:normal;writing-mode:lr-tb;fill:#49608a;fill-opacity:1;fill-rule:nonzero;stroke:none;font-family:Denmark;-inkscape-font-specification:Denmark"
-           x="116.98372"
-           y="-267.77499"
-           id="tspan13239">UTILITY</tspan>
-        <tspan
-           sodipodi:role="line"
-           style="font-size:46.39999771px;font-variant:normal;font-weight:normal;writing-mode:lr-tb;fill:#49608a;fill-opacity:1;fill-rule:nonzero;stroke:none;font-family:Denmark;-inkscape-font-specification:Denmark"
-           x="116.98372"
-           y="-209.77499"
-           id="tspan11278-3" />
-      </text>
-      <text
-         id="text3471-0-51-2"
-         transform="matrix(0.99235617,0,-0.17763746,-1.0077027,0,0)"
-         style="font-size:38.40000153px"
-         x="112.74373"
-         y="-306.75479">
-        <tspan
-           id="tspan3473-6-0-9"
-           sodipodi:role="line"
-           style="font-size:38.40000153px;font-variant:normal;font-weight:normal;writing-mode:lr-tb;fill:#49608a;fill-opacity:1;fill-rule:nonzero;stroke:none;font-family:Denmark;-inkscape-font-specification:Denmark"
-           x="112.74373"
-           y="-306.75479">boost</tspan>
-      </text>
-    </g>
-    <path
-       style="fill:#ffffff;fill-opacity:1;stroke:none"
-       d="m 201.43967,613.81579 4.64114,4.2175 3.3738,-3.71306 -0.92817,-0.84354 1.68708,-1.85636 20.53445,20.81026 4.2175,-4.64111 -22.22144,-18.95384 c 0,0 1.69594,-1.83698 2.53062,-2.78454 2.53905,-2.76559 5.98925,-4.72587 5.98925,-4.72587 0,0 -6.03647,0.58224 -8.76507,2.21476 -0.84428,0.92751 -6.75676,7.40649 -6.75676,7.40649 l -0.92819,-0.84355 -3.37382,3.71308"
-       id="path13283"
-       inkscape:connector-curvature="0"
-       sodipodi:nodetypes="cccccccccccccc" />
-    <g
-       id="g3086"
-       transform="matrix(0.99872217,-0.05053738,0.05053738,0.99872217,-31.539183,11.181538)">
-      <path
-         sodipodi:nodetypes="ccccccccc"
-         inkscape:connector-curvature="0"
-         id="path13243"
-         d="m 227.74101,611.16418 -15.09943,12.783 2.55659,3.01989 15.09944,-12.78302 c 3.56324,2.16769 7.58975,-1.2411 7.0464,-5.96538 l -4.02652,3.40879 -2.55659,-3.01989 4.02652,-3.40879 c -3.56324,-2.16769 -8.59639,2.0933 -7.04641,5.9654 z"
-         style="fill:#ffffff;fill-opacity:1;stroke:none" />
-      <path
-         sodipodi:nodetypes="ccccccccc"
-         inkscape:connector-curvature="0"
-         id="path13243-1"
-         d="m 215.25729,626.9851 15.08951,-12.7947 -2.55893,-3.01791 -15.08952,12.79471 c -3.56492,-2.16491 -7.58878,1.24699 -7.04177,5.97085 l 4.02388,-3.41192 2.55892,3.01791 -4.02387,3.41192 c 3.56491,2.16492 8.59476,-2.09997 7.04178,-5.97086 z"
-         style="fill:#ffffff;fill-opacity:1;stroke:none" />
-    </g>
-  </g>
-</svg>

doc/named_params.html

@@ -0,0 +1,444 @@
+<?xml version="1.0" encoding="Latin-1" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=Latin-1" />
+<meta name="generator" content="Docutils 0.3.1: http://docutils.sourceforge.net/" />
+<title>The Boost.NamedParams Library Boost</title>
+<link rel="stylesheet" href="../../../rst.css" type="text/css" />
+</head>
+<body>
+<div class="document" id="the-boost-namedparams-library-logo">
+<h1 class="title">The Boost.NamedParams Library <a class="reference" href="../../../index.htm"><img alt="Boost" class="boost-logo" src="../../../c++boost.gif" /></a></h1>
+<hr />
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Authors:</th><td class="field-body">David Abrahams, Daniel Wallin</td>
+</tr>
+<tr class="field"><th class="field-name">Contact:</th><td class="field-body"><a class="reference" href="mailto:dave&#64;boost-consulting.com">dave&#64;boost-consulting.com</a>, <a class="reference" href="mailto:dalwan01&#64;student.umu.se">dalwan01&#64;student.umu.se</a></td>
+</tr>
+<tr class="field"><th class="field-name">organizations:</th><td class="field-body"><a class="reference" href="http://www.boost-consulting.com">Boost Consulting</a>,</td>
+</tr>
+<tr class="field"><th class="field-name">date:</th><td class="field-body">$Date: 2004-04-17 05:51:12 -0500 (Sat, 17 Apr 2004) $</td>
+</tr>
+<tr class="field"><th class="field-name">copyright:</th><td class="field-body">Copyright David Abrahams, Daniel Wallin 2003.</td>
+</tr>
+<tr class="field"><th class="field-name">license:</th><td class="field-body">Use, modification and distribution is subject to the
+Boost Software License, Version 1.0. (See accompanying
+file LICENSE_1_0.txt or copy at
+<a class="reference" href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</td>
+</tr>
+</tbody>
+</table>
+<div class="contents topic" id="outline">
+<p class="topic-title"><a name="outline">Outline</a></p>
+<ul class="auto-toc simple">
+<li><a class="reference" href="#introduction" id="id7" name="id7">1   Introduction</a></li>
+<li><a class="reference" href="#tutorial" id="id8" name="id8">2   Tutorial</a><ul class="auto-toc">
+<li><a class="reference" href="#defining-the-keywords" id="id9" name="id9">2.1   Defining the keywords</a></li>
+<li><a class="reference" href="#defining-the-forwarding-functions" id="id10" name="id10">2.2   Defining the forwarding functions</a></li>
+<li><a class="reference" href="#defining-the-implementation-function" id="id11" name="id11">2.3   Defining the implementation function</a></li>
+</ul>
+</li>
+<li><a class="reference" href="#limitations-of-the-approach" id="id12" name="id12">3   Limitations of the Approach</a></li>
+<li><a class="reference" href="#controlling-overload-resolution" id="id13" name="id13">4   Controlling Overload Resolution</a></li>
+<li><a class="reference" href="#lazy-evaluation-of-defaults" id="id14" name="id14">5   Lazy Evaluation of Defaults</a></li>
+<li><a class="reference" href="#automatic-overload-generation" id="id15" name="id15">6   Automatic Overload Generation</a></li>
+<li><a class="reference" href="#portability" id="id16" name="id16">7   Portability</a></li>
+</ul>
+</div>
+<div class="section" id="introduction">
+<h1><a class="toc-backref" href="#id7" name="introduction">1   Introduction</a></h1>
+<p>In C++ function arguments are given meaning by their position in
+the parameter list. This protocol is fine when there are few
+parameters with default values, but as the number of parameters
+grows, so does the inconvenience of passing arguments in the
+correct order, especially in the presence of default values:</p>
+<blockquote>
+<ul>
+<li><p class="first">It can become difficult for readers to understand the meaning of
+arguments at the call site:</p>
+<pre class="literal-block">
+window* w = new_window(&quot;alert&quot;, true, true, false, 77, 65);
+</pre>
+</li>
+<li><p class="first">Since meaning is given by position, we have to choose some
+(often arbitrary) order for parameters with default values,
+making some combinations of defaults unusable:</p>
+<pre class="literal-block">
+window* new_window(
+    char const* name, bool border = true
+  , bool opaque = true, bool movable = false
+  , int width = 100, int height = 100);
+
+const bool movability = true;
+window* w = new_window(&quot;alert2&quot;, movability); // error!
+</pre>
+</li>
+<li><p class="first">Default values can not depend on the values of other function
+parameters:</p>
+<pre class="literal-block">
+window* new_window(
+    char const* name, bool border, ...
+  , int width = 100, int heigh = width); // error!
+</pre>
+</li>
+<li><p class="first">Template types can not be deduced from the default values, so
+we have to resort to overloading to provide default values for
+parameters with template type:</p>
+<pre class="literal-block">
+template&lt;class T&gt; void f(T x = 0);
+
+f(); // error!
+</pre>
+</li>
+</ul>
+</blockquote>
+<p>This library is an attempt to address the problems outlined above
+by associating each parameter with a keyword identifier.  Using
+this library, users can identify parameters by name instead of just
+argument position:</p>
+<pre class="literal-block">
+window* w = new_window(&quot;alert2&quot;, movable = movability); // OK!
+</pre>
+<!-- DWA Daniel, we explicitly *don't* need ref() for the case
+described below.  It's only when we want to pass by reference
+without a keyword that we need it.
+
+You also can't start talking about forwarding functions without
+introducing them first!
+
+The tutorial has to come before all the nasty details below.
+I'm going to comment on that and leave the next stuff alone -->
+</div>
+<div class="section" id="tutorial">
+<h1><a class="toc-backref" href="#id8" name="tutorial">2   Tutorial</a></h1>
+<!-- DWA you need some set-up here describing the problem you're
+going to solve. -->
+<p>This example shows how to wrap a function:</p>
+<pre class="literal-block">
+void foo(char const* name, float value);
+</pre>
+<p>to give both parameters names and default values.</p>
+<div class="section" id="defining-the-keywords">
+<h2><a class="toc-backref" href="#id9" name="defining-the-keywords">2.1   Defining the keywords</a></h2>
+<p>First we define the named parameter keywords. This is done by creating
+&quot;tag&quot; types for each keyword, and declaring <tt class="literal"><span class="pre">keyword&lt;</span></tt><em>tag</em><tt class="literal"><span class="pre">&gt;</span></tt> objects:</p>
+<pre class="literal-block">
+#include &lt;boost/named_params.hpp&gt;
+
+struct name_t; // tag types
+struct value_t;
+
+namespace {
+  boost::keyword&lt;name_t&gt; name;    // keyword objects
+  boost::keyword&lt;value_t&gt; value;
+}
+</pre>
+<p>Placing these keyword objects in an unnamed namespace will prevent
+link errors when you declare keywords in header files [<strong>Note</strong>:
+the tag types should generally <em>not</em> be declared in an unnamed
+namespace].  We also need to create a keywords list for our
+function.  These keywords should be declared in the same order as
+their corresponding parameters appear in the function's parameter
+list:</p>
+<pre class="literal-block">
+struct foo_keywords
+  : boost::keywords&lt;
+        name_t
+      , value_t
+    &gt;
+{};
+</pre>
+</div>
+<div class="section" id="defining-the-forwarding-functions">
+<h2><a class="toc-backref" href="#id10" name="defining-the-forwarding-functions">2.2   Defining the forwarding functions</a></h2>
+<pre class="literal-block">
+template&lt;class Params&gt;
+void foo_impl(const Params&amp;);
+
+void foo()
+{
+    foo_impl(foo_keywords()());
+}
+
+template&lt;class A0&gt;
+void foo(const A0&amp; a0)
+{
+    foo_impl(foo_keywords()(a0));
+}
+
+template&lt;class A0, class A1&gt;
+void foo(const A0&amp; a0, const A1&amp; a1)
+{
+    foo_impl(foo_keywords()(a0, a1));
+}
+</pre>
+</div>
+<div class="section" id="defining-the-implementation-function">
+<h2><a class="toc-backref" href="#id11" name="defining-the-implementation-function">2.3   Defining the implementation function</a></h2>
+<pre class="literal-block">
+template&lt;class Params&gt;
+void foo_impl(const Params&amp; params)
+{
+    std::cout &lt;&lt; params[name] &lt;&lt; &quot; = &quot; &lt;&lt; params[value] &lt;&lt; &quot;\n&quot;;
+}
+</pre>
+<p>That's it. The user calls the <tt class="literal"><span class="pre">foo()</span></tt> forwarding functions, with
+either positional or named parameters. For instance:</p>
+<pre class="literal-block">
+foo(&quot;bar&quot;, 3.14f);
+foo(value = 6.28f, &quot;baz&quot;)
+</pre>
+<p>Should print:</p>
+<pre class="literal-block">
+bar = 3.14
+baz = 6.28
+</pre>
+<p>But we still don't have any default values, leaving any of the
+parameters out results in a compilation error:</p>
+<pre class="literal-block">
+foo()
+foo(&quot;bar&quot;)
+foo(value = 3)
+</pre>
+<p>All fails.</p>
+<p>Fortunatly, adding default values to parameters is easy:</p>
+<pre class="literal-block">
+template&lt;class Params&gt;
+void foo_impl(const Params&amp; params)
+{
+    std::cout
+        &lt;&lt; params[name | &quot;unnamed&quot;] &lt;&lt; &quot; = &quot;
+        &lt;&lt; params[value | 0] &lt;&lt; &quot;\n&quot;;
+}
+</pre>
+<p>We are using <tt class="literal"><span class="pre">operator|</span></tt> to denote the default value of a named
+parameter.</p>
+<p>Going back a little to the <tt class="literal"><span class="pre">foo()</span></tt> call that didn't compile:</p>
+<pre class="literal-block">
+foo()
+foo(&quot;bar&quot;)
+foo(value = 3)
+</pre>
+<p>Now compiles, and prints:</p>
+<pre class="literal-block">
+unnamed = 0
+bar = 0
+unnamed = 3
+</pre>
+</div>
+</div>
+<div class="section" id="limitations-of-the-approach">
+<h1><a class="toc-backref" href="#id12" name="limitations-of-the-approach">3   Limitations of the Approach</a></h1>
+<p>Because the keywords' <tt class="literal"><span class="pre">operator=</span></tt> returns a temporary, and
+temporaries cannot be bound to non-<tt class="literal"><span class="pre">const</span></tt> reference parameters,
+our forwarding functions need to take their arguments by <tt class="literal"><span class="pre">const</span></tt>
+reference <a class="footnote-reference" href="#forwarding" id="id2" name="id2"><sup>1</sup></a>. As a result, an argument which is bound
+to a keyword with <tt class="literal"><span class="pre">operator=</span></tt> can be transparently passed by
+non-const reference, but positional arguments are always passed by
+<tt class="literal"><span class="pre">const</span></tt> reference unless we use the <a class="reference" href="../../bind/ref.hpp">Boost.Ref</a> library to
+indicate otherwise:</p>
+<pre class="literal-block">
+#include &lt;boost/ref.hpp&gt;
+
+float x;
+foo(value = x);     // held type is float&amp;
+foo(x);             // held type is float const&amp;, need help!
+foo(boost::ref(x)); // held type is float&amp;
+</pre>
+<p>Instances of <tt class="literal"><span class="pre">boost::reference_wrapper&lt;&gt;</span></tt> generated by
+<tt class="literal"><span class="pre">boost::ref</span></tt> will be unwrapped automatically by the library.</p>
+</div>
+<div class="section" id="controlling-overload-resolution">
+<h1><a class="toc-backref" href="#id13" name="controlling-overload-resolution">4   Controlling Overload Resolution</a></h1>
+<p>The parameters of our templated forwarding functions are completely
+general; in fact, they're a perfect match for any argument type
+whatsoever.  The problems with exposing such general function
+templates have been the subject of much discussion; especially in
+the presence of <a class="reference" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#225">unqualified calls</a>.  Probably the safest thing
+to do is to isolate the forwarding functions in a namespace
+containing no types <a class="footnote-reference" href="#using" id="id3" name="id3"><sup>2</sup></a>, but often we'd <em>like</em> our functions
+to play nicely with argument-dependent lookup and other function
+overloads.  In that case, it's neccessary to somehow remove the
+functions from the overload set when the passed argument types
+don't meet their needs.</p>
+<p>This sort of overload control can be accomplished in C++ by taking
+advantage of <a class="reference" href="http://www.semantics.org/once_weakly/w02_SFINAE.pdf">SFINAE</a> (Substitution Failure Is Not An Error). If
+type substitution during the instantiation of a function template
+results in an invalid type, no compilation error is emitted;
+instead the overload is removed from the overload set. By producing
+an invalid type in the function signature depending on the result
+of some condition, whether or not an overload is considered during
+overload resolution can be controlled.  The technique is formalized
+in the <tt class="literal"><span class="pre">enable_if</span></tt> utility.</p>
+<p>The named parameters library provides built-in SFINAE support
+through the following class template:</p>
+<pre class="literal-block">
+template&lt;
+    class KeywordTag
+  , class HasDefaultValue // mpl::true_ or mpl::false_
+  , class Predicate
+&gt;
+struct named_param;
+</pre>
+<p>The key parameter, <tt class="literal"><span class="pre">Predicate</span></tt> shall be a unary MPL lambda
+expression or <a class="reference" href="../../mpl/doc/ref/Metafunction_Class.html">Metafunction Class</a> that, when applied to the
+actual type the argument, indicates whether that argument type
+meets the function's requirements for that parameter position.</p>
+<p>For example, let's say we want to restrict our <tt class="literal"><span class="pre">foo()</span></tt> so that
+the <tt class="literal"><span class="pre">name</span></tt> parameter must be convertible to <tt class="literal"><span class="pre">const</span> <span class="pre">char*</span></tt>.
+We'll replace our use of the <tt class="literal"><span class="pre">name_t</span></tt> tag with a specialization
+of <tt class="literal"><span class="pre">boost::named_param</span></tt>:</p>
+<pre class="literal-block">
+struct foo_keywords
+  : boost::keywords&lt;
+        <strong>boost::named_param&lt;
+            name_t
+          , mpl::false_
+          , is_convertible&lt;mpl::_, const char*&gt;
+        &gt;</strong>
+      , value_t
+    &gt;
+{};
+</pre>
+<p>Now we can add an additional optional argument to each of our
+<tt class="literal"><span class="pre">foo</span></tt> overloads</p>
+<pre class="literal-block">
+template&lt;class A0&gt;
+void foo(
+    const A0&amp; a0
+  , <strong>foo_keywords::restrict&lt;A0&gt;::type x = foo_keywords()</strong>
+)
+{
+    foo_impl(x(a0));
+}
+
+template&lt;class A0, class A1&gt;
+void foo(
+    const A0&amp; a0, const A1&amp; a1
+  , <strong>foo_keywords::restrict&lt;A0,A1&gt;::type x = foo_keywords()</strong>
+)
+{
+    foo_impl(x(a0, a1));
+}
+</pre>
+<p>These additional parameters are not intended to be used directly
+by callers; they merely trigger SFINAE by becoming illegal types
+when the <tt class="literal"><span class="pre">name</span></tt> argument is not convertible to <tt class="literal"><span class="pre">const</span> <span class="pre">char*</span></tt>.</p>
+</div>
+<div class="section" id="lazy-evaluation-of-defaults">
+<h1><a class="toc-backref" href="#id14" name="lazy-evaluation-of-defaults">5   Lazy Evaluation of Defaults</a></h1>
+<p>If computing an argument's default value is expensive, it's best
+avoided when the argument is supplied by the user. In that case,
+the default value can be lazily evaluated using the following
+syntax:</p>
+<pre class="literal-block">
+params[keyword <strong>|| nullary_function</strong>];
+</pre>
+<p><tt class="literal"><span class="pre">nullary_function</span></tt> must be a function object that is callable
+without arguments, and that indicates its return type via a nested
+<tt class="literal"><span class="pre">result_type</span></tt>.  Boost.Bind can be used to produce an appropriate
+function object from a regular function pointer:</p>
+<pre class="literal-block">
+// expensive default computation function
+float default_span(float x, float theta);
+
+// implementation of bar()
+template &lt;class Params&gt;
+void bar_impl(Params const&amp; params)
+{
+    // Extract arguments
+    float x_ = params[x];
+    float theta_ = params[theta | pi];
+    float span = params[span || boost::bind(default_span, x_, theta_)];
+    ...
+}
+</pre>
+</div>
+<div class="section" id="automatic-overload-generation">
+<h1><a class="toc-backref" href="#id15" name="automatic-overload-generation">6   Automatic Overload Generation</a></h1>
+<p>To reduce the work needed to write functions with named parameters,
+we supply a macro that generates the boilerplate code.</p>
+<p>Synopsis:</p>
+<pre class="literal-block">
+BOOST_NAMED_PARAMS_FUN(
+    return_type, function_name
+  , min_arity, max_arity, keywords_type
+);
+</pre>
+<p>To generate all the forwarding functions and the implementation
+function for our example, we need only apply
+<tt class="literal"><span class="pre">BOOST_NAMED_PARAMS_FUN</span></tt> this way:</p>
+<pre class="literal-block">
+BOOST_NAMED_PARAMS_FUN(void, foo, 0, 2, foo_keywords)
+{
+    std::cout
+        &lt;&lt; p[name | &quot;unnamed&quot;] &lt;&lt; &quot; = &quot;
+        &lt;&lt; p[value | 0] &lt;&lt; &quot;\n&quot;;
+}
+</pre>
+</div>
+<div class="section" id="portability">
+<h1><a class="toc-backref" href="#id16" name="portability">7   Portability</a></h1>
+<p>Boost.NamedParams has been confirmed to work on the following compilers:</p>
+<blockquote>
+<ul class="simple">
+<li>Microsoft VC6 sp5, VC7 <a class="footnote-reference" href="#norestrict" id="id5" name="id5"><sup>3</sup></a></li>
+<li>Microsoft VC7.1</li>
+<li>GCC3.3.1 (cygwin), GCC2.95.3 (cygwin), GCC3.2 (mingw)</li>
+<li>Metrowerks Codewarrior Pro8 and Pro9 (Windows)</li>
+<li>Intel C++ 5.0,6.0,7.1,8.0 (Windows)</li>
+<li>Comeau 4.3.3</li>
+</ul>
+</blockquote>
+<hr />
+<table class="footnote" frame="void" id="forwarding" rules="none">
+<colgroup><col class="label" /><col /></colgroup>
+<tbody valign="top">
+<tr><td class="label"><a class="fn-backref" href="#id2" name="forwarding">[1]</a></td><td><p>One could provide overloads for <tt class="literal"><span class="pre">const</span></tt> and
+non-<tt class="literal"><span class="pre">const</span></tt> reference versions of each parameter, but that
+would quickly become unmanageable.  It's known as &quot;the
+forwarding problem&quot; and has been described in detail in this
+<a class="reference" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm">paper</a>.  The combinatorial explosion is avoided for the
+parameter of keywords' <tt class="literal"><span class="pre">operator=</span></tt> because they take only a
+single argument.</p>
+</td></tr>
+</tbody>
+</table>
+<table class="footnote" frame="void" id="using" rules="none">
+<colgroup><col class="label" /><col /></colgroup>
+<tbody valign="top">
+<tr><td class="label"><a class="fn-backref" href="#id3" name="using">[2]</a></td><td><p>You can always give the illusion that the function
+lives in an outer namespace by applying a <em>using-declaration</em>:</p>
+<pre class="literal-block">
+namespace foo_overloads
+{
+  // foo declarations here
+  void foo() { ... }
+  ...
+}
+using foo_overloads::foo;  
+</pre>
+</td></tr>
+</tbody>
+</table>
+<table class="footnote" frame="void" id="norestrict" rules="none">
+<colgroup><col class="label" /><col /></colgroup>
+<tbody valign="top">
+<tr><td class="label"><a class="fn-backref" href="#id5" name="norestrict">[3]</a></td><td>Restrictions doesn't work on these compilers because
+of lack of SFINAE support.</td></tr>
+</tbody>
+</table>
+</div>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="named_params.rst">View document source</a>.
+Generated on: 2004-04-17 10:54 UTC.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/named_params.rst

@@ -0,0 +1,427 @@
+++++++++++++++++++++++++++++++++++++++++++
+ The Boost.NamedParams Library |(logo)|__
+++++++++++++++++++++++++++++++++++++++++++
+
+.. |(logo)| image:: ../../../c++boost.gif
+   :alt: Boost
+   :class: boost-logo
+
+__ ../../../index.htm
+
+-------------------------------------
+
+
+:Authors: David Abrahams, Daniel Wallin
+:Contact: dave@boost-consulting.com, dalwan01@student.umu.se
+:organizations: `Boost Consulting`_, 
+:date: $Date: 2005-03-27 23:35:50 -0500 (Sun, 27 Mar 2005) $
+:copyright: Copyright David Abrahams, Daniel Wallin 2003. 
+:license: 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)
+
+.. _`Boost Consulting`: http://www.boost-consulting.com
+.. _`Open Systems Lab`: http://www.osl.iu.edu
+ 
+.. contents:: Outline
+.. section-numbering::
+
+
+Introduction
+============
+
+In C++ function arguments are given meaning by their position in
+the parameter list. This protocol is fine when there are few
+parameters with default values, but as the number of parameters
+grows, so does the inconvenience of passing arguments in the
+correct order, especially in the presence of default values:
+
+   * It can become difficult for readers to understand the meaning of
+     arguments at the call site::
+
+       window* w = new_window("alert", true, true, false, 77, 65);
+
+   * Since meaning is given by position, we have to choose some
+     (often arbitrary) order for parameters with default values,
+     making some combinations of defaults unusable::
+
+        window* new_window(
+            char const* name, bool border = true
+          , bool opaque = true, bool movable = false
+          , int width = 100, int height = 100);
+      
+        const bool movability = true;
+        window* w = new_window("alert2", movability); // error!
+
+   * Default values can not depend on the values of other function
+     parameters::
+
+        window* new_window(
+            char const* name, bool border, ...
+          , int width = 100, int heigh = width); // error!
+
+   * Template types can not be deduced from the default values, so
+     we have to resort to overloading to provide default values for
+     parameters with template type::
+
+        template<class T> void f(T x = 0);
+
+        f(); // error!
+
+This library is an attempt to address the problems outlined above
+by associating each parameter with a keyword identifier.  Using
+this library, users can identify parameters by name instead of just
+argument position::
+
+  window* w = new_window("alert2", movable = movability); // OK!
+
+
+.. DWA Daniel, we explicitly *don't* need ref() for the case
+   described below.  It's only when we want to pass by reference
+   without a keyword that we need it.
+
+   You also can't start talking about forwarding functions without
+   introducing them first!
+
+   The tutorial has to come before all the nasty details below.
+   I'm going to comment on that and leave the next stuff alone
+
+Tutorial 
+========
+
+.. DWA you need some set-up here describing the problem you're
+   going to solve.
+
+This example shows how to wrap a function::
+
+    void foo(char const* name, float value);
+
+to give both parameters names and default values.
+
+Defining the keywords
+---------------------
+
+First we define the named parameter keywords. This is done by creating
+"tag" types for each keyword, and declaring ``keyword<``\ *tag*\
+``>`` objects::
+
+     #include <boost/named_params.hpp>
+
+     struct name_t; // tag types
+     struct value_t;
+
+     namespace {
+       boost::keyword<name_t> name;    // keyword objects
+       boost::keyword<value_t> value;
+     }
+
+Placing these keyword objects in an unnamed namespace will prevent
+link errors when you declare keywords in header files [**Note**:
+the tag types should generally *not* be declared in an unnamed
+namespace].  We also need to create a keywords list for our
+function.  These keywords should be declared in the same order as
+their corresponding parameters appear in the function's parameter
+list::
+
+     struct foo_parameters
+       : boost::parameters<
+             name_t
+           , value_t
+         >
+     {};
+
+Defining the forwarding functions
+---------------------------------
+
+::
+
+     template<class Params>
+     void foo_impl(const Params&);
+
+     void foo()
+     {
+         foo_impl(foo_parameters()());
+     }
+
+     template<class A0>
+     void foo(const A0& a0)
+     {
+         foo_impl(foo_parameters()(a0));
+     }
+
+     template<class A0, class A1>
+     void foo(const A0& a0, const A1& a1)
+     {
+         foo_impl(foo_parameters()(a0, a1));
+     }
+
+Defining the implementation function
+------------------------------------
+
+::
+
+     template<class Params>
+     void foo_impl(const Params& params)
+     {
+         std::cout << params[name] << " = " << params[value] << "\n";
+     }
+
+That's it. The user calls the ``foo()`` forwarding functions, with
+either positional or named parameters. For instance::
+
+     foo("bar", 3.14f);
+     foo(value = 6.28f, "baz")
+
+Should print::
+
+     bar = 3.14
+     baz = 6.28
+
+But we still don't have any default values, leaving any of the
+parameters out results in a compilation error::
+
+     foo()
+     foo("bar")
+     foo(value = 3)
+
+All fails.
+
+Fortunatly, adding default values to parameters is easy::
+
+     template<class Params>
+     void foo_impl(const Params& params)
+     {
+         std::cout
+             << params[name | "unnamed"] << " = "
+             << params[value | 0] << "\n";
+     }
+
+We are using ``operator|`` to denote the default value of a named
+parameter.
+
+Going back a little to the ``foo()`` call that didn't compile::
+
+     foo()
+     foo("bar")
+     foo(value = 3)
+
+Now compiles, and prints::
+
+     unnamed = 0
+     bar = 0
+     unnamed = 3
+
+Limitations of the Approach
+===========================
+
+Because the keywords' ``operator=`` returns a temporary, and
+temporaries cannot be bound to non-``const`` reference parameters,
+our forwarding functions need to take their arguments by ``const``
+reference [#forwarding]_. As a result, an argument which is bound
+to a keyword with ``operator=`` can be transparently passed by
+non-const reference, but positional arguments are always passed by
+``const`` reference unless we use the `Boost.Ref`_ library to
+indicate otherwise::
+
+    #include <boost/ref.hpp>
+
+    float x;
+    foo(value = x);     // held type is float&
+    foo(x);             // held type is float const&, need help!
+    foo(boost::ref(x)); // held type is float&
+
+.. _`Boost.Ref`: ../../bind/ref.hpp
+
+
+Instances of ``boost::reference_wrapper<>`` generated by
+``boost::ref`` will be unwrapped automatically by the library.
+
+Controlling Overload Resolution
+===============================
+
+The parameters of our templated forwarding functions are completely
+general; in fact, they're a perfect match for any argument type
+whatsoever.  The problems with exposing such general function
+templates have been the subject of much discussion; especially in
+the presence of `unqualified calls`__.  Probably the safest thing
+to do is to isolate the forwarding functions in a namespace
+containing no types [#using]_, but often we'd *like* our functions
+to play nicely with argument-dependent lookup and other function
+overloads.  In that case, it's neccessary to somehow remove the
+functions from the overload set when the passed argument types
+don't meet their needs.
+
+__ http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#225
+
+This sort of overload control can be accomplished in C++ by taking
+advantage of SFINAE_ (Substitution Failure Is Not An Error). If
+type substitution during the instantiation of a function template
+results in an invalid type, no compilation error is emitted;
+instead the overload is removed from the overload set. By producing
+an invalid type in the function signature depending on the result
+of some condition, whether or not an overload is considered during
+overload resolution can be controlled.  The technique is formalized
+in the |enable_if| utility.
+
+The named parameters library provides built-in SFINAE support
+through the following class template::
+
+     template<
+         class KeywordTag
+       , class HasDefaultValue // mpl::true_ or mpl::false_
+       , class Predicate
+     >
+     struct named_param;
+
+The key parameter, ``Predicate`` shall be a unary MPL lambda
+expression or `Metafunction Class`_ that, when applied to the
+actual type the argument, indicates whether that argument type
+meets the function's requirements for that parameter position.
+
+.. _`Metafunction Class`: ../../mpl/doc/ref/Metafunction_Class.html
+
+.. _SFINAE: http://www.semantics.org/once_weakly/w02_SFINAE.pdf
+
+.. |enable_if| replace:: ``enable_if``
+.. _enable_if: ../enable_if.html
+
+For example, let's say we want to restrict our ``foo()`` so that
+the ``name`` parameter must be convertible to ``const char*``.
+We'll replace our use of the ``name_t`` tag with a specialization
+of ``boost::named_param``:
+
+.. parsed-literal::
+
+     struct foo_parameters
+       : boost::parameters<
+             **boost::named_param<
+                 name_t
+               , mpl::false\_
+               , is_convertible<mpl::\_, const char\*>
+             >**
+           , value_t
+         >
+     {};
+
+Now we can add an additional optional argument to each of our
+``foo`` overloads
+
+.. parsed-literal::
+
+     template<class A0>
+     void foo(
+         const A0& a0
+       , **foo_parameters::restrict<A0>::type x = foo_parameters()**
+     )
+     {
+         foo_impl(x(a0));
+     }
+
+     template<class A0, class A1>
+     void foo(
+         const A0& a0, const A1& a1
+       , **foo_parameters::restrict<A0,A1>::type x = foo_parameters()**
+     )
+     {
+         foo_impl(x(a0, a1));
+     }
+
+These additional parameters are not intended to be used directly
+by callers; they merely trigger SFINAE by becoming illegal types
+when the ``name`` argument is not convertible to ``const char*``.
+
+Lazy Evaluation of Defaults
+===========================
+
+If computing an argument's default value is expensive, it's best
+avoided when the argument is supplied by the user. In that case,
+the default value can be lazily evaluated using the following
+syntax:
+
+.. parsed-literal::
+
+    params[keyword **|| nullary_function**];
+
+``nullary_function`` must be a function object that is callable
+without arguments, and that indicates its return type via a nested
+``result_type``.  Boost.Bind can be used to produce an appropriate
+function object from a regular function pointer::
+
+  // expensive default computation function
+  float default_span(float x, float theta);
+
+  // implementation of bar()
+  template <class Params>
+  void bar_impl(Params const& params)
+  {
+      // Extract arguments
+      float x_ = params[x];
+      float theta_ = params[theta | pi];
+      float span = params[span || boost::bind(default_span, x_, theta_)];
+      ...
+  }
+
+Automatic Overload Generation
+=============================
+
+To reduce the work needed to write functions with named parameters,
+we supply a macro that generates the boilerplate code.
+
+Synopsis::
+
+     BOOST_NAMED_PARAMS_FUN(
+         return_type, function_name
+       , min_arity, max_arity, parameters_type
+     );
+
+To generate all the forwarding functions and the implementation
+function for our example, we need only apply
+``BOOST_NAMED_PARAMS_FUN`` this way::
+
+     BOOST_NAMED_PARAMS_FUN(void, foo, 0, 2, foo_parameters)
+     {
+         std::cout
+             << p[name | "unnamed"] << " = "
+             << p[value | 0] << "\n";
+     }
+
+Portability
+===========
+
+Boost.NamedParams has been confirmed to work on the following compilers:
+
+   - Microsoft VC6 sp5, VC7 [#norestrict]_
+   - Microsoft VC7.1
+   - GCC3.3.1 (cygwin), GCC2.95.3 (cygwin), GCC3.2 (mingw)
+   - Metrowerks Codewarrior Pro8 and Pro9 (Windows)
+   - Intel C++ 5.0,6.0,7.1,8.0 (Windows)
+   - Comeau 4.3.3
+
+-----------------------------
+
+.. [#forwarding] One could provide overloads for ``const`` and
+   non-``const`` reference versions of each parameter, but that
+   would quickly become unmanageable.  It's known as "the
+   forwarding problem" and has been described in detail in this
+   paper__.  The combinatorial explosion is avoided for the
+   parameter of keywords' ``operator=`` because they take only a
+   single argument.
+
+   __ http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm
+
+
+.. [#using] You can always give the illusion that the function
+   lives in an outer namespace by applying a *using-declaration*::
+
+      namespace foo_overloads
+      {
+        // foo declarations here
+        void foo() { ... }
+        ...
+      }
+      using foo_overloads::foo;  
+
+.. [#norestrict] Restrictions doesn't work on these compilers because
+   of lack of SFINAE support.
+

doc/named_params_ref.rst

@@ -0,0 +1,192 @@
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ The Boost.NamedParams Library Reference |(logo)|__ INCOMPLETE
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+.. |(logo)| image:: ../../../c++boost.gif
+   :alt: Boost
+   :class: boost-logo
+
+__ ../../../index.htm
+
+-------------------------------------
+
+:Authors: David Abrahams, Daniel Wallin
+:Contact: dave@boost-consulting.com, dalwan01@student.umu.se
+:organizations: `Boost Consulting`_, 
+:date: $Date: 2005-03-27 23:35:50 -0500 (Sun, 27 Mar 2005) $
+:copyright: Copyright David Abrahams, Daniel Wallin 2003. 
+:license: 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)
+
+.. _`Boost Consulting`: http://www.boost-consulting.com
+
+.. contents::
+
+concept ``keyword-expression``
+------------------------------
+
+.. parsed-literal::
+
+    template<class Tag>
+    *bound-argument* operator[](*keyword-expression*, keyword<Tag>)
+
+**Requires**
+    An argument tagged with ``Tag`` must be bound in the object.
+
+**Returns**
+    A reference to the bound argument tagged with ``Tag``.
+
+**Throws**
+    Nothrow.
+
+**Complexity**
+    O(1) runtime. O(1) compile time on good compilers. O(N), where N is
+    the number of bound arguments, on old compilers such as VC6.
+
+
+.. parsed-literal::
+
+    *bound-argument* operator[](*keyword-expression*, *named-default-expression*)
+
+**Requires**
+    Nothing.
+
+**Returns**
+    A reference to the bound argument tagged with 
+    *named-default-expression*::key_type. If no such argument is bound, the
+    default value as given by the *named-default-expression* instance is 
+    returned.
+
+**Throws**
+    Nothrow.
+
+**Complexity**
+    O(1) runtime. O(1) compile time on good compilers. O(N), where N is
+    the number of bound arguments, on old compilers such as VC6.
+
+
+concept ``named-default-expression``
+------------------------------------
+
+...
+
+
+concept ``lazy-default-expression``
+-----------------------------------
+
+...
+
+   
+
+class template ``keyword``
+--------------------------
+
+.. parsed-literal::
+
+    template<class Tag>
+    struct keyword
+    {
+        template<class T>
+        *keyword-expression* operator=(T&) const;
+
+        template<class T>
+        *keyword-expression* operator=(T const&) const;
+
+        template<class Default>
+        *named-default-expression* operator|(Default&) const;
+
+        template<class Default>
+        *named-default-expression* operator|(Default const&) const;
+
+        template<class LazyDefault>
+        *unspecified* operator||(LazyDefault const&) const;
+    };
+
+Denotes a argument keyword. ``Tag`` is a tag class, typically an incomplete type.
+
+::
+
+    template<class T> operator=(T&)
+    template<class T> operator=(T const&)
+
+**Requires**
+    Nothing.
+
+**Returns**
+    An object that holds a cv reference to ``x``, tagged with the keyword
+    ``Tag`` type. If ``T`` is an instance of ``boost::reference_wrapper<U cv>``
+    the tagged result will hold a reference to ``U cv``.
+
+**Complexity**
+    O(1) compile time and run time.
+
+**Throws**
+    Nothrow.
+
+.. parsed-literal::
+
+    template<class Default>
+    *named-default-expression* operator|(Default&) const
+
+    template<class Default>
+    *named-default-expression* operator|(Default const&) const
+
+**Requires**
+    Nothing.
+
+**Returns**
+    An object holding a reference to the given default value, tagged
+    with ``Tag``.
+
+.. parsed-literal::
+
+    template<class LazyDefault>
+    *lazy-default-expression* operator||(LazyDefault const& x) const;
+
+**Requires**
+    ``LazyDefault`` is a nullary function object, with the following
+    properties:
+
+    ======================== =======================================
+    Expression               Result
+    ======================== =======================================
+    LazyDefault::result_type Must to Copyable
+    x()                      Convertible to LazyDefault::result_type
+    ======================== =======================================
+
+**Returns**
+    ...
+
+.. parsed-literal::
+
+    template<
+        class Tag
+      , class HasDefault = mpl::true\_
+      , class Predicate = mpl::always<mpl::true\_>
+    >
+    struct named_param
+    {
+        typedef Tag key_type;
+        typedef HasDefault has_default;
+        typedef Predicate predicate;
+    };
+
+    template<class K0, class K1, ..., class KN>
+    struct parameters
+    {
+        template<class T0, class T1, ..., class TN>
+        *keyword-expression* operator()(T0 const&, T1 const&, ..., TN const&) const;
+    };
+
+* <K0, ..., KN> is either a tag type, as specified in ``keyword``, or an instantiation of
+  ``named_param``.
+
+::
+
+   template<class T0, class T1, ..., class TN> operator()(T0 const&, T1 const&, ..., TN const&) const;
+
+Composes all parameters, named and positional, into an object that can be used to query
+for specific keywords.
+

doc/ostream_string.qbk

@@ -1,78 +0,0 @@
-[/
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[article ostream_string
-[quickbook 1.5]
-[authors [Fernandes, Glen]]
-[copyright 2019 Glen Joseph Fernandes]
-[license Distributed under the Boost Software License, Version 1.0.]]
-
-[section Overview]
-
-The header <boost/utility/ostream_string.hpp> provides the function template
-`boost::ostream_string` for formatted output that satisfies the requirements of
-\[ostream.formatted.reqmts\].
-
-[endsect]
-
-[section Examples]
-
-The inserter for class template `basic_string_view` could be implemented as
-follows:
-
-```
-template<class charT, class traits>
-std::basic_ostream<charT, traits>&
-operator<<(std::basic_ostream<charT, traits>& os,
-    const basic_string_view<charT, traits>& str)
-{
-    return boost::ostream_string(os, str.data(), str.size());
-}
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-
-template<class charT, class traits>
-std::basic_ostream<charT, traits>&
-ostream_string(std::basic_ostream<charT, traits>& os,
-    const charT* data, std::size_t size);
-
-} /* boost */
-```
-
-[heading Free functions]
-
-[variablelist
-[[`template<class charT, class traits> std::basic_ostream<charT, traits>&
-ostream_string(std::basic_ostream<charT, traits>& os, const charT* data,
-std::size_t size);`]
-[[variablelist
-[[Effects]
-[Behaves like a formatted inserter (as described in
-\[ostream.formatted.reqmts\]) of `os`. Creates a character sequence `seq` of
-`size` characters starting at `data`, each widened using `os.widen()`
-(\[basic.ios.members\]). Determines padding for `seq` as described in
-\[ostream.formatted.reqmts\]. Inserts `seq` into `os`. Calls `width(0)`.]]
-[[Returns][`os`.]]]]]]
-
-[endsect]
-
-[section History]
-
-[heading boost 1.71]
-
-* Glen Fernandes updated the implementation of the `basic_string_ref` and
-`basic_string_view` stream insertion operators to write directly to the
-`basic_streambuf` and refactored that functionality into this common utility.
-
-[endsect]

doc/string_ref.qbk

@@ -1,172 +0,0 @@
-[/
- / Copyright (c) 2012 Marshall Clow
- /
- / 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)
- /]
-
-[article String_Ref
-    [quickbook 1.5]
-    [authors [Clow, Marshall]]
-    [copyright 2012 Marshall Clow]
-    [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])
-    ]
-]
-
-[/===============]
-[section Overview]
-[/===============]
-
-Boost.StringRef is an implementation of Jeffrey Yaskin's [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html N3442:
-string_ref: a non-owning reference to a string]. 
-
-When you are parsing/processing strings from some external source, frequently you want to pass a piece of text to a procedure for specialized processing. The canonical way to do this is as a `std::string`, but that has certain drawbacks:
-
-1) If you are processing a buffer of text (say a HTTP response or the contents of a file), then you have to create the string from the text you want to pass, which involves memory allocation and copying of data.
-
-2) if a routine receives a constant `std::string` and wants to pass a portion of that string to another routine, then it must create a new string of that substring.
-
-3) A routine receives a constant `std::string` and wants to return a portion of the string, then it must create a new string to return.
-
-`string_ref` is designed to solve these efficiency problems. A `string_ref` is a read-only reference to a contiguous sequence of characters, and provides much of the functionality of `std::string`. A `string_ref` is cheap to create, copy and pass by value, because it does not actually own the storage that it points to. 
-
-A `string_ref` is implemented as a small struct that contains a pointer to the start of the character data and a count. A `string_ref` is cheap to create and cheap to copy.
-
-`string_ref` acts as a container; it includes all the methods that you would expect in a container, including iteration support, `operator []`, `at` and `size`. It can be used with any of the iterator-based algorithms in the STL - as long as you don't need to change the underlying data (`sort` and `remove`, for example, will not work)
-
-Besides generic container functionality, `string_ref` provides a subset of the interface of `std::string`. This makes it easy to replace parameters of type `const std::string &` with `boost::string_ref`. Like `std::string`, `string_ref` has a static member variable named `npos` to denote the result of failed searches, and to mean "the end".
-
-Because a `string_ref` does not own the data that it "points to", it introduces lifetime issues into code that uses it. The programmer must ensure that the data that a `string_ref` refers to exists as long as the `string_ref` does.
-
-[endsect]
-
-
-[/===============]
-[section Examples]
-[/===============]
-
-Integrating `string_ref` into your code is fairly simple. Wherever you pass a `const std::string &` or `std::string` as a parameter, that's a candidate for passing a `boost::string_ref`.
-
-    std::string extract_part ( const std::string &bar ) {
-        return bar.substr ( 2, 3 );
-        }
-        
-    if ( extract_part ( "ABCDEFG" ).front() == 'C' ) { /* do something */ }
-    
-Let's figure out what happens in this (contrived) example.
-
-First, a temporary string is created from the string literal `"ABCDEFG"`, and it is passed (by reference) to the routine `extract_part`. Then a second string is created in the call `std::string::substr` and returned to `extract_part` (this copy may be elided by RVO). Then `extract_part` returns that string back to the caller (again this copy may be elided). The first temporary string is deallocated, and `front` is called on the second string, and then it is deallocated as well.
-
-Two `std::string`s are created, and two copy operations. That's (potentially) four memory allocations and deallocations, and the associated copying of data.
-
-Now let's look at the same code with `string_ref`:
-
-    boost::string_ref extract_part ( boost::string_ref bar ) {
-        return bar.substr ( 2, 3 );
-        }
-        
-    if ( extract_part ( "ABCDEFG" ).front() == "C" ) { /* do something */ }
-
-No memory allocations. No copying of character data. No changes to the code other than the types. There are two `string_ref`s created, and two `string_ref`s copied, but those are cheap operations.
-
-[endsect]
-
-
-[/=================]
-[section:reference Reference ]
-[/=================]
-
-The header file "string_ref.hpp" defines a template `boost::basic_string_ref`, and four specializations - for `char` / `wchar_t` / `char16_t` / `char32_t` .
-
-`#include <boost/utility/string_ref.hpp>`
-
-Construction and copying:
-
-    BOOST_CONSTEXPR basic_string_ref ();    // Constructs an empty string_ref
-    BOOST_CONSTEXPR basic_string_ref(const charT* str); // Constructs from a NULL-terminated string
-    BOOST_CONSTEXPR basic_string_ref(const charT* str, size_type len); // Constructs from a pointer, length pair
-    template<typename Allocator>
-    basic_string_ref(const std::basic_string<charT, traits, Allocator>& str); // Constructs from a std::string
-    basic_string_ref (const basic_string_ref &rhs);
-    basic_string_ref& operator=(const basic_string_ref &rhs);
-
-`string_ref` does not define a move constructor nor a move-assignment operator because copying a `string_ref` is just a cheap as moving one.
-
-Basic container-like functions:
-
-    BOOST_CONSTEXPR size_type size()     const ;
-    BOOST_CONSTEXPR size_type length()   const ;
-    BOOST_CONSTEXPR size_type max_size() const ;
-    BOOST_CONSTEXPR bool empty()         const ;
-    
-    // All iterators are const_iterators
-    BOOST_CONSTEXPR const_iterator  begin() const ;
-    BOOST_CONSTEXPR const_iterator cbegin() const ;
-    BOOST_CONSTEXPR const_iterator    end() const ;
-    BOOST_CONSTEXPR const_iterator   cend() const ;
-    const_reverse_iterator         rbegin() const ;
-    const_reverse_iterator        crbegin() const ;
-    const_reverse_iterator           rend() const ;
-    const_reverse_iterator          crend() const ;
-
-Access to the individual elements (all of which are const):
-
-    BOOST_CONSTEXPR const charT& operator[](size_type pos) const ;
-    const charT& at(size_t pos) const ;
-    BOOST_CONSTEXPR const charT& front() const ;
-    BOOST_CONSTEXPR const charT& back()  const ;
-    BOOST_CONSTEXPR const charT* data()  const ;
-
-Modifying the `string_ref` (but not the underlying data):
-
-    void clear();
-    void remove_prefix(size_type n);
-    void remove_suffix(size_type n);
-
-Searching:
-
-    size_type find(basic_string_ref s) const ;
-    size_type find(charT c) const ;
-    size_type rfind(basic_string_ref s) const ;
-    size_type rfind(charT c) const ;
-    size_type find_first_of(charT c) const ;
-    size_type find_last_of (charT c) const ;
-        
-    size_type find_first_of(basic_string_ref s) const ;
-    size_type find_last_of(basic_string_ref s) const ;
-    size_type find_first_not_of(basic_string_ref s) const ;
-    size_type find_first_not_of(charT c) const ;
-    size_type find_last_not_of(basic_string_ref s) const ;
-    size_type find_last_not_of(charT c) const ;
-
-String-like operations:
-
-    BOOST_CONSTEXPR basic_string_ref substr(size_type pos, size_type n=npos) const ; // Creates a new string_ref
-    bool starts_with(charT c) const ;
-    bool starts_with(basic_string_ref x) const ;
-    bool ends_with(charT c) const ;
-    bool ends_with(basic_string_ref x) const ;
-
-[endsect]
-
-[/===============]
-[section History]
-[/===============]
-
-[heading boost 1.71]
-* Glen Fernandes updated the implementation of the stream insertion operator to
-write directly to the `basic_streambuf` and refactored that functionality into
-a common utility.
-
-[heading boost 1.53]
-* Introduced
-    
-
-[endsect]
-
-
-
-

enable_if.html

@@ -1,15 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-<head>
-<meta http-equiv=refresh content="0; URL=../core/doc/html/core/enable_if.html">
-<title>Automatic redirection</title>
-</head>
-<body>
-Automatic redirection failed, please go to
-<a href="../core/doc/html/core/enable_if.html">enable_if.html</a>.&nbsp;<hr>
-<p>© Copyright Beman Dawes, 2001</p>
-<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
-file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
-at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
-</body>
-</html>

identity_type/doc/Jamfile.v2

@@ -1,44 +0,0 @@
-
-# Copyright (C) 2009-2012 Lorenzo Caminiti
-# Distributed under the Boost Software License, Version 1.0
-# (see accompanying file LICENSE_1_0.txt or a copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-# Home at http://www.boost.org/libs/utility/identity_type
-
-import quickbook ;
-using boostbook ;
-
-doxygen reference : ../../../../boost/utility/identity_type.hpp
-    :   <reftitle>"Reference"
-        <doxygen:param>PREDEFINED="DOXYGEN"
-        <doxygen:param>QUIET=YES
-        <doxygen:param>WARN_IF_UNDOCUMENTED=NO
-        <doxygen:param>HIDE_UNDOC_MEMBERS=YES
-        <doxygen:param>HIDE_UNDOC_CLASSES=YES
-        <doxygen:param>ALIASES=" Params=\"<b>Parameters:</b> <table border="0">\" Param{2}=\"<tr><td><b><tt>\\1</tt></b></td><td>\\2</td></tr>\" EndParams=\"</table>\" Returns=\"<b>Returns:</b>\" Note=\"<b>Note:</b>\" Warning=\"<b>Warning:</b>\" See=\"<b>See:</b>\" RefSect{2}=\"\\xmlonly<link linkend='boost_utility_identitytype.\\1'>\\2</link>\\endxmlonly\" RefClass{1}=\"\\xmlonly<computeroutput><classname alt='\\1'>\\1</classname></computeroutput>\\endxmlonly\" RefFunc{1}=\"\\xmlonly<computeroutput><functionname alt='\\1'>\\1</functionname></computeroutput>\\endxmlonly\" RefMacro{1}=\"\\xmlonly<computeroutput><macroname alt='\\1'>\\1</macroname></computeroutput>\\endxmlonly\" "
-    ;
-
-# This target must be called "index" so to generate "index.html" file.
-xml index : identity_type.qbk : <dependency>reference ;
-
-boostbook doc : index
-    :   <location>html
-        <format>onehtml
-        <xsl:param>toc.section.depth=0
-        <xsl:param>html.stylesheet=../../../../../doc/src/boostbook.css
-        <xsl:param>boost.root=../../../../..
-    ;
-
-#
-# This is very imperfect - it results in both html and pdf docs being built,
-# for some reason I can't get the "onehtml" format specified above to play nice
-# with the usual incantations for mixed pdf/html builds. JM 06/2012.
-#
-boostbook pdf_doc : index
-    :
-       <format>pdf
-       <format>html:<build>no
-    ;
-
-install pdf_doc_install : pdf_doc : <location>. <name>identity_type.pdf <install-type>PDF ;
-explicit pdf_doc_install ;

identity_type/doc/html/index.html

@@ -1,252 +0,0 @@
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Boost.Utility/IdentityType 1.0.0</title><link rel="stylesheet" type="text/css" href="../../../../../doc/src/boostbook.css"><meta name="generator" content="DocBook XSL Stylesheets V1.76.1"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="chapter" title="Boost.Utility/IdentityType 1.0.0"><div class="titlepage"><div><div><h2 class="title"><a name="boost_utility_identitytype"></a>Boost.Utility/IdentityType 1.0.0</h2></div><div><div class="author"><h3 class="author"><span class="firstname">Lorenzo</span> <span class="surname">Caminiti <code class="email">&lt;<a class="email" href="mailto:lorcaminiti@gmail.com">lorcaminiti@gmail.com</a>&gt;</code></span></h3></div></div><div><p class="copyright">Copyright © 2009-2012 Lorenzo
-      Caminiti</p></div><div><div class="legalnotice" title="Legal Notice"><a name="boost_utility_identitytype.legal"></a><p>
-        Distributed under the Boost Software License, Version 1.0 (see accompanying
-        file LICENSE_1_0.txt or a 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></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#boost_utility_identitytype.motivation">Motivation</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.solution">Solution</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.templates">Templates</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.abstract_types">Abstract Types</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.annex__usage">Annex: Usage</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.annex__implementation">Annex:
-    Implementation</a></span></dt><dt><span class="section"><a href="#reference">Reference</a></span></dt></dl></div><p>
-    This library allows to wrap types within round parenthesis so they can always
-    be passed as macro parameters.
-  </p><div class="section boost_utility_identitytype_motivation" title="Motivation"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.motivation"></a><a class="link" href="#boost_utility_identitytype.motivation" title="Motivation">Motivation</a></h2></div></div></div><p>
-      Consider the following macro which declares a variable named <code class="computeroutput"><span class="identifier">var</span></code><code class="literal"><span class="emphasis"><em>n</em></span></code>
-      with the specified <code class="literal"><span class="emphasis"><em>type</em></span></code> (see also
-      <a href="../../test/var_error.cpp" target="_top"><code class="literal">var_error.cpp</code></a>):
-    </p><p>
-</p><pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">VAR</span><span class="special">(</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">n</span><span class="special">)</span> <span class="identifier">type</span> <span class="identifier">var</span> <span class="error">#</span><span class="preprocessor"># n</span>
-
-<span class="identifier">VAR</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="number">1</span><span class="special">);</span>                    <span class="comment">// OK.</span>
-<span class="identifier">VAR</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;,</span> <span class="number">2</span><span class="special">);</span>    <span class="comment">// Error.</span>
-</pre><p>
-    </p><p>
-      The first macro invocation works correctly declaring a variable named <code class="computeroutput"><span class="identifier">var1</span></code> of type <code class="computeroutput"><span class="keyword">int</span></code>.
-      However, the second macro invocation fails generating a preprocessor error
-      similar to the following:
-    </p><pre class="programlisting">error: macro "VAR" passed 3 arguments, but takes just 2
-</pre><p>
-      That is because the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span></code> type passed as the first macro parameter
-      contains a comma <code class="computeroutput"><span class="special">,</span></code> not wrapped
-      by round parenthesis <code class="computeroutput"><span class="special">()</span></code>. The preprocessor
-      interprets that unwrapped comma as a separation between macro parameters concluding
-      that a total of three (and not two) parameters are passed to the macro in the
-      following order:
-    </p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
-          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span></code>
-        </li><li class="listitem">
-          <code class="computeroutput"><span class="keyword">char</span><span class="special">&gt;</span></code>
-        </li><li class="listitem">
-          <code class="computeroutput"><span class="number">2</span></code>
-        </li></ol></div><p>
-      Note that, differently from the compiler, the preprocessor only recognizes
-      round parenthesis <code class="computeroutput"><span class="special">()</span></code>. Angular
-      <code class="computeroutput"><span class="special">&lt;&gt;</span></code> and squared <code class="computeroutput"><span class="special">[]</span></code> parenthesis are not recognized by the preprocessor
-      when parsing macro parameters.
-    </p></div><div class="section boost_utility_identitytype_solution" title="Solution"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.solution"></a><a class="link" href="#boost_utility_identitytype.solution" title="Solution">Solution</a></h2></div></div></div><p>
-      In some cases, it might be possible to workaround this issue by avoiding to
-      pass the type expression to the macro all together. For example, in the case
-      above a <code class="computeroutput"><span class="keyword">typedef</span></code> could have been
-      used to specify the type expression with the commas outside the macro (see
-      also <a href="../../test/var.cpp" target="_top"><code class="literal">var.cpp</code></a>):
-    </p><p>
-</p><pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;</span> <span class="identifier">map_type</span><span class="special">;</span>
-<span class="identifier">VAR</span><span class="special">(</span><span class="identifier">map_type</span><span class="special">,</span> <span class="number">3</span><span class="special">);</span> <span class="comment">// OK.</span>
-</pre><p>
-    </p><p>
-      When this is neither possible nor desired (e.g., see the function template
-      <code class="computeroutput"><span class="identifier">f</span></code> in the section below), this
-      library header <code class="computeroutput"><a class="link" href="#header.boost.utility.identity_type_hpp" title="Header &lt;boost/utility/identity_type.hpp&gt;">boost/utility/identity_type.hpp</a></code>
-      defines a macro <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
-      which can be used to workaround the issue while keeping the type expression
-      as one of the macro parameters (see also <a href="../../test/var.cpp" target="_top"><code class="literal">var.cpp</code></a>).
-    </p><p>
-</p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">/</span><span class="identifier">identity_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-
-<span class="identifier">VAR</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;)),</span> <span class="number">4</span><span class="special">);</span> <span class="comment">// OK.</span>
-</pre><p>
-    </p><p>
-      The <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code> macro
-      expands to an expression that evaluates (at compile-time) to the specified
-      type. The specified type is never split into multiple macro parameters because
-      it is always wrapped by a set of extra round parenthesis <code class="computeroutput"><span class="special">()</span></code>.
-      In fact, a total of two sets of round parenthesis must be used: The parenthesis
-      to invoke the macro <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">(...)</span></code> plus the inner parenthesis to wrap the
-      type passed to the macro <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((...))</span></code>.
-    </p><p>
-      This macro works on any <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/standards" target="_top">C++03</a>
-      compiler (and it does not use <a href="http://en.wikipedia.org/wiki/Variadic_macro" target="_top">variadic
-      macros</a>). <sup>[<a name="boost_utility_identitytype.solution.f0" href="#ftn.boost_utility_identitytype.solution.f0" class="footnote">1</a>]</sup> The authors originally developed and tested this library using
-      GNU Compiler Collection (GCC) C++ 4.5.3 (with and without C++11 features enabled
-      <code class="computeroutput"><span class="special">-</span><span class="identifier">std</span><span class="special">=</span><span class="identifier">c</span><span class="special">++</span><span class="number">0</span><span class="identifier">x</span></code>) on Cygwin
-      and Miscrosoft Visual C++ (MSVC) 8.0 on Windows 7. See the library <a href="http://www.boost.org/development/tests/release/developer/utility-identity_type.html" target="_top">regressions
-      test results</a> for more information on supported compilers and platforms.
-    </p></div><div class="section boost_utility_identitytype_templates" title="Templates"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.templates"></a><a class="link" href="#boost_utility_identitytype.templates" title="Templates">Templates</a></h2></div></div></div><p>
-      This macro must be prefixed by <code class="computeroutput"><span class="keyword">typename</span></code>
-      when used within templates. For example, let's program a macro that declares
-      a function parameter named <code class="computeroutput"><span class="identifier">arg</span></code><code class="literal"><span class="emphasis"><em>n</em></span></code>
-      with the specified <code class="literal"><span class="emphasis"><em>type</em></span></code> (see also
-      <a href="../../test/template.cpp" target="_top"><code class="literal">template.cpp</code></a>):
-    </p><p>
-</p><pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">ARG</span><span class="special">(</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">n</span><span class="special">)</span> <span class="identifier">type</span> <span class="identifier">arg</span> <span class="error">#</span><span class="preprocessor"># n</span>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span> <span class="comment">// Prefix macro with `typename` in templates.</span>
-    <span class="identifier">ARG</span><span class="special">(</span><span class="keyword">typename</span> <span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)),</span> <span class="number">1</span><span class="special">)</span>
-<span class="special">)</span> <span class="special">{</span>
-    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">arg1</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
-<span class="special">}</span>
-</pre><p>
-    </p><p>
-</p><pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;</span> <span class="identifier">a</span><span class="special">;</span>
-<span class="identifier">a</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="char">'a'</span><span class="special">;</span>
-
-<span class="identifier">f</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;(</span><span class="identifier">a</span><span class="special">);</span> <span class="comment">// OK...</span>
-<span class="comment">// f(a);    // ... but error.</span>
-</pre><p>
-    </p><p>
-      However, note that the template parameter <code class="computeroutput"><span class="keyword">char</span></code>
-      must be manually specified when invoking the function as in <code class="computeroutput"><span class="identifier">f</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;(</span><span class="identifier">a</span><span class="special">)</span></code>. In fact,
-      when the <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
-      macro is used to wrap a function template parameter, the template parameter
-      can no longer be automatically deduced by the compiler form the function call
-      as <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> would
-      have done. <sup>[<a name="boost_utility_identitytype.templates.f0" href="#ftn.boost_utility_identitytype.templates.f0" class="footnote">2</a>]</sup> (This limitation does not apply to class templates because class
-      template parameters must always be explicitly specified.) In other words, without
-      using the <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
-      macro, C++ would normally be able to automatically deduce the function template
-      parameter as shown below:
-    </p><p>
-</p><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">void</span> <span class="identifier">g</span><span class="special">(</span>
-    <span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">arg1</span>
-<span class="special">)</span> <span class="special">{</span>
-    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">arg1</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
-<span class="special">}</span>
-</pre><p>
-    </p><p>
-</p><pre class="programlisting"><span class="identifier">g</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;(</span><span class="identifier">a</span><span class="special">);</span> <span class="comment">// OK...</span>
-<span class="identifier">g</span><span class="special">(</span><span class="identifier">a</span><span class="special">);</span>       <span class="comment">// ... and also OK.</span>
-</pre><p>
-    </p></div><div class="section boost_utility_identitytype_abstract_types" title="Abstract Types"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.abstract_types"></a><a class="link" href="#boost_utility_identitytype.abstract_types" title="Abstract Types">Abstract Types</a></h2></div></div></div><p>
-      On some compilers (e.g., GCC), using this macro on abstract types (i.e., classes
-      with one or more pure virtual functions) generates a compiler error. This can
-      be avoided by manipulating the type adding and removing a reference to it.
-    </p><p>
-      Let's program a macro that performs a static assertion on a <a href="http://en.wikipedia.org/wiki/Template_metaprogramming" target="_top">Template
-      Meta-Programming</a> (TMP) meta-function (similarly to Boost.MPL <a href="http://www.boost.org/doc/libs/1_36_0/libs/mpl/doc/refmanual/assert.html" target="_top"><code class="computeroutput"><span class="identifier">BOOST_MPL_ASSERT</span></code></a>). The <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code> macro can be used
-      to pass a meta-function with multiple template parameters to the assert macro
-      (so to handle the commas separating the template parameters). In this case,
-      if the meta-function is an abstract type, it needs to be manipulated adding
-      and removing a reference to it (see also <a href="../../test/abstract.cpp" target="_top"><code class="literal">abstract.cpp</code></a>):
-    </p><p>
-</p><pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">TMP_ASSERT</span><span class="special">(</span><span class="identifier">metafunction</span><span class="special">)</span> <span class="special">\</span>
-    <span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">(</span><span class="identifier">metafunction</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">b</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">abstract</span> <span class="special">{</span>
-    <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="identifier">b</span><span class="special">;</span>
-    <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>     <span class="comment">// Pure virtual function.</span>
-<span class="special">};</span>
-
-<span class="identifier">TMP_ASSERT</span><span class="special">(</span>
-    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special">&lt;</span>            <span class="comment">// Add and remove</span>
-        <span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span>           <span class="comment">// reference for</span>
-            <span class="identifier">boost</span><span class="special">::</span><span class="identifier">add_reference</span><span class="special">&lt;</span>       <span class="comment">// abstract type.</span>
-                <span class="identifier">abstract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">true</span><span class="special">&gt;</span>
-            <span class="special">&gt;::</span><span class="identifier">type</span>
-        <span class="special">))</span>
-    <span class="special">&gt;::</span><span class="identifier">type</span>
-<span class="special">);</span>
-</pre><p>
-    </p></div><div class="section boost_utility_identitytype_annex__usage" title="Annex: Usage"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.annex__usage"></a><a class="link" href="#boost_utility_identitytype.annex__usage" title="Annex: Usage">Annex: Usage</a></h2></div></div></div><p>
-      The <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code> macro
-      can be used either when calling a user-defined macro (as shown by the examples
-      so far), or internally when implementing a user-defined macro (as shown below).
-      When <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code> is
-      used in the implementation of the user-defined macro, the caller of the user
-      macro will have to specify the extra parenthesis (see also <a href="../../test/paren.cpp" target="_top"><code class="literal">paren.cpp</code></a>):
-    </p><p>
-</p><pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">TMP_ASSERT_PAREN</span><span class="special">(</span><span class="identifier">parenthesized_metafunction</span><span class="special">)</span> <span class="special">\</span>
-    <span class="comment">/* use `BOOST_IDENTITY_TYPE` in macro definition instead of invocation */</span> <span class="special">\</span>
-    <span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">(</span><span class="identifier">parenthesized_metafunction</span><span class="special">)::</span><span class="identifier">value</span><span class="special">)</span>
-
-<span class="preprocessor">#define</span> <span class="identifier">TMP_ASSERT</span><span class="special">(</span><span class="identifier">metafunction</span><span class="special">)</span> <span class="special">\</span>
-    <span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">(</span><span class="identifier">metafunction</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span>
-
-<span class="comment">// Specify only extra parenthesis `((...))`.</span>
-<span class="identifier">TMP_ASSERT_PAREN</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&gt;));</span>
-
-<span class="comment">// Specify both the extra parenthesis `((...))` and `BOOST_IDENTITY_TYPE` macro.</span>
-<span class="identifier">TMP_ASSERT</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&gt;)));</span>
-</pre><p>
-    </p><p>
-      However, note that the caller will <span class="emphasis"><em>always</em></span> have to specify
-      the extra parenthesis even when the macro parameters contain no comma:
-    </p><p>
-</p><pre class="programlisting"><span class="identifier">TMP_ASSERT_PAREN</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;));</span> <span class="comment">// Always extra `((...))`.</span>
-
-<span class="identifier">TMP_ASSERT</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;);</span> <span class="comment">// No extra `((...))` and no macro.</span>
-</pre><p>
-    </p><p>
-      In some cases, using <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
-      in the implementation of the user-defined macro might provide the best syntax
-      for the caller. For example, this is the case for <code class="computeroutput"><span class="identifier">BOOST_MPL_ASSERT</span></code>
-      because the majority of template meta-programming expressions contain unwrapped
-      commas so it is less confusing for the user to always specify the extra parenthesis
-      <code class="computeroutput"><span class="special">((...))</span></code> instead of using <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>:
-    </p><pre class="programlisting"><span class="identifier">BOOST_MPL_ASSERT</span><span class="special">((</span> <span class="comment">// Natural syntax.</span>
-    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">and_</span><span class="special">&lt;</span>
-          <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span>
-        <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span>
-    <span class="special">&gt;</span>
-<span class="special">));</span>
-</pre><p>
-      However, in other situations it might be preferable to not require the extra
-      parenthesis in the common cases and handle commas as special cases using <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>. For example, this
-      is the case for <a href="http://www.boost.org/libs/local_function" target="_top"><code class="computeroutput"><span class="identifier">BOOST_LOCAL_FUNCTION</span></code></a> for which always
-      requiring the extra parenthesis <code class="computeroutput"><span class="special">((...))</span></code>
-      around the types would lead to an unnatural syntax for the local function signature:
-    </p><pre class="programlisting"><span class="keyword">int</span> <span class="identifier">BOOST_LOCAL_FUNCTION</span><span class="special">(</span> <span class="special">((</span><span class="keyword">int</span><span class="special">&amp;))</span> <span class="identifier">x</span><span class="special">,</span> <span class="special">((</span><span class="keyword">int</span><span class="special">&amp;))</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">{</span> <span class="comment">// Unnatural syntax.</span>
-    <span class="keyword">return</span> <span class="identifier">x</span> <span class="special">+</span> <span class="identifier">y</span><span class="special">;</span>
-<span class="special">}</span> <span class="identifier">BOOST_LOCAL_FUNCTION_NAME</span><span class="special">(</span><span class="identifier">add</span><span class="special">)</span>
-</pre><p>
-      Instead requiring the user to specify <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
-      only when needed allows for the more natural syntax <code class="computeroutput"><span class="identifier">BOOST_LOCAL_FUNCTION</span><span class="special">(</span><span class="keyword">int</span><span class="special">&amp;</span>
-      <span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">)</span></code> in the common cases when the parameter types
-      contain no comma (while still allowing to specify parameter types with commas
-      as special cases using <code class="computeroutput"><span class="identifier">BOOST_LOCAL_FUNCTION</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;))&amp;</span>
-      <span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">)</span></code>).
-    </p></div><div class="section boost_utility_identitytype_annex__implementation" title="Annex: Implementation"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.annex__implementation"></a><a class="link" href="#boost_utility_identitytype.annex__implementation" title="Annex: Implementation">Annex:
-    Implementation</a></h2></div></div></div><p>
-      The implementation of this library macro is equivalent to the following: <sup>[<a name="boost_utility_identitytype.annex__implementation.f0" href="#ftn.boost_utility_identitytype.annex__implementation.f0" class="footnote">3</a>]</sup>
-    </p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">function_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-
-<span class="preprocessor">#define</span> <span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">(</span><span class="identifier">parenthesized_type</span><span class="special">)</span> <span class="special">\</span>
-    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">function_traits</span><span class="special">&lt;</span><span class="keyword">void</span> <span class="identifier">parenthesized_type</span><span class="special">&gt;::</span><span class="identifier">arg1_type</span>
-</pre><p>
-      Essentially, the type is wrapped between round parenthesis <code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span>
-      <span class="keyword">char</span><span class="special">&gt;)</span></code>
-      so it can be passed as a single macro parameter even if it contains commas.
-      Then the parenthesized type is transformed into the type of a function returning
-      <code class="computeroutput"><span class="keyword">void</span></code> and with the specified type
-      as the type of the first and only argument <code class="computeroutput"><span class="keyword">void</span>
-      <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;)</span></code>. Finally, the type of the first argument
-      <code class="computeroutput"><span class="identifier">arg1_type</span></code> is extracted at compile-time
-      using the <code class="computeroutput"><span class="identifier">function_traits</span></code> meta-function
-      therefore obtaining the original type from the parenthesized type (effectively
-      stripping the extra parenthesis from around the specified type).
-    </p></div><div class="section reference" title="Reference"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="reference"></a>Reference</h2></div></div></div><div class="section header_boost_utility_identity_type_hpp" title="Header &lt;boost/utility/identity_type.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.boost.utility.identity_type_hpp"></a>Header &lt;<a href="../../../../../boost/utility/identity_type.hpp" target="_top">boost/utility/identity_type.hpp</a>&gt;</h3></div></div></div><p>Wrap type expressions with round parenthesis so they can be passed to macros even if they contain commas. </p><pre class="synopsis">
-
-<a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a>(parenthesized_type)</pre><div class="refentry" title="Macro BOOST_IDENTITY_TYPE"><a name="BOOST_IDENTITY_TYPE"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro BOOST_IDENTITY_TYPE</span></h2><p>BOOST_IDENTITY_TYPE — This macro allows to wrap the specified type expression within extra round parenthesis so the type can be passed as a single macro parameter even if it contains commas (not already wrapped within round parenthesis). </p></div><h2 class="refsynopsisdiv-title">Synopsis</h2><div class="refsynopsisdiv"><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.boost.utility.identity_type_hpp" title="Header &lt;boost/utility/identity_type.hpp&gt;">boost/utility/identity_type.hpp</a>&gt;
-
-</span>BOOST_IDENTITY_TYPE(parenthesized_type)</pre></div><div class="refsect1" title="Description"><a name="id554262"></a><h2>Description</h2><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table class="table"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">parenthesized_type</code></strong></span></td><td>The type expression to be passed as macro parameter wrapped by a single set of round parenthesis <code class="computeroutput">(...)</code>. This type expression can contain an arbitrary number of commas.  </td></tr></tbody></table></div><p>
-</p><p>This macro works on any C++03 compiler (it does not use variadic macros).</p><p>This macro must be prefixed by <code class="computeroutput">typename</code> when used within templates. Note that the compiler will not be able to automatically determine function template parameters when they are wrapped with this macro (these parameters need to be explicitly specified when calling the function template).</p><p>On some compilers (like GCC), using this macro on abstract types requires to add and remove a reference to the specified type. </p></div></div></div></div><div class="footnotes"><br><hr width="100" align="left"><div class="footnote"><p><sup>[<a id="ftn.boost_utility_identitytype.solution.f0" href="#boost_utility_identitytype.solution.f0" class="para">1</a>] </sup>
-        Using variadic macros, it would be possible to require a single set of extra
-        parenthesis <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>type</em></span></code><code class="computeroutput"><span class="special">)</span></code> instead of two <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span></code><code class="literal"><span class="emphasis"><em>type</em></span></code><code class="computeroutput"><span class="special">))</span></code> but variadic macros are not part of C++03
-        (even if nowadays they are supported by most modern compilers and they are
-        also part of C++11).
-      </p></div><div class="footnote"><p><sup>[<a id="ftn.boost_utility_identitytype.templates.f0" href="#boost_utility_identitytype.templates.f0" class="para">2</a>] </sup>
-        This is because the implementation of <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
-        wraps the specified type within a meta-function.
-      </p></div><div class="footnote"><p><sup>[<a id="ftn.boost_utility_identitytype.annex__implementation.f0" href="#boost_utility_identitytype.annex__implementation.f0" class="para">3</a>] </sup>
-        There is absolutely no guarantee that the macro is actually implemented using
-        the code listed in this documentation. The listed code is for explanatory
-        purposes only.
-      </p></div></div></div></body></html>

identity_type/doc/identity_type.qbk

@@ -1,165 +0,0 @@
-
-[/ Copyright (C) 2009-2012 Lorenzo Caminiti ]
-[/ Distributed under the Boost Software License, Version 1.0 ]
-[/ (see accompanying file LICENSE_1_0.txt or a copy at ]
-[/ http://www.boost.org/LICENSE_1_0.txt) ]
-[/ Home at http://www.boost.org/libs/utility/identity_type ]
-
-[library Boost.Utility/IdentityType
-    [quickbook 1.5]
-    [version 1.0.0]
-    [copyright 2009-2012 Lorenzo Caminiti]
-    [purpose wraps types with round parenthesis]
-    [license
-        Distributed under the Boost Software License, Version 1.0
-        (see accompanying file LICENSE_1_0.txt or a copy at
-        [@http://www.boost.org/LICENSE_1_0.txt])
-    ]
-    [authors [Caminiti <email>lorcaminiti@gmail.com</email>, Lorenzo]]
-    [category Utilities]
-]
-
-This library allows to wrap types within round parenthesis so they can always be passed as macro parameters.
-
-[import ../test/var_error.cpp]
-[import ../test/var.cpp]
-[import ../test/template.cpp]
-[import ../test/abstract.cpp]
-[import ../test/paren.cpp]
-
-[section Motivation]
-
-Consider the following macro which declares a variable named `var`[^['n]] with the specified [^['type]] (see also [@../../test/var_error.cpp =var_error.cpp=]):
-
-[var_error]
-
-The first macro invocation works correctly declaring a variable named `var1` of type `int`.
-However, the second macro invocation fails generating a preprocessor error similar to the following:
-
-[pre
-    error: macro "VAR" passed 3 arguments, but takes just 2
-]
-
-That is because the `std::map` type passed as the first macro parameter contains a comma `,` not wrapped by round parenthesis `()`.
-The preprocessor interprets that unwrapped comma as a separation between macro parameters concluding that a total of three (and not two) parameters are passed to the macro in the following order:
-
-# `std::map<int`
-# `char>`
-# `2`
-
-Note that, differently from the compiler, the preprocessor only recognizes round parenthesis `()`.
-Angular `<>` and squared `[]` parenthesis are not recognized by the preprocessor when parsing macro parameters.
-
-[endsect]
-
-[section Solution]
-
-In some cases, it might be possible to workaround this issue by avoiding to pass the type expression to the macro all together.
-For example, in the case above a `typedef` could have been used to specify the type expression with the commas outside the macro (see also [@../../test/var.cpp =var.cpp=]):
-
-[var_typedef]
-
-When this is neither possible nor desired (e.g., see the function template `f` in the section below), this library header [headerref boost/utility/identity_type.hpp] defines a macro [macroref BOOST_IDENTITY_TYPE] which can be used to workaround the issue while keeping the type expression as one of the macro parameters (see also [@../../test/var.cpp =var.cpp=]).
-
-[var_ok]
-
-The [macroref BOOST_IDENTITY_TYPE] macro expands to an expression that evaluates (at compile-time) to the specified type.
-The specified type is never split into multiple macro parameters because it is always wrapped by a set of extra round parenthesis `()`.
-In fact, a total of two sets of round parenthesis must be used: The parenthesis to invoke the macro `BOOST_IDENTITY_TYPE(...)` plus the inner parenthesis to wrap the type passed to the macro `BOOST_IDENTITY_TYPE((...))`.
-
-This macro works on any [@http://www.open-std.org/JTC1/SC22/WG21/docs/standards C++03] compiler (and it does not use [@http://en.wikipedia.org/wiki/Variadic_macro variadic macros]).
-[footnote
-Using variadic macros, it would be possible to require a single set of extra parenthesis `BOOST_IDENTITY_TYPE(`[^['type]]`)` instead of two `BOOST_IDENTITY_TYPE((`[^['type]]`))` but variadic macros are not part of C++03 (even if nowadays they are supported by most modern compilers and they are also part of C++11).
-]
-The authors originally developed and tested this library using GNU Compiler Collection (GCC) C++ 4.5.3 (with and without C++11 features enabled `-std=c++0x`) on Cygwin and Miscrosoft Visual C++ (MSVC) 8.0 on Windows 7.
-See the library [@http://www.boost.org/development/tests/release/developer/utility-identity_type.html regressions test results] for more information on supported compilers and platforms.
-
-[endsect]
-
-[section Templates]
-
-This macro must be prefixed by `typename` when used within templates.
-For example, let's program a macro that declares a function parameter named `arg`[^['n]] with the specified [^['type]] (see also [@../../test/template.cpp =template.cpp=]):
-
-[template_f_decl]
-[template_f_call]
-
-However, note that the template parameter `char` must be manually specified when invoking the function as in `f<char>(a)`.
-In fact, when the [macroref BOOST_IDENTITY_TYPE] macro is used to wrap a function template parameter, the template parameter can no longer be automatically deduced by the compiler form the function call as `f(a)` would have done.
-[footnote
-This is because the implementation of [macroref BOOST_IDENTITY_TYPE] wraps the specified type within a meta-function.
-]
-(This limitation does not apply to class templates because class template parameters must always be explicitly specified.)
-In other words, without using the [macroref BOOST_IDENTITY_TYPE] macro, C++ would normally be able to automatically deduce the function template parameter as shown below:
-
-[template_g_decl]
-[template_g_call]
-
-[endsect]
-
-[section Abstract Types]
-
-On some compilers (e.g., GCC), using this macro on abstract types (i.e., classes with one or more pure virtual functions) generates a compiler error.
-This can be avoided by manipulating the type adding and removing a reference to it.
-
-Let's program a macro that performs a static assertion on a [@http://en.wikipedia.org/wiki/Template_metaprogramming Template Meta-Programming] (TMP) meta-function (similarly to Boost.MPL [@http://www.boost.org/doc/libs/1_36_0/libs/mpl/doc/refmanual/assert.html `BOOST_MPL_ASSERT`]).
-The [macroref BOOST_IDENTITY_TYPE] macro can be used to pass a meta-function with multiple template parameters to the assert macro (so to handle the commas separating the template parameters).
-In this case, if the meta-function is an abstract type, it needs to be manipulated adding and removing a reference to it (see also [@../../test/abstract.cpp =abstract.cpp=]):
-
-[abstract]
-
-[endsect]
-
-[section Annex: Usage]
-
-The [macroref BOOST_IDENTITY_TYPE] macro can be used either when calling a user-defined macro (as shown by the examples so far), or internally when implementing a user-defined macro (as shown below).
-When [macroref BOOST_IDENTITY_TYPE] is used in the implementation of the user-defined macro, the caller of the user macro will have to specify the extra parenthesis (see also [@../../test/paren.cpp =paren.cpp=]):
-
-[paren]
-
-However, note that the caller will /always/ have to specify the extra parenthesis even when the macro parameters contain no comma:
-
-[paren_always]
-
-In some cases, using [macroref BOOST_IDENTITY_TYPE] in the implementation of the user-defined macro might provide the best syntax for the caller.
-For example, this is the case for `BOOST_MPL_ASSERT` because the majority of template meta-programming expressions contain unwrapped commas so it is less confusing for the user to always specify the extra parenthesis `((...))` instead of using [macroref BOOST_IDENTITY_TYPE]:
-
-    BOOST_MPL_ASSERT(( // Natural syntax.
-        boost::mpl::and_<
-              boost::is_const<T>
-            , boost::is_reference<T>
-        >
-    ));
-
-However, in other situations it might be preferable to not require the extra parenthesis in the common cases and handle commas as special cases using [macroref BOOST_IDENTITY_TYPE].
-For example, this is the case for [@http://www.boost.org/libs/local_function `BOOST_LOCAL_FUNCTION`] for which always requiring the extra parenthesis `((...))` around the types would lead to an unnatural syntax for the local function signature:
-
-    int BOOST_LOCAL_FUNCTION( ((int&)) x, ((int&)) y ) { // Unnatural syntax.
-        return x + y;
-    } BOOST_LOCAL_FUNCTION_NAME(add)
-
-Instead requiring the user to specify [macroref BOOST_IDENTITY_TYPE] only when needed allows for the more natural syntax `BOOST_LOCAL_FUNCTION(int& x, int& y)` in the common cases when the parameter types contain no comma (while still allowing to specify parameter types with commas as special cases using `BOOST_LOCAL_FUNCTION(BOOST_IDENTITY_TYPE((std::map<int, char>))& x, int& y)`).
-
-[endsect]
-
-[section Annex: Implementation]
-
-The implementation of this library macro is equivalent to the following:
-[footnote
-There is absolutely no guarantee that the macro is actually implemented using the code listed in this documentation.
-The listed code is for explanatory purposes only.
-]
-
-    #include <boost/type_traits/function_traits.hpp>
-    
-    #define BOOST_IDENTITY_TYPE(parenthesized_type) \
-        boost::function_traits<void parenthesized_type>::arg1_type
-
-Essentially, the type is wrapped between round parenthesis `(std::map<int, char>)` so it can be passed as a single macro parameter even if it contains commas.
-Then the parenthesized type is transformed into the type of a function returning `void` and with the specified type as the type of the first and only argument `void (std::map<int, char>)`.
-Finally, the type of the first argument `arg1_type` is extracted at compile-time using the `function_traits` meta-function therefore obtaining the original type from the parenthesized type (effectively stripping the extra parenthesis from around the specified type).
-
-[endsect]
-
-[xinclude reference.xml]
-

identity_type/index.html

@@ -1,15 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-  <head>
-    <meta http-equiv="refresh" content="0; URL=doc/html/index.html">
-  </head>
-  <body>
-    Automatic redirection failed, click this 
-    <a href="doc/html/index.html">link</a> &nbsp;<hr>
-    <p>© Copyright Lorenzo Caminiti, 2009-2012</p>
-    <p>Distributed under the Boost Software License, Version 1.0 (see 
-    accompanying file <a href="../../../LICENSE_1_0.txt">
-    LICENSE_1_0.txt</a> or a copy at
-    <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
-  </body>
-</html>

identity_type/test/Jamfile.v2

@@ -1,16 +0,0 @@
-
-# Copyright (C) 2009-2012 Lorenzo Caminiti
-# Distributed under the Boost Software License, Version 1.0
-# (see accompanying file LICENSE_1_0.txt or a copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-# Home at http://www.boost.org/libs/utility/identity_type
-
-import testing ;
-
-compile-fail var_error.cpp ;
-run var.cpp ;
-run template.cpp ;
-run abstract.cpp ;
-run noncopyable.cpp ;
-run paren.cpp ;
-

identity_type/test/abstract.cpp

@@ -1,35 +0,0 @@
-
-// Copyright (C) 2009-2012 Lorenzo Caminiti
-// Distributed under the Boost Software License, Version 1.0
-// (see accompanying file LICENSE_1_0.txt or a copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// Home at http://www.boost.org/libs/utility/identity_type
-
-#include <boost/utility/identity_type.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-
-//[abstract
-#define TMP_ASSERT(metafunction) \
-    BOOST_STATIC_ASSERT(metafunction::value)
-
-template<typename T, bool b>
-struct abstract {
-    static const bool value = b;
-    virtual void f(T const& x) = 0;     // Pure virtual function.
-};
-
-TMP_ASSERT(
-    boost::remove_reference<            // Add and remove
-        BOOST_IDENTITY_TYPE((           // reference for
-            boost::add_reference<       // abstract type.
-                abstract<int, true>
-            >::type
-        ))
-    >::type
-);
-//]
-
-int main() { return 0; }
-

identity_type/test/noncopyable.cpp

@@ -1,25 +0,0 @@
-
-// Copyright (C) 2009-2012 Lorenzo Caminiti
-// Distributed under the Boost Software License, Version 1.0
-// (see accompanying file LICENSE_1_0.txt or a copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// Home at http://www.boost.org/libs/utility/identity_type
-
-#include <boost/utility/identity_type.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/noncopyable.hpp>
-
-//[noncopyable
-#define TMP_ASSERT(metafunction) \
-    BOOST_STATIC_ASSERT(metafunction::value)
-
-template<typename T, T init>
-struct noncopyable : boost::noncopyable {
-    static const T value = init;
-};
-
-TMP_ASSERT(BOOST_IDENTITY_TYPE((noncopyable<bool, true>)));
-//]
-
-int main() { return 0; }
-

identity_type/test/paren.cpp

@@ -1,35 +0,0 @@
-
-// Copyright (C) 2009-2012 Lorenzo Caminiti
-// Distributed under the Boost Software License, Version 1.0
-// (see accompanying file LICENSE_1_0.txt or a copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// Home at http://www.boost.org/libs/utility/identity_type
-
-#include <boost/utility/identity_type.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <map>
-
-//[paren
-#define TMP_ASSERT_PAREN(parenthesized_metafunction) \
-    /* use `BOOST_IDENTITY_TYPE` in macro definition instead of invocation */ \
-    BOOST_STATIC_ASSERT(BOOST_IDENTITY_TYPE(parenthesized_metafunction)::value)
-
-#define TMP_ASSERT(metafunction) \
-    BOOST_STATIC_ASSERT(metafunction::value)
-
-// Specify only extra parenthesis `((...))`.
-TMP_ASSERT_PAREN((boost::is_const<std::map<int, char> const>));
-
-// Specify both the extra parenthesis `((...))` and `BOOST_IDENTITY_TYPE` macro.
-TMP_ASSERT(BOOST_IDENTITY_TYPE((boost::is_const<std::map<int, char> const>)));
-//]
-
-//[paren_always
-TMP_ASSERT_PAREN((boost::is_const<int const>)); // Always extra `((...))`.
-
-TMP_ASSERT(boost::is_const<int const>); // No extra `((...))` and no macro.
-//]
-
-int main() { return 0; }
-

identity_type/test/template.cpp

@@ -1,48 +0,0 @@
-
-// Copyright (C) 2009-2012 Lorenzo Caminiti
-// Distributed under the Boost Software License, Version 1.0
-// (see accompanying file LICENSE_1_0.txt or a copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// Home at http://www.boost.org/libs/utility/identity_type
-
-#include <boost/utility/identity_type.hpp>
-#include <map>
-#include <iostream>
-
-//[template_f_decl
-#define ARG(type, n) type arg ## n
-
-template<typename T>
-void f( // Prefix macro with `typename` in templates.
-    ARG(typename BOOST_IDENTITY_TYPE((std::map<int, T>)), 1)
-) {
-    std::cout << arg1[0] << std::endl;
-}
-//]
-
-//[template_g_decl
-template<typename T>
-void g(
-    std::map<int, T> arg1
-) {
-    std::cout << arg1[0] << std::endl;
-}
-//]
-
-int main() {
-    //[template_f_call
-    std::map<int, char> a;
-    a[0] = 'a';
-    
-    f<char>(a); // OK...
-    // f(a);    // ... but error.
-    //]
-
-    //[template_g_call
-    g<char>(a); // OK...
-    g(a);       // ... and also OK.
-    //]
-    
-    return 0;
-}
-

identity_type/test/var.cpp

@@ -1,26 +0,0 @@
-
-// Copyright (C) 2009-2012 Lorenzo Caminiti
-// Distributed under the Boost Software License, Version 1.0
-// (see accompanying file LICENSE_1_0.txt or a copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// Home at http://www.boost.org/libs/utility/identity_type
-
-#include <map>
-
-#define VAR(type, n) type var ## n
-
-VAR(int, 1); // OK.
-
-//[var_typedef
-typedef std::map<int, char> map_type;
-VAR(map_type, 3); // OK.
-//]
-
-//[var_ok
-#include <boost/utility/identity_type.hpp>
-
-VAR(BOOST_IDENTITY_TYPE((std::map<int, char>)), 4); // OK.
-//]
-
-int main() { return 0; }
-

identity_type/test/var_error.cpp

@@ -1,18 +0,0 @@
-
-// Copyright (C) 2009-2012 Lorenzo Caminiti
-// Distributed under the Boost Software License, Version 1.0
-// (see accompanying file LICENSE_1_0.txt or a copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// Home at http://www.boost.org/libs/utility/identity_type
-
-#include <map>
-
-//[var_error
-#define VAR(type, n) type var ## n
-
-VAR(int, 1);                    // OK.
-VAR(std::map<int, char>, 2);    // Error.
-//]
-
-int main() { return 0; }
-

in_place_factories.html

@@ -1,296 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//SoftQuad Software//DTD HoTMetaL PRO 5.0::19981217::extensions to HTML 4.0//EN" "hmpro5.dtd">
-
-<HTML>
-
-<HEAD>
-<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=windows-1252">
-<TITLE>In_place_factory Documentation</TITLE>
-</HEAD>
-
-<BODY BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#800080">
-<H2 align="left"><IMG SRC="../../boost.png" WIDTH="276" HEIGHT="86"></H2>
-
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <blockquote>
-        <blockquote>
-          <blockquote>
-<H2 align="left">Header &lt;<A
-HREF="../../boost/utility/in_place_factory.hpp">boost/utility/in_place_factory.hpp</A>&gt; </H2>
-
-<H2 align="left">Header &lt;<A
-HREF="../../boost/utility/typed_in_place_factory.hpp">boost/utility/typed_in_place_factory.hpp</A>&gt; </H2>
-
-          </blockquote>
-        </blockquote>
-      </blockquote>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>&nbsp;</p>
-
-<H2>Contents</H2>
-<DL CLASS="page-index">
-  <DT><A HREF="#mot">Motivation</A></DT>
-  <DT><A HREF="#framework">Framework</A></DT>
-  <DT><A HREF="#specification">Specification</A></DT>
-  <DT><A HREF="#container-usage">Container-side Usage</A></DT>
-  <DT><A HREF="#user-usage">User-side Usage</A></DT>
-</DL>
-
-<HR>
-
-<H2><A NAME="mot"></A>Motivation</H2>
-
-<p>Suppose we have a class</p>
-<pre>struct X
-{
-  X ( int, std::string ) ;
-} ;</pre>
-<p>And a container for it which supports an empty state (that is, which can contain zero objects):</p>
-<pre>struct C
-{
-   C() : contained_(0) {}
-  ~C() { delete contained_ ; }
-  X* contained_ ;
-} ;</pre>
-<p>A container designed to support an empty state typically doesn't require the contained type to be DefaultConstructible,
-but it typically requires it to be CopyConstructible as a mechanism to
-initialize the object to store:</p>
-<pre>struct C
-{
-   C() : contained_(0) {}
-   C ( X const& v ) : contained_ ( new X(v) ) {}
-  ~C() { delete contained_ ; }
-  X* contained_ ;
-} ;</pre>
-<p>There is a subtle problem with this: since the mechanism used to initialize the stored object is copy construction,
-there must exist a previously constructed source object to copy from. This
-object is likely to be temporary and serve no purpose besides being the source</p>
-<pre>void foo()
-{
-  // Temporary object created.
-  C c( X(123,"hello") ) ;
-}
-</pre>
-<p>A solution to this problem is to support direct construction of the contained
-object right in the container's storage.<br>
-In this scheme, the user supplies the arguments for the X constructor
-directly to the container:</p>
-<pre>struct C
-{
-   C() : contained_(0) {}
-   C ( X const& v ) : contained_ ( new X(v) ) {}
-   C ( int a0, std::string a1 ) : contained_ ( new X(a0,a1) ) {}
-  ~C() { delete contained_ ; }
-  X* contained_ ;
-} ;</pre>
-<pre>void foo()
-{
-  // Wrapped object constructed in-place
-  // No temporary created.
-  C c(123,"hello") ;
-}
-</pre>
-<p>Clearly, this solution doesn't scale well since the container must duplicate all the constructor overloads from the contained type
-(at least all those which are to be supported directly in the container).</p>
-
-<H2><A NAME="framework"></A>Framework</H2>
-<p>
-This library proposes a framework to allow some containers to directly contruct contained objects in-place without requiring
-the entire set of constructor overloads from the contained type. It also allows the container to remove the CopyConstuctible
-requirement from the contained type since objects can be directly constructed in-place without need of a copy.<br>
-The only requirement on the container is that it must provide proper storage (that is, correctly aligned and sized).
-Naturally, the container will typically support uninitialized storage to avoid the in-place construction to override
-a fully-constructed object (as this would defeat the purpose of in-place construction)
-</p>
-<p>For this purpose, the framework provides two families of classes collectively called: InPlaceFactories and TypedInPlaceFactories.<br>
-Essentially, these classes hold a sequence of actual parameters and a method to contruct an object in place using these parameters.
-Each member of the family differs only in the number (and type) of the parameter list. The first family
-takes the type of the object to construct directly in method provided for that
-purpose, whereas the second family incorporates that type in the factory class
-itself..</p>
-<p>From the container POV, using the framework amounts to calling the factory's method to contruct the object in place.
-From the user POV, it amounts to creating the right factory object to hold the parameters and pass it to the container.<br>
-The following simplified example shows the basic idea. A complete example follows the formal specification of the framework:</p>
-<pre>struct C
-{
-   template&lt;class InPlaceFactory&gt;
-   C ( InPlaceFactory const& aFactory )
-    :
-    contained_ ( uninitialized_storage() )
-   {
-     aFactory.template apply&lt;X&gt;(contained_);
-   }
-
-  ~C() 
-  { 
-    contained_ -> X::~X();
-    delete[] contained_ ; 
-  }
-
-  char* uninitialized_storage() { return new char[sizeof(X)] ; }
-
-  char* contained_ ;
-} ;
-
-void foo()
-{
-  C c( in_place(123,"hello") ) ;
-}
-</pre>
-
-<HR>
-
-<H2><A NAME="specification">Specification</A></H2>
-
-<p>The following is the first member of the family of 'in_place_factory' classes, along with its corresponding helper template function.
-The rest of the family varies only in the number and type of template (and constructor) parameters.</p>
-<PRE>namespace boost {
-
-struct in_place_factory_base {} ;
-
-template&lt;class A0&gt;
-class in_place_factory : public in_place_factory_base
-{
-  public:</PRE>
-
-<PRE>    in_place_factory ( A0 const& a0 ) : m_a0(a0) {}
-
-    template&lt; class T &gt;
-    void apply ( void* address ) const
-    {
-      new (address) T(m_a0);
-    }
-
-  private:</PRE>
-
-<PRE>    A0 const& m_a0 ;
-} ;
-
-template&lt;class A0&gt;
-in_place_factory&lt;A0&gt; in_place ( A0 const& a0 )
-{
-  return in_place_factory&lt;A0&gt;(a0);
-}
-</PRE>
-
-<p>Similarly, the following is the first member of the family of 'typed_in_place_factory' classes, along with its corresponding
-helper template function. The rest of the family varies only in the number and type of template (and constructor) parameters.</p>
-<PRE>namespace boost {
-
-struct typed_in_place_factory_base {} ;
-
-template&lt;class T, class A0&gt;
-class typed_in_place_factory : public typed_in_place_factory_base
-{
-  public:</PRE>
-
-<PRE>    typed_in_place_factory ( A0 const& a0 ) : m_a0(a0) {}
-
-    void apply ( void* address ) const
-    {
-      new (address) T(m_a0);
-    }
-
-  private:</PRE>
-
-<PRE>    A0 const& m_a0 ;
-} ;
-
-template&lt;class T, class A0&gt;
-typed_in_place_factory&lt;A0&gt; in_place ( A0 const& a0 )
-{
-  return typed_in_place_factory&lt;T,A0&gt;(a0);
-}</PRE>
-
-<PRE>}
-</PRE>
-
-<p>As you can see, the 'in_place_factory' and 'typed_in_place_factory' template classes varies only in the way they specify
-the target type: in the first family, the type is given as a template argument to the apply member function while in the
-second it is given directly as part of the factory class.<br>
-When the container holds a unique non-polymorphic type (such as the case of Boost.Optional), it knows the exact dynamic-type
-of the contained object and can pass it to the apply() method of a (non-typed) factory.
-In this case, end users can use an 'in_place_factory' instance which can be constructed without the type of the object to construct.<br>
-However, if the container holds heterogeneous or polymorphic objects (such as the case of Boost.Variant), the dynamic-type
-of the object to be constructed must be known by the factory itslef. In this case, end users must use a 'typed_in_place_factory'
-instead.</p>
-
-<HR>
-
-<h2><A NAME="container-usage">Container-side Usage</a></h2>
-
-<p>As shown in the introductory simplified example, the container class must
-contain methods that accept an instance of
-these factories and pass the object's storage to the factory's apply method.<br>
-However, the type of the factory class cannot be completly specified in the container class because that would
-defeat the whole purpose of the factories which is to allow the container to accept a variadic argument list
-for the constructor of its contained object.<br>
-The correct function overload must be based on the only distinctive and common
-characteristic of all the classes in each family, the base class.<br>
-Depending on the container class, you can use 'enable_if' to generate the right overload, or use the following
-dispatch technique (used in the Boost.Optional class):
-</p>
-<pre>struct C
-{
-   C() : contained_(0) {}
-   C ( X const& v ) : contained_ ( new X(v) ) {}
-
-   template&lt;class Expr&gt
-   C ( Expr const& expr )
-    :
-    contained_ ( uninitialized_storage() )
-   {
-    construct(expr,&expr)
-   }
-
-  ~C() { delete contained_ ; }
-
-  template&lt;class InPlaceFactory&gt;
-  void construct ( InPlaceFactory const& aFactory, boost::in_place_factory_base* )
-  {
-    aFactory.template apply&lt;X&gt;(contained_);
-  }
-
-  template&lt;class TypedInPlaceFactory&gt;
-  void construct ( TypedInPlaceFactory const& aFactory, boost::typed_in_place_factory_base* )
-  {
-    aFactory.apply(contained_);
-  }
-
-  X* uninitialized_storage() { return static_cast&lt;X*&gt;(new char[sizeof(X)]) ; }
-
-  X* contained_ ;
-} ;
-</pre>
-
-<hr>
-
-<h2><A NAME="user-usage">User-side Usage</a></h2>
-
-<p>End users pass to the container an instance of a factory object holding the actual parameters needed to construct the
-contained object directly within the container. For this, the helper template function 'in_place' is used.<br>
-The call 'in_place(a0,a1,a2,...,an)' constructs a (non-typed) 'in_place_factory' instance with the given argument list.<br>
-The call 'in_place&lt;T&gt;(a0,a1,a2,...,an)' constructs a 'typed_in_place_factory' instance with the given argument list for the
-type 'T'.</p>
-<pre>void foo()
-{
-  C a( in_place(123,"hello") ) ;    // in_place_factory passed
-  C b( in_place&lt;X&gt;(456,"world") ) ; // typed_in_place_factory passed
-}
-</pre>
-
-<P>Revised September 17, 2004</P>
-<p>© Copyright Fernando Luis Cacciola Carballal, 2004</p>
-<p> Use, modification, and distribution are subject to the Boost Software
-License, Version 1.0. (See accompanying file <a href="../../LICENSE_1_0.txt">
-LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
-www.boost.org/LICENSE_1_0.txt</a>)</p>
-<P>Developed by <A HREF="mailto:fernando_cacciola@hotmail.com">Fernando Cacciola</A>,
-the latest version of this file can be found at <A
-HREF="http://www.boost.org">www.boost.org</A>, and the boost
-<A HREF="http://www.boost.org/more/mailing_lists.htm#main">discussion lists</A></P>
-</BODY>
-</HTML>

include/boost/call_traits.hpp

@@ -1,20 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/utility for most recent version including documentation.
-
-//  See boost/detail/call_traits.hpp
-//  for full copyright notices.
-
-#ifndef BOOST_CALL_TRAITS_HPP
-#define BOOST_CALL_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#include <boost/detail/call_traits.hpp>
-
-#endif // BOOST_CALL_TRAITS_HPP

include/boost/compressed_pair.hpp

@@ -1,20 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/utility for most recent version including documentation.
-
-//  See boost/detail/compressed_pair.hpp
-//  for full copyright notices.
-
-#ifndef BOOST_COMPRESSED_PAIR_HPP
-#define BOOST_COMPRESSED_PAIR_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#include <boost/detail/compressed_pair.hpp>
-
-#endif // BOOST_COMPRESSED_PAIR_HPP

include/boost/detail/call_traits.hpp

@@ -1,172 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/utility for most recent version including documentation.
-
-// call_traits: defines typedefs for function usage
-// (see libs/utility/call_traits.htm)
-
-/* Release notes:
-   23rd July 2000:
-      Fixed array specialization. (JM)
-      Added Borland specific fixes for reference types
-      (issue raised by Steve Cleary).
-*/
-
-#ifndef BOOST_DETAIL_CALL_TRAITS_HPP
-#define BOOST_DETAIL_CALL_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-#include <cstddef>
-
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits/is_enum.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/detail/workaround.hpp>
-
-namespace boost{
-
-namespace detail{
-
-template <typename T, bool small_>
-struct ct_imp2
-{
-   typedef const T& param_type;
-};
-
-template <typename T>
-struct ct_imp2<T, true>
-{
-   typedef const T param_type;
-};
-
-template <typename T, bool isp, bool b1, bool b2>
-struct ct_imp
-{
-   typedef const T& param_type;
-};
-
-template <typename T, bool isp, bool b2>
-struct ct_imp<T, isp, true, b2>
-{
-   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
-};
-
-template <typename T, bool isp, bool b1>
-struct ct_imp<T, isp, b1, true>
-{
-   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
-};
-
-template <typename T, bool b1, bool b2>
-struct ct_imp<T, true, b1, b2>
-{
-   typedef const T param_type;
-};
-
-}
-
-template <typename T>
-struct call_traits
-{
-public:
-   typedef T value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   //
-   // C++ Builder workaround: we should be able to define a compile time
-   // constant and pass that as a single template parameter to ct_imp<T,bool>,
-   // however compiler bugs prevent this - instead pass three bool's to
-   // ct_imp<T,bool,bool,bool> and add an extra partial specialisation
-   // of ct_imp to handle the logic. (JM)
-   typedef typename boost::detail::ct_imp<
-      T,
-      ::boost::is_pointer<T>::value,
-      ::boost::is_arithmetic<T>::value,
-      ::boost::is_enum<T>::value
-   >::param_type param_type;
-};
-
-template <typename T>
-struct call_traits<T&>
-{
-   typedef T& value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef T& param_type;  // hh removed const
-};
-
-#if BOOST_WORKAROUND( __BORLANDC__,  < 0x5A0 )
-// these are illegal specialisations; cv-qualifies applied to
-// references have no effect according to [8.3.2p1],
-// C++ Builder requires them though as it treats cv-qualified
-// references as distinct types...
-template <typename T>
-struct call_traits<T&const>
-{
-   typedef T& value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef T& param_type;  // hh removed const
-};
-template <typename T>
-struct call_traits<T&volatile>
-{
-   typedef T& value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef T& param_type;  // hh removed const
-};
-template <typename T>
-struct call_traits<T&const volatile>
-{
-   typedef T& value_type;
-   typedef T& reference;
-   typedef const T& const_reference;
-   typedef T& param_type;  // hh removed const
-};
-
-template <typename T>
-struct call_traits< T * >
-{
-   typedef T * value_type;
-   typedef T * & reference;
-   typedef T * const & const_reference;
-   typedef T * const param_type;  // hh removed const
-};
-#endif
-#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
-template <typename T, std::size_t N>
-struct call_traits<T [N]>
-{
-private:
-   typedef T array_type[N];
-public:
-   // degrades array to pointer:
-   typedef const T* value_type;
-   typedef array_type& reference;
-   typedef const array_type& const_reference;
-   typedef const T* const param_type;
-};
-
-template <typename T, std::size_t N>
-struct call_traits<const T [N]>
-{
-private:
-   typedef const T array_type[N];
-public:
-   // degrades array to pointer:
-   typedef const T* value_type;
-   typedef array_type& reference;
-   typedef const array_type& const_reference;
-   typedef const T* const param_type;
-};
-#endif
-
-}
-
-#endif // BOOST_DETAIL_CALL_TRAITS_HPP

include/boost/detail/compressed_pair.hpp

@@ -1,452 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/utility for most recent version including documentation.
-
-// compressed_pair: pair that "compresses" empty members
-// (see libs/utility/doc/html/compressed_pair.html)
-//
-// JM changes 25 Jan 2004:
-// For the case where T1 == T2 and both are empty, then first() and second()
-// should return different objects.
-// JM changes 25 Jan 2000:
-// Removed default arguments from compressed_pair_switch to get
-// C++ Builder 4 to accept them
-// rewriten swap to get gcc and C++ builder to compile.
-// added partial specialisations for case T1 == T2 to avoid duplicate constructor defs.
-
-#ifndef BOOST_DETAIL_COMPRESSED_PAIR_HPP
-#define BOOST_DETAIL_COMPRESSED_PAIR_HPP
-
-#include <algorithm>
-
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/is_empty.hpp>
-#include <boost/type_traits/is_final.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/call_traits.hpp>
-
-#ifdef BOOST_MSVC
-# pragma warning(push)
-# pragma warning(disable:4512)
-#endif 
-namespace boost
-{
-
-template <class T1, class T2>
-class compressed_pair;
-
-
-// compressed_pair
-
-namespace details
-{
-   template<class T, bool E = boost::is_final<T>::value>
-   struct compressed_pair_empty
-      : ::boost::false_type { };
-
-   template<class T>
-   struct compressed_pair_empty<T, false>
-      : ::boost::is_empty<T> { };
-
-   // JM altered 26 Jan 2000:
-   template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty>
-   struct compressed_pair_switch;
-
-   template <class T1, class T2>
-   struct compressed_pair_switch<T1, T2, false, false, false>
-      {static const int value = 0;};
-
-   template <class T1, class T2>
-   struct compressed_pair_switch<T1, T2, false, true, true>
-      {static const int value = 3;};
-
-   template <class T1, class T2>
-   struct compressed_pair_switch<T1, T2, false, true, false>
-      {static const int value = 1;};
-
-   template <class T1, class T2>
-   struct compressed_pair_switch<T1, T2, false, false, true>
-      {static const int value = 2;};
-
-   template <class T1, class T2>
-   struct compressed_pair_switch<T1, T2, true, true, true>
-      {static const int value = 4;};
-
-   template <class T1, class T2>
-   struct compressed_pair_switch<T1, T2, true, false, false>
-      {static const int value = 5;};
-
-   template <class T1, class T2, int Version> class compressed_pair_imp;
-
-#ifdef __GNUC__
-   // workaround for GCC (JM):
-   using std::swap;
-#endif
-   //
-   // can't call unqualified swap from within classname::swap
-   // as Koenig lookup rules will find only the classname::swap
-   // member function not the global declaration, so use cp_swap
-   // as a forwarding function (JM):
-   template <typename T>
-   inline void cp_swap(T& t1, T& t2)
-   {
-#ifndef __GNUC__
-      using std::swap;
-#endif
-      swap(t1, t2);
-   }
-
-   // 0    derive from neither
-
-   template <class T1, class T2>
-   class compressed_pair_imp<T1, T2, 0>
-   {
-   public:
-      typedef T1                                                 first_type;
-      typedef T2                                                 second_type;
-      typedef typename call_traits<first_type>::param_type       first_param_type;
-      typedef typename call_traits<second_type>::param_type      second_param_type;
-      typedef typename call_traits<first_type>::reference        first_reference;
-      typedef typename call_traits<second_type>::reference       second_reference;
-      typedef typename call_traits<first_type>::const_reference  first_const_reference;
-      typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-      compressed_pair_imp() {} 
-
-      compressed_pair_imp(first_param_type x, second_param_type y)
-         : first_(x), second_(y) {}
-
-      compressed_pair_imp(first_param_type x)
-         : first_(x) {}
-
-      compressed_pair_imp(second_param_type y)
-         : second_(y) {}
-
-      first_reference       first()       {return first_;}
-      first_const_reference first() const {return first_;}
-
-      second_reference       second()       {return second_;}
-      second_const_reference second() const {return second_;}
-
-      void swap(::boost::compressed_pair<T1, T2>& y)
-      {
-         cp_swap(first_, y.first());
-         cp_swap(second_, y.second());
-      }
-   private:
-      first_type first_;
-      second_type second_;
-   };
-
-   // 1    derive from T1
-
-   template <class T1, class T2>
-   class compressed_pair_imp<T1, T2, 1>
-      : protected ::boost::remove_cv<T1>::type
-   {
-   public:
-      typedef T1                                                 first_type;
-      typedef T2                                                 second_type;
-      typedef typename call_traits<first_type>::param_type       first_param_type;
-      typedef typename call_traits<second_type>::param_type      second_param_type;
-      typedef typename call_traits<first_type>::reference        first_reference;
-      typedef typename call_traits<second_type>::reference       second_reference;
-      typedef typename call_traits<first_type>::const_reference  first_const_reference;
-      typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-      compressed_pair_imp() {}
-
-      compressed_pair_imp(first_param_type x, second_param_type y)
-         : first_type(x), second_(y) {}
-
-      compressed_pair_imp(first_param_type x)
-         : first_type(x) {}
-
-      compressed_pair_imp(second_param_type y)
-         : second_(y) {}
-
-      first_reference       first()       {return *this;}
-      first_const_reference first() const {return *this;}
-
-      second_reference       second()       {return second_;}
-      second_const_reference second() const {return second_;}
-
-      void swap(::boost::compressed_pair<T1,T2>& y)
-      {
-         // no need to swap empty base class:
-         cp_swap(second_, y.second());
-      }
-   private:
-      second_type second_;
-   };
-
-   // 2    derive from T2
-
-   template <class T1, class T2>
-   class compressed_pair_imp<T1, T2, 2>
-      : protected ::boost::remove_cv<T2>::type
-   {
-   public:
-      typedef T1                                                 first_type;
-      typedef T2                                                 second_type;
-      typedef typename call_traits<first_type>::param_type       first_param_type;
-      typedef typename call_traits<second_type>::param_type      second_param_type;
-      typedef typename call_traits<first_type>::reference        first_reference;
-      typedef typename call_traits<second_type>::reference       second_reference;
-      typedef typename call_traits<first_type>::const_reference  first_const_reference;
-      typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-      compressed_pair_imp() {}
-
-      compressed_pair_imp(first_param_type x, second_param_type y)
-         : second_type(y), first_(x) {}
-
-      compressed_pair_imp(first_param_type x)
-         : first_(x) {}
-
-      compressed_pair_imp(second_param_type y)
-         : second_type(y) {}
-
-      first_reference       first()       {return first_;}
-      first_const_reference first() const {return first_;}
-
-      second_reference       second()       {return *this;}
-      second_const_reference second() const {return *this;}
-
-      void swap(::boost::compressed_pair<T1,T2>& y)
-      {
-         // no need to swap empty base class:
-         cp_swap(first_, y.first());
-      }
-
-   private:
-      first_type first_;
-   };
-
-   // 3    derive from T1 and T2
-
-   template <class T1, class T2>
-   class compressed_pair_imp<T1, T2, 3>
-      : protected ::boost::remove_cv<T1>::type,
-        protected ::boost::remove_cv<T2>::type
-   {
-   public:
-      typedef T1                                                 first_type;
-      typedef T2                                                 second_type;
-      typedef typename call_traits<first_type>::param_type       first_param_type;
-      typedef typename call_traits<second_type>::param_type      second_param_type;
-      typedef typename call_traits<first_type>::reference        first_reference;
-      typedef typename call_traits<second_type>::reference       second_reference;
-      typedef typename call_traits<first_type>::const_reference  first_const_reference;
-      typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-      compressed_pair_imp() {}
-
-      compressed_pair_imp(first_param_type x, second_param_type y)
-         : first_type(x), second_type(y) {}
-
-      compressed_pair_imp(first_param_type x)
-         : first_type(x) {}
-
-      compressed_pair_imp(second_param_type y)
-         : second_type(y) {}
-
-      first_reference       first()       {return *this;}
-      first_const_reference first() const {return *this;}
-
-      second_reference       second()       {return *this;}
-      second_const_reference second() const {return *this;}
-      //
-      // no need to swap empty bases:
-      void swap(::boost::compressed_pair<T1,T2>&) {}
-   };
-
-   // JM
-   // 4    T1 == T2, T1 and T2 both empty
-   //      Originally this did not store an instance of T2 at all
-   //      but that led to problems beause it meant &x.first() == &x.second()
-   //      which is not true for any other kind of pair, so now we store an instance
-   //      of T2 just in case the user is relying on first() and second() returning
-   //      different objects (albeit both empty).
-   template <class T1, class T2>
-   class compressed_pair_imp<T1, T2, 4>
-      : protected ::boost::remove_cv<T1>::type
-   {
-   public:
-      typedef T1                                                 first_type;
-      typedef T2                                                 second_type;
-      typedef typename call_traits<first_type>::param_type       first_param_type;
-      typedef typename call_traits<second_type>::param_type      second_param_type;
-      typedef typename call_traits<first_type>::reference        first_reference;
-      typedef typename call_traits<second_type>::reference       second_reference;
-      typedef typename call_traits<first_type>::const_reference  first_const_reference;
-      typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-      compressed_pair_imp() {}
-
-      compressed_pair_imp(first_param_type x, second_param_type y)
-         : first_type(x), m_second(y) {}
-
-      compressed_pair_imp(first_param_type x)
-         : first_type(x), m_second(x) {}
-
-      first_reference       first()       {return *this;}
-      first_const_reference first() const {return *this;}
-
-      second_reference       second()       {return m_second;}
-      second_const_reference second() const {return m_second;}
-
-      void swap(::boost::compressed_pair<T1,T2>&) {}
-   private:
-      T2 m_second;
-   };
-
-   // 5    T1 == T2 and are not empty:   //JM
-
-   template <class T1, class T2>
-   class compressed_pair_imp<T1, T2, 5>
-   {
-   public:
-      typedef T1                                                 first_type;
-      typedef T2                                                 second_type;
-      typedef typename call_traits<first_type>::param_type       first_param_type;
-      typedef typename call_traits<second_type>::param_type      second_param_type;
-      typedef typename call_traits<first_type>::reference        first_reference;
-      typedef typename call_traits<second_type>::reference       second_reference;
-      typedef typename call_traits<first_type>::const_reference  first_const_reference;
-      typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-      compressed_pair_imp() {}
-
-      compressed_pair_imp(first_param_type x, second_param_type y)
-         : first_(x), second_(y) {}
-
-      compressed_pair_imp(first_param_type x)
-         : first_(x), second_(x) {}
-
-      first_reference       first()       {return first_;}
-      first_const_reference first() const {return first_;}
-
-      second_reference       second()       {return second_;}
-      second_const_reference second() const {return second_;}
-
-      void swap(::boost::compressed_pair<T1, T2>& y)
-      {
-         cp_swap(first_, y.first());
-         cp_swap(second_, y.second());
-      }
-   private:
-      first_type first_;
-      second_type second_;
-   };
-
-}  // details
-
-template <class T1, class T2>
-class compressed_pair
-   : private ::boost::details::compressed_pair_imp<T1, T2,
-             ::boost::details::compressed_pair_switch<
-                    T1,
-                    T2,
-                    ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
-                    ::boost::details::compressed_pair_empty<T1>::value,
-                    ::boost::details::compressed_pair_empty<T2>::value>::value>
-{
-private:
-   typedef details::compressed_pair_imp<T1, T2,
-             ::boost::details::compressed_pair_switch<
-                    T1,
-                    T2,
-                    ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
-                    ::boost::details::compressed_pair_empty<T1>::value,
-                    ::boost::details::compressed_pair_empty<T2>::value>::value> base;
-public:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   typedef typename call_traits<first_type>::reference        first_reference;
-   typedef typename call_traits<second_type>::reference       second_reference;
-   typedef typename call_traits<first_type>::const_reference  first_const_reference;
-   typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-            compressed_pair() : base() {}
-            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
-   explicit compressed_pair(first_param_type x) : base(x) {}
-   explicit compressed_pair(second_param_type y) : base(y) {}
-
-   first_reference       first()       {return base::first();}
-   first_const_reference first() const {return base::first();}
-
-   second_reference       second()       {return base::second();}
-   second_const_reference second() const {return base::second();}
-
-   void swap(compressed_pair& y) { base::swap(y); }
-};
-
-// JM
-// Partial specialisation for case where T1 == T2:
-//
-template <class T>
-class compressed_pair<T, T>
-   : private details::compressed_pair_imp<T, T,
-             ::boost::details::compressed_pair_switch<
-                    T,
-                    T,
-                    ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
-                    ::boost::details::compressed_pair_empty<T>::value,
-                    ::boost::details::compressed_pair_empty<T>::value>::value>
-{
-private:
-   typedef details::compressed_pair_imp<T, T,
-             ::boost::details::compressed_pair_switch<
-                    T,
-                    T,
-                    ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
-                    ::boost::details::compressed_pair_empty<T>::value,
-                    ::boost::details::compressed_pair_empty<T>::value>::value> base;
-public:
-   typedef T                                                  first_type;
-   typedef T                                                  second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   typedef typename call_traits<first_type>::reference        first_reference;
-   typedef typename call_traits<second_type>::reference       second_reference;
-   typedef typename call_traits<first_type>::const_reference  first_const_reference;
-   typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-            compressed_pair() : base() {}
-            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
-#if !(defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530))
-   explicit 
-#endif
-      compressed_pair(first_param_type x) : base(x) {}
-
-   first_reference       first()       {return base::first();}
-   first_const_reference first() const {return base::first();}
-
-   second_reference       second()       {return base::second();}
-   second_const_reference second() const {return base::second();}
-
-   void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }
-};
-
-template <class T1, class T2>
-inline
-void
-swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
-{
-   x.swap(y);
-}
-
-} // boost
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif 
-
-#endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP
-

include/boost/detail/ob_compressed_pair.hpp

@@ -1,499 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/utility for most recent version including documentation.
-//  see libs/utility/compressed_pair.hpp
-//
-/* Release notes:
-   20 Jan 2001:
-        Fixed obvious bugs (David Abrahams)
-   07 Oct 2000:
-      Added better single argument constructor support.
-   03 Oct 2000:
-      Added VC6 support (JM).
-   23rd July 2000:
-      Additional comments added. (JM)
-   Jan 2000:
-      Original version: this version crippled for use with crippled compilers
-      - John Maddock Jan 2000.
-*/
-
-
-#ifndef BOOST_OB_COMPRESSED_PAIR_HPP
-#define BOOST_OB_COMPRESSED_PAIR_HPP
-
-#include <algorithm>
-#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
-#include <boost/type_traits/object_traits.hpp>
-#endif
-#ifndef BOOST_SAME_TRAITS_HPP
-#include <boost/type_traits/same_traits.hpp>
-#endif
-#ifndef BOOST_CALL_TRAITS_HPP
-#include <boost/call_traits.hpp>
-#endif
-
-namespace boost
-{
-#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
-//
-// use member templates to emulate
-// partial specialisation.  Note that due to
-// problems with overload resolution with VC6
-// each of the compressed_pair versions that follow
-// have one template single-argument constructor
-// in place of two specific constructors:
-//
-
-template <class T1, class T2>
-class compressed_pair;
-
-namespace detail{
-
-template <class A, class T1, class T2>
-struct best_conversion_traits
-{
-   typedef char one;
-   typedef char (&two)[2];
-   static A a;
-   static one test(T1);
-   static two test(T2);
-
-   enum { value = sizeof(test(a)) };
-};
-
-template <int>
-struct init_one;
-
-template <>
-struct init_one<1>
-{
-   template <class A, class T1, class T2>
-   static void init(const A& a, T1* p1, T2*)
-   {
-      *p1 = a;
-   }
-};
-
-template <>
-struct init_one<2>
-{
-   template <class A, class T1, class T2>
-   static void init(const A& a, T1*, T2* p2)
-   {
-      *p2 = a;
-   }
-};
-
-
-// T1 != T2, both non-empty
-template <class T1, class T2>
-class compressed_pair_0
-{
-private:
-   T1 _first;
-   T2 _second;
-public:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   typedef typename call_traits<first_type>::reference        first_reference;
-   typedef typename call_traits<second_type>::reference       second_reference;
-   typedef typename call_traits<first_type>::const_reference  first_const_reference;
-   typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-            compressed_pair_0() : _first(), _second() {}
-            compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {}
-   template <class A>
-   explicit compressed_pair_0(const A& val)
-   {
-      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, &_second);
-   }
-   compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x)
-      : _first(x.first()), _second(x.second()) {}
-
-#if 0
-  compressed_pair_0& operator=(const compressed_pair_0& x) {
-    cout << "assigning compressed pair 0" << endl;
-    _first = x._first;
-    _second = x._second;
-    cout << "finished assigning compressed pair 0" << endl;
-    return *this;
-  }
-#endif
-
-   first_reference       first()       { return _first; }
-   first_const_reference first() const { return _first; }
-
-   second_reference       second()       { return _second; }
-   second_const_reference second() const { return _second; }
-
-   void swap(compressed_pair_0& y)
-   {
-      using std::swap;
-      swap(_first, y._first);
-      swap(_second, y._second);
-   }
-};
-
-// T1 != T2, T2 empty
-template <class T1, class T2>
-class compressed_pair_1 : T2
-{
-private:
-   T1 _first;
-public:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   typedef typename call_traits<first_type>::reference        first_reference;
-   typedef typename call_traits<second_type>::reference       second_reference;
-   typedef typename call_traits<first_type>::const_reference  first_const_reference;
-   typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-            compressed_pair_1() : T2(), _first() {}
-            compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {}
-
-   template <class A>
-   explicit compressed_pair_1(const A& val)
-   {
-      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2*>(this));
-   }
-
-   compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x)
-      : T2(x.second()), _first(x.first()) {}
-
-   first_reference       first()       { return _first; }
-   first_const_reference first() const { return _first; }
-
-   second_reference       second()       { return *this; }
-   second_const_reference second() const { return *this; }
-
-   void swap(compressed_pair_1& y)
-   {
-      // no need to swap empty base class:
-      using std::swap;
-      swap(_first, y._first);
-   }
-};
-
-// T1 != T2, T1 empty
-template <class T1, class T2>
-class compressed_pair_2 : T1
-{
-private:
-   T2 _second;
-public:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   typedef typename call_traits<first_type>::reference        first_reference;
-   typedef typename call_traits<second_type>::reference       second_reference;
-   typedef typename call_traits<first_type>::const_reference  first_const_reference;
-   typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-            compressed_pair_2() : T1(), _second() {}
-            compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {}
-   template <class A>
-   explicit compressed_pair_2(const A& val)
-   {
-      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), &_second);
-   }
-   compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x)
-      : T1(x.first()), _second(x.second()) {}
-
-#if 0
-  compressed_pair_2& operator=(const compressed_pair_2& x) {
-    cout << "assigning compressed pair 2" << endl;
-    T1::operator=(x);
-    _second = x._second;
-    cout << "finished assigning compressed pair 2" << endl;
-    return *this;
-  }
-#endif
-   first_reference       first()       { return *this; }
-   first_const_reference first() const { return *this; }
-
-   second_reference       second()       { return _second; }
-   second_const_reference second() const { return _second; }
-
-   void swap(compressed_pair_2& y)
-   {
-      // no need to swap empty base class:
-      using std::swap;
-      swap(_second, y._second);
-   }
-};
-
-// T1 != T2, both empty
-template <class T1, class T2>
-class compressed_pair_3 : T1, T2
-{
-public:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   typedef typename call_traits<first_type>::reference        first_reference;
-   typedef typename call_traits<second_type>::reference       second_reference;
-   typedef typename call_traits<first_type>::const_reference  first_const_reference;
-   typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-            compressed_pair_3() : T1(), T2() {}
-            compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {}
-   template <class A>
-   explicit compressed_pair_3(const A& val)
-   {
-      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), static_cast<T2*>(this));
-   }
-   compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x)
-      : T1(x.first()), T2(x.second()) {}
-
-   first_reference       first()       { return *this; }
-   first_const_reference first() const { return *this; }
-
-   second_reference       second()       { return *this; }
-   second_const_reference second() const { return *this; }
-
-   void swap(compressed_pair_3& y)
-   {
-      // no need to swap empty base classes:
-   }
-};
-
-// T1 == T2, and empty
-template <class T1, class T2>
-class compressed_pair_4 : T1
-{
-public:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   typedef typename call_traits<first_type>::reference        first_reference;
-   typedef typename call_traits<second_type>::reference       second_reference;
-   typedef typename call_traits<first_type>::const_reference  first_const_reference;
-   typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-            compressed_pair_4() : T1() {}
-            compressed_pair_4(first_param_type x, second_param_type y) : T1(x), m_second(y) {}
-   // only one single argument constructor since T1 == T2
-   explicit compressed_pair_4(first_param_type x) : T1(x), m_second(x) {}
-   compressed_pair_4(const ::boost::compressed_pair<T1,T2>& x)
-      : T1(x.first()), m_second(x.second()) {}
-
-   first_reference       first()       { return *this; }
-   first_const_reference first() const { return *this; }
-
-   second_reference       second()       { return m_second; }
-   second_const_reference second() const { return m_second; }
-
-   void swap(compressed_pair_4& y)
-   {
-      // no need to swap empty base classes:
-   }
-private:
-   T2 m_second;
-};
-
-// T1 == T2, not empty
-template <class T1, class T2>
-class compressed_pair_5
-{
-private:
-   T1 _first;
-   T2 _second;
-public:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   typedef typename call_traits<first_type>::reference        first_reference;
-   typedef typename call_traits<second_type>::reference       second_reference;
-   typedef typename call_traits<first_type>::const_reference  first_const_reference;
-   typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-            compressed_pair_5() : _first(), _second() {}
-            compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {}
-   // only one single argument constructor since T1 == T2
-   explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {}
-   compressed_pair_5(const ::boost::compressed_pair<T1,T2>& c) 
-      : _first(c.first()), _second(c.second()) {}
-
-   first_reference       first()       { return _first; }
-   first_const_reference first() const { return _first; }
-
-   second_reference       second()       { return _second; }
-   second_const_reference second() const { return _second; }
-
-   void swap(compressed_pair_5& y)
-   {
-      using std::swap;
-      swap(_first, y._first);
-      swap(_second, y._second);
-   }
-};
-
-template <bool e1, bool e2, bool same>
-struct compressed_pair_chooser
-{
-   template <class T1, class T2>
-   struct rebind
-   {
-      typedef compressed_pair_0<T1, T2> type;
-   };
-};
-
-template <>
-struct compressed_pair_chooser<false, true, false>
-{
-   template <class T1, class T2>
-   struct rebind
-   {
-      typedef compressed_pair_1<T1, T2> type;
-   };
-};
-
-template <>
-struct compressed_pair_chooser<true, false, false>
-{
-   template <class T1, class T2>
-   struct rebind
-   {
-      typedef compressed_pair_2<T1, T2> type;
-   };
-};
-
-template <>
-struct compressed_pair_chooser<true, true, false>
-{
-   template <class T1, class T2>
-   struct rebind
-   {
-      typedef compressed_pair_3<T1, T2> type;
-   };
-};
-
-template <>
-struct compressed_pair_chooser<true, true, true>
-{
-   template <class T1, class T2>
-   struct rebind
-   {
-      typedef compressed_pair_4<T1, T2> type;
-   };
-};
-
-template <>
-struct compressed_pair_chooser<false, false, true>
-{
-   template <class T1, class T2>
-   struct rebind
-   {
-      typedef compressed_pair_5<T1, T2> type;
-   };
-};
-
-template <class T1, class T2>
-struct compressed_pair_traits
-{
-private:
-   typedef compressed_pair_chooser<is_empty<T1>::value, is_empty<T2>::value, is_same<T1,T2>::value> chooser;
-   typedef typename chooser::template rebind<T1, T2> bound_type;
-public:
-   typedef typename bound_type::type type;
-};
-
-} // namespace detail
-
-template <class T1, class T2>
-class compressed_pair : public detail::compressed_pair_traits<T1, T2>::type
-{
-private:
-   typedef typename detail::compressed_pair_traits<T1, T2>::type base_type;
-public:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   typedef typename call_traits<first_type>::reference        first_reference;
-   typedef typename call_traits<second_type>::reference       second_reference;
-   typedef typename call_traits<first_type>::const_reference  first_const_reference;
-   typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-            compressed_pair() : base_type() {}
-            compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {}
-   template <class A>
-   explicit compressed_pair(const A& x) : base_type(x){}
-
-   first_reference       first()       { return base_type::first(); }
-   first_const_reference first() const { return base_type::first(); }
-
-   second_reference       second()       { return base_type::second(); }
-   second_const_reference second() const { return base_type::second(); }
-};
-
-template <class T1, class T2>
-inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
-{
-   x.swap(y);
-}
-
-#else
-// no partial specialisation, no member templates:
-
-template <class T1, class T2>
-class compressed_pair
-{
-private:
-   T1 _first;
-   T2 _second;
-public:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   typedef typename call_traits<first_type>::reference        first_reference;
-   typedef typename call_traits<second_type>::reference       second_reference;
-   typedef typename call_traits<first_type>::const_reference  first_const_reference;
-   typedef typename call_traits<second_type>::const_reference second_const_reference;
-
-            compressed_pair() : _first(), _second() {}
-            compressed_pair(first_param_type x, second_param_type y) : _first(x), _second(y) {}
-   explicit compressed_pair(first_param_type x) : _first(x), _second() {}
-   // can't define this in case T1 == T2:
-   // explicit compressed_pair(second_param_type y) : _first(), _second(y) {}
-
-   first_reference       first()       { return _first; }
-   first_const_reference first() const { return _first; }
-
-   second_reference       second()       { return _second; }
-   second_const_reference second() const { return _second; }
-
-   void swap(compressed_pair& y)
-   {
-      using std::swap;
-      swap(_first, y._first);
-      swap(_second, y._second);
-   }
-};
-
-template <class T1, class T2>
-inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
-{
-   x.swap(y);
-}
-
-#endif
-
-} // boost
-
-#endif // BOOST_OB_COMPRESSED_PAIR_HPP
-
-
-

include/boost/operators.hpp

@@ -1,911 +0,0 @@
-//  Boost operators.hpp header file  ----------------------------------------//
-
-//  (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-2001.
-//  (C) Copyright Daniel Frey 2002-2017.
-//  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/libs/utility/operators.htm for documentation.
-
-//  Revision History
-//  23 Nov 17 Protect dereferenceable<> from overloaded operator&.
-//  15 Oct 17 Adapted to C++17, replace std::iterator<> with manual
-//            implementation.
-//  22 Feb 16 Added ADL protection, preserve old work-arounds in
-//            operators_v1.hpp and clean up this file. (Daniel Frey)
-//  16 Dec 10 Limit warning suppression for 4284 to older versions of VC++
-//            (Matthew Bradbury, fixes #4432)
-//  07 Aug 08 Added "euclidean" spelling. (Daniel Frey)
-//  03 Apr 08 Make sure "convertible to bool" is sufficient
-//            for T::operator<, etc. (Daniel Frey)
-//  24 May 07 Changed empty_base to depend on T, see
-//            http://svn.boost.org/trac/boost/ticket/979
-//  21 Oct 02 Modified implementation of operators to allow compilers with a
-//            correct named return value optimization (NRVO) to produce optimal
-//            code.  (Daniel Frey)
-//  02 Dec 01 Bug fixed in random_access_iteratable.  (Helmut Zeisel)
-//  28 Sep 01 Factored out iterator operator groups.  (Daryle Walker)
-//  27 Aug 01 'left' form for non commutative operators added;
-//            additional classes for groups of related operators added;
-//            workaround for empty base class optimization
-//            bug of GCC 3.0 (Helmut Zeisel)
-//  25 Jun 01 output_iterator_helper changes: removed default template
-//            parameters, added support for self-proxying, additional
-//            documentation and tests (Aleksey Gurtovoy)
-//  29 May 01 Added operator classes for << and >>.  Added input and output
-//            iterator helper classes.  Added classes to connect equality and
-//            relational operators.  Added classes for groups of related
-//            operators.  Reimplemented example operator and iterator helper
-//            classes in terms of the new groups.  (Daryle Walker, with help
-//            from Alexy Gurtovoy)
-//  11 Feb 01 Fixed bugs in the iterator helpers which prevented explicitly
-//            supplied arguments from actually being used (Dave Abrahams)
-//  04 Jul 00 Fixed NO_OPERATORS_IN_NAMESPACE bugs, major cleanup and
-//            refactoring of compiler workarounds, additional documentation
-//            (Alexy Gurtovoy and Mark Rodgers with some help and prompting from
-//            Dave Abrahams)
-//  28 Jun 00 General cleanup and integration of bugfixes from Mark Rodgers and
-//            Jeremy Siek (Dave Abrahams)
-//  20 Jun 00 Changes to accommodate Borland C++Builder 4 and Borland C++ 5.5
-//            (Mark Rodgers)
-//  20 Jun 00 Minor fixes to the prior revision (Aleksey Gurtovoy)
-//  10 Jun 00 Support for the base class chaining technique was added
-//            (Aleksey Gurtovoy). See documentation and the comments below
-//            for the details.
-//  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
-//  18 Nov 99 Change name "divideable" to "dividable", remove unnecessary
-//            specializations of dividable, subtractable, modable (Ed Brey)
-//  17 Nov 99 Add comments (Beman Dawes)
-//            Remove unnecessary specialization of operators<> (Ed Brey)
-//  15 Nov 99 Fix less_than_comparable<T,U> second operand type for first two
-//            operators.(Beman Dawes)
-//  12 Nov 99 Add operators templates (Ed Brey)
-//  11 Nov 99 Add single template parameter version for compilers without
-//            partial specialization (Beman Dawes)
-//  10 Nov 99 Initial version
-
-// 10 Jun 00:
-// An additional optional template parameter was added to most of
-// operator templates to support the base class chaining technique (see
-// documentation for the details). Unfortunately, a straightforward
-// implementation of this change would have broken compatibility with the
-// previous version of the library by making it impossible to use the same
-// template name (e.g. 'addable') for both the 1- and 2-argument versions of
-// an operator template. This implementation solves the backward-compatibility
-// issue at the cost of some simplicity.
-//
-// One of the complications is an existence of special auxiliary class template
-// 'is_chained_base<>' (see 'operators_detail' namespace below), which is used
-// to determine whether its template parameter is a library's operator template
-// or not. You have to specialize 'is_chained_base<>' for each new
-// operator template you add to the library.
-//
-// However, most of the non-trivial implementation details are hidden behind
-// several local macros defined below, and as soon as you understand them,
-// you understand the whole library implementation.
-
-#ifndef BOOST_OPERATORS_HPP
-#define BOOST_OPERATORS_HPP
-
-// If old work-arounds are needed, refer to the preserved version without
-// ADL protection.
-#if defined(BOOST_NO_OPERATORS_IN_NAMESPACE) || defined(BOOST_USE_OPERATORS_V1)
-#include "operators_v1.hpp"
-#else
-
-#include <cstddef>
-#include <iterator>
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/core/addressof.hpp>
-
-#if defined(__sgi) && !defined(__GNUC__)
-#   pragma set woff 1234
-#endif
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1600)
-#   pragma warning( disable : 4284 ) // complaint about return type of
-#endif                               // operator-> not begin a UDT
-
-// In this section we supply the xxxx1 and xxxx2 forms of the operator
-// templates, which are explicitly targeted at the 1-type-argument and
-// 2-type-argument operator forms, respectively.
-
-namespace boost
-{
-namespace operators_impl
-{
-namespace operators_detail
-{
-
-template <typename T> class empty_base {};
-
-} // namespace operators_detail
-
-//  Basic operator classes (contributed by Dave Abrahams) ------------------//
-
-//  Note that friend functions defined in a class are implicitly inline.
-//  See the C++ std, 11.4 [class.friend] paragraph 5
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct less_than_comparable2 : B
-{
-     friend bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
-     friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
-     friend bool operator>(const U& x, const T& y)  { return y < x; }
-     friend bool operator<(const U& x, const T& y)  { return y > x; }
-     friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
-     friend bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
-};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct less_than_comparable1 : B
-{
-     friend bool operator>(const T& x, const T& y)  { return y < x; }
-     friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
-     friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
-};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct equality_comparable2 : B
-{
-     friend bool operator==(const U& y, const T& x) { return x == y; }
-     friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
-     friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
-};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct equality_comparable1 : B
-{
-     friend bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
-};
-
-// A macro which produces "name_2left" from "name".
-#define BOOST_OPERATOR2_LEFT(name) name##2##_##left
-
-//  NRVO-friendly implementation (contributed by Daniel Frey) ---------------//
-
-#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-// This is the optimal implementation for ISO/ANSI C++,
-// but it requires the compiler to implement the NRVO.
-// If the compiler has no NRVO, this is the best symmetric
-// implementation available.
-
-#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                   \
-template <class T, class U, class B = operators_detail::empty_base<T> > \
-struct NAME##2 : B                                                      \
-{                                                                       \
-  friend T operator OP( const T& lhs, const U& rhs )                    \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
-  friend T operator OP( const U& lhs, const T& rhs )                    \
-    { T nrv( rhs ); nrv OP##= lhs; return nrv; }                        \
-};                                                                      \
-                                                                        \
-template <class T, class B = operators_detail::empty_base<T> >          \
-struct NAME##1 : B                                                      \
-{                                                                       \
-  friend T operator OP( const T& lhs, const T& rhs )                    \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
-};
-
-#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
-template <class T, class U, class B = operators_detail::empty_base<T> > \
-struct NAME##2 : B                                                      \
-{                                                                       \
-  friend T operator OP( const T& lhs, const U& rhs )                    \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
-};                                                                      \
-                                                                        \
-template <class T, class U, class B = operators_detail::empty_base<T> > \
-struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
-{                                                                       \
-  friend T operator OP( const U& lhs, const T& rhs )                    \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
-};                                                                      \
-                                                                        \
-template <class T, class B = operators_detail::empty_base<T> >          \
-struct NAME##1 : B                                                      \
-{                                                                       \
-  friend T operator OP( const T& lhs, const T& rhs )                    \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
-};
-
-#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-// For compilers without NRVO the following code is optimal, but not
-// symmetric!  Note that the implementation of
-// BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
-// optimization opportunities to the compiler :)
-
-#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                   \
-template <class T, class U, class B = operators_detail::empty_base<T> > \
-struct NAME##2 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
-  friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \
-};                                                                      \
-                                                                        \
-template <class T, class B = operators_detail::empty_base<T> >          \
-struct NAME##1 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
-};
-
-#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
-template <class T, class U, class B = operators_detail::empty_base<T> > \
-struct NAME##2 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
-};                                                                      \
-                                                                        \
-template <class T, class U, class B = operators_detail::empty_base<T> > \
-struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
-{                                                                       \
-  friend T operator OP( const U& lhs, const T& rhs )                    \
-    { return T( lhs ) OP##= rhs; }                                      \
-};                                                                      \
-                                                                        \
-template <class T, class B = operators_detail::empty_base<T> >          \
-struct NAME##1 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
-};
-
-#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-BOOST_BINARY_OPERATOR_COMMUTATIVE( multipliable, * )
-BOOST_BINARY_OPERATOR_COMMUTATIVE( addable, + )
-BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( subtractable, - )
-BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( dividable, / )
-BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( modable, % )
-BOOST_BINARY_OPERATOR_COMMUTATIVE( xorable, ^ )
-BOOST_BINARY_OPERATOR_COMMUTATIVE( andable, & )
-BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )
-
-#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
-#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
-#undef BOOST_OPERATOR2_LEFT
-
-//  incrementable and decrementable contributed by Jeremy Siek
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct incrementable : B
-{
-  friend T operator++(T& x, int)
-  {
-    incrementable_type nrv(x);
-    ++x;
-    return nrv;
-  }
-private: // The use of this typedef works around a Borland bug
-  typedef T incrementable_type;
-};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct decrementable : B
-{
-  friend T operator--(T& x, int)
-  {
-    decrementable_type nrv(x);
-    --x;
-    return nrv;
-  }
-private: // The use of this typedef works around a Borland bug
-  typedef T decrementable_type;
-};
-
-//  Iterator operator classes (contributed by Jeremy Siek) ------------------//
-
-template <class T, class P, class B = operators_detail::empty_base<T> >
-struct dereferenceable : B
-{
-  P operator->() const
-  {
-    return ::boost::addressof(*static_cast<const T&>(*this));
-  }
-};
-
-template <class T, class I, class R, class B = operators_detail::empty_base<T> >
-struct indexable : B
-{
-  R operator[](I n) const
-  {
-    return *(static_cast<const T&>(*this) + n);
-  }
-};
-
-//  More operator classes (contributed by Daryle Walker) --------------------//
-//  (NRVO-friendly implementation contributed by Daniel Frey) ---------------//
-
-#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-#define BOOST_BINARY_OPERATOR( NAME, OP )                               \
-template <class T, class U, class B = operators_detail::empty_base<T> > \
-struct NAME##2 : B                                                      \
-{                                                                       \
-  friend T operator OP( const T& lhs, const U& rhs )                    \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
-};                                                                      \
-                                                                        \
-template <class T, class B = operators_detail::empty_base<T> >          \
-struct NAME##1 : B                                                      \
-{                                                                       \
-  friend T operator OP( const T& lhs, const T& rhs )                    \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
-};
-
-#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-#define BOOST_BINARY_OPERATOR( NAME, OP )                               \
-template <class T, class U, class B = operators_detail::empty_base<T> > \
-struct NAME##2 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
-};                                                                      \
-                                                                        \
-template <class T, class B = operators_detail::empty_base<T> >          \
-struct NAME##1 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
-};
-
-#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-BOOST_BINARY_OPERATOR( left_shiftable, << )
-BOOST_BINARY_OPERATOR( right_shiftable, >> )
-
-#undef BOOST_BINARY_OPERATOR
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct equivalent2 : B
-{
-  friend bool operator==(const T& x, const U& y)
-  {
-    return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
-  }
-};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct equivalent1 : B
-{
-  friend bool operator==(const T&x, const T&y)
-  {
-    return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
-  }
-};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct partially_ordered2 : B
-{
-  friend bool operator<=(const T& x, const U& y)
-    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
-  friend bool operator>=(const T& x, const U& y)
-    { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
-  friend bool operator>(const U& x, const T& y)
-    { return y < x; }
-  friend bool operator<(const U& x, const T& y)
-    { return y > x; }
-  friend bool operator<=(const U& x, const T& y)
-    { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
-  friend bool operator>=(const U& x, const T& y)
-    { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
-};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct partially_ordered1 : B
-{
-  friend bool operator>(const T& x, const T& y)
-    { return y < x; }
-  friend bool operator<=(const T& x, const T& y)
-    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
-  friend bool operator>=(const T& x, const T& y)
-    { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
-};
-
-//  Combined operator classes (contributed by Daryle Walker) ----------------//
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct totally_ordered2
-    : less_than_comparable2<T, U
-    , equality_comparable2<T, U, B
-      > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct totally_ordered1
-    : less_than_comparable1<T
-    , equality_comparable1<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct additive2
-    : addable2<T, U
-    , subtractable2<T, U, B
-      > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct additive1
-    : addable1<T
-    , subtractable1<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct multiplicative2
-    : multipliable2<T, U
-    , dividable2<T, U, B
-      > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct multiplicative1
-    : multipliable1<T
-    , dividable1<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct integer_multiplicative2
-    : multiplicative2<T, U
-    , modable2<T, U, B
-      > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct integer_multiplicative1
-    : multiplicative1<T
-    , modable1<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct arithmetic2
-    : additive2<T, U
-    , multiplicative2<T, U, B
-      > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct arithmetic1
-    : additive1<T
-    , multiplicative1<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct integer_arithmetic2
-    : additive2<T, U
-    , integer_multiplicative2<T, U, B
-      > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct integer_arithmetic1
-    : additive1<T
-    , integer_multiplicative1<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct bitwise2
-    : xorable2<T, U
-    , andable2<T, U
-    , orable2<T, U, B
-      > > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct bitwise1
-    : xorable1<T
-    , andable1<T
-    , orable1<T, B
-      > > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct unit_steppable
-    : incrementable<T
-    , decrementable<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct shiftable2
-    : left_shiftable2<T, U
-    , right_shiftable2<T, U, B
-      > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct shiftable1
-    : left_shiftable1<T
-    , right_shiftable1<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct ring_operators2
-    : additive2<T, U
-    , subtractable2_left<T, U
-    , multipliable2<T, U, B
-      > > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct ring_operators1
-    : additive1<T
-    , multipliable1<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct ordered_ring_operators2
-    : ring_operators2<T, U
-    , totally_ordered2<T, U, B
-      > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct ordered_ring_operators1
-    : ring_operators1<T
-    , totally_ordered1<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct field_operators2
-    : ring_operators2<T, U
-    , dividable2<T, U
-    , dividable2_left<T, U, B
-      > > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct field_operators1
-    : ring_operators1<T
-    , dividable1<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct ordered_field_operators2
-    : field_operators2<T, U
-    , totally_ordered2<T, U, B
-      > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct ordered_field_operators1
-    : field_operators1<T
-    , totally_ordered1<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct euclidian_ring_operators2
-    : ring_operators2<T, U
-    , dividable2<T, U
-    , dividable2_left<T, U
-    , modable2<T, U
-    , modable2_left<T, U, B
-      > > > > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct euclidian_ring_operators1
-    : ring_operators1<T
-    , dividable1<T
-    , modable1<T, B
-      > > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct ordered_euclidian_ring_operators2
-    : totally_ordered2<T, U
-    , euclidian_ring_operators2<T, U, B
-      > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct ordered_euclidian_ring_operators1
-    : totally_ordered1<T
-    , euclidian_ring_operators1<T, B
-      > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct euclidean_ring_operators2
-    : ring_operators2<T, U
-    , dividable2<T, U
-    , dividable2_left<T, U
-    , modable2<T, U
-    , modable2_left<T, U, B
-      > > > > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct euclidean_ring_operators1
-    : ring_operators1<T
-    , dividable1<T
-    , modable1<T, B
-      > > > {};
-
-template <class T, class U, class B = operators_detail::empty_base<T> >
-struct ordered_euclidean_ring_operators2
-    : totally_ordered2<T, U
-    , euclidean_ring_operators2<T, U, B
-      > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct ordered_euclidean_ring_operators1
-    : totally_ordered1<T
-    , euclidean_ring_operators1<T, B
-      > > {};
-
-template <class T, class P, class B = operators_detail::empty_base<T> >
-struct input_iteratable
-    : equality_comparable1<T
-    , incrementable<T
-    , dereferenceable<T, P, B
-      > > > {};
-
-template <class T, class B = operators_detail::empty_base<T> >
-struct output_iteratable
-    : incrementable<T, B
-      > {};
-
-template <class T, class P, class B = operators_detail::empty_base<T> >
-struct forward_iteratable
-    : input_iteratable<T, P, B
-      > {};
-
-template <class T, class P, class B = operators_detail::empty_base<T> >
-struct bidirectional_iteratable
-    : forward_iteratable<T, P
-    , decrementable<T, B
-      > > {};
-
-//  To avoid repeated derivation from equality_comparable,
-//  which is an indirect base class of bidirectional_iterable,
-//  random_access_iteratable must not be derived from totally_ordered1
-//  but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001)
-template <class T, class P, class D, class R, class B = operators_detail::empty_base<T> >
-struct random_access_iteratable
-    : bidirectional_iteratable<T, P
-    , less_than_comparable1<T
-    , additive2<T, D
-    , indexable<T, D, R, B
-      > > > > {};
-
-
-//
-// Here's where we put it all together, defining the xxxx forms of the templates.
-// We also define specializations of is_chained_base<> for
-// the xxxx, xxxx1, and xxxx2 templates.
-//
-
-namespace operators_detail
-{
-
-// A type parameter is used instead of a plain bool because Borland's compiler
-// didn't cope well with the more obvious non-type template parameter.
-struct true_t {};
-struct false_t {};
-
-} // namespace operators_detail
-
-// is_chained_base<> - a traits class used to distinguish whether an operator
-// template argument is being used for base class chaining, or is specifying a
-// 2nd argument type.
-
-// Unspecialized version assumes that most types are not being used for base
-// class chaining. We specialize for the operator templates defined in this
-// library.
-template<class T> struct is_chained_base {
-  typedef operators_detail::false_t value;
-};
-
-// Provide a specialization of 'is_chained_base<>'
-// for a 4-type-argument operator template.
-# define BOOST_OPERATOR_TEMPLATE4(template_name4)           \
-  template<class T, class U, class V, class W, class B>     \
-  struct is_chained_base< template_name4<T, U, V, W, B> > { \
-    typedef operators_detail::true_t value;                 \
-  };
-
-// Provide a specialization of 'is_chained_base<>'
-// for a 3-type-argument operator template.
-# define BOOST_OPERATOR_TEMPLATE3(template_name3)        \
-  template<class T, class U, class V, class B>           \
-  struct is_chained_base< template_name3<T, U, V, B> > { \
-    typedef operators_detail::true_t value;              \
-  };
-
-// Provide a specialization of 'is_chained_base<>'
-// for a 2-type-argument operator template.
-# define BOOST_OPERATOR_TEMPLATE2(template_name2)     \
-  template<class T, class U, class B>                 \
-  struct is_chained_base< template_name2<T, U, B> > { \
-    typedef operators_detail::true_t value;           \
-  };
-
-// Provide a specialization of 'is_chained_base<>'
-// for a 1-type-argument operator template.
-# define BOOST_OPERATOR_TEMPLATE1(template_name1)  \
-  template<class T, class B>                       \
-  struct is_chained_base< template_name1<T, B> > { \
-    typedef operators_detail::true_t value;        \
-  };
-
-// BOOST_OPERATOR_TEMPLATE(template_name) defines template_name<> such that it
-// can be used for specifying both 1-argument and 2-argument forms. Requires the
-// existence of two previously defined class templates named '<template_name>1'
-// and '<template_name>2' which must implement the corresponding 1- and 2-
-// argument forms.
-//
-// The template type parameter O == is_chained_base<U>::value is used to
-// distinguish whether the 2nd argument to <template_name> is being used for
-// base class chaining from another boost operator template or is describing a
-// 2nd operand type. O == true_t only when U is actually an another operator
-// template from the library. Partial specialization is used to select an
-// implementation in terms of either '<template_name>1' or '<template_name>2'.
-//
-
-# define BOOST_OPERATOR_TEMPLATE(template_name)                                       \
-template <class T                                                                     \
-         ,class U = T                                                                 \
-         ,class B = operators_detail::empty_base<T>                                   \
-         ,class O = typename is_chained_base<U>::value                                \
-         >                                                                            \
-struct template_name;                                                                 \
-                                                                                      \
-template<class T, class U, class B>                                                   \
-struct template_name<T, U, B, operators_detail::false_t>                              \
-  : template_name##2<T, U, B> {};                                                     \
-                                                                                      \
-template<class T, class U>                                                            \
-struct template_name<T, U, operators_detail::empty_base<T>, operators_detail::true_t> \
-  : template_name##1<T, U> {};                                                        \
-                                                                                      \
-template <class T, class B>                                                           \
-struct template_name<T, T, B, operators_detail::false_t>                              \
-  : template_name##1<T, B> {};                                                        \
-                                                                                      \
-template<class T, class U, class B, class O>                                          \
-struct is_chained_base< template_name<T, U, B, O> > {                                 \
-  typedef operators_detail::true_t value;                                             \
-};                                                                                    \
-                                                                                      \
-BOOST_OPERATOR_TEMPLATE2(template_name##2)                                            \
-BOOST_OPERATOR_TEMPLATE1(template_name##1)
-
-BOOST_OPERATOR_TEMPLATE(less_than_comparable)
-BOOST_OPERATOR_TEMPLATE(equality_comparable)
-BOOST_OPERATOR_TEMPLATE(multipliable)
-BOOST_OPERATOR_TEMPLATE(addable)
-BOOST_OPERATOR_TEMPLATE(subtractable)
-BOOST_OPERATOR_TEMPLATE2(subtractable2_left)
-BOOST_OPERATOR_TEMPLATE(dividable)
-BOOST_OPERATOR_TEMPLATE2(dividable2_left)
-BOOST_OPERATOR_TEMPLATE(modable)
-BOOST_OPERATOR_TEMPLATE2(modable2_left)
-BOOST_OPERATOR_TEMPLATE(xorable)
-BOOST_OPERATOR_TEMPLATE(andable)
-BOOST_OPERATOR_TEMPLATE(orable)
-
-BOOST_OPERATOR_TEMPLATE1(incrementable)
-BOOST_OPERATOR_TEMPLATE1(decrementable)
-
-BOOST_OPERATOR_TEMPLATE2(dereferenceable)
-BOOST_OPERATOR_TEMPLATE3(indexable)
-
-BOOST_OPERATOR_TEMPLATE(left_shiftable)
-BOOST_OPERATOR_TEMPLATE(right_shiftable)
-BOOST_OPERATOR_TEMPLATE(equivalent)
-BOOST_OPERATOR_TEMPLATE(partially_ordered)
-
-BOOST_OPERATOR_TEMPLATE(totally_ordered)
-BOOST_OPERATOR_TEMPLATE(additive)
-BOOST_OPERATOR_TEMPLATE(multiplicative)
-BOOST_OPERATOR_TEMPLATE(integer_multiplicative)
-BOOST_OPERATOR_TEMPLATE(arithmetic)
-BOOST_OPERATOR_TEMPLATE(integer_arithmetic)
-BOOST_OPERATOR_TEMPLATE(bitwise)
-BOOST_OPERATOR_TEMPLATE1(unit_steppable)
-BOOST_OPERATOR_TEMPLATE(shiftable)
-BOOST_OPERATOR_TEMPLATE(ring_operators)
-BOOST_OPERATOR_TEMPLATE(ordered_ring_operators)
-BOOST_OPERATOR_TEMPLATE(field_operators)
-BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
-BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
-BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
-BOOST_OPERATOR_TEMPLATE(euclidean_ring_operators)
-BOOST_OPERATOR_TEMPLATE(ordered_euclidean_ring_operators)
-BOOST_OPERATOR_TEMPLATE2(input_iteratable)
-BOOST_OPERATOR_TEMPLATE1(output_iteratable)
-BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
-BOOST_OPERATOR_TEMPLATE2(bidirectional_iteratable)
-BOOST_OPERATOR_TEMPLATE4(random_access_iteratable)
-
-#undef BOOST_OPERATOR_TEMPLATE
-#undef BOOST_OPERATOR_TEMPLATE4
-#undef BOOST_OPERATOR_TEMPLATE3
-#undef BOOST_OPERATOR_TEMPLATE2
-#undef BOOST_OPERATOR_TEMPLATE1
-
-template <class T, class U>
-struct operators2
-    : totally_ordered2<T,U
-    , integer_arithmetic2<T,U
-    , bitwise2<T,U
-      > > > {};
-
-template <class T, class U = T>
-struct operators : operators2<T, U> {};
-
-template <class T> struct operators<T, T>
-    : totally_ordered<T
-    , integer_arithmetic<T
-    , bitwise<T
-    , unit_steppable<T
-      > > > > {};
-
-//  Iterator helper classes (contributed by Jeremy Siek) -------------------//
-//  (Input and output iterator helpers contributed by Daryle Walker) -------//
-//  (Changed to use combined operator classes by Daryle Walker) ------------//
-//  (Adapted to C++17 by Daniel Frey) --------------------------------------//
-template <class Category,
-          class T,
-          class Distance = std::ptrdiff_t,
-          class Pointer = T*,
-          class Reference = T&>
-struct iterator_helper
-{
-  typedef Category iterator_category;
-  typedef T value_type;
-  typedef Distance difference_type;
-  typedef Pointer pointer;
-  typedef Reference reference;
-};
-
-template <class T,
-          class V,
-          class D = std::ptrdiff_t,
-          class P = V const *,
-          class R = V const &>
-struct input_iterator_helper
-  : input_iteratable<T, P
-  , iterator_helper<std::input_iterator_tag, V, D, P, R
-    > > {};
-
-template<class T>
-struct output_iterator_helper
-  : output_iteratable<T
-  , iterator_helper<std::output_iterator_tag, void, void, void, void
-  > >
-{
-  T& operator*()  { return static_cast<T&>(*this); }
-  T& operator++() { return static_cast<T&>(*this); }
-};
-
-template <class T,
-          class V,
-          class D = std::ptrdiff_t,
-          class P = V*,
-          class R = V&>
-struct forward_iterator_helper
-  : forward_iteratable<T, P
-  , iterator_helper<std::forward_iterator_tag, V, D, P, R
-    > > {};
-
-template <class T,
-          class V,
-          class D = std::ptrdiff_t,
-          class P = V*,
-          class R = V&>
-struct bidirectional_iterator_helper
-  : bidirectional_iteratable<T, P
-  , iterator_helper<std::bidirectional_iterator_tag, V, D, P, R
-    > > {};
-
-template <class T,
-          class V,
-          class D = std::ptrdiff_t,
-          class P = V*,
-          class R = V&>
-struct random_access_iterator_helper
-  : random_access_iteratable<T, P, D, R
-  , iterator_helper<std::random_access_iterator_tag, V, D, P, R
-    > >
-{
-  friend D requires_difference_operator(const T& x, const T& y) {
-    return x - y;
-  }
-}; // random_access_iterator_helper
-
-} // namespace operators_impl
-using namespace operators_impl;
-
-} // namespace boost
-
-#if defined(__sgi) && !defined(__GNUC__)
-#pragma reset woff 1234
-#endif
-
-#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
-#endif // BOOST_OPERATORS_HPP

include/boost/operators_v1.hpp

@@ -1,951 +0,0 @@
-//  Boost operators.hpp header file  ----------------------------------------//
-
-//  (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-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/libs/utility/operators.htm for documentation.
-
-//  Revision History
-//  22 Feb 16 Preserve old work-arounds. (Daniel Frey)
-//  16 Dec 10 Limit warning suppression for 4284 to older versions of VC++
-//            (Matthew Bradbury, fixes #4432)
-//  07 Aug 08 Added "euclidean" spelling. (Daniel Frey)
-//  03 Apr 08 Make sure "convertible to bool" is sufficient
-//            for T::operator<, etc. (Daniel Frey)
-//  24 May 07 Changed empty_base to depend on T, see
-//            http://svn.boost.org/trac/boost/ticket/979
-//  21 Oct 02 Modified implementation of operators to allow compilers with a
-//            correct named return value optimization (NRVO) to produce optimal
-//            code.  (Daniel Frey)
-//  02 Dec 01 Bug fixed in random_access_iteratable.  (Helmut Zeisel)
-//  28 Sep 01 Factored out iterator operator groups.  (Daryle Walker)
-//  27 Aug 01 'left' form for non commutative operators added;
-//            additional classes for groups of related operators added;
-//            workaround for empty base class optimization
-//            bug of GCC 3.0 (Helmut Zeisel)
-//  25 Jun 01 output_iterator_helper changes: removed default template 
-//            parameters, added support for self-proxying, additional 
-//            documentation and tests (Aleksey Gurtovoy)
-//  29 May 01 Added operator classes for << and >>.  Added input and output
-//            iterator helper classes.  Added classes to connect equality and
-//            relational operators.  Added classes for groups of related
-//            operators.  Reimplemented example operator and iterator helper
-//            classes in terms of the new groups.  (Daryle Walker, with help
-//            from Alexy Gurtovoy)
-//  11 Feb 01 Fixed bugs in the iterator helpers which prevented explicitly
-//            supplied arguments from actually being used (Dave Abrahams)
-//  04 Jul 00 Fixed NO_OPERATORS_IN_NAMESPACE bugs, major cleanup and
-//            refactoring of compiler workarounds, additional documentation
-//            (Alexy Gurtovoy and Mark Rodgers with some help and prompting from
-//            Dave Abrahams) 
-//  28 Jun 00 General cleanup and integration of bugfixes from Mark Rodgers and
-//            Jeremy Siek (Dave Abrahams)
-//  20 Jun 00 Changes to accommodate Borland C++Builder 4 and Borland C++ 5.5
-//            (Mark Rodgers)
-//  20 Jun 00 Minor fixes to the prior revision (Aleksey Gurtovoy)
-//  10 Jun 00 Support for the base class chaining technique was added
-//            (Aleksey Gurtovoy). See documentation and the comments below 
-//            for the details. 
-//  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
-//  18 Nov 99 Change name "divideable" to "dividable", remove unnecessary
-//            specializations of dividable, subtractable, modable (Ed Brey) 
-//  17 Nov 99 Add comments (Beman Dawes)
-//            Remove unnecessary specialization of operators<> (Ed Brey)
-//  15 Nov 99 Fix less_than_comparable<T,U> second operand type for first two
-//            operators.(Beman Dawes)
-//  12 Nov 99 Add operators templates (Ed Brey)
-//  11 Nov 99 Add single template parameter version for compilers without
-//            partial specialization (Beman Dawes)
-//  10 Nov 99 Initial version
-
-// 10 Jun 00:
-// An additional optional template parameter was added to most of 
-// operator templates to support the base class chaining technique (see 
-// documentation for the details). Unfortunately, a straightforward
-// implementation of this change would have broken compatibility with the
-// previous version of the library by making it impossible to use the same
-// template name (e.g. 'addable') for both the 1- and 2-argument versions of
-// an operator template. This implementation solves the backward-compatibility
-// issue at the cost of some simplicity.
-//
-// One of the complications is an existence of special auxiliary class template
-// 'is_chained_base<>' (see 'detail' namespace below), which is used
-// to determine whether its template parameter is a library's operator template
-// or not. You have to specialize 'is_chained_base<>' for each new 
-// operator template you add to the library.
-//
-// However, most of the non-trivial implementation details are hidden behind 
-// several local macros defined below, and as soon as you understand them,
-// you understand the whole library implementation. 
-
-#ifndef BOOST_OPERATORS_V1_HPP
-#define BOOST_OPERATORS_V1_HPP
-
-#include <cstddef>
-#include <iterator>
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#if defined(__sgi) && !defined(__GNUC__)
-#   pragma set woff 1234
-#endif
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1600)
-#   pragma warning( disable : 4284 ) // complaint about return type of 
-#endif                               // operator-> not begin a UDT
-
-namespace boost {
-namespace detail {
-
-template <typename T> class empty_base {};
-
-} // namespace detail
-} // namespace boost
-
-// In this section we supply the xxxx1 and xxxx2 forms of the operator
-// templates, which are explicitly targeted at the 1-type-argument and
-// 2-type-argument operator forms, respectively. Some compilers get confused
-// when inline friend functions are overloaded in namespaces other than the
-// global namespace. When BOOST_NO_OPERATORS_IN_NAMESPACE is defined, all of
-// these templates must go in the global namespace.
-
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
-namespace boost
-{
-#endif
-
-//  Basic operator classes (contributed by Dave Abrahams) ------------------//
-
-//  Note that friend functions defined in a class are implicitly inline.
-//  See the C++ std, 11.4 [class.friend] paragraph 5
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct less_than_comparable2 : B
-{
-     friend bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
-     friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
-     friend bool operator>(const U& x, const T& y)  { return y < x; }
-     friend bool operator<(const U& x, const T& y)  { return y > x; }
-     friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
-     friend bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
-};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct less_than_comparable1 : B
-{
-     friend bool operator>(const T& x, const T& y)  { return y < x; }
-     friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
-     friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct equality_comparable2 : B
-{
-     friend bool operator==(const U& y, const T& x) { return x == y; }
-     friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
-     friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
-};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct equality_comparable1 : B
-{
-     friend bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
-};
-
-// A macro which produces "name_2left" from "name".
-#define BOOST_OPERATOR2_LEFT(name) name##2##_##left
-
-//  NRVO-friendly implementation (contributed by Daniel Frey) ---------------//
-
-#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-// This is the optimal implementation for ISO/ANSI C++,
-// but it requires the compiler to implement the NRVO.
-// If the compiler has no NRVO, this is the best symmetric
-// implementation available.
-
-#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                         \
-template <class T, class U, class B = ::boost::detail::empty_base<T> >        \
-struct NAME##2 : B                                                            \
-{                                                                             \
-  friend T operator OP( const T& lhs, const U& rhs )                          \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
-  friend T operator OP( const U& lhs, const T& rhs )                          \
-    { T nrv( rhs ); nrv OP##= lhs; return nrv; }                              \
-};                                                                            \
-                                                                              \
-template <class T, class B = ::boost::detail::empty_base<T> >                 \
-struct NAME##1 : B                                                            \
-{                                                                             \
-  friend T operator OP( const T& lhs, const T& rhs )                          \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
-};
-
-#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
-template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
-struct NAME##2 : B                                                      \
-{                                                                       \
-  friend T operator OP( const T& lhs, const U& rhs )                    \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
-};                                                                      \
-                                                                        \
-template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
-struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
-{                                                                       \
-  friend T operator OP( const U& lhs, const T& rhs )                    \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
-};                                                                      \
-                                                                        \
-template <class T, class B = ::boost::detail::empty_base<T> >           \
-struct NAME##1 : B                                                      \
-{                                                                       \
-  friend T operator OP( const T& lhs, const T& rhs )                    \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
-};
-
-#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-// For compilers without NRVO the following code is optimal, but not
-// symmetric!  Note that the implementation of
-// BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
-// optimization opportunities to the compiler :)
-
-#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                   \
-template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
-struct NAME##2 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
-  friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \
-};                                                                      \
-                                                                        \
-template <class T, class B = ::boost::detail::empty_base<T> >           \
-struct NAME##1 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
-};
-
-#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
-template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
-struct NAME##2 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
-};                                                                      \
-                                                                        \
-template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
-struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
-{                                                                       \
-  friend T operator OP( const U& lhs, const T& rhs )                    \
-    { return T( lhs ) OP##= rhs; }                                      \
-};                                                                      \
-                                                                        \
-template <class T, class B = ::boost::detail::empty_base<T> >           \
-struct NAME##1 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
-};
-
-#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-BOOST_BINARY_OPERATOR_COMMUTATIVE( multipliable, * )
-BOOST_BINARY_OPERATOR_COMMUTATIVE( addable, + )
-BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( subtractable, - )
-BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( dividable, / )
-BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( modable, % )
-BOOST_BINARY_OPERATOR_COMMUTATIVE( xorable, ^ )
-BOOST_BINARY_OPERATOR_COMMUTATIVE( andable, & )
-BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )
-
-#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
-#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
-#undef BOOST_OPERATOR2_LEFT
-
-//  incrementable and decrementable contributed by Jeremy Siek
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct incrementable : B
-{
-  friend T operator++(T& x, int)
-  {
-    incrementable_type nrv(x);
-    ++x;
-    return nrv;
-  }
-private: // The use of this typedef works around a Borland bug
-  typedef T incrementable_type;
-};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct decrementable : B
-{
-  friend T operator--(T& x, int)
-  {
-    decrementable_type nrv(x);
-    --x;
-    return nrv;
-  }
-private: // The use of this typedef works around a Borland bug
-  typedef T decrementable_type;
-};
-
-//  Iterator operator classes (contributed by Jeremy Siek) ------------------//
-
-template <class T, class P, class B = ::boost::detail::empty_base<T> >
-struct dereferenceable : B
-{
-  P operator->() const
-  { 
-    return &*static_cast<const T&>(*this); 
-  }
-};
-
-template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
-struct indexable : B
-{
-  R operator[](I n) const
-  {
-    return *(static_cast<const T&>(*this) + n);
-  }
-};
-
-//  More operator classes (contributed by Daryle Walker) --------------------//
-//  (NRVO-friendly implementation contributed by Daniel Frey) ---------------//
-
-#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-#define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
-template <class T, class U, class B = ::boost::detail::empty_base<T> >        \
-struct NAME##2 : B                                                            \
-{                                                                             \
-  friend T operator OP( const T& lhs, const U& rhs )                          \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
-};                                                                            \
-                                                                              \
-template <class T, class B = ::boost::detail::empty_base<T> >                 \
-struct NAME##1 : B                                                            \
-{                                                                             \
-  friend T operator OP( const T& lhs, const T& rhs )                          \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
-};
-
-#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-#define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
-template <class T, class U, class B = ::boost::detail::empty_base<T> >        \
-struct NAME##2 : B                                                            \
-{                                                                             \
-  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; }       \
-};                                                                            \
-                                                                              \
-template <class T, class B = ::boost::detail::empty_base<T> >                 \
-struct NAME##1 : B                                                            \
-{                                                                             \
-  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
-};
-
-#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-
-BOOST_BINARY_OPERATOR( left_shiftable, << )
-BOOST_BINARY_OPERATOR( right_shiftable, >> )
-
-#undef BOOST_BINARY_OPERATOR
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct equivalent2 : B
-{
-  friend bool operator==(const T& x, const U& y)
-  {
-    return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
-  }
-};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct equivalent1 : B
-{
-  friend bool operator==(const T&x, const T&y)
-  {
-    return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
-  }
-};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct partially_ordered2 : B
-{
-  friend bool operator<=(const T& x, const U& y)
-    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
-  friend bool operator>=(const T& x, const U& y)
-    { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
-  friend bool operator>(const U& x, const T& y)
-    { return y < x; }
-  friend bool operator<(const U& x, const T& y)
-    { return y > x; }
-  friend bool operator<=(const U& x, const T& y)
-    { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
-  friend bool operator>=(const U& x, const T& y)
-    { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
-};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct partially_ordered1 : B
-{
-  friend bool operator>(const T& x, const T& y)
-    { return y < x; }
-  friend bool operator<=(const T& x, const T& y)
-    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
-  friend bool operator>=(const T& x, const T& y)
-    { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
-};
-
-//  Combined operator classes (contributed by Daryle Walker) ----------------//
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct totally_ordered2
-    : less_than_comparable2<T, U
-    , equality_comparable2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct totally_ordered1
-    : less_than_comparable1<T
-    , equality_comparable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct additive2
-    : addable2<T, U
-    , subtractable2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct additive1
-    : addable1<T
-    , subtractable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct multiplicative2
-    : multipliable2<T, U
-    , dividable2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct multiplicative1
-    : multipliable1<T
-    , dividable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct integer_multiplicative2
-    : multiplicative2<T, U
-    , modable2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct integer_multiplicative1
-    : multiplicative1<T
-    , modable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct arithmetic2
-    : additive2<T, U
-    , multiplicative2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct arithmetic1
-    : additive1<T
-    , multiplicative1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct integer_arithmetic2
-    : additive2<T, U
-    , integer_multiplicative2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct integer_arithmetic1
-    : additive1<T
-    , integer_multiplicative1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct bitwise2
-    : xorable2<T, U
-    , andable2<T, U
-    , orable2<T, U, B
-      > > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct bitwise1
-    : xorable1<T
-    , andable1<T
-    , orable1<T, B
-      > > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct unit_steppable
-    : incrementable<T
-    , decrementable<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct shiftable2
-    : left_shiftable2<T, U
-    , right_shiftable2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct shiftable1
-    : left_shiftable1<T
-    , right_shiftable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct ring_operators2
-    : additive2<T, U
-    , subtractable2_left<T, U
-    , multipliable2<T, U, B
-      > > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct ring_operators1
-    : additive1<T
-    , multipliable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct ordered_ring_operators2
-    : ring_operators2<T, U
-    , totally_ordered2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct ordered_ring_operators1
-    : ring_operators1<T
-    , totally_ordered1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct field_operators2
-    : ring_operators2<T, U
-    , dividable2<T, U
-    , dividable2_left<T, U, B
-      > > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct field_operators1
-    : ring_operators1<T
-    , dividable1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct ordered_field_operators2
-    : field_operators2<T, U
-    , totally_ordered2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct ordered_field_operators1
-    : field_operators1<T
-    , totally_ordered1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct euclidian_ring_operators2
-    : ring_operators2<T, U
-    , dividable2<T, U
-    , dividable2_left<T, U
-    , modable2<T, U
-    , modable2_left<T, U, B
-      > > > > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct euclidian_ring_operators1
-    : ring_operators1<T
-    , dividable1<T
-    , modable1<T, B
-      > > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct ordered_euclidian_ring_operators2
-    : totally_ordered2<T, U
-    , euclidian_ring_operators2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct ordered_euclidian_ring_operators1
-    : totally_ordered1<T
-    , euclidian_ring_operators1<T, B
-      > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct euclidean_ring_operators2
-    : ring_operators2<T, U
-    , dividable2<T, U
-    , dividable2_left<T, U
-    , modable2<T, U
-    , modable2_left<T, U, B
-      > > > > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct euclidean_ring_operators1
-    : ring_operators1<T
-    , dividable1<T
-    , modable1<T, B
-      > > > {};
-
-template <class T, class U, class B = ::boost::detail::empty_base<T> >
-struct ordered_euclidean_ring_operators2
-    : totally_ordered2<T, U
-    , euclidean_ring_operators2<T, U, B
-      > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct ordered_euclidean_ring_operators1
-    : totally_ordered1<T
-    , euclidean_ring_operators1<T, B
-      > > {};
-
-template <class T, class P, class B = ::boost::detail::empty_base<T> >
-struct input_iteratable
-    : equality_comparable1<T
-    , incrementable<T
-    , dereferenceable<T, P, B
-      > > > {};
-
-template <class T, class B = ::boost::detail::empty_base<T> >
-struct output_iteratable
-    : incrementable<T, B
-      > {};
-
-template <class T, class P, class B = ::boost::detail::empty_base<T> >
-struct forward_iteratable
-    : input_iteratable<T, P, B
-      > {};
-
-template <class T, class P, class B = ::boost::detail::empty_base<T> >
-struct bidirectional_iteratable
-    : forward_iteratable<T, P
-    , decrementable<T, B
-      > > {};
-
-//  To avoid repeated derivation from equality_comparable,
-//  which is an indirect base class of bidirectional_iterable,
-//  random_access_iteratable must not be derived from totally_ordered1
-//  but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001)
-template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
-struct random_access_iteratable
-    : bidirectional_iteratable<T, P
-    , less_than_comparable1<T
-    , additive2<T, D
-    , indexable<T, D, R, B
-      > > > > {};
-
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
-} // namespace boost
-#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
-
-
-// BOOST_IMPORT_TEMPLATE1 .. BOOST_IMPORT_TEMPLATE4 -
-//
-// When BOOST_NO_OPERATORS_IN_NAMESPACE is defined we need a way to import an
-// operator template into the boost namespace. BOOST_IMPORT_TEMPLATE1 is used
-// for one-argument forms of operator templates; BOOST_IMPORT_TEMPLATE2 for
-// two-argument forms. Note that these macros expect to be invoked from within
-// boost.
-
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
-
-  // The template is already in boost so we have nothing to do.
-# define BOOST_IMPORT_TEMPLATE4(template_name)
-# define BOOST_IMPORT_TEMPLATE3(template_name)
-# define BOOST_IMPORT_TEMPLATE2(template_name)
-# define BOOST_IMPORT_TEMPLATE1(template_name)
-
-#else // BOOST_NO_OPERATORS_IN_NAMESPACE
-
-#  ifndef BOOST_NO_USING_TEMPLATE
-
-     // Bring the names in with a using-declaration
-     // to avoid stressing the compiler.
-#    define BOOST_IMPORT_TEMPLATE4(template_name) using ::template_name;
-#    define BOOST_IMPORT_TEMPLATE3(template_name) using ::template_name;
-#    define BOOST_IMPORT_TEMPLATE2(template_name) using ::template_name;
-#    define BOOST_IMPORT_TEMPLATE1(template_name) using ::template_name;
-
-#  else
-
-     // Otherwise, because a Borland C++ 5.5 bug prevents a using declaration
-     // from working, we are forced to use inheritance for that compiler.
-#    define BOOST_IMPORT_TEMPLATE4(template_name)                                             \
-     template <class T, class U, class V, class W, class B = ::boost::detail::empty_base<T> > \
-     struct template_name : ::template_name<T, U, V, W, B> {};
-
-#    define BOOST_IMPORT_TEMPLATE3(template_name)                                    \
-     template <class T, class U, class V, class B = ::boost::detail::empty_base<T> > \
-     struct template_name : ::template_name<T, U, V, B> {};
-
-#    define BOOST_IMPORT_TEMPLATE2(template_name)                           \
-     template <class T, class U, class B = ::boost::detail::empty_base<T> > \
-     struct template_name : ::template_name<T, U, B> {};
-
-#    define BOOST_IMPORT_TEMPLATE1(template_name)                  \
-     template <class T, class B = ::boost::detail::empty_base<T> > \
-     struct template_name : ::template_name<T, B> {};
-
-#  endif // BOOST_NO_USING_TEMPLATE
-
-#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
-
-//
-// Here's where we put it all together, defining the xxxx forms of the templates
-// in namespace boost. We also define specializations of is_chained_base<> for
-// the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
-// necessary.
-//
-
-// is_chained_base<> - a traits class used to distinguish whether an operator
-// template argument is being used for base class chaining, or is specifying a
-// 2nd argument type.
-
-namespace boost {
-// A type parameter is used instead of a plain bool because Borland's compiler
-// didn't cope well with the more obvious non-type template parameter.
-namespace detail {
-  struct true_t {};
-  struct false_t {};
-} // namespace detail
-
-// Unspecialized version assumes that most types are not being used for base
-// class chaining. We specialize for the operator templates defined in this
-// library.
-template<class T> struct is_chained_base {
-  typedef ::boost::detail::false_t value;
-};
-
-} // namespace boost
-
-// Import a 4-type-argument operator template into boost (if necessary) and
-// provide a specialization of 'is_chained_base<>' for it.
-# define BOOST_OPERATOR_TEMPLATE4(template_name4)                     \
-  BOOST_IMPORT_TEMPLATE4(template_name4)                              \
-  template<class T, class U, class V, class W, class B>               \
-  struct is_chained_base< ::boost::template_name4<T, U, V, W, B> > {  \
-    typedef ::boost::detail::true_t value;                            \
-  };
-
-// Import a 3-type-argument operator template into boost (if necessary) and
-// provide a specialization of 'is_chained_base<>' for it.
-# define BOOST_OPERATOR_TEMPLATE3(template_name3)                     \
-  BOOST_IMPORT_TEMPLATE3(template_name3)                              \
-  template<class T, class U, class V, class B>                        \
-  struct is_chained_base< ::boost::template_name3<T, U, V, B> > {     \
-    typedef ::boost::detail::true_t value;                            \
-  };
-
-// Import a 2-type-argument operator template into boost (if necessary) and
-// provide a specialization of 'is_chained_base<>' for it.
-# define BOOST_OPERATOR_TEMPLATE2(template_name2)                  \
-  BOOST_IMPORT_TEMPLATE2(template_name2)                           \
-  template<class T, class U, class B>                              \
-  struct is_chained_base< ::boost::template_name2<T, U, B> > {     \
-    typedef ::boost::detail::true_t value;                         \
-  };
-
-// Import a 1-type-argument operator template into boost (if necessary) and
-// provide a specialization of 'is_chained_base<>' for it.
-# define BOOST_OPERATOR_TEMPLATE1(template_name1)                  \
-  BOOST_IMPORT_TEMPLATE1(template_name1)                           \
-  template<class T, class B>                                       \
-  struct is_chained_base< ::boost::template_name1<T, B> > {        \
-    typedef ::boost::detail::true_t value;                         \
-  };
-
-// BOOST_OPERATOR_TEMPLATE(template_name) defines template_name<> such that it
-// can be used for specifying both 1-argument and 2-argument forms. Requires the
-// existence of two previously defined class templates named '<template_name>1'
-// and '<template_name>2' which must implement the corresponding 1- and 2-
-// argument forms.
-//
-// The template type parameter O == is_chained_base<U>::value is used to
-// distinguish whether the 2nd argument to <template_name> is being used for
-// base class chaining from another boost operator template or is describing a
-// 2nd operand type. O == true_t only when U is actually an another operator
-// template from the library. Partial specialization is used to select an
-// implementation in terms of either '<template_name>1' or '<template_name>2'.
-//
-
-# define BOOST_OPERATOR_TEMPLATE(template_name)                    \
-template <class T                                                  \
-         ,class U = T                                              \
-         ,class B = ::boost::detail::empty_base<T>                 \
-         ,class O = typename is_chained_base<U>::value             \
-         >                                                         \
-struct template_name : template_name##2<T, U, B> {};               \
-                                                                   \
-template<class T, class U, class B>                                \
-struct template_name<T, U, B, ::boost::detail::true_t>             \
-  : template_name##1<T, U> {};                                     \
-                                                                   \
-template <class T, class B>                                        \
-struct template_name<T, T, B, ::boost::detail::false_t>            \
-  : template_name##1<T, B> {};                                     \
-                                                                   \
-template<class T, class U, class B, class O>                       \
-struct is_chained_base< ::boost::template_name<T, U, B, O> > {     \
-  typedef ::boost::detail::true_t value;                           \
-};                                                                 \
-                                                                   \
-BOOST_OPERATOR_TEMPLATE2(template_name##2)                         \
-BOOST_OPERATOR_TEMPLATE1(template_name##1)
-
-
-
-namespace boost {
-    
-BOOST_OPERATOR_TEMPLATE(less_than_comparable)
-BOOST_OPERATOR_TEMPLATE(equality_comparable)
-BOOST_OPERATOR_TEMPLATE(multipliable)
-BOOST_OPERATOR_TEMPLATE(addable)
-BOOST_OPERATOR_TEMPLATE(subtractable)
-BOOST_OPERATOR_TEMPLATE2(subtractable2_left)
-BOOST_OPERATOR_TEMPLATE(dividable)
-BOOST_OPERATOR_TEMPLATE2(dividable2_left)
-BOOST_OPERATOR_TEMPLATE(modable)
-BOOST_OPERATOR_TEMPLATE2(modable2_left)
-BOOST_OPERATOR_TEMPLATE(xorable)
-BOOST_OPERATOR_TEMPLATE(andable)
-BOOST_OPERATOR_TEMPLATE(orable)
-
-BOOST_OPERATOR_TEMPLATE1(incrementable)
-BOOST_OPERATOR_TEMPLATE1(decrementable)
-
-BOOST_OPERATOR_TEMPLATE2(dereferenceable)
-BOOST_OPERATOR_TEMPLATE3(indexable)
-
-BOOST_OPERATOR_TEMPLATE(left_shiftable)
-BOOST_OPERATOR_TEMPLATE(right_shiftable)
-BOOST_OPERATOR_TEMPLATE(equivalent)
-BOOST_OPERATOR_TEMPLATE(partially_ordered)
-
-BOOST_OPERATOR_TEMPLATE(totally_ordered)
-BOOST_OPERATOR_TEMPLATE(additive)
-BOOST_OPERATOR_TEMPLATE(multiplicative)
-BOOST_OPERATOR_TEMPLATE(integer_multiplicative)
-BOOST_OPERATOR_TEMPLATE(arithmetic)
-BOOST_OPERATOR_TEMPLATE(integer_arithmetic)
-BOOST_OPERATOR_TEMPLATE(bitwise)
-BOOST_OPERATOR_TEMPLATE1(unit_steppable)
-BOOST_OPERATOR_TEMPLATE(shiftable)
-BOOST_OPERATOR_TEMPLATE(ring_operators)
-BOOST_OPERATOR_TEMPLATE(ordered_ring_operators)
-BOOST_OPERATOR_TEMPLATE(field_operators)
-BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
-BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
-BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
-BOOST_OPERATOR_TEMPLATE(euclidean_ring_operators)
-BOOST_OPERATOR_TEMPLATE(ordered_euclidean_ring_operators)
-BOOST_OPERATOR_TEMPLATE2(input_iteratable)
-BOOST_OPERATOR_TEMPLATE1(output_iteratable)
-BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
-BOOST_OPERATOR_TEMPLATE2(bidirectional_iteratable)
-BOOST_OPERATOR_TEMPLATE4(random_access_iteratable)
-
-#undef BOOST_OPERATOR_TEMPLATE
-#undef BOOST_OPERATOR_TEMPLATE4
-#undef BOOST_OPERATOR_TEMPLATE3
-#undef BOOST_OPERATOR_TEMPLATE2
-#undef BOOST_OPERATOR_TEMPLATE1
-#undef BOOST_IMPORT_TEMPLATE1
-#undef BOOST_IMPORT_TEMPLATE2
-#undef BOOST_IMPORT_TEMPLATE3
-#undef BOOST_IMPORT_TEMPLATE4
-
-// The following 'operators' classes can only be used portably if the derived class
-// declares ALL of the required member operators.
-template <class T, class U>
-struct operators2
-    : totally_ordered2<T,U
-    , integer_arithmetic2<T,U
-    , bitwise2<T,U
-      > > > {};
-
-template <class T, class U = T>
-struct operators : operators2<T, U> {};
-
-template <class T> struct operators<T, T>
-    : totally_ordered<T
-    , integer_arithmetic<T
-    , bitwise<T
-    , unit_steppable<T
-      > > > > {};
-
-//  Iterator helper classes (contributed by Jeremy Siek) -------------------//
-//  (Input and output iterator helpers contributed by Daryle Walker) -------//
-//  (Changed to use combined operator classes by Daryle Walker) ------------//
-template <class T,
-          class V,
-          class D = std::ptrdiff_t,
-          class P = V const *,
-          class R = V const &>
-struct input_iterator_helper
-  : input_iteratable<T, P
-  , std::iterator<std::input_iterator_tag, V, D, P, R
-    > > {};
-
-template<class T>
-struct output_iterator_helper
-  : output_iteratable<T
-  , std::iterator<std::output_iterator_tag, void, void, void, void
-  > >
-{
-  T& operator*()  { return static_cast<T&>(*this); }
-  T& operator++() { return static_cast<T&>(*this); }
-};
-
-template <class T,
-          class V,
-          class D = std::ptrdiff_t,
-          class P = V*,
-          class R = V&>
-struct forward_iterator_helper
-  : forward_iteratable<T, P
-  , std::iterator<std::forward_iterator_tag, V, D, P, R
-    > > {};
-
-template <class T,
-          class V,
-          class D = std::ptrdiff_t,
-          class P = V*,
-          class R = V&>
-struct bidirectional_iterator_helper
-  : bidirectional_iteratable<T, P
-  , std::iterator<std::bidirectional_iterator_tag, V, D, P, R
-    > > {};
-
-template <class T,
-          class V, 
-          class D = std::ptrdiff_t,
-          class P = V*,
-          class R = V&>
-struct random_access_iterator_helper
-  : random_access_iteratable<T, P, D, R
-  , std::iterator<std::random_access_iterator_tag, V, D, P, R
-    > >
-{
-  friend D requires_difference_operator(const T& x, const T& y) {
-    return x - y;
-  }
-}; // random_access_iterator_helper
-
-} // namespace boost
-
-#if defined(__sgi) && !defined(__GNUC__)
-#pragma reset woff 1234
-#endif
-
-#endif // BOOST_OPERATORS_V1_HPP

include/boost/utility.hpp

@@ -1,24 +0,0 @@
-//  Boost utility.hpp header file  -------------------------------------------//
-
-//  Copyright 1999-2003 Aleksey Gurtovoy.  Use, modification, and distribution are
-//  subject to the Boost Software License, Version 1.0.  (See accompanying file
-//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-//  See <http://www.boost.org/libs/utility/> for the library's home page.
-
-#ifndef BOOST_UTILITY_HPP
-#define BOOST_UTILITY_HPP
-
-// Use of this header is discouraged and it will be deprecated.
-// Please include one or more of the headers below instead.
-
-#include <boost/utility/base_from_member.hpp>
-#include <boost/utility/binary.hpp>
-#include <boost/utility/identity_type.hpp>
-
-#include <boost/core/addressof.hpp>
-#include <boost/core/enable_if.hpp>
-#include <boost/core/checked_delete.hpp>
-#include <boost/core/noncopyable.hpp>
-
-#endif  // BOOST_UTILITY_HPP

include/boost/utility/base_from_member.hpp

@@ -1,172 +0,0 @@
-//  boost utility/base_from_member.hpp header file  --------------------------//
-
-//  Copyright 2001, 2003, 2004, 2012 Daryle Walker.  Use, modification, and
-//  distribution are subject to the Boost Software License, Version 1.0.  (See
-//  accompanying file LICENSE_1_0.txt or a copy at
-//  <http://www.boost.org/LICENSE_1_0.txt>.)
-
-//  See <http://www.boost.org/libs/utility/> for the library's home page.
-
-#ifndef BOOST_UTILITY_BASE_FROM_MEMBER_HPP
-#define BOOST_UTILITY_BASE_FROM_MEMBER_HPP
-
-#include <boost/config.hpp>
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/utility/enable_if.hpp>
-
-
-//  Base-from-member arity configuration macro  ------------------------------//
-
-// The following macro determines how many arguments will be in the largest
-// constructor template of base_from_member.  Constructor templates will be
-// generated from one argument to this maximum.  Code from other files can read
-// this number if they need to always match the exact maximum base_from_member
-// uses.  The maximum constructor length can be changed by overriding the
-// #defined constant.  Make sure to apply the override, if any, for all source
-// files during project compiling for consistency.
-
-// Contributed by Jonathan Turkanis
-
-#ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY
-#define BOOST_BASE_FROM_MEMBER_MAX_ARITY  10
-#endif
-
-
-//  An iteration of a constructor template for base_from_member  -------------//
-
-// A macro that should expand to:
-//     template < typename T1, ..., typename Tn >
-//     base_from_member( T1 x1, ..., Tn xn )
-//         : member( x1, ..., xn )
-//         {}
-// This macro should only persist within this file.
-
-#define BOOST_PRIVATE_CTR_DEF( z, n, data )                   \
-    template < BOOST_PP_ENUM_PARAMS(n, typename T) >          \
-    base_from_member( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) )  \
-        : member( BOOST_PP_ENUM_PARAMS(n, x) )                \
-        {}                                                    \
-    /**/
-
-
-namespace boost
-{
-
-namespace detail
-{
-
-//  Type-unmarking class template  -------------------------------------------//
-
-// Type-trait to get the raw type, i.e. the type without top-level reference nor
-// cv-qualification, from a type expression.  Mainly for function arguments, any
-// reference part is stripped first.
-
-// Contributed by Daryle Walker
-
-template < typename T >
-struct remove_cv_ref
-{
-    typedef typename ::boost::remove_cv<typename
-     ::boost::remove_reference<T>::type>::type  type;
-
-};  // boost::detail::remove_cv_ref
-
-//  Unmarked-type comparison class template  ---------------------------------//
-
-// Type-trait to check if two type expressions have the same raw type.
-
-// Contributed by Daryle Walker, based on a work-around by Luc Danton
-
-template < typename T, typename U >
-struct is_related
-    : public ::boost::is_same<
-     typename ::boost::detail::remove_cv_ref<T>::type,
-     typename ::boost::detail::remove_cv_ref<U>::type >
-{};
-
-//  Enable-if-on-unidentical-unmarked-type class template  -------------------//
-
-// Enable-if on the first two type expressions NOT having the same raw type.
-
-// Contributed by Daryle Walker, based on a work-around by Luc Danton
-
-#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
-template<typename ...T>
-struct enable_if_unrelated
-    : public ::boost::enable_if_c<true>
-{};
-
-template<typename T, typename U, typename ...U2>
-struct enable_if_unrelated<T, U, U2...>
-    : public ::boost::disable_if< ::boost::detail::is_related<T, U> >
-{};
-#endif
-
-}  // namespace boost::detail
-
-
-//  Base-from-member class template  -----------------------------------------//
-
-// Helper to initialize a base object so a derived class can use this
-// object in the initialization of another base class.  Used by
-// Dietmar Kuehl from ideas by Ron Klatcho to solve the problem of a
-// base class needing to be initialized by a member.
-
-// Contributed by Daryle Walker
-
-template < typename MemberType, int UniqueID = 0 >
-class base_from_member
-{
-protected:
-    MemberType  member;
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
-    !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && \
-    !(defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 4))
-    template <typename ...T, typename EnableIf = typename
-     ::boost::detail::enable_if_unrelated<base_from_member, T...>::type>
-    explicit BOOST_CONSTEXPR base_from_member( T&& ...x )
-        BOOST_NOEXCEPT_IF( BOOST_NOEXCEPT_EXPR(::new ((void*) 0) MemberType(
-         static_cast<T&&>(x)... )) )  // no std::is_nothrow_constructible...
-        : member( static_cast<T&&>(x)... )     // ...nor std::forward needed
-        {}
-#else
-    base_from_member()
-        : member()
-        {}
-
-    template < typename T0 > explicit base_from_member( T0 x0 ) : member( x0 ) {}
-    BOOST_PP_REPEAT_FROM_TO( 2, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
-     BOOST_PRIVATE_CTR_DEF, _ )
-#endif
-
-};  // boost::base_from_member
-
-template < typename MemberType, int UniqueID >
-class base_from_member<MemberType&, UniqueID>
-{
-protected:
-    MemberType& member;
-
-    explicit BOOST_CONSTEXPR base_from_member( MemberType& x )
-        BOOST_NOEXCEPT
-        : member( x )
-        {}
-
-};  // boost::base_from_member
-
-}  // namespace boost
-
-
-// Undo any private macros
-#undef BOOST_PRIVATE_CTR_DEF
-
-
-#endif  // BOOST_UTILITY_BASE_FROM_MEMBER_HPP

include/boost/utility/binary.hpp

@@ -1,708 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2005 Matthew Calabrese
-
-    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)
-==============================================================================*/
-
-#ifndef BOOST_UTILITY_BINARY_HPP
-#define BOOST_UTILITY_BINARY_HPP
-
-/*=============================================================================
-
-    Binary Literal Utility
-    ______________________
-
-
-    The following code works by converting the input bit pattern into a
-    Boost.Preprocessor sequence, then converting groupings of 3 bits each into
-    the corresponding octal digit, and finally concatenating all of the digits
-    together along with a leading zero. This yields a standard octal literal
-    with the desired value as specified in bits.
-
-==============================================================================*/
-
-#include <boost/preprocessor/control/deduce_d.hpp>
-#include <boost/preprocessor/facilities/identity.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/seq/cat.hpp>
-#include <boost/preprocessor/seq/transform.hpp>
-#include <boost/preprocessor/arithmetic/mod.hpp>
-#include <boost/preprocessor/seq/size.hpp>
-#include <boost/preprocessor/facilities/empty.hpp>
-#include <boost/preprocessor/control/while.hpp>
-
-#define BOOST_BINARY( bit_groupings )                                          \
-  BOOST_BINARY_LITERAL_D( BOOST_PP_DEDUCE_D(), bit_groupings ) 
-
-#define BOOST_BINARY_U( bit_groupings )                                        \
-  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, U ) 
-
-#define BOOST_BINARY_L( bit_groupings )                                        \
-  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, L ) 
-
-#define BOOST_BINARY_UL( bit_groupings )                                       \
-  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, UL ) 
-
-#define BOOST_BINARY_LU( bit_groupings )                                       \
-  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LU ) 
-
-#define BOOST_BINARY_LL( bit_groupings )                                       \
-  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LL ) 
-
-#define BOOST_BINARY_ULL( bit_groupings )                                      \
-  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, ULL ) 
-
-#define BOOST_BINARY_LLU( bit_groupings )                                      \
-  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LLU ) 
-
-#define BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, suffix )                 \
-  BOOST_SUFFIXED_BINARY_LITERAL_D( BOOST_PP_DEDUCE_D(), bit_groupings, suffix ) 
-
-#define BOOST_SUFFIXED_BINARY_LITERAL_D( d, bit_groupings, suffix )            \
-  BOOST_PP_CAT( BOOST_BINARY_LITERAL_D( d, bit_groupings ), suffix ) 
-
-#define BOOST_BINARY_LITERAL_D( d, bit_groupings )                             \
-  BOOST_PP_SEQ_CAT                                                             \
-  ( (0) BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE( d, bit_groupings )  \
-  ) 
-
-#define BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE( d, bit_groupings )  \
-  BOOST_PP_SEQ_TRANSFORM                                                       \
-  ( BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION                                     \
-  , BOOST_PP_NIL                                                               \
-  , BOOST_PP_IDENTITY( BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE )()\
-    ( BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE                                    \
-      (                                                                        \
-        d                                                                      \
-      , BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE( d, bit_groupings )    \
-      )                                                                        \
-    )                                                                          \
-  ) 
-
-#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE( bit_sequence )   \
-  BOOST_PP_CAT                                                                 \
-  ( BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1 bit_sequence      \
-  , END_BIT                                                                    \
-  ) 
-
-#define BOOST_DETAIL_BITS_PER_OCTIT 3
-
-#define BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE( d, incomplete_nibble_sequence ) \
-  BOOST_PP_CAT                                                                 \
-  ( BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_                            \
-  , BOOST_PP_MOD_D( d                                                          \
-                  , BOOST_PP_SEQ_SIZE( incomplete_nibble_sequence )            \
-                  , BOOST_DETAIL_BITS_PER_OCTIT                                \
-                  )                                                            \
-  )                                                                            \
-  incomplete_nibble_sequence 
-
-#define BOOST_DETAIL_FIXED_COMPL( bit )                                        \
-  BOOST_PP_CAT( BOOST_DETAIL_FIXED_COMPL_, bit )
-
-#define BOOST_DETAIL_FIXED_COMPL_0 1 
-
-#define BOOST_DETAIL_FIXED_COMPL_1 0 
-
-#define BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE( d, bit_groupings )    \
-  BOOST_PP_EMPTY                                                               \
-  BOOST_PP_CAT( BOOST_PP_WHILE_, d )                                           \
-  ( BOOST_DETAIL_BINARY_LITERAL_PREDICATE                                      \
-  , BOOST_DETAIL_BINARY_LITERAL_OPERATION                                      \
-  , bit_groupings ()                                                           \
-  ) 
-
-#define BOOST_DETAIL_BINARY_LITERAL_PREDICATE( d, state )                      \
-  BOOST_DETAIL_FIXED_COMPL( BOOST_DETAIL_IS_NULLARY_ARGS( state ) ) 
-
-#define BOOST_DETAIL_BINARY_LITERAL_OPERATION( d, state )                      \
-  BOOST_DETAIL_SPLIT_AND_SWAP                                                  \
-  ( BOOST_PP_CAT( BOOST_DETAIL_BINARY_LITERAL_ELEMENT_, state ) ) 
-
-#define BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION( s, dummy_param, tuple )        \
-  BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL tuple 
-
-#define BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL( bit2, bit1, bit0 )               \
-  BOOST_DETAIL_TRIPLE_TO_OCTAL_ ## bit2 ## bit1 ## bit0 
-
-#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_1 (0)(0)
-#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_2 (0)
-#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_0  
-
-#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1END_BIT  
-
-#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1( bit )        \
-  ( ( bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2 
-
-#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2( bit )        \
-  bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3 
-
-#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3( bit )        \
-  bit ) ) BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1 
-
-#define BOOST_DETAIL_SPLIT_AND_SWAP( params )                                  \
-  BOOST_PP_IDENTITY( BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS )()( params )
-
-#define BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS( first_param, second_param )        \
-  second_param first_param 
-
-#define BOOST_DETAIL_LEFT_OF_COMMA( params )                                   \
-  BOOST_PP_IDENTITY( BOOST_DETAIL_FIRST_MACRO_PARAM )()( params ) 
-
-#define BOOST_DETAIL_FIRST_MACRO_PARAM( first_param, second_param )            \
-  first_param 
-
-/* Begin derived concepts from Chaos by Paul Mensonides */
-
-#define BOOST_DETAIL_IS_NULLARY_ARGS( param )                                  \
-  BOOST_DETAIL_LEFT_OF_COMMA                                                   \
-  ( BOOST_PP_CAT( BOOST_DETAIL_IS_NULLARY_ARGS_R_                              \
-                , BOOST_DETAIL_IS_NULLARY_ARGS_C param                         \
-                )                                                              \
-  ) 
-
-#define BOOST_DETAIL_IS_NULLARY_ARGS_C()                                       \
-  1 
-
-#define BOOST_DETAIL_IS_NULLARY_ARGS_R_1                                       \
-  1, BOOST_PP_NIL 
-
-#define BOOST_DETAIL_IS_NULLARY_ARGS_R_BOOST_DETAIL_IS_NULLARY_ARGS_C          \
-  0, BOOST_PP_NIL 
-
-/* End derived concepts from Chaos by Paul Mensonides */
-
-#define BOOST_DETAIL_TRIPLE_TO_OCTAL_000 0 
-#define BOOST_DETAIL_TRIPLE_TO_OCTAL_001 1 
-#define BOOST_DETAIL_TRIPLE_TO_OCTAL_010 2 
-#define BOOST_DETAIL_TRIPLE_TO_OCTAL_011 3 
-#define BOOST_DETAIL_TRIPLE_TO_OCTAL_100 4 
-#define BOOST_DETAIL_TRIPLE_TO_OCTAL_101 5 
-#define BOOST_DETAIL_TRIPLE_TO_OCTAL_110 6 
-#define BOOST_DETAIL_TRIPLE_TO_OCTAL_111 7 
-
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0 (0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1 (1), 
-
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10 (1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11 (1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10 (1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11 (1)(1), 
-
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000 (0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001 (0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010 (0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011 (0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100 (1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101 (1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110 (1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111 (1)(1)(1), 
-
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000 (0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001 (0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010 (0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011 (0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100 (0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101 (0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110 (0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111 (0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000 (1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001 (1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010 (1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011 (1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100 (1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101 (1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110 (1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111 (1)(1)(1)(1), 
-
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000 (0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001 (0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010 (0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011 (0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100 (0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101 (0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110 (0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111 (0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000 (0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001 (0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010 (0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011 (0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100 (0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101 (0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110 (0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111 (0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000 (1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001 (1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010 (1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011 (1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100 (1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101 (1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110 (1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111 (1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000 (1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001 (1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010 (1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011 (1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100 (1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101 (1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110 (1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111 (1)(1)(1)(1)(1), 
-
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000000 (0)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000001 (0)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000010 (0)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000011 (0)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000100 (0)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000101 (0)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000110 (0)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000111 (0)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001000 (0)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001001 (0)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001010 (0)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001011 (0)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001100 (0)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001101 (0)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001110 (0)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001111 (0)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010000 (0)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010001 (0)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010010 (0)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010011 (0)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010100 (0)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010101 (0)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010110 (0)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010111 (0)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011000 (0)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011001 (0)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011010 (0)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011011 (0)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011100 (0)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011101 (0)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011110 (0)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011111 (0)(1)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100000 (1)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100001 (1)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100010 (1)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100011 (1)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100100 (1)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100101 (1)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100110 (1)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100111 (1)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101000 (1)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101001 (1)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101010 (1)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101011 (1)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101100 (1)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101101 (1)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101110 (1)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101111 (1)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110000 (1)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110001 (1)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110010 (1)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110011 (1)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110100 (1)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110101 (1)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110110 (1)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110111 (1)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111000 (1)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111001 (1)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111010 (1)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111011 (1)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111100 (1)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111101 (1)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111110 (1)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111111 (1)(1)(1)(1)(1)(1), 
-
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000000 (0)(0)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000001 (0)(0)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000010 (0)(0)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000011 (0)(0)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000100 (0)(0)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000101 (0)(0)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000110 (0)(0)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000111 (0)(0)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001000 (0)(0)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001001 (0)(0)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001010 (0)(0)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001011 (0)(0)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001100 (0)(0)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001101 (0)(0)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001110 (0)(0)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001111 (0)(0)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010000 (0)(0)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010001 (0)(0)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010010 (0)(0)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010011 (0)(0)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010100 (0)(0)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010101 (0)(0)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010110 (0)(0)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010111 (0)(0)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011000 (0)(0)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011001 (0)(0)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011010 (0)(0)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011011 (0)(0)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011100 (0)(0)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011101 (0)(0)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011110 (0)(0)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011111 (0)(0)(1)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100000 (0)(1)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100001 (0)(1)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100010 (0)(1)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100011 (0)(1)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100100 (0)(1)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100101 (0)(1)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100110 (0)(1)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100111 (0)(1)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101000 (0)(1)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101001 (0)(1)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101010 (0)(1)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101011 (0)(1)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101100 (0)(1)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101101 (0)(1)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101110 (0)(1)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101111 (0)(1)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110000 (0)(1)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110001 (0)(1)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110010 (0)(1)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110011 (0)(1)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110100 (0)(1)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110101 (0)(1)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110110 (0)(1)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110111 (0)(1)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111000 (0)(1)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111001 (0)(1)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111010 (0)(1)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111011 (0)(1)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111100 (0)(1)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111101 (0)(1)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111110 (0)(1)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111111 (0)(1)(1)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000000 (1)(0)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000001 (1)(0)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000010 (1)(0)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000011 (1)(0)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000100 (1)(0)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000101 (1)(0)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000110 (1)(0)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000111 (1)(0)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001000 (1)(0)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001001 (1)(0)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001010 (1)(0)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001011 (1)(0)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001100 (1)(0)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001101 (1)(0)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001110 (1)(0)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001111 (1)(0)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010000 (1)(0)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010001 (1)(0)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010010 (1)(0)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010011 (1)(0)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010100 (1)(0)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010101 (1)(0)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010110 (1)(0)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010111 (1)(0)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011000 (1)(0)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011001 (1)(0)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011010 (1)(0)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011011 (1)(0)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011100 (1)(0)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011101 (1)(0)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011110 (1)(0)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011111 (1)(0)(1)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100000 (1)(1)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100001 (1)(1)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100010 (1)(1)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100011 (1)(1)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100100 (1)(1)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100101 (1)(1)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100110 (1)(1)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100111 (1)(1)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101000 (1)(1)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101001 (1)(1)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101010 (1)(1)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101011 (1)(1)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101100 (1)(1)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101101 (1)(1)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101110 (1)(1)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101111 (1)(1)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110000 (1)(1)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110001 (1)(1)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110010 (1)(1)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110011 (1)(1)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110100 (1)(1)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110101 (1)(1)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110110 (1)(1)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110111 (1)(1)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111000 (1)(1)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111001 (1)(1)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111010 (1)(1)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111011 (1)(1)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111100 (1)(1)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111101 (1)(1)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111110 (1)(1)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111111 (1)(1)(1)(1)(1)(1)(1), 
-
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000000 (0)(0)(0)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000001 (0)(0)(0)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000010 (0)(0)(0)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000011 (0)(0)(0)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000100 (0)(0)(0)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000101 (0)(0)(0)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000110 (0)(0)(0)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000111 (0)(0)(0)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001000 (0)(0)(0)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001001 (0)(0)(0)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001010 (0)(0)(0)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001011 (0)(0)(0)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001100 (0)(0)(0)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001101 (0)(0)(0)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001110 (0)(0)(0)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001111 (0)(0)(0)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010000 (0)(0)(0)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010001 (0)(0)(0)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010010 (0)(0)(0)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010011 (0)(0)(0)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010100 (0)(0)(0)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010101 (0)(0)(0)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010110 (0)(0)(0)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010111 (0)(0)(0)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011000 (0)(0)(0)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011001 (0)(0)(0)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011010 (0)(0)(0)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011011 (0)(0)(0)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011100 (0)(0)(0)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011101 (0)(0)(0)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011110 (0)(0)(0)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011111 (0)(0)(0)(1)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100000 (0)(0)(1)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100001 (0)(0)(1)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100010 (0)(0)(1)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100011 (0)(0)(1)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100100 (0)(0)(1)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100101 (0)(0)(1)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100110 (0)(0)(1)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100111 (0)(0)(1)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101000 (0)(0)(1)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101001 (0)(0)(1)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101010 (0)(0)(1)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101011 (0)(0)(1)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101100 (0)(0)(1)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101101 (0)(0)(1)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101110 (0)(0)(1)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101111 (0)(0)(1)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110000 (0)(0)(1)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110001 (0)(0)(1)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110010 (0)(0)(1)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110011 (0)(0)(1)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110100 (0)(0)(1)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110101 (0)(0)(1)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110110 (0)(0)(1)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110111 (0)(0)(1)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111000 (0)(0)(1)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111001 (0)(0)(1)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111010 (0)(0)(1)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111011 (0)(0)(1)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111100 (0)(0)(1)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111101 (0)(0)(1)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111110 (0)(0)(1)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111111 (0)(0)(1)(1)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000000 (0)(1)(0)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000001 (0)(1)(0)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000010 (0)(1)(0)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000011 (0)(1)(0)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000100 (0)(1)(0)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000101 (0)(1)(0)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000110 (0)(1)(0)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000111 (0)(1)(0)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001000 (0)(1)(0)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001001 (0)(1)(0)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001010 (0)(1)(0)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001011 (0)(1)(0)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001100 (0)(1)(0)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001101 (0)(1)(0)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001110 (0)(1)(0)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001111 (0)(1)(0)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010000 (0)(1)(0)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010001 (0)(1)(0)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010010 (0)(1)(0)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010011 (0)(1)(0)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010100 (0)(1)(0)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010101 (0)(1)(0)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010110 (0)(1)(0)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010111 (0)(1)(0)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011000 (0)(1)(0)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011001 (0)(1)(0)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011010 (0)(1)(0)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011011 (0)(1)(0)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011100 (0)(1)(0)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011101 (0)(1)(0)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011110 (0)(1)(0)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011111 (0)(1)(0)(1)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100000 (0)(1)(1)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100001 (0)(1)(1)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100010 (0)(1)(1)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100011 (0)(1)(1)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100100 (0)(1)(1)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100101 (0)(1)(1)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100110 (0)(1)(1)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100111 (0)(1)(1)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101000 (0)(1)(1)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101001 (0)(1)(1)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101010 (0)(1)(1)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101011 (0)(1)(1)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101100 (0)(1)(1)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101101 (0)(1)(1)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101110 (0)(1)(1)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101111 (0)(1)(1)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110000 (0)(1)(1)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110001 (0)(1)(1)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110010 (0)(1)(1)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110011 (0)(1)(1)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110100 (0)(1)(1)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110101 (0)(1)(1)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110110 (0)(1)(1)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110111 (0)(1)(1)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111000 (0)(1)(1)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111001 (0)(1)(1)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111010 (0)(1)(1)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111011 (0)(1)(1)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111100 (0)(1)(1)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111101 (0)(1)(1)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111110 (0)(1)(1)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111111 (0)(1)(1)(1)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000000 (1)(0)(0)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000001 (1)(0)(0)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000010 (1)(0)(0)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000011 (1)(0)(0)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000100 (1)(0)(0)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000101 (1)(0)(0)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000110 (1)(0)(0)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000111 (1)(0)(0)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001000 (1)(0)(0)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001001 (1)(0)(0)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001010 (1)(0)(0)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001011 (1)(0)(0)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001100 (1)(0)(0)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001101 (1)(0)(0)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001110 (1)(0)(0)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001111 (1)(0)(0)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010000 (1)(0)(0)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010001 (1)(0)(0)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010010 (1)(0)(0)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010011 (1)(0)(0)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010100 (1)(0)(0)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010101 (1)(0)(0)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010110 (1)(0)(0)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010111 (1)(0)(0)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011000 (1)(0)(0)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011001 (1)(0)(0)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011010 (1)(0)(0)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011011 (1)(0)(0)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011100 (1)(0)(0)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011101 (1)(0)(0)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011110 (1)(0)(0)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011111 (1)(0)(0)(1)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100000 (1)(0)(1)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100001 (1)(0)(1)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100010 (1)(0)(1)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100011 (1)(0)(1)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100100 (1)(0)(1)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100101 (1)(0)(1)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100110 (1)(0)(1)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100111 (1)(0)(1)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101000 (1)(0)(1)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101001 (1)(0)(1)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101010 (1)(0)(1)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101011 (1)(0)(1)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101100 (1)(0)(1)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101101 (1)(0)(1)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101110 (1)(0)(1)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101111 (1)(0)(1)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110000 (1)(0)(1)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110001 (1)(0)(1)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110010 (1)(0)(1)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110011 (1)(0)(1)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110100 (1)(0)(1)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110101 (1)(0)(1)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110110 (1)(0)(1)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110111 (1)(0)(1)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111000 (1)(0)(1)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111001 (1)(0)(1)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111010 (1)(0)(1)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111011 (1)(0)(1)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111100 (1)(0)(1)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111101 (1)(0)(1)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111110 (1)(0)(1)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111111 (1)(0)(1)(1)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000000 (1)(1)(0)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000001 (1)(1)(0)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000010 (1)(1)(0)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000011 (1)(1)(0)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000100 (1)(1)(0)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000101 (1)(1)(0)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000110 (1)(1)(0)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000111 (1)(1)(0)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001000 (1)(1)(0)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001001 (1)(1)(0)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001010 (1)(1)(0)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001011 (1)(1)(0)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001100 (1)(1)(0)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001101 (1)(1)(0)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001110 (1)(1)(0)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001111 (1)(1)(0)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010000 (1)(1)(0)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010001 (1)(1)(0)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010010 (1)(1)(0)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010011 (1)(1)(0)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010100 (1)(1)(0)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010101 (1)(1)(0)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010110 (1)(1)(0)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010111 (1)(1)(0)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011000 (1)(1)(0)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011001 (1)(1)(0)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011010 (1)(1)(0)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011011 (1)(1)(0)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011100 (1)(1)(0)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011101 (1)(1)(0)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011110 (1)(1)(0)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011111 (1)(1)(0)(1)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100000 (1)(1)(1)(0)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100001 (1)(1)(1)(0)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100010 (1)(1)(1)(0)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100011 (1)(1)(1)(0)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100100 (1)(1)(1)(0)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100101 (1)(1)(1)(0)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100110 (1)(1)(1)(0)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100111 (1)(1)(1)(0)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101000 (1)(1)(1)(0)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101001 (1)(1)(1)(0)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101010 (1)(1)(1)(0)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101011 (1)(1)(1)(0)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101100 (1)(1)(1)(0)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101101 (1)(1)(1)(0)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101110 (1)(1)(1)(0)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101111 (1)(1)(1)(0)(1)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110000 (1)(1)(1)(1)(0)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110001 (1)(1)(1)(1)(0)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110010 (1)(1)(1)(1)(0)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110011 (1)(1)(1)(1)(0)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110100 (1)(1)(1)(1)(0)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110101 (1)(1)(1)(1)(0)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110110 (1)(1)(1)(1)(0)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110111 (1)(1)(1)(1)(0)(1)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111000 (1)(1)(1)(1)(1)(0)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111001 (1)(1)(1)(1)(1)(0)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111010 (1)(1)(1)(1)(1)(0)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111011 (1)(1)(1)(1)(1)(0)(1)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111100 (1)(1)(1)(1)(1)(1)(0)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111101 (1)(1)(1)(1)(1)(1)(0)(1), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111110 (1)(1)(1)(1)(1)(1)(1)(0), 
-#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111111 (1)(1)(1)(1)(1)(1)(1)(1), 
-
-#endif

include/boost/utility/chk_dbl_die.hpp

@@ -0,0 +1,17 @@
+//object_tracked with DTOR check for double destruction (death)
+#ifndef BOOST_DEBUG_UTILITY_CHK_DBL_DELETE_HPP_LJE20040129
+#define BOOST_UTILITY_CHK_DBL_DELETE_HPP_LJE20040129
+#include "boost/utility/object_tracked.hpp"
+#include <boost/test/test_tools.hpp>
+namespace utility
+{
+struct chk_dbl_die
+: public object_tracked
+{
+    ~chk_dbl_die(void)
+    {
+        BOOST_CHECK(am_i_live());
+    }
+};
+}//exit utility namespace
+#endif

include/boost/utility/compare_pointees.hpp

@@ -1,76 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-//
-// 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)
-//
-// See http://www.boost.org/libs/optional for documentation.
-//
-// You are welcome to contact the author at:
-//  fernando_cacciola@hotmail.com
-//
-#ifndef BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP
-#define BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP
-
-#include<functional>
-
-namespace boost {
-
-// template<class OP> bool equal_pointees(OP const& x, OP const& y);
-// template<class OP> struct equal_pointees_t;
-//
-// Being OP a model of OptionalPointee (either a pointer or an optional):
-//
-// If both x and y have valid pointees, returns the result of (*x == *y)
-// If only one has a valid pointee, returns false.
-// If none have valid pointees, returns true.
-// No-throw
-template<class OptionalPointee>
-inline
-bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
-{
-  return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
-}
-
-template<class OptionalPointee>
-struct equal_pointees_t
-{
-  typedef bool result_type;
-  typedef OptionalPointee first_argument_type;
-  typedef OptionalPointee second_argument_type;
-
-  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
-    { return equal_pointees(x,y) ; }
-} ;
-
-// template<class OP> bool less_pointees(OP const& x, OP const& y);
-// template<class OP> struct less_pointees_t;
-//
-// Being OP a model of OptionalPointee (either a pointer or an optional):
-//
-// If y has not a valid pointee, returns false.
-// ElseIf x has not a valid pointee, returns true.
-// ElseIf both x and y have valid pointees, returns the result of (*x < *y)
-// No-throw
-template<class OptionalPointee>
-inline
-bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
-{
-  return !y ? false : ( !x ? true : (*x) < (*y) ) ;
-}
-
-template<class OptionalPointee>
-struct less_pointees_t
-{
-  typedef bool result_type;
-  typedef OptionalPointee first_argument_type;
-  typedef OptionalPointee second_argument_type;
-
-  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
-    { return less_pointees(x,y) ; }
-} ;
-
-} // namespace boost
-
-#endif
-

include/boost/utility/detail/in_place_factory_prefix.hpp

@@ -1,36 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-// Copyright (C) 2007, Tobias Schwinger.
-//
-// 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)
-//
-// See http://www.boost.org/libs/optional for documentation.
-//
-// You are welcome to contact the author at:
-//  fernando_cacciola@hotmail.com
-//
-#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
-#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
-
-#include <new>
-#include <cstddef>
-#include <boost/config.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/punctuation/paren.hpp>
-#include <boost/preprocessor/iteration/iterate.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-
-#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT(z,n,_) BOOST_PP_CAT(m_a,n) BOOST_PP_LPAREN() BOOST_PP_CAT(a,n) BOOST_PP_RPAREN()
-#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL(z,n,_) BOOST_PP_CAT(A,n) const& BOOST_PP_CAT(m_a,n);
-
-#define BOOST_MAX_INPLACE_FACTORY_ARITY 10
-
-#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
-
-#endif
-

include/boost/utility/detail/in_place_factory_suffix.hpp

@@ -1,23 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-// Copyright (C) 2007, Tobias Schwinger.
-//
-// 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)
-//
-// See http://www.boost.org/libs/optional for documentation.
-//
-// You are welcome to contact the author at:
-//  fernando_cacciola@hotmail.com
-//
-#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
-#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
-
-#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT
-#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL
-#undef BOOST_MAX_INPLACE_FACTORY_ARITY
-
-#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
-
-#endif
-

include/boost/utility/detail/minstd_rand.hpp

@@ -1,58 +0,0 @@
-#ifndef BOOST_UTILITY_DETAIL_MINSTD_RAND_HPP_INCLUDED
-#define BOOST_UTILITY_DETAIL_MINSTD_RAND_HPP_INCLUDED
-
-// Copyright 2017 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
-//
-// An implementation of minstd_rand that does not require
-// the Random library
-
-#include <boost/cstdint.hpp>
-
-namespace boost
-{
-namespace detail
-{
-
-class minstd_rand
-{
-private:
-
-    boost::uint_least32_t x_;
-
-    enum { a = 48271, m = 2147483647 };
-
-public:
-
-    minstd_rand(): x_( 1 )
-    {
-    }
-
-    explicit minstd_rand( boost::uint_least32_t x ): x_( x % m )
-    {
-        if( x_ == 0 )
-        {
-            x_ = 1;
-        }
-    }
-
-    boost::uint_least32_t operator()()
-    {
-        boost::uint_least64_t y = x_;
-
-        y = ( a * y ) % m;
-
-        x_ = static_cast<boost::uint_least32_t>( y );
-
-        return x_;
-    }
-};
-
-} // namespace detail
-} // namespace boost
-
-#endif // #ifndef BOOST_UTILITY_DETAIL_MINSTD_RAND_HPP_INCLUDED

include/boost/utility/detail/result_of_iterate.hpp

@@ -1,218 +0,0 @@
-// Boost result_of library
-
-//  Copyright Douglas Gregor 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)
-
-//  Copyright Daniel Walker, Eric Niebler, Michel Morin 2008-2012.
-//  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/utility
-#if !defined(BOOST_PP_IS_ITERATING)
-# error Boost result_of - do not include this file!
-#endif
-
-// CWPro8 requires an argument in a function type specialization
-#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3002)) && BOOST_PP_ITERATION() == 0
-# define BOOST_RESULT_OF_ARGS void
-#else
-# define BOOST_RESULT_OF_ARGS BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)
-#endif
-
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct tr1_result_of<F(BOOST_RESULT_OF_ARGS)>
-    : conditional<
-        is_pointer<F>::value || is_member_function_pointer<F>::value
-        , boost::detail::tr1_result_of_impl<
-            typename remove_cv<F>::type,
-            typename remove_cv<F>::type(BOOST_RESULT_OF_ARGS),
-            (boost::detail::result_of_has_result_type<F>::value)>
-        , boost::detail::tr1_result_of_impl<
-            F,
-            F(BOOST_RESULT_OF_ARGS),
-            (boost::detail::result_of_has_result_type<F>::value)> >::type { };
-#endif
-
-#ifdef BOOST_RESULT_OF_USE_DECLTYPE
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<F(BOOST_RESULT_OF_ARGS)>
-    : detail::cpp0x_result_of<F(BOOST_RESULT_OF_ARGS)> { };
-#endif // BOOST_RESULT_OF_USE_DECLTYPE
-
-#ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<F(BOOST_RESULT_OF_ARGS)>
-    : conditional<detail::result_of_has_result_type<F>::value || detail::result_of_has_result<F>::value,
-               tr1_result_of<F(BOOST_RESULT_OF_ARGS)>,
-               detail::cpp0x_result_of<F(BOOST_RESULT_OF_ARGS)> >::type { };
-#endif // BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
-
-#if defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
-
-namespace detail {
-
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct cpp0x_result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
-    : conditional<
-          is_member_function_pointer<F>::value
-        , detail::tr1_result_of_impl<
-            typename remove_cv<F>::type,
-            typename remove_cv<F>::type(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
-          >
-        , detail::cpp0x_result_of_impl<
-              F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))
-          >
-      >::type
-{};
-
-#ifdef BOOST_NO_SFINAE_EXPR
-
-template<typename F>
-struct BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION());
-
-template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename T)>
-struct BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<R(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), T))> {
-    R operator()(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), T)) const;
-    typedef result_of_private_type const &(*pfn_t)(...);
-    operator pfn_t() const volatile;
-};
-
-template<typename F>
-struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())
-  : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
-{};
-
-template<typename F>
-struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<F *>
-  : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
-{};
-
-template<typename F>
-struct BOOST_PP_CAT(result_of_select_call_wrapper_type_, BOOST_PP_ITERATION())
-  : conditional<
-        is_class<typename remove_reference<F>::type>::value,
-        result_of_wrap_callable_class<F>,
-        type_identity<BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<typename remove_cv<typename remove_reference<F>::type>::type> >
-    >::type
-{};
-
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename T)>
-struct BOOST_PP_CAT(result_of_is_callable_, BOOST_PP_ITERATION()) {
-    typedef typename BOOST_PP_CAT(result_of_select_call_wrapper_type_, BOOST_PP_ITERATION())<F>::type wrapper_t;
-    static const bool value = (
-        sizeof(result_of_no_type) == sizeof(detail::result_of_is_private_type(
-            (boost::declval<wrapper_t>()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)), result_of_weird_type())
-        ))
-    );
-    typedef integral_constant<bool, value> type;
-};
-
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), true>
-    : lazy_enable_if<
-          BOOST_PP_CAT(result_of_is_callable_, BOOST_PP_ITERATION())<F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), T)>
-        , cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false>
-      >
-{};
-
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false>
-{
-  typedef decltype(
-    boost::declval<F>()(
-      BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
-    )
-  ) type;
-};
-
-#else // BOOST_NO_SFINAE_EXPR
-
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)),
-                            typename result_of_always_void<decltype(
-                                boost::declval<F>()(
-                                    BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
-                                )
-                            )>::type> {
-  typedef decltype(
-    boost::declval<F>()(
-      BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
-    )
-  ) type;
-};
-
-#endif // BOOST_NO_SFINAE_EXPR
-
-} // namespace detail
-
-#else // defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
-
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<F(BOOST_RESULT_OF_ARGS)>
-    : tr1_result_of<F(BOOST_RESULT_OF_ARGS)> { };
-#endif
-
-#endif // defined(BOOST_RESULT_OF_USE_DECLTYPE)
-
-#undef BOOST_RESULT_OF_ARGS
-
-#if BOOST_PP_ITERATION() >= 1
-
-namespace detail {
-
-template<typename R,  typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct tr1_result_of_impl<R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
-{
-  typedef R type;
-};
-
-template<typename R,  typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct tr1_result_of_impl<R (&)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
-{
-  typedef R type;
-};
-
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct tr1_result_of_impl<R (T0::*)
-                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T)),
-                 FArgs, false>
-{
-  typedef R type;
-};
-
-template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct tr1_result_of_impl<R (T0::*)
-                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
-                     const,
-                 FArgs, false>
-{
-  typedef R type;
-};
-
-template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct tr1_result_of_impl<R (T0::*)
-                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
-                     volatile,
-                 FArgs, false>
-{
-  typedef R type;
-};
-
-template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct tr1_result_of_impl<R (T0::*)
-                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
-                     const volatile,
-                 FArgs, false>
-{
-  typedef R type;
-};
-#endif
-
-}
-#endif

include/boost/utility/enable_if.hpp

@@ -0,0 +1,87 @@
+// Copyright 2003 © The Trustees of Indiana University.
+
+// Boost Software License - Version 1.0 - August 17th, 2003
+
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+//    Authors: Jaakko Järvi (jajarvi at osl.iu.edu)
+//             Jeremiah Willcock (jewillco at osl.iu.edu)
+//             Andrew Lumsdaine (lums at osl.iu.edu)
+
+
+#ifndef BOOST_UTILITY_ENABLE_IF_HPP
+#define BOOST_UTILITY_ENABLE_IF_HPP
+
+namespace boost
+{
+ 
+  template <bool B, class T = void>
+  struct enable_if_c {
+    typedef T type;
+  };
+
+  template <class T>
+  struct enable_if_c<false, T> {};
+
+  template <class Cond, class T = void> 
+  struct enable_if : public enable_if_c<Cond::value, T> {};
+
+  template <bool B, class T>
+  struct lazy_enable_if_c {
+    typedef typename T::type type;
+  };
+
+  template <class T>
+  struct lazy_enable_if_c<false, T> {};
+
+  template <class Cond, class T> 
+  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
+
+
+  template <bool B, class T = void>
+  struct disable_if_c {
+    typedef T type;
+  };
+
+  template <class T>
+  struct disable_if_c<true, T> {};
+
+  template <class Cond, class T = void> 
+  struct disable_if : public disable_if_c<Cond::value, T> {};
+
+  template <bool B, class T>
+  struct lazy_disable_if_c {
+    typedef typename T::type type;
+  };
+
+  template <class T>
+  struct lazy_disable_if_c<true, T> {};
+
+  template <class Cond, class T> 
+  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
+
+
+  
+} // namespace boost
+
+#endif

include/boost/utility/identity_type.hpp

@@ -1,46 +0,0 @@
-
-// Copyright (C) 2009-2012 Lorenzo Caminiti
-// Distributed under the Boost Software License, Version 1.0
-// (see accompanying file LICENSE_1_0.txt or a copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// Home at http://www.boost.org/libs/utility/identity_type
-
-/** @file
-Wrap type expressions with round parenthesis so they can be passed to macros
-even if they contain commas.
-*/
-
-#ifndef BOOST_IDENTITY_TYPE_HPP_
-#define BOOST_IDENTITY_TYPE_HPP_
-
-#include <boost/type_traits/function_traits.hpp>
-
-/**
-@brief This macro allows to wrap the specified type expression within extra
-round parenthesis so the type can be passed as a single macro parameter even if
-it contains commas (not already wrapped within round parenthesis).
-
-@Params
-@Param{parenthesized_type,
-The type expression to be passed as macro parameter wrapped by a single set
-of round parenthesis <c>(...)</c>.
-This type expression can contain an arbitrary number of commas.
-}
-@EndParams
-
-This macro works on any C++03 compiler (it does not use variadic macros).
-
-This macro must be prefixed by <c>typename</c> when used within templates.
-Note that the compiler will not be able to automatically determine function
-template parameters when they are wrapped with this macro (these parameters
-need to be explicitly specified when calling the function template).
-
-On some compilers (like GCC), using this macro on abstract types requires to
-add and remove a reference to the specified type.
-*/
-#define BOOST_IDENTITY_TYPE(parenthesized_type) \
-    /* must NOT prefix this with `::` to work with parenthesized syntax */ \
-    boost::function_traits< void parenthesized_type >::arg1_type
-
-#endif // #include guard
-

include/boost/utility/in_place_factory.hpp

@@ -1,86 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-// Copyright (C) 2007, Tobias Schwinger.
-//
-// 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)
-//
-// See http://www.boost.org/libs/optional for documentation.
-//
-// You are welcome to contact the author at:
-//  fernando_cacciola@hotmail.com
-//
-#ifndef BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
-#ifndef BOOST_PP_IS_ITERATING
-
-#include <boost/utility/detail/in_place_factory_prefix.hpp>
-
-namespace boost {
-
-class in_place_factory_base {} ;
-
-#define  BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY)
-#define  BOOST_PP_FILENAME_1 <boost/utility/in_place_factory.hpp>
-#include BOOST_PP_ITERATE()
-
-} // namespace boost
-
-#include <boost/utility/detail/in_place_factory_suffix.hpp>
-
-#define BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
-#else
-#define N BOOST_PP_ITERATION()
-
-#if N
-template< BOOST_PP_ENUM_PARAMS(N, class A) >
-#endif
-class BOOST_PP_CAT(in_place_factory,N)
-  : 
-  public in_place_factory_base
-{
-public:
-
-  explicit BOOST_PP_CAT(in_place_factory,N)
-      ( BOOST_PP_ENUM_BINARY_PARAMS(N,A,const& a) )
-#if N > 0
-    : BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _)
-#endif
-  {}
-
-  template<class T>
-  void* apply(void* address) const
-  {
-    return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
-  }
-
-  template<class T>
-  void* apply(void* address, std::size_t n) const
-  {
-    for(char* next = address = this->BOOST_NESTED_TEMPLATE apply<T>(address);
-        !! --n;)
-      this->BOOST_NESTED_TEMPLATE apply<T>(next = next+sizeof(T));
-    return address; 
-  }
-
-  BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _)
-};
-
-#if N > 0
-template< BOOST_PP_ENUM_PARAMS(N, class A) >
-inline BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
-in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
-{
-  return BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
-      ( BOOST_PP_ENUM_PARAMS(N, a) );
-}
-#else
-inline in_place_factory0 in_place()
-{
-  return in_place_factory0();
-}
-#endif
-
-#undef N
-#endif
-#endif
-

include/boost/utility/lexicographic.hpp

@@ -0,0 +1,105 @@
+// Copyright (c) 2003 Jan Langer
+// 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)
+
+//  See library home page at http://www.boost.org/libs/utility
+ 
+#ifndef BOOST_UTILITY_LEXICOGRAPHIC_HPP
+#define BOOST_UTILITY_LEXICOGRAPHIC_HPP
+
+namespace boost
+{
+
+  class lexicographic
+  {
+    public:
+      enum result_type { minus = -1, equivalent = 0, plus = +1 };
+    
+    private:
+      typedef void (lexicographic::*unspecified_bool_type) ();
+      void safe_bool_conversion () {}
+        
+      template <typename T1, typename T2>
+      result_type do_compare (T1 const &a, T2 const &b) const
+      {
+          if (a < b)
+              return minus;
+          else if (b < a)
+              return plus;
+          else 
+              return equivalent;
+      }
+      template <typename T1, typename T2, typename Cmp>
+      result_type do_compare (T1 const &a, T2 const &b, Cmp cmp) const
+      {
+          if (cmp (a, b))
+              return minus;
+          else if (cmp (b, a))
+              return plus;
+          else 
+              return equivalent;
+      }
+      
+    public:
+      lexicographic () : m_value (equivalent) {}
+
+      template <typename T1, typename T2>
+      lexicographic (T1 const &a, T2 const &b) 
+          : m_value (do_compare (a, b))
+      {}
+      template <typename T1, typename T2, typename Cmp>
+      lexicographic (T1 const &a, T2 const &b, Cmp cmp) 
+          : m_value (do_compare (a, b, cmp))
+      {}
+    
+      template <typename T1, typename T2>
+      lexicographic &operator () (T1 const &a, T2 const &b)
+      {
+          if (m_value == equivalent) 
+            m_value = do_compare (a, b);
+          return *this;
+      }
+      template <typename T1, typename T2, typename Cmp>
+      lexicographic &operator () (T1 const &a, T2 const &b, Cmp cmp)
+      {
+          if (m_value == equivalent) 
+            m_value = do_compare (a, b, cmp); 
+          return *this;
+      }
+
+      result_type result () const 
+      { 
+          return m_value; 
+      }
+      
+      operator unspecified_bool_type () const 
+      { 
+          return (m_value == minus) 
+                      ? &lexicographic::safe_bool_conversion 
+                      : 0; 
+      }
+      
+      // somehow only needed old compilers
+      bool operator ! () const
+      {
+          return m_value != minus;
+      }
+
+    private:
+      result_type m_value;
+  };
+
+  bool operator == (lexicographic l1, lexicographic l2)
+  {
+      return l1.result () == l2.result ();
+  }
+  
+  bool operator != (lexicographic l1, lexicographic l2)
+  {
+      return l1.result () != l2.result ();
+  }
+  
+} // namespace boost
+
+#endif // BOOST_UTILITY_LEXICOGRAPHIC_HPP

include/boost/utility/obj_id.hpp

@@ -0,0 +1,49 @@
+#ifndef UTILITY_OBJ_ID_HPP
+#define UTILITY_OBJ_ID_HPP
+namespace utility
+  {
+  struct obj_id
+   /**@class obj_id
+    * @brief Provide unique id for objects
+    */
+    {
+          typedef
+        unsigned
+      id_type
+        ;
+      ~obj_id(void)
+        {}
+      obj_id(void)
+        :m_id(the_last_id()++)
+        {}
+      obj_id(obj_id const&)
+        :m_id(the_last_id()++)
+        {}
+        void
+      operator=(obj_id const&)
+        {}
+        id_type
+      id_get(void)const
+        { return m_id
+        ;}
+          static
+        id_type&
+      the_last_id(void)
+        //reference to count if id's created
+        ;
+    private:
+        id_type
+      m_id
+        ;
+    };//end obj_id struct
+  }//exit utility namespace
+//----------------------------  
+//ChangeLog:
+//  2005-06-17: Larry Evans
+//    WHAT:
+//      rm'ed virtual DTOR
+//    WHY:
+//      comment that had accompanied it and justified use of
+//      virtual DTOR is no longer relevant.
+#endif
+

include/boost/utility/object_tracked.hpp

@@ -0,0 +1,118 @@
+//Simple class which keeps track of members
+#ifndef UTILITY_OBJECT_TRACKED_HPP_LJE20040112
+#define UTILITY_OBJECT_TRACKED_HPP_LJE20040112
+//#define UTILITY_OBJECT_TRACKED_SET_OF_OBJECTS_TRACE_MODE
+//#define UTILITY_OBJECT_TRACKED_TRACE_MODE
+#include <set>
+#include "boost/utility/obj_id.hpp"
+#if defined(UTILITY_OBJECT_TRACKED_SET_OF_OBJECTS_TRACE_MODE)\
+ || defined(UTILITY_OBJECT_TRACKED_TRACE_MODE)
+#include "boost/io/filters/mout.hpp"
+#endif
+namespace utility
+{
+class object_tracked
+: public obj_id
+{
+ private:
+ 
+      struct 
+    set_of_objects_tracked
+      : public std::set<object_tracked const*>
+    {
+            typedef 
+          std::set<object_tracked const*>
+        super_type
+        ;
+        ~set_of_objects_tracked(void)
+        {
+          #ifdef UTILITY_OBJECT_TRACKED_SET_OF_OBJECTS_TRACE_MODE
+            mout()<<"set_of_objects_tracked-\n";
+          #endif
+        }
+        set_of_objects_tracked(void)
+        {
+          #ifdef UTILITY_OBJECT_TRACKED_SET_OF_OBJECTS_TRACE_MODE
+            mout()<<"set_of_objects_tracked+\n";
+          #endif
+        }
+          void
+        reset(void)
+        {
+            super_type::clear();
+            obj_id::the_last_id() = 0;
+        }
+          bool
+        contains(object_tracked const*& a_obj)const
+        {
+            return find(a_obj) != end();
+        }
+        
+    };
+        static
+      set_of_objects_tracked
+    our_members
+    ;
+ public:
+        static
+      void
+    reset(void)
+    {
+        our_members.reset();
+    }
+        static
+      unsigned
+    members_size(void)
+    {
+          return our_members.size();
+    }
+    
+    object_tracked(void)
+    {
+        our_members.insert(this);
+      #ifdef UTILITY_OBJECT_TRACKED_TRACE_MODE
+        mout()<<"object_tracked+:id="<<id_get()<<":default\n";
+      #endif
+    }
+    object_tracked(object_tracked const& a_obj)
+    {
+        our_members.insert(this);
+      #ifdef UTILITY_OBJECT_TRACKED_TRACE_MODE
+        mout()<<"object_tracked+:id="<<id_get()<<":copy\n";
+      #endif
+    }
+
+        virtual 
+    ~object_tracked(void) 
+    { 
+      #ifdef UTILITY_OBJECT_TRACKED_TRACE_MODE
+        mout()<<"object_tracked-:id="<<id_get()<<":am_i_live="<<am_i_live()<<"\n";
+      #endif  
+        utility::object_tracked const*me=this;
+        our_members.erase(me); 
+    }
+        bool
+    am_i_live(void)const
+    //Purpose:
+    //  Used to check for multiple destructor calls.  Should always return true
+    //  if only place where our_members.erase is called is in
+    //  ~object_tracked.
+    {
+        utility::object_tracked const*me=this;
+        bool result=utility::object_tracked::our_members.contains(me);
+        return result;
+    }
+        static
+      bool
+    is_live(utility::object_tracked const*a_ot)
+    {
+        bool result=utility::object_tracked::our_members.contains(a_ot);
+        return result;
+    }
+
+};
+
+}//exit utility namespace
+
+#endif
+

include/boost/utility/ostream_string.hpp

@@ -1,95 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_UTILITY_OSTREAM_STRING_HPP
-#define BOOST_UTILITY_OSTREAM_STRING_HPP
-
-#include <boost/config.hpp>
-#include <iosfwd>
-#include <cstddef>
-
-namespace boost {
-namespace detail {
-
-template<class charT, class traits>
-inline std::size_t
-oss_put(std::basic_ostream<charT, traits>& os, const charT* data,
-    std::size_t size)
-{
-    return static_cast<std::size_t>(os.rdbuf()->sputn(data, size));
-}
-
-template<class charT, class traits>
-inline bool
-oss_fill(std::basic_ostream<charT, traits>& os, std::size_t size)
-{
-    charT c = os.fill();
-    charT fill[] = { c, c, c, c, c, c, c, c };
-    enum {
-        chunk = sizeof fill / sizeof(charT)
-    };
-    for (; size > chunk; size -= chunk) {
-        if (boost::detail::oss_put(os, fill, chunk) != chunk) {
-            return false;
-        }
-    }
-    return boost::detail::oss_put(os, fill, size) == size;
-}
-
-template<class charT, class traits>
-class oss_guard {
-public:
-    explicit oss_guard(std::basic_ostream<charT, traits>& os) BOOST_NOEXCEPT
-        : os_(&os) { }
-    ~oss_guard() BOOST_NOEXCEPT_IF(false) {
-        if (os_) {
-            os_->setstate(std::basic_ostream<charT, traits>::badbit);
-        }
-    }
-    void release() BOOST_NOEXCEPT {
-        os_ = 0;
-    }
-private:
-    oss_guard(const oss_guard&);
-    oss_guard& operator=(const oss_guard&);
-    std::basic_ostream<charT, traits>* os_;
-};
-
-} /* detail */
-
-template<class charT, class traits>
-inline std::basic_ostream<charT, traits>&
-ostream_string(std::basic_ostream<charT, traits>& os, const charT* data,
-    std::size_t size)
-{
-    typedef std::basic_ostream<charT, traits> stream;
-    detail::oss_guard<charT, traits> guard(os);
-    typename stream::sentry entry(os);
-    if (entry) {
-        std::size_t width = static_cast<std::size_t>(os.width());
-        if (width <= size) {
-            if (detail::oss_put(os, data, size) != size) {
-                return os;
-            }
-        } else if ((os.flags() & stream::adjustfield) == stream::left) {
-            if (detail::oss_put(os, data, size) != size ||
-                !detail::oss_fill(os, width - size)) {
-                return os;
-            }
-        } else if (!detail::oss_fill(os, width - size) ||
-            detail::oss_put(os, data, size) != size) {
-            return os;
-        }
-        os.width(0);
-    }
-    guard.release();
-    return os;
-}
-
-} /* boost */
-
-#endif

include/boost/utility/result_of.hpp

@@ -1,234 +0,0 @@
-// Boost result_of library
-
-//  Copyright Douglas Gregor 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)
-
-// For more information, see http://www.boost.org/libs/utility
-#ifndef BOOST_RESULT_OF_HPP
-#define BOOST_RESULT_OF_HPP
-
-#include <boost/config.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/iteration/iterate.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
-#include <boost/preprocessor/facilities/intercept.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_member_function_pointer.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/declval.hpp>
-#include <boost/type_traits/conditional.hpp>
-#include <boost/type_traits/type_identity.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/core/enable_if.hpp>
-
-#ifndef BOOST_RESULT_OF_NUM_ARGS
-#  define BOOST_RESULT_OF_NUM_ARGS 16
-#endif
-
-// Use the decltype-based version of result_of by default if the compiler
-// supports N3276 <http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf>.
-// The user can force the choice by defining BOOST_RESULT_OF_USE_DECLTYPE,
-// BOOST_RESULT_OF_USE_TR1, or BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK but not more than one!
-#if (defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_RESULT_OF_USE_TR1)) || \
-    (defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)) || \
-    (defined(BOOST_RESULT_OF_USE_TR1) && defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK))
-#  error More than one of BOOST_RESULT_OF_USE_DECLTYPE, BOOST_RESULT_OF_USE_TR1 and \
-  BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK cannot be defined at the same time.
-#endif
-
-#ifndef BOOST_RESULT_OF_USE_TR1
-#  ifndef BOOST_RESULT_OF_USE_DECLTYPE
-#    ifndef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
-#      ifndef BOOST_NO_CXX11_DECLTYPE_N3276 // this implies !defined(BOOST_NO_CXX11_DECLTYPE)
-#        define BOOST_RESULT_OF_USE_DECLTYPE
-#      else
-#        define BOOST_RESULT_OF_USE_TR1
-#      endif
-#    endif
-#  endif
-#endif
-
-namespace boost {
-
-template<typename F> struct result_of;
-template<typename F> struct tr1_result_of; // a TR1-style implementation of result_of
-
-#if !defined(BOOST_NO_SFINAE)
-namespace detail {
-
-typedef char result_of_yes_type;      // sizeof(result_of_yes_type) == 1
-typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type)  == 2
-
-template<class T> struct result_of_has_type {};
-
-template<class T> struct result_of_has_result_type_impl
-{
-    template<class U> static result_of_yes_type f( result_of_has_type<typename U::result_type>* );
-    template<class U> static result_of_no_type f( ... );
-
-    typedef boost::integral_constant<bool, sizeof(f<T>(0)) == sizeof(result_of_yes_type)> type;
-};
-
-template<class T> struct result_of_has_result_type: result_of_has_result_type_impl<T>::type
-{
-};
-
-// Work around a nvcc bug by only defining has_result when it's needed.
-#ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
-
-template<template<class> class C> struct result_of_has_template {};
-
-template<class T> struct result_of_has_result_impl
-{
-    template<class U> static result_of_yes_type f( result_of_has_template<U::template result>* );
-    template<class U> static result_of_no_type f( ... );
-
-    typedef boost::integral_constant<bool, sizeof(f<T>(0)) == sizeof(result_of_yes_type)> type;
-};
-
-template<class T> struct result_of_has_result: result_of_has_result_impl<T>::type
-{
-};
-
-#endif
-
-template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
-
-template<typename F> struct cpp0x_result_of;
-
-#ifdef BOOST_NO_SFINAE_EXPR
-
-// There doesn't seem to be any other way to turn this off such that the presence of
-// the user-defined operator,() below doesn't cause spurious warning all over the place,
-// so unconditionally turn it off.
-#if BOOST_MSVC
-#  pragma warning(disable: 4913) // user defined binary operator ',' exists but no overload could convert all operands, default built-in binary operator ',' used
-#endif
-
-struct result_of_private_type {};
-
-struct result_of_weird_type {
-  friend result_of_private_type operator,(result_of_private_type, result_of_weird_type);
-};
-
-template<typename T>
-result_of_no_type result_of_is_private_type(T const &);
-result_of_yes_type result_of_is_private_type(result_of_private_type);
-
-template<typename C>
-struct result_of_callable_class : C {
-    result_of_callable_class();
-    typedef result_of_private_type const &(*pfn_t)(...);
-    operator pfn_t() const volatile;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class {
-  typedef result_of_callable_class<C> type;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class<C const> {
-  typedef result_of_callable_class<C> const type;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class<C volatile> {
-  typedef result_of_callable_class<C> volatile type;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class<C const volatile> {
-  typedef result_of_callable_class<C> const volatile type;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class<C &> {
-  typedef typename result_of_wrap_callable_class<C>::type &type;
-};
-
-template<typename F, bool TestCallability = true> struct cpp0x_result_of_impl;
-
-#else // BOOST_NO_SFINAE_EXPR
-
-template<typename T>
-struct result_of_always_void
-{
-  typedef void type;
-};
-
-template<typename F, typename Enable = void> struct cpp0x_result_of_impl {};
-
-#endif // BOOST_NO_SFINAE_EXPR
-
-template<typename F>
-struct result_of_void_impl
-{
-  typedef void type;
-};
-
-template<typename R>
-struct result_of_void_impl<R (*)(void)>
-{
-  typedef R type;
-};
-
-template<typename R>
-struct result_of_void_impl<R (&)(void)>
-{
-  typedef R type;
-};
-
-// Determine the return type of a function pointer or pointer to member.
-template<typename F, typename FArgs>
-struct result_of_pointer
-  : tr1_result_of_impl<typename remove_cv<F>::type, FArgs, false> { };
-
-template<typename F, typename FArgs>
-struct tr1_result_of_impl<F, FArgs, true>
-{
-  typedef typename F::result_type type;
-};
-
-template<typename FArgs>
-struct is_function_with_no_args : false_type {};
-
-template<typename F>
-struct is_function_with_no_args<F(void)> : true_type {};
-
-template<typename F, typename FArgs>
-struct result_of_nested_result : F::template result<FArgs>
-{};
-
-template<typename F, typename FArgs>
-struct tr1_result_of_impl<F, FArgs, false>
-  : conditional<is_function_with_no_args<FArgs>::value,
-             result_of_void_impl<F>,
-             result_of_nested_result<F, FArgs> >::type
-{};
-
-} // end namespace detail
-
-#define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,<boost/utility/detail/result_of_iterate.hpp>))
-#include BOOST_PP_ITERATE()
-
-#if 0
-// inform dependency trackers, as they can't see through macro includes
-#include <boost/utility/detail/result_of_iterate.hpp>
-#endif
-
-#else
-#  define BOOST_NO_RESULT_OF 1
-#endif
-
-}
-
-#endif // BOOST_RESULT_OF_HPP

include/boost/utility/select_by_size.hpp

@@ -0,0 +1,175 @@
+// (C) Copyright Jonathan Turkanis 2004.
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies. This
+// software is provided "as is" without express or implied warranty, and
+// with no claim as to its suitability for any purpose.
+
+//
+// Intended as an alternative to type_traits::yes_type and type_traits::no_type.
+// Provides an arbitrary number of types (case_<0>, case_<1>, ...) for
+// determining the results of overload resultion using 'sizeof', plus a uniform
+// means of using the result. yes_type and no_type are typedefs for case_<1>
+// and case_<0>. A single case with negative argument, case_<-1>, is also 
+// provided, for convenience.
+//
+// This header may be included any number of times, with
+// BOOST_SELECT_BY_SIZE_MAX_CASE defined to be the largest N such that case_<N>
+// is needed for a particular application. It defaults to 2.
+//
+// This header depends only on Boost.Config and Boost.Preprocessor. Dependence
+// on Type Traits or MPL was intentionally avoided, to leave open the 
+// possibility that select_by_size could be used by these libraries.
+//
+// Example usage:
+//
+//    #define BOOST_SELECT_BY_SIZE_MAX_CASE 7         // Needed for > 2 cases.
+//    #include <boost/utility/select_by_size.hpp>
+//
+//    using namespace boost::utility;
+//
+//    case_<0> helper(bool);           // could use 'case_<false>' or 'no_type'.
+//    case_<1> helper(int);            // could use 'case_<true>' or' yes_type'.
+//    case_<2> helper(unsigned);
+//    case_<3> helper(long);
+//    case_<4> helper(unsigned long);
+//    case_<5> helper(float);
+//    case_<6> helper(double);
+//    case_<7> helper(const char*);
+//
+//    struct test {
+//        static const int value =
+//            select_by_size< sizeof(helper(9876UL)) >::value;
+//        BOOST_STATIC_ASSERT(value == 4);
+//    };
+//
+// For compilers with integral constant expression problems, e.g. Borland 5.x,
+// one can also write
+//
+//    struct test {
+//        BOOST_SELECT_BY_SIZE(int, value, helper(9876UL));
+//    };
+//
+// to define a static integral constant 'value' equal to
+//
+//    select_by_size< sizeof(helper(9876UL)) >::value.
+//
+
+// Include guards surround all contents of this header except for explicit
+// specializations of select_by_size for case_<N> with N > 2.
+
+#ifndef BOOST_UTILITY_SELECT_BY_SIZE_HPP_INCLUDED
+#define BOOST_UTILITY_SELECT_BY_SIZE_HPP_INCLUDED
+
+// The lowest N for which select_by_size< sizeof(case_<N>) > has not been
+// specialized.
+#define SELECT_BY_SIZE_MAX_SPECIALIZED 2
+
+#include <boost/config.hpp>    // BOOST_STATIC_CONSTANT.
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+
+/* Alternative implementation using max_align. 
+
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+
+namespace boost { namespace utility {
+
+template<int N>
+struct case_ { char c[(N + 1) * alignment_of<detail::max_align>::value]; };
+
+template<unsigned Size>
+struct select_by_size {
+    BOOST_STATIC_CONSTANT(int, value = 
+        (Size / alignment_of<detail::max_align>::value - 1));
+};
+
+} }             // End namespaces utility, boost.
+
+*/              // End alternate implementation.
+
+namespace boost { namespace utility {
+
+//--------------Definition of case_-------------------------------------------//
+
+template<int N> struct case_ { char c1; case_<N - 1> c2; };
+template<> struct case_<-1> { char c; };
+typedef case_<true> yes_type;
+typedef case_<false> no_type;
+
+//--------------Declaration of select_by_size---------------------------------//
+
+template<unsigned Size> struct select_by_size;
+
+} }             // End namespaces utility, boost.
+
+//--------------Definition of SELECT_BY_SIZE_SPEC-----------------------------//
+
+// Sepecializes select_by_size for sizeof(case<n-1>). The decrement is used
+// here because the preprocessor library doesn't handle negative integers.
+#define SELECT_BY_SIZE_SPEC(n)                                                 \
+    namespace boost { namespace utility {                                      \
+      namespace detail {                                                       \
+        static const int BOOST_PP_CAT(sizeof_case_, n) = sizeof(case_<n - 1>); \
+      }                                                                        \
+      template<>                                                               \
+      struct select_by_size< detail::BOOST_PP_CAT(sizeof_case_, n) > {         \
+          struct type { BOOST_STATIC_CONSTANT(int, value = n - 1); };          \
+          BOOST_STATIC_CONSTANT(int, value = type::value);                     \
+      };                                                                       \
+    } }                                                                        \
+    /**/
+
+//--------------Default specializations of select_by_size---------------------//
+
+SELECT_BY_SIZE_SPEC(0) // select_by_size< sizeof(case<-1>) >
+SELECT_BY_SIZE_SPEC(1) // select_by_size< sizeof(case<0>) >
+SELECT_BY_SIZE_SPEC(2) // select_by_size< sizeof(case<1>) >
+
+//--------------Definition of SELECT_BY_SIZE----------------------------------//
+
+#define BOOST_SELECT_BY_SIZE(type_, name, expr)                                \
+    BOOST_STATIC_CONSTANT(                                                     \
+        unsigned,                                                              \
+        BOOST_PP_CAT(boost_select_by_size_temp_, name) = sizeof(expr)          \
+    );                                                                         \
+    BOOST_STATIC_CONSTANT(                                                     \
+        type_,                                                                 \
+        name =                                                                 \
+            ( boost::utility::select_by_size<                                  \
+                BOOST_PP_CAT(boost_select_by_size_temp_, name)                 \
+              >::value )                                                       \
+    )                                                                          \
+    /**/
+
+#endif          // #ifndef BOOST_UTILITY_SELECT_BY_SIZE_HPP_INCLUDED
+
+//----------Specializations of SELECT_BY_SIZE (outside main inclued guards)---//
+
+// Specialize select_by_size for sizeof(case_<N>) for each N less than
+// BOOST_SELECT_BY_SIZE_CASES for which this specialization has not already been
+// performed.
+
+#if !BOOST_PP_IS_ITERATING //-------------------------------------------------//
+    #include <boost/preprocessor/iteration/iterate.hpp>
+    #if !defined(BOOST_SELECT_BY_SIZE_MAX_CASE) || \
+        (BOOST_SELECT_BY_SIZE_MAX_CASE < 2)
+        #undef BOOST_SELECT_BY_SIZE_MAX_CASE
+        #define BOOST_SELECT_BY_SIZE_MAX_CASE 2
+    #endif
+
+    #if (BOOST_SELECT_BY_SIZE_MAX_CASE > SELECT_BY_SIZE_MAX_SPECIALIZED)
+        #define BOOST_PP_FILENAME_1 <boost/utility/select_by_size.hpp>
+        #define BOOST_PP_ITERATION_LIMITS ( SELECT_BY_SIZE_MAX_SPECIALIZED, \
+                                            BOOST_SELECT_BY_SIZE_MAX_CASE )
+        #include BOOST_PP_ITERATE()
+        #undef SELECT_BY_SIZE_MAX_SPECIALIZED
+        #define SELECT_BY_SIZE_MAX_SPECIALIZED BOOST_SELECT_BY_SIZE_MAX_CASE
+    #endif // #if (BOOST_SELECT_BY_SIZE_CASES > SELECT_BY_SIZE_MAX_SPECIALIZED)
+
+    #undef BOOST_SELECT_BY_SIZE_MAX_CASE
+#else // #if !BOOST_PP_IS_ITERATING //----------------------------------------//
+    SELECT_BY_SIZE_SPEC(BOOST_PP_INC(BOOST_PP_ITERATION()))
+#endif // #if !BOOST_PP_IS_ITERATING //---------------------------------------//

include/boost/utility/string_ref.hpp

@@ -1,516 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2012-2015.
-   Copyright (c) Glen Joseph Fernandes 2019 (glenjofe@gmail.com)
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    For more information, see http://www.boost.org
-
-    Based on the StringRef implementation in LLVM (http://llvm.org) and
-    N3422 by Jeffrey Yasskin
-        http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
-
-*/
-
-#ifndef BOOST_STRING_REF_HPP
-#define BOOST_STRING_REF_HPP
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/utility/ostream_string.hpp>
-#include <boost/utility/string_ref_fwd.hpp>
-#include <boost/throw_exception.hpp>
-
-#include <cstddef>
-#include <stdexcept>
-#include <algorithm>
-#include <iterator>
-#include <string>
-#include <iosfwd>
-
-#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || (defined(BOOST_GCC) && ((BOOST_GCC+0) / 100) <= 406)
-// GCC 4.6 cannot handle a defaulted function with noexcept specifier
-#define BOOST_STRING_REF_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
-#endif
-
-namespace boost {
-
-    namespace detail {
-    //  A helper functor because sometimes we don't have lambdas
-        template <typename charT, typename traits>
-        class string_ref_traits_eq {
-        public:
-            string_ref_traits_eq ( charT ch ) : ch_(ch) {}
-            bool operator () ( charT val ) const { return traits::eq ( ch_, val ); }
-            charT ch_;
-            };
-        }
-
-    template<typename charT, typename traits>
-    class basic_string_ref {
-    public:
-        // types
-        typedef charT value_type;
-        typedef const charT* pointer;
-        typedef const charT& reference;
-        typedef const charT& const_reference;
-        typedef pointer const_iterator; // impl-defined
-        typedef const_iterator iterator;
-        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-        typedef const_reverse_iterator reverse_iterator;
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-        static BOOST_CONSTEXPR_OR_CONST size_type npos = size_type(-1);
-
-        // construct/copy
-        BOOST_CONSTEXPR basic_string_ref () BOOST_NOEXCEPT
-            : ptr_(NULL), len_(0) {}
-
-        // by defaulting these functions, basic_string_ref becomes
-        //  trivially copy/move constructible.
-        BOOST_CONSTEXPR basic_string_ref (const basic_string_ref &rhs) BOOST_NOEXCEPT
-#ifndef BOOST_STRING_REF_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
-            = default;
-#else
-            : ptr_(rhs.ptr_), len_(rhs.len_) {}
-#endif
-
-        basic_string_ref& operator=(const basic_string_ref &rhs) BOOST_NOEXCEPT
-#ifndef BOOST_STRING_REF_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
-            = default;
-#else
-            {
-            ptr_ = rhs.ptr_;
-            len_ = rhs.len_;
-            return *this;
-            }
-#endif
-
-        basic_string_ref(const charT* str) BOOST_NOEXCEPT
-            : ptr_(str), len_(traits::length(str)) {}
-
-        template<typename Allocator>
-        basic_string_ref(const std::basic_string<charT, traits, Allocator>& str)
-            : ptr_(str.data()), len_(str.length()) {}
-
-// #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
-//         // Constructing a string_ref from a temporary string is a bad idea
-//         template<typename Allocator>
-//         basic_string_ref(      std::basic_string<charT, traits, Allocator>&&)
-//             = delete;
-// #endif
-
-        BOOST_CONSTEXPR basic_string_ref(const charT* str, size_type len) BOOST_NOEXCEPT
-            : ptr_(str), len_(len) {}
-
-#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-        template<typename Allocator>
-        explicit operator std::basic_string<charT, traits, Allocator>() const {
-            return std::basic_string<charT, traits, Allocator> ( begin(), end());
-            }
-#endif
-
-        std::basic_string<charT, traits> to_string () const {
-            return std::basic_string<charT, traits> ( begin(), end());
-            }
-
-        // iterators
-        BOOST_CONSTEXPR const_iterator   begin() const { return ptr_; }
-        BOOST_CONSTEXPR const_iterator  cbegin() const { return ptr_; }
-        BOOST_CONSTEXPR const_iterator     end() const { return ptr_ + len_; }
-        BOOST_CONSTEXPR const_iterator    cend() const { return ptr_ + len_; }
-                const_reverse_iterator  rbegin() const { return const_reverse_iterator (end()); }
-                const_reverse_iterator crbegin() const { return const_reverse_iterator (end()); }
-                const_reverse_iterator    rend() const { return const_reverse_iterator (begin()); }
-                const_reverse_iterator   crend() const { return const_reverse_iterator (begin()); }
-
-        // capacity
-        BOOST_CONSTEXPR size_type size()     const { return len_; }
-        BOOST_CONSTEXPR size_type length()   const { return len_; }
-        BOOST_CONSTEXPR size_type max_size() const { return len_; }
-        BOOST_CONSTEXPR bool empty()         const { return len_ == 0; }
-
-        // element access
-        BOOST_CONSTEXPR const charT& operator[](size_type pos) const { return ptr_[pos]; }
-
-        const charT& at(size_t pos) const {
-            if ( pos >= len_ )
-                BOOST_THROW_EXCEPTION( std::out_of_range ( "boost::string_ref::at" ) );
-            return ptr_[pos];
-            }
-
-        BOOST_CONSTEXPR const charT& front() const { return ptr_[0]; }
-        BOOST_CONSTEXPR const charT& back()  const { return ptr_[len_-1]; }
-        BOOST_CONSTEXPR const charT* data()  const { return ptr_; }
-
-        // modifiers
-        void clear() { len_ = 0; }
-        void remove_prefix(size_type n) {
-            if ( n > len_ )
-                n = len_;
-            ptr_ += n;
-            len_ -= n;
-            }
-
-        void remove_suffix(size_type n) {
-            if ( n > len_ )
-                n = len_;
-            len_ -= n;
-            }
-
-
-        // basic_string_ref string operations
-        basic_string_ref substr(size_type pos, size_type n=npos) const {
-            if ( pos > size())
-                BOOST_THROW_EXCEPTION( std::out_of_range ( "string_ref::substr" ) );
-            return basic_string_ref(data() + pos, (std::min)(size() - pos, n));
-            }
-
-        int compare(basic_string_ref x) const {
-            const int cmp = traits::compare ( ptr_, x.ptr_, (std::min)(len_, x.len_));
-            return cmp != 0 ? cmp : ( len_ == x.len_ ? 0 : len_ < x.len_ ? -1 : 1 );
-            }
-
-        bool starts_with(charT c) const { return !empty() && traits::eq ( c, front()); }
-        bool starts_with(basic_string_ref x) const {
-            return len_ >= x.len_ && traits::compare ( ptr_, x.ptr_, x.len_ ) == 0;
-            }
-
-        bool ends_with(charT c) const { return !empty() && traits::eq ( c, back()); }
-        bool ends_with(basic_string_ref x) const {
-            return len_ >= x.len_ && traits::compare ( ptr_ + len_ - x.len_, x.ptr_, x.len_ ) == 0;
-            }
-
-        size_type find(basic_string_ref s) const {
-            if (s.empty()) return 0;
-            const_iterator iter = std::search ( this->cbegin (), this->cend (),
-                                                s.cbegin (), s.cend (), traits::eq );
-            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
-            }
-
-        size_type find(charT c) const {
-            const_iterator iter = std::find_if ( this->cbegin (), this->cend (),
-                                    detail::string_ref_traits_eq<charT, traits> ( c ));
-            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
-            }
-
-        size_type rfind(basic_string_ref s) const {
-            if (s.empty()) return 0;
-            const_reverse_iterator iter = std::search ( this->crbegin (), this->crend (),
-                                                s.crbegin (), s.crend (), traits::eq );
-            return iter == this->crend () ? npos : (std::distance(iter, this->crend()) - s.size());
-            }
-
-        size_type rfind(charT c) const {
-            const_reverse_iterator iter = std::find_if ( this->crbegin (), this->crend (),
-                                    detail::string_ref_traits_eq<charT, traits> ( c ));
-            return iter == this->crend () ? npos : (this->size() - 1 - std::distance(this->crbegin(), iter));
-            }
-
-        size_type find_first_of(charT c) const { return  find (c); }
-        size_type find_last_of (charT c) const { return rfind (c); }
-
-        size_type find_first_of(basic_string_ref s) const {
-            const_iterator iter = std::find_first_of
-                ( this->cbegin (), this->cend (), s.cbegin (), s.cend (), traits::eq );
-            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
-            }
-
-        size_type find_last_of(basic_string_ref s) const {
-            const_reverse_iterator iter = std::find_first_of
-                ( this->crbegin (), this->crend (), s.cbegin (), s.cend (), traits::eq );
-            return iter == this->crend () ? npos : (this->size() - 1 - std::distance(this->crbegin(), iter));
-            }
-
-        size_type find_first_not_of(basic_string_ref s) const {
-            const_iterator iter = find_not_of ( this->cbegin (), this->cend (), s );
-            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
-            }
-
-        size_type find_first_not_of(charT c) const {
-            for ( const_iterator iter = this->cbegin (); iter != this->cend (); ++iter )
-                if ( !traits::eq ( c, *iter ))
-                    return std::distance ( this->cbegin (), iter );
-            return npos;
-            }
-
-        size_type find_last_not_of(basic_string_ref s) const {
-            const_reverse_iterator iter = find_not_of ( this->crbegin (), this->crend (), s );
-            return iter == this->crend () ? npos : (this->size() - 1 - std::distance(this->crbegin(), iter));
-            }
-
-        size_type find_last_not_of(charT c) const {
-            for ( const_reverse_iterator iter = this->crbegin (); iter != this->crend (); ++iter )
-                if ( !traits::eq ( c, *iter ))
-                    return this->size() - 1 - std::distance(this->crbegin(), iter);
-            return npos;
-            }
-
-    private:
-
-        template <typename Iterator>
-        Iterator find_not_of ( Iterator first, Iterator last, basic_string_ref s ) const {
-            for ( ; first != last ; ++first )
-                if ( 0 == traits::find ( s.ptr_, s.len_, *first ))
-                    return first;
-            return last;
-            }
-
-
-
-        const charT *ptr_;
-        std::size_t len_;
-        };
-
-
-//  Comparison operators
-//  Equality
-    template<typename charT, typename traits>
-    inline bool operator==(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
-        if ( x.size () != y.size ()) return false;
-        return x.compare(y) == 0;
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline bool operator==(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
-        return x == basic_string_ref<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline bool operator==(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
-        return basic_string_ref<charT, traits>(x) == y;
-        }
-
-    template<typename charT, typename traits>
-    inline bool operator==(basic_string_ref<charT, traits> x, const charT * y) {
-        return x == basic_string_ref<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits>
-    inline bool operator==(const charT * x, basic_string_ref<charT, traits> y) {
-        return basic_string_ref<charT, traits>(x) == y;
-        }
-
-//  Inequality
-    template<typename charT, typename traits>
-    inline bool operator!=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
-        if ( x.size () != y.size ()) return true;
-        return x.compare(y) != 0;
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline bool operator!=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
-        return x != basic_string_ref<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline bool operator!=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
-        return basic_string_ref<charT, traits>(x) != y;
-        }
-
-    template<typename charT, typename traits>
-    inline bool operator!=(basic_string_ref<charT, traits> x, const charT * y) {
-        return x != basic_string_ref<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits>
-    inline bool operator!=(const charT * x, basic_string_ref<charT, traits> y) {
-        return basic_string_ref<charT, traits>(x) != y;
-        }
-
-//  Less than
-    template<typename charT, typename traits>
-    inline bool operator<(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
-        return x.compare(y) < 0;
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline bool operator<(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
-        return x < basic_string_ref<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline bool operator<(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
-        return basic_string_ref<charT, traits>(x) < y;
-        }
-
-    template<typename charT, typename traits>
-    inline bool operator<(basic_string_ref<charT, traits> x, const charT * y) {
-        return x < basic_string_ref<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits>
-    inline bool operator<(const charT * x, basic_string_ref<charT, traits> y) {
-        return basic_string_ref<charT, traits>(x) < y;
-        }
-
-//  Greater than
-    template<typename charT, typename traits>
-    inline bool operator>(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
-        return x.compare(y) > 0;
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline bool operator>(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
-        return x > basic_string_ref<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline bool operator>(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
-        return basic_string_ref<charT, traits>(x) > y;
-        }
-
-    template<typename charT, typename traits>
-    inline bool operator>(basic_string_ref<charT, traits> x, const charT * y) {
-        return x > basic_string_ref<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits>
-    inline bool operator>(const charT * x, basic_string_ref<charT, traits> y) {
-        return basic_string_ref<charT, traits>(x) > y;
-        }
-
-//  Less than or equal to
-    template<typename charT, typename traits>
-    inline bool operator<=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
-        return x.compare(y) <= 0;
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline bool operator<=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
-        return x <= basic_string_ref<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline bool operator<=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
-        return basic_string_ref<charT, traits>(x) <= y;
-        }
-
-    template<typename charT, typename traits>
-    inline bool operator<=(basic_string_ref<charT, traits> x, const charT * y) {
-        return x <= basic_string_ref<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits>
-    inline bool operator<=(const charT * x, basic_string_ref<charT, traits> y) {
-        return basic_string_ref<charT, traits>(x) <= y;
-        }
-
-//  Greater than or equal to
-    template<typename charT, typename traits>
-    inline bool operator>=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
-        return x.compare(y) >= 0;
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline bool operator>=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
-        return x >= basic_string_ref<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline bool operator>=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
-        return basic_string_ref<charT, traits>(x) >= y;
-        }
-
-    template<typename charT, typename traits>
-    inline bool operator>=(basic_string_ref<charT, traits> x, const charT * y) {
-        return x >= basic_string_ref<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits>
-    inline bool operator>=(const charT * x, basic_string_ref<charT, traits> y) {
-        return basic_string_ref<charT, traits>(x) >= y;
-        }
-
-    // Inserter
-    template<class charT, class traits>
-    inline std::basic_ostream<charT, traits>&
-    operator<<(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
-        return boost::ostream_string(os, str.data(), str.size());
-        }
-
-#if 0
-    // numeric conversions
-    //
-    //  These are short-term implementations.
-    //  In a production environment, I would rather avoid the copying.
-    //
-    inline int stoi (string_ref str, size_t* idx=0, int base=10) {
-        return std::stoi ( std::string(str), idx, base );
-        }
-
-    inline long stol (string_ref str, size_t* idx=0, int base=10) {
-        return std::stol ( std::string(str), idx, base );
-        }
-
-    inline unsigned long stoul (string_ref str, size_t* idx=0, int base=10) {
-        return std::stoul ( std::string(str), idx, base );
-        }
-
-    inline long long stoll (string_ref str, size_t* idx=0, int base=10) {
-        return std::stoll ( std::string(str), idx, base );
-        }
-
-    inline unsigned long long stoull (string_ref str, size_t* idx=0, int base=10) {
-        return std::stoull ( std::string(str), idx, base );
-        }
-
-    inline float stof (string_ref str, size_t* idx=0) {
-        return std::stof ( std::string(str), idx );
-        }
-
-    inline double stod (string_ref str, size_t* idx=0) {
-        return std::stod ( std::string(str), idx );
-        }
-
-    inline long double stold (string_ref str, size_t* idx=0)  {
-        return std::stold ( std::string(str), idx );
-        }
-
-    inline int  stoi (wstring_ref str, size_t* idx=0, int base=10) {
-        return std::stoi ( std::wstring(str), idx, base );
-        }
-
-    inline long stol (wstring_ref str, size_t* idx=0, int base=10) {
-        return std::stol ( std::wstring(str), idx, base );
-        }
-
-    inline unsigned long stoul (wstring_ref str, size_t* idx=0, int base=10) {
-        return std::stoul ( std::wstring(str), idx, base );
-        }
-
-    inline long long stoll (wstring_ref str, size_t* idx=0, int base=10) {
-        return std::stoll ( std::wstring(str), idx, base );
-        }
-
-    inline unsigned long long stoull (wstring_ref str, size_t* idx=0, int base=10) {
-        return std::stoull ( std::wstring(str), idx, base );
-        }
-
-    inline float  stof (wstring_ref str, size_t* idx=0) {
-        return std::stof ( std::wstring(str), idx );
-        }
-
-    inline double stod (wstring_ref str, size_t* idx=0) {
-        return std::stod ( std::wstring(str), idx );
-        }
-
-    inline long double stold (wstring_ref str, size_t* idx=0) {
-        return std::stold ( std::wstring(str), idx );
-        }
-#endif
-
-}
-
-#if 0
-namespace std {
-    // Hashing
-    template<> struct hash<boost::string_ref>;
-    template<> struct hash<boost::u16string_ref>;
-    template<> struct hash<boost::u32string_ref>;
-    template<> struct hash<boost::wstring_ref>;
-}
-#endif
-
-#endif

include/boost/utility/string_ref_fwd.hpp

@@ -1,37 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2012-2012.
-
-   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)
-
-    For more information, see http://www.boost.org
-
-    Based on the StringRef implementation in LLVM (http://llvm.org) and
-    N3422 by Jeffrey Yasskin
-        http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
-
-*/
-
-#ifndef BOOST_STRING_REF_FWD_HPP
-#define BOOST_STRING_REF_FWD_HPP
-
-#include <boost/config.hpp>
-#include <string>
-
-namespace boost {
-
-    template<typename charT, typename traits = std::char_traits<charT> > class basic_string_ref;
-    typedef basic_string_ref<char,     std::char_traits<char> >        string_ref;
-    typedef basic_string_ref<wchar_t,  std::char_traits<wchar_t> >    wstring_ref;
-
-#ifndef BOOST_NO_CXX11_CHAR16_T
-    typedef basic_string_ref<char16_t, std::char_traits<char16_t> > u16string_ref;
-#endif
-
-#ifndef BOOST_NO_CXX11_CHAR32_T
-    typedef basic_string_ref<char32_t, std::char_traits<char32_t> > u32string_ref;
-#endif
-
-}
-
-#endif

include/boost/utility/string_view.hpp

@@ -1,671 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2012-2015.
-   Copyright (c) Beman Dawes 2015
-   Copyright (c) Glen Joseph Fernandes 2019 (glenjofe@gmail.com)
-
-   Distributed under the Boost Software License, Version 1.0. (See accompanying
-   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    For more information, see http://www.boost.org
-
-    Based on the StringRef implementation in LLVM (http://llvm.org) and
-    N3422 by Jeffrey Yasskin
-        http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
-    Updated July 2015 to reflect the Library Fundamentals TS
-        http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4480.html
-*/
-
-#ifndef BOOST_STRING_VIEW_HPP
-#define BOOST_STRING_VIEW_HPP
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/utility/ostream_string.hpp>
-#include <boost/utility/string_view_fwd.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/container_hash/hash_fwd.hpp>
-
-#include <cstddef>
-#include <stdexcept>
-#include <algorithm>
-#include <iterator>
-#include <string>
-#include <cstring>
-#include <iosfwd>
-
-#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || (defined(BOOST_GCC) && ((BOOST_GCC+0) / 100) <= 406)
-// GCC 4.6 cannot handle a defaulted function with noexcept specifier
-#define BOOST_STRING_VIEW_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
-#endif
-
-namespace boost {
-
-    namespace detail {
-    //  A helper functor because sometimes we don't have lambdas
-        template <typename charT, typename traits>
-        class string_view_traits_eq {
-        public:
-            string_view_traits_eq ( charT ch ) : ch_(ch) {}
-            bool operator()( charT val ) const { return traits::eq (ch_, val); }
-            charT ch_;
-            };
-        }
-
-    template<typename charT, typename traits>  // traits defaulted in string_view_fwd.hpp
-    class basic_string_view {
-    public:
-      // types
-      typedef traits                                traits_type;
-      typedef charT                                 value_type;
-      typedef charT*                                pointer;
-      typedef const charT*                          const_pointer;
-      typedef charT&                                reference;
-      typedef const charT&                          const_reference;
-      typedef const_pointer                         const_iterator; // impl-defined
-      typedef const_iterator                        iterator;
-      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-      typedef const_reverse_iterator                reverse_iterator;
-      typedef std::size_t                           size_type;
-      typedef std::ptrdiff_t                        difference_type;
-      static BOOST_CONSTEXPR_OR_CONST size_type     npos = size_type(-1);
-
-      // construct/copy
-      BOOST_CONSTEXPR basic_string_view() BOOST_NOEXCEPT
-        : ptr_(NULL), len_(0) {}
-
-      // by defaulting these functions, basic_string_ref becomes
-      //  trivially copy/move constructible.
-      BOOST_CONSTEXPR basic_string_view(const basic_string_view &rhs) BOOST_NOEXCEPT
-#ifndef BOOST_STRING_VIEW_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
-        = default;
-#else
-        : ptr_(rhs.ptr_), len_(rhs.len_) {}
-#endif
-
-      basic_string_view& operator=(const basic_string_view &rhs) BOOST_NOEXCEPT
-#ifndef BOOST_STRING_VIEW_NO_CXX11_DEFAULTED_NOEXCEPT_FUNCTIONS
-            = default;
-#else
-        {
-        ptr_ = rhs.ptr_;
-        len_ = rhs.len_;
-        return *this;
-        }
-#endif
-
-      template<typename Allocator>
-        basic_string_view(const std::basic_string<charT, traits, Allocator>& str) BOOST_NOEXCEPT
-          : ptr_(str.data()), len_(str.length()) {}
-
-// #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
-//       // Constructing a string_view from a temporary string is a bad idea
-//       template<typename Allocator>
-//         basic_string_view(      std::basic_string<charT, traits, Allocator>&&)
-//           = delete;
-// #endif
-
-      BOOST_CONSTEXPR basic_string_view(const charT* str)
-        : ptr_(str), len_(traits::length(str)) {}
-
-      BOOST_CONSTEXPR basic_string_view(const charT* str, size_type len)
-        : ptr_(str), len_(len) {}
-
-        // iterators
-        BOOST_CONSTEXPR const_iterator   begin() const BOOST_NOEXCEPT { return ptr_; }
-        BOOST_CONSTEXPR const_iterator  cbegin() const BOOST_NOEXCEPT { return ptr_; }
-        BOOST_CONSTEXPR const_iterator     end() const BOOST_NOEXCEPT { return ptr_ + len_; }
-        BOOST_CONSTEXPR const_iterator    cend() const BOOST_NOEXCEPT { return ptr_ + len_; }
-                const_reverse_iterator  rbegin() const BOOST_NOEXCEPT { return const_reverse_iterator(end()); }
-                const_reverse_iterator crbegin() const BOOST_NOEXCEPT { return const_reverse_iterator(end()); }
-                const_reverse_iterator    rend() const BOOST_NOEXCEPT { return const_reverse_iterator(begin()); }
-                const_reverse_iterator   crend() const BOOST_NOEXCEPT { return const_reverse_iterator(begin()); }
-
-        // capacity
-        BOOST_CONSTEXPR size_type size()     const BOOST_NOEXCEPT { return len_; }
-        BOOST_CONSTEXPR size_type length()   const BOOST_NOEXCEPT { return len_; }
-        BOOST_CONSTEXPR size_type max_size() const BOOST_NOEXCEPT { return len_; }
-        BOOST_CONSTEXPR bool empty()         const BOOST_NOEXCEPT { return len_ == 0; }
-
-        // element access
-        BOOST_CONSTEXPR const_reference operator[](size_type pos) const BOOST_NOEXCEPT { return ptr_[pos]; }
-
-        BOOST_CONSTEXPR const_reference at(size_t pos) const {
-            return pos >= len_ ? BOOST_THROW_EXCEPTION(std::out_of_range("boost::string_view::at")), ptr_[0] : ptr_[pos];
-            }
-
-        BOOST_CONSTEXPR const_reference front() const                { return ptr_[0]; }
-        BOOST_CONSTEXPR const_reference back()  const                { return ptr_[len_-1]; }
-        BOOST_CONSTEXPR const_pointer data()    const BOOST_NOEXCEPT { return ptr_; }
-
-        // modifiers
-        void clear() BOOST_NOEXCEPT { len_ = 0; }          // Boost extension
-
-        BOOST_CXX14_CONSTEXPR void remove_prefix(size_type n) {
-            if ( n > len_ )
-                n = len_;
-            ptr_ += n;
-            len_ -= n;
-            }
-
-        BOOST_CXX14_CONSTEXPR void remove_suffix(size_type n) {
-            if ( n > len_ )
-                n = len_;
-            len_ -= n;
-            }
-
-        BOOST_CXX14_CONSTEXPR void swap(basic_string_view& s) BOOST_NOEXCEPT {
-            std::swap(ptr_, s.ptr_);
-            std::swap(len_, s.len_);
-            }
-
-        // basic_string_view string operations
-#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-        template<typename Allocator>
-        explicit operator std::basic_string<charT, traits, Allocator>() const {
-            return std::basic_string<charT, traits, Allocator>(begin(), end());
-            }
-#endif
-
-#ifndef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
-        template<typename Allocator = std::allocator<charT> >
-        std::basic_string<charT, traits, Allocator> to_string(const Allocator& a = Allocator()) const {
-            return std::basic_string<charT, traits, Allocator>(begin(), end(), a);
-            }
-#else
-        std::basic_string<charT, traits> to_string() const {
-            return std::basic_string<charT, traits>(begin(), end());
-            }
-
-        template<typename Allocator>
-        std::basic_string<charT, traits, Allocator> to_string(const Allocator& a) const {
-            return std::basic_string<charT, traits, Allocator>(begin(), end(), a);
-            }
-#endif
-
-        size_type copy(charT* s, size_type n, size_type pos=0) const {
-            if (pos > size())
-                BOOST_THROW_EXCEPTION(std::out_of_range("string_view::copy" ));
-            size_type rlen = (std::min)(n, len_ - pos);
-            traits_type::copy(s, data() + pos, rlen);
-            return rlen;
-            }
-
-        BOOST_CXX14_CONSTEXPR basic_string_view substr(size_type pos, size_type n=npos) const {
-            if ( pos > size())
-                BOOST_THROW_EXCEPTION( std::out_of_range ( "string_view::substr" ) );
-            return basic_string_view(data() + pos, (std::min)(size() - pos, n));
-            }
-
-        BOOST_CXX14_CONSTEXPR int compare(basic_string_view x) const BOOST_NOEXCEPT {
-            const int cmp = traits::compare(ptr_, x.ptr_, (std::min)(len_, x.len_));
-            return cmp != 0 ? cmp : (len_ == x.len_ ? 0 : len_ < x.len_ ? -1 : 1);
-            }
-
-        BOOST_CXX14_CONSTEXPR int compare(size_type pos1, size_type n1, basic_string_view x)
-          const BOOST_NOEXCEPT {
-            return substr(pos1, n1).compare(x);
-            }
-
-        BOOST_CXX14_CONSTEXPR int compare(size_type pos1, size_type n1,
-          basic_string_view x, size_type pos2, size_type n2) const {
-            return substr(pos1, n1).compare(x.substr(pos2, n2));
-            }
-
-        BOOST_CXX14_CONSTEXPR int compare(const charT* x) const {
-            return compare(basic_string_view(x));
-            }
-
-        BOOST_CXX14_CONSTEXPR int compare(size_type pos1, size_type n1, const charT* x) const {
-            return substr(pos1, n1).compare(basic_string_view(x));
-            }
-
-        BOOST_CXX14_CONSTEXPR int compare(size_type pos1, size_type n1,
-          const charT* x, size_type n2) const {
-            return substr(pos1, n1).compare(basic_string_view(x, n2));
-            }
-
-        //  Searches
-        BOOST_CONSTEXPR bool starts_with(charT c) const BOOST_NOEXCEPT {              // Boost extension
-            return !empty() && traits::eq(c, front());
-            }
-
-        BOOST_CONSTEXPR bool starts_with(basic_string_view x) const BOOST_NOEXCEPT {  // Boost extension
-            return len_ >= x.len_ && traits::compare(ptr_, x.ptr_, x.len_) == 0;
-            }
-
-        BOOST_CONSTEXPR bool ends_with(charT c) const BOOST_NOEXCEPT {                // Boost extension
-            return !empty() && traits::eq(c, back());
-            }
-
-        BOOST_CONSTEXPR bool ends_with(basic_string_view x) const BOOST_NOEXCEPT {    // Boost extension
-            return len_ >= x.len_ &&
-               traits::compare(ptr_ + len_ - x.len_, x.ptr_, x.len_) == 0;
-            }
-
-        //  find
-        BOOST_CXX14_CONSTEXPR size_type find(basic_string_view s, size_type pos = 0) const BOOST_NOEXCEPT {
-            if (pos > size())
-              return npos;
-            if (s.empty())
-              return pos;
-            if (s.size() > size() - pos)
-                return npos;
-            const charT* cur = ptr_ + pos;
-            const charT* last = cend() - s.size() + 1;
-            for (; cur != last ; ++cur) {
-                cur = traits::find(cur, last - cur, s[0]);
-                if (!cur)
-                    return npos;
-                if (traits::compare(cur, s.cbegin(), s.size()) == 0)
-                    return cur - ptr_;
-            }
-            return npos;
-            }
-        BOOST_CXX14_CONSTEXPR size_type find(charT c, size_type pos = 0) const BOOST_NOEXCEPT {
-            if (pos > size())
-              return npos;
-            const charT* ret_ptr = traits::find(ptr_ + pos, len_ - pos, c);
-            if (ret_ptr)
-              return ret_ptr - ptr_;
-            return npos;
-            }
-        BOOST_CXX14_CONSTEXPR size_type find(const charT* s, size_type pos, size_type n) const BOOST_NOEXCEPT
-            { return find(basic_string_view(s, n), pos); }
-        BOOST_CXX14_CONSTEXPR size_type find(const charT* s, size_type pos = 0) const BOOST_NOEXCEPT
-            { return find(basic_string_view(s), pos); }
-
-        //  rfind
-        BOOST_CXX14_CONSTEXPR size_type rfind(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT {
-            if (len_ < s.len_)
-              return npos;
-            if (pos > len_ - s.len_)
-              pos = len_ - s.len_;
-            if (s.len_ == 0u)     // an empty string is always found
-              return pos;
-            for (const charT* cur = ptr_ + pos; ; --cur) {
-                if (traits::compare(cur, s.ptr_, s.len_) == 0)
-                  return cur - ptr_;
-                if (cur == ptr_)
-                  return npos;
-                };
-            }
-        BOOST_CXX14_CONSTEXPR size_type rfind(charT c, size_type pos = npos) const BOOST_NOEXCEPT
-            { return rfind(basic_string_view(&c, 1), pos); }
-        BOOST_CXX14_CONSTEXPR size_type rfind(const charT* s, size_type pos, size_type n) const BOOST_NOEXCEPT
-            { return rfind(basic_string_view(s, n), pos); }
-        BOOST_CXX14_CONSTEXPR size_type rfind(const charT* s, size_type pos = npos) const BOOST_NOEXCEPT
-            { return rfind(basic_string_view(s), pos); }
-
-        //  find_first_of
-        BOOST_CXX14_CONSTEXPR size_type find_first_of(basic_string_view s, size_type pos = 0) const BOOST_NOEXCEPT {
-            if (pos >= len_ || s.len_ == 0)
-              return npos;
-            const_iterator iter = std::find_first_of
-                (this->cbegin () + pos, this->cend (), s.cbegin (), s.cend (), traits::eq);
-            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
-            }
-        BOOST_CXX14_CONSTEXPR size_type find_first_of(charT c, size_type pos = 0) const BOOST_NOEXCEPT
-            { return find(c, pos); }
-        BOOST_CXX14_CONSTEXPR size_type find_first_of(const charT* s, size_type pos, size_type n) const BOOST_NOEXCEPT
-            { return find_first_of(basic_string_view(s, n), pos); }
-        BOOST_CXX14_CONSTEXPR size_type find_first_of(const charT* s, size_type pos = 0) const BOOST_NOEXCEPT
-            { return find_first_of(basic_string_view(s), pos); }
-
-        //  find_last_of
-        BOOST_CXX14_CONSTEXPR size_type find_last_of(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT {
-            if (s.len_ == 0u)
-              return npos;
-            if (pos >= len_)
-              pos = 0;
-            else
-              pos = len_ - (pos+1);
-            const_reverse_iterator iter = std::find_first_of
-                ( this->crbegin () + pos, this->crend (), s.cbegin (), s.cend (), traits::eq );
-            return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter);
-            }
-        BOOST_CXX14_CONSTEXPR size_type find_last_of(charT c, size_type pos = npos) const BOOST_NOEXCEPT
-            { return find_last_of(basic_string_view(&c, 1), pos); }
-        BOOST_CXX14_CONSTEXPR size_type find_last_of(const charT* s, size_type pos, size_type n) const BOOST_NOEXCEPT
-            { return find_last_of(basic_string_view(s, n), pos); }
-        BOOST_CXX14_CONSTEXPR size_type find_last_of(const charT* s, size_type pos = npos) const BOOST_NOEXCEPT
-            { return find_last_of(basic_string_view(s), pos); }
-
-        //  find_first_not_of
-        BOOST_CXX14_CONSTEXPR size_type find_first_not_of(basic_string_view s, size_type pos = 0) const BOOST_NOEXCEPT {
-            if (pos >= len_)
-              return npos;
-            if (s.len_ == 0)
-              return pos;
-            const_iterator iter = find_not_of ( this->cbegin () + pos, this->cend (), s );
-            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
-            }
-        BOOST_CXX14_CONSTEXPR size_type find_first_not_of(charT c, size_type pos = 0) const BOOST_NOEXCEPT
-            { return find_first_not_of(basic_string_view(&c, 1), pos); }
-        BOOST_CXX14_CONSTEXPR size_type find_first_not_of(const charT* s, size_type pos, size_type n) const BOOST_NOEXCEPT
-            { return find_first_not_of(basic_string_view(s, n), pos); }
-        BOOST_CXX14_CONSTEXPR size_type find_first_not_of(const charT* s, size_type pos = 0) const BOOST_NOEXCEPT
-            { return find_first_not_of(basic_string_view(s), pos); }
-
-        //  find_last_not_of
-        BOOST_CXX14_CONSTEXPR size_type find_last_not_of(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT {
-            if (pos >= len_)
-              pos = len_ - 1;
-            if (s.len_ == 0u)
-              return pos;
-            pos = len_ - (pos+1);
-            const_reverse_iterator iter = find_not_of ( this->crbegin () + pos, this->crend (), s );
-            return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
-            }
-        BOOST_CXX14_CONSTEXPR size_type find_last_not_of(charT c, size_type pos = npos) const BOOST_NOEXCEPT
-            { return find_last_not_of(basic_string_view(&c, 1), pos); }
-        BOOST_CXX14_CONSTEXPR size_type find_last_not_of(const charT* s, size_type pos, size_type n) const BOOST_NOEXCEPT
-            { return find_last_not_of(basic_string_view(s, n), pos); }
-        BOOST_CXX14_CONSTEXPR size_type find_last_not_of(const charT* s, size_type pos = npos) const BOOST_NOEXCEPT
-            { return find_last_not_of(basic_string_view(s), pos); }
-
-    private:
-        template <typename r_iter>
-        size_type reverse_distance(r_iter first, r_iter last) const BOOST_NOEXCEPT {
-        // Portability note here: std::distance is not NOEXCEPT, but calling it with a string_view::reverse_iterator will not throw.
-            return len_ - 1 - std::distance ( first, last );
-            }
-
-        template <typename Iterator>
-        Iterator find_not_of(Iterator first, Iterator last, basic_string_view s) const BOOST_NOEXCEPT {
-            for (; first != last ; ++first)
-                if ( 0 == traits::find(s.ptr_, s.len_, *first))
-                    return first;
-            return last;
-            }
-
-        const charT *ptr_;
-        std::size_t len_;
-        };
-
-
-//  Comparison operators
-//  Equality
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        if (x.size () != y.size ()) return false;
-        return x.compare(y) == 0;
-        }
-
-//  Inequality
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        if ( x.size () != y.size ()) return true;
-        return x.compare(y) != 0;
-        }
-
-//  Less than
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
-                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return x.compare(y) < 0;
-        }
-
-//  Greater than
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
-                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return x.compare(y) > 0;
-        }
-
-//  Less than or equal to
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return x.compare(y) <= 0;
-        }
-
-//  Greater than or equal to
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return x.compare(y) >= 0;
-        }
-
-// "sufficient additional overloads of comparison functions"
-    template<typename charT, typename traits, typename Allocator>
-    inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
-                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
-        return x == basic_string_view<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline BOOST_CXX14_CONSTEXPR bool operator==(const std::basic_string<charT, traits, Allocator> & x,
-                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return basic_string_view<charT, traits>(x) == y;
-        }
-
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
-                                              const charT * y) BOOST_NOEXCEPT {
-        return x == basic_string_view<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator==(const charT * x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return basic_string_view<charT, traits>(x) == y;
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
-                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
-        return x != basic_string_view<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline BOOST_CXX14_CONSTEXPR bool operator!=(const std::basic_string<charT, traits, Allocator> & x,
-                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return basic_string_view<charT, traits>(x) != y;
-        }
-
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
-                           const charT * y) BOOST_NOEXCEPT {
-        return x != basic_string_view<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator!=(const charT * x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return basic_string_view<charT, traits>(x) != y;
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
-                    const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
-        return x < basic_string_view<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline BOOST_CXX14_CONSTEXPR bool operator<(const std::basic_string<charT, traits, Allocator> & x,
-                                basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return basic_string_view<charT, traits>(x) < y;
-        }
-
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
-                          const charT * y) BOOST_NOEXCEPT {
-        return x < basic_string_view<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator<(const charT * x,
-                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return basic_string_view<charT, traits>(x) < y;
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
-                    const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
-        return x > basic_string_view<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline BOOST_CXX14_CONSTEXPR bool operator>(const std::basic_string<charT, traits, Allocator> & x,
-                                basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return basic_string_view<charT, traits>(x) > y;
-        }
-
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
-                          const charT * y) BOOST_NOEXCEPT {
-        return x > basic_string_view<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator>(const charT * x,
-                          basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return basic_string_view<charT, traits>(x) > y;
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
-                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
-        return x <= basic_string_view<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline BOOST_CXX14_CONSTEXPR bool operator<=(const std::basic_string<charT, traits, Allocator> & x,
-                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return basic_string_view<charT, traits>(x) <= y;
-        }
-
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
-                           const charT * y) BOOST_NOEXCEPT {
-        return x <= basic_string_view<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator<=(const charT * x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return basic_string_view<charT, traits>(x) <= y;
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
-                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
-        return x >= basic_string_view<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits, typename Allocator>
-    inline BOOST_CXX14_CONSTEXPR bool operator>=(const std::basic_string<charT, traits, Allocator> & x,
-                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return basic_string_view<charT, traits>(x) >= y;
-        }
-
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
-                           const charT * y) BOOST_NOEXCEPT {
-        return x >= basic_string_view<charT, traits>(y);
-        }
-
-    template<typename charT, typename traits>
-    inline BOOST_CXX14_CONSTEXPR bool operator>=(const charT * x,
-                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
-        return basic_string_view<charT, traits>(x) >= y;
-        }
-
-    // Inserter
-    template<class charT, class traits>
-    inline std::basic_ostream<charT, traits>&
-    operator<<(std::basic_ostream<charT, traits>& os,
-      const basic_string_view<charT,traits>& str) {
-        return boost::ostream_string(os, str.data(), str.size());
-        }
-
-#if 0
-    // numeric conversions
-    //
-    //  These are short-term implementations.
-    //  In a production environment, I would rather avoid the copying.
-    //
-    inline int stoi (string_view str, size_t* idx=0, int base=10) {
-        return std::stoi ( std::string(str), idx, base );
-        }
-
-    inline long stol (string_view str, size_t* idx=0, int base=10) {
-        return std::stol ( std::string(str), idx, base );
-        }
-
-    inline unsigned long stoul (string_view str, size_t* idx=0, int base=10) {
-        return std::stoul ( std::string(str), idx, base );
-        }
-
-    inline long long stoll (string_view str, size_t* idx=0, int base=10) {
-        return std::stoll ( std::string(str), idx, base );
-        }
-
-    inline unsigned long long stoull (string_view str, size_t* idx=0, int base=10) {
-        return std::stoull ( std::string(str), idx, base );
-        }
-
-    inline float stof (string_view str, size_t* idx=0) {
-        return std::stof ( std::string(str), idx );
-        }
-
-    inline double stod (string_view str, size_t* idx=0) {
-        return std::stod ( std::string(str), idx );
-        }
-
-    inline long double stold (string_view str, size_t* idx=0)  {
-        return std::stold ( std::string(str), idx );
-        }
-
-    inline int  stoi (wstring_view str, size_t* idx=0, int base=10) {
-        return std::stoi ( std::wstring(str), idx, base );
-        }
-
-    inline long stol (wstring_view str, size_t* idx=0, int base=10) {
-        return std::stol ( std::wstring(str), idx, base );
-        }
-
-    inline unsigned long stoul (wstring_view str, size_t* idx=0, int base=10) {
-        return std::stoul ( std::wstring(str), idx, base );
-        }
-
-    inline long long stoll (wstring_view str, size_t* idx=0, int base=10) {
-        return std::stoll ( std::wstring(str), idx, base );
-        }
-
-    inline unsigned long long stoull (wstring_view str, size_t* idx=0, int base=10) {
-        return std::stoull ( std::wstring(str), idx, base );
-        }
-
-    inline float  stof (wstring_view str, size_t* idx=0) {
-        return std::stof ( std::wstring(str), idx );
-        }
-
-    inline double stod (wstring_view str, size_t* idx=0) {
-        return std::stod ( std::wstring(str), idx );
-        }
-
-    inline long double stold (wstring_view str, size_t* idx=0) {
-        return std::stold ( std::wstring(str), idx );
-        }
-#endif
-
-    template <class charT, class traits>
-    std::size_t hash_value(basic_string_view<charT, traits> s) {
-        return boost::hash_range(s.begin(), s.end());
-        }
-}
-
-#if 0
-namespace std {
-    // Hashing
-    template<> struct hash<boost::string_view>;
-    template<> struct hash<boost::u16string_view>;
-    template<> struct hash<boost::u32string_view>;
-    template<> struct hash<boost::wstring_view>;
-}
-#endif
-
-#endif

include/boost/utility/string_view_fwd.hpp

@@ -1,39 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2012-2012.
-
-   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)
-
-    For more information, see http://www.boost.org
-
-    Based on the StringRef implementation in LLVM (http://llvm.org) and
-    N3422 by Jeffrey Yasskin
-        http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
-    Updated July 2015 to reflect the Library Fundamentals TS
-        http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4480.html
-
-*/
-
-#ifndef BOOST_STRING_VIEW_FWD_HPP
-#define BOOST_STRING_VIEW_FWD_HPP
-
-#include <boost/config.hpp>
-#include <string>
-
-namespace boost {
-
-    template<typename charT, typename traits = std::char_traits<charT> > class basic_string_view;
-    typedef basic_string_view<char,     std::char_traits<char> >        string_view;
-    typedef basic_string_view<wchar_t,  std::char_traits<wchar_t> >    wstring_view;
-
-#ifndef BOOST_NO_CXX11_CHAR16_T
-    typedef basic_string_view<char16_t, std::char_traits<char16_t> > u16string_view;
-#endif
-
-#ifndef BOOST_NO_CXX11_CHAR32_T
-    typedef basic_string_view<char32_t, std::char_traits<char32_t> > u32string_view;
-#endif
-
-}
-
-#endif

include/boost/utility/trace_scope.hpp

@@ -0,0 +1,40 @@
+#ifndef UTILITY_TRACE_SCOPE_HPP
+#define UTILITY_TRACE_SCOPE_HPP
+#include "boost/io/filters/mout.hpp"
+#include <string>
+namespace utility
+{
+  class
+trace_scope
+  //Purpose:
+  //  Indicate on cout when a scope entered and exited.
+  {
+  public:
+    trace_scope(char const* a_scopeName)
+      : m_scopeName(a_scopeName)
+      { init()
+      ;}
+    trace_scope(std::string const& a_scopeName)
+      : m_scopeName(a_scopeName)
+      { init()
+      ;}
+    ~trace_scope(void)
+      {
+      ; --mout()
+      ; std::string l_context("===>Exit:")
+      ; mout()<<l_context<<m_scopeName<<std::endl
+      ;}
+  private:
+      void
+    init(void)
+      { 
+      ; std::string l_context("===>Enter:")
+      ; mout()<<l_context<<m_scopeName<<std::endl
+      ; ++mout()
+      ;}
+      std::string
+    m_scopeName
+      ;
+  };//end trace_scope class
+}//exit utility namespace
+#endif

include/boost/utility/trace_scope_stk.hpp

@@ -0,0 +1,46 @@
+#ifndef UTILITY_TRACE_SCOPE_STK_HPP
+#define UTILITY_TRACE_SCOPE_STK_HPP
+#include <vector>
+#include "boost/utility/trace_scope.hpp"
+namespace utility
+{
+struct trace_scope_stk
+  : public trace_scope
+  //Purpose:
+  //  Simply keeps a stack variables of
+  //  type trace_scope_stk
+  {
+  public:
+        static
+      std::string const&
+    top_name(void)
+      { return c_scope_names.back()
+      ;}
+        static
+      std::string const
+    top_result(bool result_bool)
+      { std::string  result_string(c_scope_names.back())
+      ; result_string += std::string(":result=")
+      ; result_string += c_test_results[result_bool]
+      ; return result_string
+      ;}
+    trace_scope_stk(std::string const& a_name)
+      : trace_scope(a_name)
+      { c_scope_names.push_back(a_name)
+      ;}
+    ~trace_scope_stk(void)
+      { c_scope_names.pop_back()
+      ;}
+  private:
+        static
+      std::vector<std::string>
+    c_scope_names
+      ;
+        static
+      std::string const
+    c_test_results[2]
+      ;
+  };
+}//exit utility namespace
+#endif
+

include/boost/utility/type_deduction.hpp

@@ -0,0 +1,476 @@
+/*=============================================================================
+    Copyright (c) 2001-2003 Joel de Guzman
+
+    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)
+==============================================================================*/
+#ifndef BOOST_TYPE_DEDUCTION_IPP
+#define BOOST_TYPE_DEDUCTION_IPP
+
+/*=============================================================================
+
+    Return Type Deduction
+    [JDG Sept. 15, 2003]
+
+    Before C++ adopts the typeof, there is currently no way to deduce the
+    result type of an expression such as x + y. This deficiency is a major
+    problem with template metaprogramming; for example, when writing
+    forwarding functions that attempt to capture the essence of an
+    expression inside a function. Consider the std::plus<T>:
+
+        template <typename T>
+        struct plus : public binary_function<T, T, T>
+        {
+            T operator()(T const& x, T const& y) const
+            {
+                return x + y;
+            }
+        };
+
+    What's wrong with this? Well, this functor does not accurately capture
+    the behavior of the plus operator. 1) It does not handle the case where
+    x and y are of different types (e.g. x is short and y is int). 2) It
+    assumes that the arguments and return type are the same (i.e. when
+    adding a short and an int, the return type ought to be an int). Due to
+    these shortcomings, std::plus<T>(x, y) is a poor substitute for x + y.
+
+    The case where x is short and y is int does not really expose the
+    problem. We can simply use std::plus<int> and be happy that the
+    operands x and y will simply be converted to an int. The problem
+    becomes evident when an operand is a user defined type such as bigint.
+    Here, the conversion to bigint is simply not acceptable. Even if the
+    unnecessary conversion is tolerable, in generic code, it is not always
+    possible to choose the right T type that can accomodate both x and y
+    operands.
+
+    To truly model the plus operator, what we need is a polymorphic functor
+    that can take arbitrary x and y operands. Here's a rough schematic:
+
+        struct plus
+        {
+            template <typename X, typename Y>
+            unspecified-type
+            operator()(X const& x, Y const& y) const
+            {
+                return x + y;
+            }
+        };
+
+    Now, we can handle the case where X and Y are arbitrary types. We've
+    solved the first problem. To solve the second problem, we need some
+    form of return type deduction mechanism. If we had the typeof, it would
+    be something like:
+
+        template <typename X, typename Y>
+        typeof(X() + Y())
+        operator()(X const& x, Y const& y) const
+        {
+            return x + y;
+        }
+
+    Without the typeof facility, it is only possible to wrap an expression
+    such as x + y in a function or functor if we are given a hint that
+    tells us what the actual result type of such an expression is. Such a
+    hint can be in the form of a metaprogram, that, given the types of the
+    arguments, will return the result type. Example:
+
+        template <typename X, typename Y>
+        struct result_of_plus
+        {
+            typedef unspecified-type type;
+        };
+
+    Given a result_of_plus metaprogram, we can complete our polymorphic
+    plus functor:
+
+        struct plus
+        {
+            template <typename X, typename Y>
+            typename result_of_plus<X, Y>::type
+            operator()(X const& x, Y const& y) const
+            {
+                return x + y;
+            }
+        };
+
+    The process is not automatic. We have to specialize the metaprogram for
+    specific argument types. Examples:
+
+        template <>
+        struct result_of_plus<short, int>
+        {
+            typedef int type;
+        };
+
+        template <typename T>
+        struct result_of_plus<std::complex<T>, std::complex<T> >
+        {
+            typedef std::complex<T> type;
+        };
+
+    To make it easier for the user, specializations are provided for common
+    types such as primitive c++ types (e.g. int, char, double, etc.), and
+    standard types (e.g. std::complex, iostream, std containers and
+    iterators).
+
+    To further improve the ease of use, for user defined classes, we can
+    supply a few more basic specializations through metaprogramming using
+    heuristics based on canonical operator rules (Such heuristics can be
+    found in the LL and Phoenix, for example). For example, it is rather
+    common that the result of x += y is X& or the result of x || y is a
+    bool. The client is out of luck if her classes do not follow the
+    canonical rules. She'll then have to supply her own specialization.
+
+    The type deduction mechanism demostrated below approaches the problem
+    not through specialization and heuristics, but through a limited form
+    of typeof mechanism. The code does not use heuristics, hence, no
+    guessing games. The code takes advantage of the fact that, in general,
+    the result type of an expression is related to one its arguments' type.
+    For example, x + y, where x has type int and y has type double, has the
+    result type double (the second operand type). Another example, x[y]
+    where x is a vector<T> and y is a std::size_t, has the result type
+    vector<T>::reference (the vector<T>'s reference type type).
+
+    The limited form of type deduction presented can detect common
+    relations if the result of a binary or unary operation, given arguments
+    x and y with types X and Y (respectively), is X, Y, X&, Y&, X*, Y*, X
+    const*, Y const*, bool, int, unsigned, double, container and iterator
+    elements (e.g the T, where X is: T[N], T*, vector<T>, map<T>,
+    vector<T>::iterator). More arguments/return type relationships can be
+    established if needed.
+
+    A set of overloaded test(T) functions capture these argument related
+    types. Each test(T) function returns a distinct type that can be used
+    to determine the exact type of an expression.
+
+    Consider:
+
+        template <typename X, typename Y>
+        x_value_type
+        test(X const&);
+
+        template <typename X, typename Y>
+        y_value_type
+        test(Y const&);
+
+    Given an expression x + y, where x is int and y is double, the call to:
+
+        test<int, double>(x + y)
+
+    will return a y_value_type.
+
+    Now, if we rig x_value_type and y_value_type such that both have unique
+    sizes, we can use sizeof(test<X, Y>(x + y)) to determine if the result
+    type is either X or Y.
+
+    For example, if:
+
+        sizeof(test<X, Y>(x + y)) == sizeof(y_value_type)
+
+    then, we know for sure that the result of x + y has type Y.
+
+    The same basic scheme can be used to detect more argument-dependent
+    return types where the sizeof the test(T) return type is used to index
+    through a boost::mpl vector which holds each of the corresponding
+    result types.
+
+==============================================================================*/
+#include <boost/mpl/vector/vector20.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/preprocessor/cat.hpp>
+
+namespace boost {
+
+struct error_cant_deduce_type {};
+
+  namespace type_deduction_detail
+  {
+    typedef char(&bool_value_type)[1];
+    typedef char(&int_value_type)[2];
+    typedef char(&uint_value_type)[3];
+    typedef char(&double_value_type)[4];
+
+    typedef char(&bool_reference_type)[5];
+    typedef char(&int_reference_type)[6];
+    typedef char(&uint_reference_type)[7];
+    typedef char(&double_reference_type)[8];
+
+    typedef char(&x_value_type)[9];
+    typedef char(&x_reference_type)[10];
+    typedef char(&x_const_pointer_type)[11];
+    typedef char(&x_pointer_type)[12];
+
+    typedef char(&y_value_type)[13];
+    typedef char(&y_reference_type)[14];
+    typedef char(&y_const_pointer_type)[15];
+    typedef char(&y_pointer_type)[16];
+
+    typedef char(&container_reference_type)[17];
+    typedef char(&container_const_reference_type)[18];
+    typedef char(&container_mapped_type)[19];
+
+    typedef char(&cant_deduce_type)[20];
+
+    template <typename T, typename PlainT = typename remove_cv<T>::type>
+    struct is_basic
+        : mpl::or_<
+            is_same<PlainT, bool>
+          , is_same<PlainT, int>
+          , is_same<PlainT, unsigned>
+          , is_same<PlainT, double>
+        > {};
+
+    template <typename C>
+    struct reference_type
+    {
+        typedef typename C::reference type;
+    };
+
+    template <typename T, std::size_t N>
+    struct reference_type<T[N]>
+    {
+        typedef T& type;
+    };
+
+    template <typename T>
+    struct reference_type<T*>
+    {
+        typedef T& type;
+    };
+
+    template <typename C>
+    struct const_reference_type
+    {
+        typedef typename C::const_reference type;
+    };
+
+    template <typename C>
+    struct mapped_type
+    {
+        typedef typename C::mapped_type type;
+    };
+
+    struct asymmetric;
+
+    template <typename X, typename Y>
+    cant_deduce_type
+    test(...); // The black hole !!!
+
+    template <typename X, typename Y>
+    bool_value_type
+    test(bool const&);
+
+    template <typename X, typename Y>
+    int_value_type
+    test(int const&);
+
+    template <typename X, typename Y>
+    uint_value_type
+    test(unsigned const&);
+
+    template <typename X, typename Y>
+    double_value_type
+    test(double const&);
+
+    template <typename X, typename Y>
+    bool_reference_type
+    test(bool&);
+
+    template <typename X, typename Y>
+    int_reference_type
+    test(int&);
+
+    template <typename X, typename Y>
+    uint_reference_type
+    test(unsigned&);
+
+    template <typename X, typename Y>
+    double_reference_type
+    test(double&);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<is_basic<X>, is_const<X> >
+      , x_value_type
+    >::type
+    test(X const&);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        is_basic<X>
+      , x_reference_type
+    >::type
+    test(X&);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<X>
+          , is_const<X>
+        >
+      , x_const_pointer_type
+    >::type
+    test(X const*);
+
+    template <typename X, typename Y>
+    x_pointer_type
+    test(X*);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<Y>
+          , is_same<Y, asymmetric>
+          , is_const<Y>
+          , is_same<X, Y>
+        >
+      , y_value_type
+    >::type
+    test(Y const&);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<Y>
+          , is_same<Y, asymmetric>
+          , is_same<X, Y>
+        >
+      , y_reference_type
+    >::type
+    test(Y&);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_same<Y, asymmetric>
+          , is_const<Y>
+          , is_same<X, Y>
+        >
+      , y_const_pointer_type
+    >::type
+    test(Y const*);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_same<Y, asymmetric>
+          , is_same<X, Y>
+        >
+      , y_pointer_type
+    >::type
+    test(Y*);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        is_basic<typename X::value_type>
+      , container_reference_type
+    >::type
+    test(typename X::reference);
+
+    template <typename X, typename Y, typename Z>
+    typename enable_if<
+        mpl::and_<
+            mpl::or_<is_array<X>, is_pointer<X> >
+          , mpl::not_<is_basic<Z> >
+        >
+      , container_reference_type
+    >::type
+    test(Z&);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        is_basic<typename X::value_type>
+      , container_const_reference_type
+    >::type
+    test(typename X::const_reference);
+
+    template <typename X, typename Y>
+    typename disable_if<
+        is_basic<typename X::mapped_type>
+      , container_mapped_type
+    >::type
+    test(typename X::mapped_type);
+
+    template <typename X, typename Y>
+    struct base_result_of
+    {
+        typedef typename remove_reference<X>::type x_type;
+        typedef typename remove_reference<Y>::type y_type;
+
+        typedef mpl::vector20<
+            mpl::identity<bool>
+          , mpl::identity<int>
+          , mpl::identity<unsigned>
+          , mpl::identity<double>
+          , mpl::identity<bool&>
+          , mpl::identity<int&>
+          , mpl::identity<unsigned&>
+          , mpl::identity<double&>
+          , mpl::identity<x_type>
+          , mpl::identity<x_type&>
+          , mpl::identity<x_type const*>
+          , mpl::identity<x_type*>
+          , mpl::identity<y_type>
+          , mpl::identity<y_type&>
+          , mpl::identity<y_type const*>
+          , mpl::identity<y_type*>
+          , reference_type<x_type>
+          , const_reference_type<x_type>
+          , mapped_type<x_type>
+          , mpl::identity<error_cant_deduce_type>
+        >
+        types;
+    };
+
+}} // namespace boost::type_deduction_detail
+
+#define BOOST_RESULT_OF_COMMON(expr, name, Y, SYMMETRY)                         \
+    struct name                                                                 \
+    {                                                                           \
+        typedef type_deduction_detail::base_result_of<X, Y> base_type;          \
+        static typename base_type::x_type x;                                    \
+        static typename base_type::y_type y;                                    \
+                                                                                \
+        BOOST_STATIC_CONSTANT(int,                                              \
+            size = sizeof(                                                      \
+                type_deduction_detail::test<                                    \
+                    typename base_type::x_type                                  \
+                  , SYMMETRY                                                    \
+                >(expr)                                                         \
+            ));                                                                 \
+                                                                                \
+        BOOST_STATIC_CONSTANT(int, index = (size / sizeof(char)) - 1);          \
+                                                                                \
+        typedef typename mpl::at_c<                                  	        \
+            typename base_type::types, index>::type id;                         \
+        typedef typename id::type type;                                         \
+    };
+
+#define BOOST_UNARY_RESULT_OF(expr, name)                                       \
+    template <typename X>                                                       \
+    BOOST_RESULT_OF_COMMON(expr, name,                                          \
+        type_deduction_detail::asymmetric, type_deduction_detail::asymmetric)
+
+#define BOOST_BINARY_RESULT_OF(expr, name)                                      \
+    template <typename X, typename Y>                                           \
+    BOOST_RESULT_OF_COMMON(expr, name, Y, typename base_type::y_type)
+
+#define BOOST_ASYMMETRIC_BINARY_RESULT_OF(expr, name)                           \
+    template <typename X, typename Y>                                           \
+    BOOST_RESULT_OF_COMMON(expr, name, Y, type_deduction_detail::asymmetric)
+
+#endif

include/boost/utility/typed_in_place_factory.hpp

@@ -1,77 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-// Copyright (C) 2007, Tobias Schwinger.
-//
-// 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)
-//
-// See http://www.boost.org/libs/optional for documentation.
-//
-// You are welcome to contact the author at:
-//  fernando_cacciola@hotmail.com
-//
-#ifndef BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
-#ifndef BOOST_PP_IS_ITERATING
-
-#include <boost/utility/detail/in_place_factory_prefix.hpp>
-
-namespace boost {
-
-class typed_in_place_factory_base {} ;
-
-#define  BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY)
-#define  BOOST_PP_FILENAME_1 <boost/utility/typed_in_place_factory.hpp>
-#include BOOST_PP_ITERATE()
-
-} // namespace boost
-
-#include <boost/utility/detail/in_place_factory_suffix.hpp>
-
-#define BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
-#else 
-#define N BOOST_PP_ITERATION()
-
-template< class T BOOST_PP_ENUM_TRAILING_PARAMS(N,class A) >
-class BOOST_PP_CAT(typed_in_place_factory,N) 
-  : 
-  public typed_in_place_factory_base
-{
-public:
-
-  typedef T value_type;
-
-  explicit BOOST_PP_CAT(typed_in_place_factory,N) 
-      ( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
-#if N > 0
-    : BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _)
-#endif
-  {}
-
-  void* apply (void* address) const
-  {
-    return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
-  }
-
-  void* apply (void* address, std::size_t n) const
-  {
-    for(void* next = address = this->apply(address); !! --n;)
-      this->apply(next = static_cast<char *>(next) + sizeof(T));
-    return address; 
-  }
-
-  BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _)
-};
-
-template< class T BOOST_PP_ENUM_TRAILING_PARAMS(N, class A) >
-inline BOOST_PP_CAT(typed_in_place_factory,N)<
-    T BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >
-in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
-{
-  return BOOST_PP_CAT(typed_in_place_factory,N)< 
-      T BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >( BOOST_PP_ENUM_PARAMS(N, a) );
-}
-
-#undef N
-#endif
-#endif
-

include/boost/utility/value_init.hpp

@@ -1,281 +0,0 @@
-// (C) Copyright 2002-2008, Fernando Luis Cacciola Carballal.
-//
-// 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)
-//
-// 21 Ago 2002 (Created) Fernando Cacciola
-// 24 Dec 2007 (Refactored and worked around various compiler bugs) Fernando Cacciola, Niels Dekker
-// 23 May 2008 (Fixed operator= const issue, added initialized_value) Niels Dekker, Fernando Cacciola
-// 21 Ago 2008 (Added swap) Niels Dekker, Fernando Cacciola
-// 20 Feb 2009 (Fixed logical const-ness issues) Niels Dekker, Fernando Cacciola
-// 03 Apr 2010 (Added initialized<T>, suggested by Jeffrey Hellrung, fixing #3472) Niels Dekker
-// 30 May 2010 (Made memset call conditional, fixing #3869) Niels Dekker
-//
-#ifndef BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
-#define BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
-
-// Note: The implementation of boost::value_initialized had to deal with the
-// fact that various compilers haven't fully implemented value-initialization.
-// The constructor of boost::value_initialized<T> works around these compiler
-// issues, by clearing the bytes of T, before constructing the T object it
-// contains. More details on these issues are at libs/utility/value_init.htm
-
-#include <boost/aligned_storage.hpp>
-#include <boost/config.hpp> // For BOOST_NO_COMPLETE_VALUE_INITIALIZATION.
-#include <boost/detail/workaround.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/cv_traits.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-#include <boost/swap.hpp>
-#include <cstring>
-#include <new>
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-// It is safe to ignore the following warning from MSVC 7.1 or higher:
-// "warning C4351: new behavior: elements of array will be default initialized"
-#pragma warning(disable: 4351)
-// It is safe to ignore the following MSVC warning, which may pop up when T is 
-// a const type: "warning C4512: assignment operator could not be generated".
-#pragma warning(disable: 4512)
-#endif
-
-#ifdef BOOST_NO_COMPLETE_VALUE_INITIALIZATION
-  // Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED 
-  // suggests that a workaround should be applied, because of compiler issues 
-  // regarding value-initialization.
-  #define BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
-#endif
-
-// Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND
-// switches the value-initialization workaround either on or off.
-#ifndef BOOST_DETAIL_VALUE_INIT_WORKAROUND
-  #ifdef BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
-  #define BOOST_DETAIL_VALUE_INIT_WORKAROUND 1
-  #else
-  #define BOOST_DETAIL_VALUE_INIT_WORKAROUND 0
-  #endif
-#endif
-
-namespace boost {
-
-template<class T>
-class initialized
-{
-  private :
-    struct wrapper
-    {
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
-      typename
-#endif 
-      remove_const<T>::type data;
-
-      BOOST_GPU_ENABLED
-      wrapper()
-      :
-      data()
-      {
-      }
-
-      BOOST_GPU_ENABLED
-      wrapper(T const & arg)
-      :
-      data(arg)
-      {
-      }
-    };
-
-    mutable
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
-      typename
-#endif 
-      aligned_storage<sizeof(wrapper), alignment_of<wrapper>::value>::type x;
-
-    BOOST_GPU_ENABLED
-    wrapper * wrapper_address() const
-    {
-      return static_cast<wrapper *>( static_cast<void*>(&x));
-    }
-
-  public :
-
-    BOOST_GPU_ENABLED
-    initialized()
-    {
-#if BOOST_DETAIL_VALUE_INIT_WORKAROUND
-      std::memset(&x, 0, sizeof(x));
-#endif
-      new (wrapper_address()) wrapper();
-    }
-
-    BOOST_GPU_ENABLED
-    initialized(initialized const & arg)
-    {
-      new (wrapper_address()) wrapper( static_cast<wrapper const &>(*(arg.wrapper_address())));
-    }
-
-    BOOST_GPU_ENABLED
-    explicit initialized(T const & arg)
-    {
-      new (wrapper_address()) wrapper(arg);
-    }
-
-    BOOST_GPU_ENABLED
-    initialized & operator=(initialized const & arg)
-    {
-      // Assignment is only allowed when T is non-const.
-      BOOST_STATIC_ASSERT( ! is_const<T>::value );
-      *wrapper_address() = static_cast<wrapper const &>(*(arg.wrapper_address()));
-      return *this;
-    }
-
-    BOOST_GPU_ENABLED
-    ~initialized()
-    {
-      wrapper_address()->wrapper::~wrapper();
-    }
-
-    BOOST_GPU_ENABLED
-    T const & data() const
-    {
-      return wrapper_address()->data;
-    }
-
-    BOOST_GPU_ENABLED
-    T& data()
-    {
-      return wrapper_address()->data;
-    }
-
-    BOOST_GPU_ENABLED
-    void swap(initialized & arg)
-    {
-      ::boost::swap( this->data(), arg.data() );
-    }
-
-    BOOST_GPU_ENABLED
-    operator T const &() const
-    {
-      return wrapper_address()->data;
-    }
-
-    BOOST_GPU_ENABLED
-    operator T&()
-    {
-      return wrapper_address()->data;
-    }
-
-} ;
-
-template<class T>
-BOOST_GPU_ENABLED
-T const& get ( initialized<T> const& x )
-{
-  return x.data() ;
-}
-
-template<class T>
-BOOST_GPU_ENABLED
-T& get ( initialized<T>& x )
-{
-  return x.data() ;
-}
-
-template<class T>
-BOOST_GPU_ENABLED
-void swap ( initialized<T> & lhs, initialized<T> & rhs )
-{
-  lhs.swap(rhs) ;
-}
-
-template<class T>
-class value_initialized
-{
-  private :
-
-    // initialized<T> does value-initialization by default.
-    initialized<T> m_data;
-
-  public :
-    
-    BOOST_GPU_ENABLED
-    value_initialized()
-    :
-    m_data()
-    { }
-    
-    BOOST_GPU_ENABLED
-    T const & data() const
-    {
-      return m_data.data();
-    }
-
-    BOOST_GPU_ENABLED
-    T& data()
-    {
-      return m_data.data();
-    }
-
-    BOOST_GPU_ENABLED
-    void swap(value_initialized & arg)
-    {
-      m_data.swap(arg.m_data);
-    }
-
-    BOOST_GPU_ENABLED
-    operator T const &() const
-    {
-      return m_data;
-    }
-
-    BOOST_GPU_ENABLED
-    operator T&()
-    {
-      return m_data;
-    }
-} ;
-
-
-template<class T>
-BOOST_GPU_ENABLED
-T const& get ( value_initialized<T> const& x )
-{
-  return x.data() ;
-}
-
-template<class T>
-BOOST_GPU_ENABLED
-T& get ( value_initialized<T>& x )
-{
-  return x.data() ;
-}
-
-template<class T>
-BOOST_GPU_ENABLED
-void swap ( value_initialized<T> & lhs, value_initialized<T> & rhs )
-{
-  lhs.swap(rhs) ;
-}
-
-
-class initialized_value_t
-{
-  public :
-    
-    template <class T> BOOST_GPU_ENABLED operator T() const
-    {
-      return initialized<T>().data();
-    }
-};
-
-initialized_value_t const initialized_value = {} ;
-
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif

index.html

@@ -1,49 +0,0 @@
-<html>
-	<head>
-		<meta http-equiv="Content-Language" content="en-us">
-		<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
-		<meta name="ProgId" content="FrontPage.Editor.Document">
-		<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-		<title>Boost Utility Library</title>
-	</head>
-	<body bgcolor="#FFFFFF">
-		<h1><IMG SRC="../../boost.png" WIDTH="276" HEIGHT="86" align="center">Boost 
-			Utility Library</h1>
-		<p>The Boost Utility Library isn't really a single library at all. It is just a 
-			collection for components too small to be called libraries in their own right.</p>
-		<p>But that doesn't mean there isn't useful stuff here. Take a look:</p>
-		<blockquote>
-			<p>
-				<a href="../core/doc/html/core/addressof.html">addressof</a> (moved to the Boost.Core library)<br>
-				<a href="doc/html/base_from_member.html">base_from_member</a><br>
-				<a href="utility.htm#BOOST_BINARY">BOOST_BINARY</a><br>
-				<a href="call_traits.htm">call_traits</a><br>
-				<a href="../core/doc/html/core/checked_delete.html">checked_delete</a> (moved to the Boost.Core library)<br>
-				<a href="doc/html/compressed_pair.html">compressed_pair</a><br>
-				<a href="../type_traits/doc/html/boost_typetraits/reference/declval.html">declval</a> (moved to the Boost.TypeTraits library)<br>
-				<a href="../core/doc/html/core/enable_if.html">enable_if</a> (moved to the Boost.Core library)<br>
-				<a href="in_place_factories.html">in_place_factory</a><br>
-				<a href="iterator_adaptors.htm">iterator_adaptors</a><br>
-				<a href="../iterator/doc/generator_iterator.htm">generator iterator adaptors</a> (moved to the Boost.Iterator library)<br>
-				<a href="../iterator/doc/html/iterator/algorithms/next_prior.html">next/prior</a> (moved to the Boost.Iterator library)<br>
-				<a href="../core/doc/html/core/noncopyable.html">noncopyable</a> (moved to the Boost.Core library)<br>
-				<a href="operators.htm">operators</a><br>
-				<a href="utility.htm#result_of">result_of</a><br>
-				<a href="throw_exception.html">throw_exception</a><br>
-				<a href="utility.htm">utility</a><br>
-            <a href="doc/html/ostream_string.html">ostream_string</a><br>
-            <a href="doc/html/string_ref.html">string_ref</a><br>
-            <a href="value_init.htm">value_init</a><br>
-         </p>
-		</blockquote>
-		<hr>
-		<p>&copy; Copyright Beman Dawes, 2001</p>
-        <p>Distributed under the Boost Software License, Version 1.0. (See 
-        accompanying file <a href="../../LICENSE_1_0.txt">
-        LICENSE_1_0.txt</a> or copy at
-        <a href="http://www.boost.org/LICENSE_1_0.txt">
-        www.boost.org/LICENSE_1_0.txt</a>)</p>
-		<p>Revised 
-			<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->07 November, 2006<!--webbot bot="Timestamp" endspan i-checksum="39368" --></p>
-		</body>
-</html>

iterator_adaptors.htm

@@ -1,11 +0,0 @@
-<!-- Copyright David Abrahams 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) -->
-<html>
-<head>
-<meta http-equiv="refresh" content="0; URL=../iterator/doc/index.html">
-</head>
-<body>
-This documentation moved to <a href="../iterator/doc/index.html">../iterator/doc/index.html</a>.
-</body>
-</html>

meta/libraries.json

@@ -1,139 +0,0 @@
-[
-    {
-        "key": "utility",
-        "name": "Utility",
-        "authors": [
-            "Dave Abrahams and others"
-        ],
-        "description": "Class noncopyable plus checked_delete(), checked_array_delete(), next(), prior() function templates, plus base-from-member idiom.",
-        "documentation": "utility.htm",
-        "category": [
-            "Algorithms",
-            "Function-objects",
-            "Memory",
-            "Miscellaneous",
-            "Patterns"
-        ]
-    },
-    {
-        "key": "utility/call_traits",
-        "name": "Call Traits",
-        "authors": [
-            "John Maddock, Howard Hinnant, et al"
-        ],
-        "description": "Defines types for passing parameters.",
-        "documentation": "call_traits.htm",
-        "category": [
-            "Generic"
-        ]
-    },
-    {
-        "key": "utility/compressed_pair",
-        "name": "Compressed Pair",
-        "authors": [
-            "John Maddock, Howard Hinnant, et al"
-        ],
-        "description": "Empty member optimization.",
-        "documentation": "compressed_pair.htm",
-        "category": [
-            "Data",
-            "Patterns"
-        ]
-    },
-    {
-        "key": "utility/identity_type",
-        "name": "Identity Type",
-        "authors": [
-            "Lorenzo Caminiti"
-        ],
-        "description": "Wrap types within round parenthesis so they can always be passed as macro parameters.",
-        "documentation": "identity_type/",
-        "category": [
-            "Preprocessor"
-        ],
-        "maintainers": [
-            "Lorenzo Caminiti <lorcaminiti -at- gmail.com>"
-        ]
-    },
-    {
-        "key": "utility/in_place_factories",
-        "name": "In Place Factory, Typed In Place Factory",
-        "authors": [
-            "Fernando Cacciola"
-        ],
-        "description": "Generic in-place construction of contained objects with a variadic argument-list.",
-        "documentation": "in_place_factories.html",
-        "category": [
-            "Generic"
-        ]
-    },
-    {
-        "key": "utility/operators",
-        "name": "Operators",
-        "authors": [
-            "Dave Abrahams",
-            "Jeremy Siek"
-        ],
-        "description": "Templates ease arithmetic classes and iterators.",
-        "documentation": "operators.htm",
-        "category": [
-            "Generic",
-            "Iterators",
-            "Math"
-        ],
-        "maintainers": [
-            "Daniel Frey <d.frey -at- gmx.de>"
-        ]
-    },
-    {
-        "key": "utility/ostream_string",
-        "name": "ostream_string",
-        "description": "String formatted output function.",
-        "documentation": "doc/html/ostream_string.html",
-        "category": [
-            "IO"
-        ],
-        "authors": "Glen Fernandes",
-        "maintainers": [
-            "Glen Fernandes <glenjofe -at- gmail.com>"
-        ]
-    },
-    {
-        "key": "utility/result_of",
-        "name": "Result Of",
-        "description": "Determines the type of a function call expression.",
-        "documentation": "utility.htm#result_of",
-        "category": [
-            "Function-objects"
-        ],
-        "authors": "",
-        "maintainers": [
-            "Daniel Walker <daniel.j.walker -at- gmail.com>"
-        ]
-    },
-    {
-        "key": "utility/string_ref",
-        "name": "string_ref",
-        "description": "String view templates.",
-        "documentation": "doc/html/string_ref.html",
-        "category": [
-            "Containers"
-        ],
-        "authors": "Marshall Clow",
-        "maintainers": [
-            "Marshall Clow <marshall -at- idio.com>"
-        ]
-    },
-    {
-        "key": "utility/value_initialized",
-        "name": "Value Initialized",
-        "authors": [
-            "Fernando Cacciola"
-        ],
-        "description": "Wrapper for uniform-syntax value initialization, based on the original idea of David Abrahams.",
-        "documentation": "value_init.htm",
-        "category": [
-            "Miscellaneous"
-        ]
-    }
-]

queue.html

@@ -0,0 +1,180 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title>queue</title>
+  </head>
+  <body>
+    <h1><img src="../../c++boost.gif" alt="C++ Boost" width="277" height="86" /><br />queue</h1>
+    <p>A <tt>boost::queue</tt> is a container adaptor that provides both <a href="http://www.sgi.com/tech/stl/queue.html">std::queue</a> and <a href="./Buffer.html">Buffer</a> functionality.</p>
+
+    <h3>Where Defined</h3>
+    <p><a href="../../boost/pending/queue.hpp"><tt>boost/queue.hpp</tt></a></p>
+
+    <h3>Template Parameters</h3>
+    <table border="1">
+      <tr>
+        <th>Parameter</th>
+        <th>Description</th>
+        <th>Default</th>
+      </tr>
+      <tr valign="top">
+        <td><tt>T</tt></td>
+        <td>The type of object stored in the <tt>queue</tt>.</td>
+        <td> </td>
+      </tr>
+      <tr valign="top">
+        <td><tt>Sequence</tt></td>
+        <td>The type of the underlying container used to implement the <tt>queue</tt>.</td>
+        <td><tt><a href="http://www.sgi.com/tech/stl/Deque.html">std::deque</a>&lt;T&gt;</tt></td>
+      </tr>
+    </table>
+
+    <h3>Models</h3>
+    <ul>
+      <li><a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</a></li>
+      <li><a href="./Buffer.html">Buffer</a></li>
+    </ul>
+
+    <h3>Type Requirements</h3>
+    <ul>
+      <li><tt>T</tt> is a model of <a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>.</li>
+      <li><tt>Sequence</tt> is a model of <a href="./CopyConstructible.html">Copy Constructible</a>.</li>
+      <li><tt>Sequence</tt> is a model of <a href="http://www.sgi.com/tech/stl/FrontInsertionSequence.html">FrontInsertionSequence</a></li>
+      <li><tt>Sequence</tt> is a model of <a href="http://www.sgi.com/tech/stl/BackInsertionSequence.html">BackInsertionSequence</a></li>
+      <li><tt>Sequence::value_type</tt> is the same type as <tt>T</tt>.</li>
+      <li>If <tt>operator==</tt> is used, then <tt>T</tt> is a model of <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.</li>
+      <li>If <tt>operator&lt;</tt> is used, then <tt>T</tt> is a model of <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThan Comparable</a>.</li>
+    </ul>
+
+    <h3>Public Base Classes</h3>
+    <p>None.</p>
+
+    <h3>Members</h3>
+    <table border="1">
+      <tr>
+        <th>Member</th>
+        <th>Where Defined</th>
+        <th>Description</th>
+      </tr>
+      <tr valign="top">
+        <td><tt>value_type</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>The type of object stored in the <tt>queue</tt>.  This is the same as <tt>T</tt> and <tt>Sequence::value_type</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>size_type</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>An unsigned integral type.  This is the same as <tt>Sequence::size_type</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>queue()</tt></td>
+        <td><a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</a></td>
+        <td>The default constructor.  Creates an empty <tt>queue</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>queue(const Sequence&amp; c)</tt></td>
+        <td><tt>boost::queue</tt></td>
+        <td>The constructor.  Creates a <tt>queue</tt> initialized to contain the elements in <tt>c</tt>, in back-insertion order.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>bool empty() const</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>Returns <tt>true</tt> if the <tt>queue</tt> contains no elements, and <tt>false</tt> otherwise.  <tt>empty()</tt> is equivalent to <tt>size() == 0</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>size_type size() const</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>Returns the number of elements contained in the <tt>queue</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>value_type&amp; top()</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>Returns a mutable reference to the least recently inserted element in the <tt>queue</tt>.  Precondition: <tt>empty()</tt> is <tt>false</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>value_type&amp; front()</tt></td>
+        <td><a href="http://www.sgi.com/tech/stl/queue.html">std::queue</a></td>
+        <td>Serves the same function as <tt>value_type&amp; top()</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>const value_type&amp; top() const</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>Returns a const reference to the least recently inserted element in the <tt>queue</tt>.  Precondition: <tt>empty()</tt> is <tt>false</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>const value_type&amp; front() const</tt></td>
+        <td><tt>boost::queue</tt>, not <a href="http://www.sgi.com/tech/stl/queue.html">std::queue</a></td>
+        <td>Serves the same function as <tt>const value_type&amp; top() const</tt>.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>void push(const value_type&amp; x)</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>Inserts <tt>x</tt> into the <tt>queue</tt>.  Postcondition: <tt>size()</tt> will be incremented by 1.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>void pop()</tt></td>
+        <td><a href="./Buffer.html">Buffer</a></td>
+        <td>Removes the least recently inserted element from the <tt>queue</tt>.  Postcondition: <tt>size()</tt> will be decremented by 1.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>bool operator==(const queue&amp;, const queue&amp;)</tt></td>
+        <td><tt>boost::queue</tt></td>
+        <td>Compares two queues for equality.  Two queues are equal if they contain the same number of elements and if they are equal element-by-element.  This is a global function, not a member function.</td>
+      </tr>
+      <tr valign="top">
+        <td><tt>bool operator&lt;(const queue&amp;, const queue&amp;)</tt></td>
+        <td><tt>boost::queue</tt></td>
+        <td>Lexicographical ordering of two queues.  This is a global function, not a member function.</td>
+      </tr>
+    </table>
+
+    <h3>Complexity</h3>
+    <ul>
+      <li>The time complexity of all three structure-modifying operations--<tt>push()</tt>, <tt>pop()</tt>, and <tt>update()</tt>--is <tt>O(1)</tt>.</li>
+      <li>The time complexity of the constructor that takes in a <tt>Sequence</tt> argument is linear time in the size of the <tt>Sequence</tt>.</li>
+    </ul>
+
+    <h3>Example</h3>
+<pre>#include &lt;boost/queue&gt;
+#include &lt;cassert&gt;
+
+int main()
+{
+  boost::queue&lt;int&gt; Q;
+
+  Q.push(8);
+  Q.push(7);
+  Q.push(6);
+  Q.push(2);
+  
+  assert(Q.size() == 4);
+  assert(Q.top() == 8);
+  Q.pop();
+
+  assert(Q.top() == 7);
+  Q.pop();
+
+  assert(Q.top() == 6);
+  Q.pop();
+  
+  assert(Q.top() == 2);
+  Q.pop();
+
+  assert(Q.empty());
+
+  return 0;
+}
+</pre>
+
+    <hr />
+    <table border="0">
+      <tr valign="top">
+        <td>Copyright &copy; 2004</td>
+        <td><a href="../../people/jeremy_siek.htm">Jeremy Siek</a>, Univ. of Notre Dame (<a href="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</td>
+      </tr>
+    </table>
+    <p>Use, modification, and distribution are subject to the Boost Software License, Version 1.0 at <a href="../../LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a></p>
+  </body>
+</html>
+

ref_call_test.cpp

@@ -0,0 +1,158 @@
+#include <boost/ref.hpp>
+#include <functional>
+#include <algorithm>
+#include <vector>
+#include <cassert>
+
+class generate_zero {
+public:
+  typedef int result_type;
+  generate_zero() {}
+  int operator()() const { return 0; }
+
+private:
+  generate_zero(const generate_zero&);
+};
+
+class generate_zero_no_result_type {
+public:
+  generate_zero_no_result_type() {}
+  int operator()() const { return 0; }
+
+private:
+  generate_zero_no_result_type(const generate_zero_no_result_type&);
+};
+
+template<typename F>
+void check_generate_zero(F f)
+{
+  assert(f() == 0);
+}
+
+class negate_with_result_type
+{
+public:
+  typedef int result_type;
+
+  negate_with_result_type() {}
+  int operator()(int x) const { return -x; }
+
+private:
+  negate_with_result_type(const negate_with_result_type&);
+};
+
+class negate_with_result_of
+{
+public:
+  template<typename T>
+  struct result_of
+  {
+    typedef int type;
+  };
+
+  negate_with_result_of() {}
+  int operator()(int x) const { return -x; }
+
+private:
+  negate_with_result_of(const negate_with_result_of&);
+};
+
+template<typename F>
+void check_negate(F f)
+{
+  int x = 5;
+  assert(f(x) == -x);
+}
+
+class add_with_result_type
+{
+public:
+  typedef int result_type;
+
+  add_with_result_type() {}
+  int operator()(int x, int y) const { return x + y; }
+
+private:
+  add_with_result_type(const add_with_result_type&);
+};
+
+class add_with_result_of
+{
+public:
+  template<typename F> struct result_of { typedef int type; };
+
+  add_with_result_of() {}
+  int operator()(int x, int y) const { return x + y; }
+
+private:
+  add_with_result_of(const add_with_result_of&);
+};
+
+template<typename F>
+void check_sum(F f)
+{
+  int x = 3;
+  int y = 5;
+  assert(f(x, y) == x+y);
+}
+
+struct zero_negate_add_result_type
+{
+public:
+  typedef int result_type;
+
+  zero_negate_add_result_type() {}
+  int operator()() const { return 0; }
+  int operator()(int x) const { return -x; }
+  int operator()(int x, int y) const { return x+y; }
+
+private:
+  zero_negate_add_result_type(const zero_negate_add_result_type&);
+};
+
+struct zero_negate_add_result_of
+{
+public:
+  template<typename F> struct result_of { typedef int type; };
+
+  zero_negate_add_result_of() {}
+  int operator()() const { return 0; }
+  int operator()(int x) const { return -x; }
+  int operator()(int x, int y) const { return x+y; }
+
+private:
+  zero_negate_add_result_of(const zero_negate_add_result_of&);
+};
+
+int main()
+{
+  // Arity zero function objects
+  generate_zero gz;
+  generate_zero_no_result_type gznrt;
+  check_generate_zero(boost::ref(gz));
+  boost::ref(gznrt);
+
+  // Arity 1 function objects
+  negate_with_result_type nrt;
+  negate_with_result_of nro;
+  check_negate(boost::ref(nrt));
+  check_negate(boost::ref(nro));
+
+  // Arity 2 function objects
+  add_with_result_type art;
+  add_with_result_of aro;
+  check_sum(boost::ref(art));
+  check_sum(boost::ref(aro));
+
+  // Arity overloading in function objects
+  zero_negate_add_result_type znart;
+  zero_negate_add_result_type znaro;
+  check_generate_zero(boost::ref(znart));
+  check_negate(boost::ref(znart));
+  check_sum(boost::ref(znart));
+  check_generate_zero(boost::ref(znaro));
+  check_negate(boost::ref(znaro));
+  check_sum(boost::ref(znaro));
+
+  return 0;
+}

result_of_test.cpp

@@ -0,0 +1,45 @@
+#include <boost/result_of.hpp>
+#include <utility>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+struct int_result_type { typedef int result_type; };
+
+struct int_result_of
+{
+  template<typename F> struct result { typedef int type; };
+};
+
+struct int_result_type_and_float_result_of
+{
+  typedef int result_type;
+  template<typename F> struct result { typedef float type; };
+};
+
+struct X {};
+
+int main()
+{
+  using namespace boost;
+
+  typedef int (*func_ptr)(float, double);
+  typedef int (&func_ref)(float, double);
+  typedef int (X::*mem_func_ptr)(float);
+  typedef int (X::*mem_func_ptr_c)(float) const;
+  typedef int (X::*mem_func_ptr_v)(float) volatile;
+  typedef int (X::*mem_func_ptr_cv)(float) const volatile;
+
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type(float)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, void>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const int_result_of(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, void>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of(char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(char, float)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<func_ref(char, float)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr(X,char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_c(X,char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_v(X,char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_cv(X,char)>::type, int>::value));
+  return 0;
+}

select_by_size.html

@@ -0,0 +1,232 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<STYLE>
+		.code { font-family:monospace; font-size: 10pt }
+        H1, H2, H3 { font-family:Verdana, Tahoma, sans-serif; font-weight:0 }
+        H1 { font-size: 20pt }
+        H2 { font-size: 16pt }
+		P { color: black }
+		TH { text-align:left }
+		A { text-decoration:none }
+        A:visited { color: #005E20 }
+        A.contact { color: black; text-decoration:none }
+		.code { font-family:monospace; font-size: 10pt }
+		.headingCode { font-family:monospace; font-size: 12pt }
+		.concept { font-weight: bold }
+	</STYLE>
+</HEAD>
+<BODY>
+
+
+<TABLE BORDER='0' WIDTH='100%'>
+<TR>
+    <TD WIDTH="*" STYLE='text-align:left'><H1>Select-By-Size</H1></TD>
+    <TD ALIGN=right>
+        <TABLE>
+            <TR>
+                <TD STYLE='text-align:center'><A HREF='../../index.html'><IMG BORDER=0 SRC='../../kangaroo.gif'></A></TD>
+            </TR>
+            <TR>
+                <TD ALIGN='center'>
+                    <A STYLE='text-align:center;color: black;font: bold italic 12pt/17pt Verdana, sans-serif; text-decoration:none' HREF='../../index.html'>Metaprogramming<BR>Utilities</A>
+                </TD>
+            </TR>
+        </TABLE>
+    </TD>
+</TR>
+</TABLE>
+
+<H2>Contents</H2>
+
+<DL STYLE='margin-left:1em'>
+	<DT>1. <A HREF='#overview'>Overview</A>
+	<DT>2. <A HREF='#example'>Example</A>
+	<DT>3. <A HREF='#description'>Description</A>
+	<DT>4. <A HREF='#synopsis'>Synopsis</A>
+	<DT>5. <A HREF='#rationale'>Rationale</A>
+	<DT>6. <A HREF='#implementation'>Implementation</A>
+	<DT>7. <A HREF='#dependencies'>Dependencies</A>
+	<DT>8. <A HREF='#portability'>Portability</A>
+	<DT>9. <A HREF='#feedback'>Feedback</A>
+</DL>
+
+<A NAME='overview'></A>
+<H2>Overview</H2>
+
+<P>
+	The header <A HREF='../../boost/utility/select_by_size.hpp'><SPAN CLASS='code'>&lt;boost/utility/select_by_size.hpp&gt;</SPAN></A> provides template classes and macros for determining the results of overload resolution at compile time using <SPAN CLASS='code'>sizeof</SPAN>. It is intended as an alternative to <A HREF='http://www.boost.org/boost/type_traits/detail/yes_no_type.hpp'><SPAN CLASS='code'>type_traits::yes_type</SPAN></A> and <A HREF='http://www.boost.org/boost/type_traits/detail/yes_no_type.hpp'><SPAN CLASS='code'>type_traits::no_type</SPAN></A> from the <A HREF='http://www.boost.org/libs/type_traits/index.html'>Type Traits</A> library. It provides an arbitrary number of types, <SPAN CLASS='code'>case_&lt;0&gt;</SPAN>, <SPAN CLASS='code'>case_&lt;1&gt;</SPAN>, <SPAN CLASS='code'>case_&lt;2&gt;</SPAN>, <SPAN CLASS='code'>... </SPAN>, for use as the return types of helper functions, plus a template <SPAN CLASS='code'>select_by_size</SPAN> which provides access to the result of the overload resolution. There is also a macro <SPAN CLASS='code'>BOOST_SELECT_BY_SIZE</SPAN>, similar to <A HREF='http://www.boost.org/libs/config/config.htm'><SPAN CLASS='code'>BOOST_STATIC_CONSTANT</SPAN></A>, for use with compilers which have trouble with integral constant expressions. (<I>See</I> <A HREF='http://www.boost.org/more/int_const_guidelines.htm'>Coding Guidelines for Integral Constant Expressions</A>.) 
+</P>
+
+<P>
+	The <SPAN CLASS='code'>typedefs</SPAN> <SPAN CLASS='code'>yes_type</SPAN> and <SPAN CLASS='code'>no_type</SPAN> are provided as shorthands for <SPAN CLASS='code'>case_&lt;1&gt;</SPAN> and <SPAN CLASS='code'>case_&lt;0&gt;</SPAN>. In some cases, <SPAN CLASS='code'>case_&lt;true&gt;</SPAN> and <SPAN CLASS='code'>case_&lt;false&gt;</SPAN> may be more suggestive. There is also a single return type representing a negative value: <SPAN CLASS='code'>case_&lt;-1&gt;</SPAN>.
+</P>
+
+<P>All types decribes in this document reside in the namespace <SPAN CLASS='code'>boost::utility</SPAN>.
+
+<A NAME='example'></A>
+<H2>Example</H2>
+
+<PRE>    #include &lt;boost/static_assert.hpp&gt;
+    #define BOOST_SELECT_BY_SIZE_MAX_CASE 7  
+    #include &lt;boost/utility/select_by_size.hpp&gt;
+
+    using namespace boost::utility;
+
+    case_&lt;0&gt; helper(bool);           
+    case_&lt;1&gt; helper(int);            
+    case_&lt;2&gt; helper(unsigned);
+    case_&lt;3&gt; helper(long);
+    case_&lt;4&gt; helper(unsigned long);
+    case_&lt;5&gt; helper(float);
+    case_&lt;6&gt; helper(double);
+    case_&lt;7&gt; helper(const char*);
+
+    struct test {
+        static const int value =
+            select_by_size&lt; sizeof(helper("hello")) &gt;::value;
+        BOOST_STATIC_ASSERT(value == 7);
+    };
+
+    struct test2 {
+        BOOST_SELECT_BY_SIZE(int, value, helper("hello"));
+        BOOST_STATIC_ASSERT(value == 7);
+    };</PRE>
+
+<A NAME='description'></A>
+<H2>Description</H2>
+
+<H3>The template <SPAN CLASS='headingCode'>case_</SPAN></H3>
+
+<P>
+	The defining property of the class template <SPAN CLASS='code'>case_</SPAN> is that the sizes of the types
+<PRE>    case_&lt;-1&gt;, case_&lt;0&gt;, case_&lt;1&gt;, case_&lt;2&gt;, case_&lt;3&gt;, ...</PRE>
+form a strictly increasing sequence. With well-behaved implementations, <SPAN CLASS='code'>sizeof(case_&lt;-1&gt;)</SPAN> will be small, as will be the difference in size between adjacent types in the sequence.
+</P>
+
+<H3>The template <SPAN CLASS='headingCode'>select_by_size</SPAN></H3>
+
+<P>
+	The defining property of the class template <SPAN CLASS='code'>select_by_size</SPAN> is that for each integer <SPAN CLASS='code'>N</SPAN> in the range <SPAN CLASS='code'>select_by_size</SPAN> through <SPAN CLASS='code'>BOOST_SELECT_BY_SIZE_MAX_CASE</SPAN>, we have the equality
+<PRE>    select_by_size< sizeof(case_&lt;N&gt;) >::value == N</PRE>
+</P>
+
+<H3>The macro <SPAN CLASS='headingCode'>BOOST_SELECT_BY_SIZE</SPAN></H3>
+
+<P>
+	The macro <SPAN CLASS='code'>BOOST_SELECT_BY_SIZE(type, name, expr)</SPAN> can be used similarly to <SPAN CLASS='code'>BOOST_STATIC_CONSTANT</SPAN> to define a <SPAN CLASS='code'>static const</SPAN> intergral class member <SPAN CLASS='code'>name</SPAN> of type <SPAN CLASS='code'>type</SPAN> with value equal to <SPAN CLASS='code'>select_by_size< sizeof(expr) >::value</SPAN>.
+</P>
+
+<H3>The macro <SPAN CLASS='headingCode'>BOOST_SELECT_BY_SIZE_MAX_CASE</SPAN></H3>
+
+<P>
+	In order to make use of <SPAN CLASS='code'>select_by_size</SPAN> with specializations <SPAN CLASS='code'>case_&lt;N&gt;</SPAN> for <SPAN CLASS='code'>N</SPAN> other than <SPAN CLASS='code'>-1</SPAN>, <SPAN CLASS='code'>0</SPAN> and <SPAN CLASS='code'>1</SPAN>,
+	the symbol <SPAN CLASS='code'>BOOST_SELECT_BY_SIZE_MAX_CASE</SPAN> must be defined as an intergral value greater than or equal to <SPAN CLASS='code'>N</SPAN> before including the header <SPAN CLASS='code'>&lt;boost/utility/select_by_size.hpp&gt;</SPAN>. The header may be included multiple times with different values of <SPAN CLASS='code'>BOOST_SELECT_BY_SIZE_MAX_CASE</SPAN>.
+</P>
+
+<P>
+	It is possible to implement <SPAN CLASS='code'>select_by_size</SPAN> in such a way that this macro is not necessary. <I>See</I> <A HREF='#implementation'>Implementation</A>, below, for a discussion.
+</P>
+
+<A NAME='Synopsis'></A>
+<H2>Synopsis</H2>
+
+<PRE>    namespace boost {
+      namespace utility {
+
+        template&lt;int N&gt; struct <B>case_</B> { [<I>unspecified</I>] };
+
+        template&lt;unsigned N&gt; 
+        struct <B>select_by_size</B> {
+            struct type { 
+                static const unsigned value = 
+                    [M <I>such that</I> sizeof(case_&lt;M&gt;) == N];
+            };
+            static const unsigned value = type::value;
+        };
+ 
+        #define <B>BOOST_SELECT_BY_SIZE</B>(type, name, expr) [<I>unspecified</I>]
+      } 
+    }</PRE>
+
+<A NAME='rationale'></A>
+<H2>Rationale</H2>
+
+The utility of <SPAN CLASS='code'>type_traits::yes_type</SPAN> and <SPAN CLASS='code'>type_traits::no_type</SPAN> is well-known. The advantages of using <SPAN CLASS='code'>select_by_size</SPAN> are:
+
+<UL type='box'>
+    <LI STYLE='list-style-type: square'>It documents the fact that <SPAN CLASS='code'>sizeof</SPAN> is being used to determine the result of overload resolution.
+    <LI STYLE='list-style-type: square'>It eliminates the need to compare a given <SPAN CLASS='code'>sizeof</SPAN> expression with <SPAN CLASS='code'>sizeof(type_traits::yes_type)</SPAN>.
+    <LI STYLE='list-style-type: square'>It allows the use of an aribtrary number of cases.</LI>
+</UL>
+
+<P>
+    Until recently the author knew of only one use for <SPAN CLASS='code'>select_by_size</SPAN> with more than two cases, and so regarded it as a <I>trick</I>. He then discovered a second use, elevating it to a <I>method</I>. With the discovery of a third use, it is now a <I>programming paradigm</I>. (The three known uses are determing template arity, as in <A HREF='http://www.boost.org/boost/mpl/aux_/template_arity.hpp'><SPAN CLASS='code'>&lt;boost/mpl/aux_/template_arity.hpp&gt;</SPAN></A>, <A HREF='http://www.boost.org/people/joel_de_guzman.htm'>Joel de Guzman</A>'s type deduction system in the <A HREF='http://www.boost.org/more/mailing_lists.htm#sandbox'>Boost Sandbox</A> at <SPAN CLASS='code'>&lt;boost/utility/type_deduction.hpp&gt;</SPAN>, and Reece Dunn's type deduction system for his Output Formatters library, also in the <A HREF='http://www.boost.org/more/mailing_lists.htm#sandbox'>Boost Sandbox</A>, at <SPAN CLASS='code'>&lt;boost/outfmt/detail/type_traits.hpp&gt;</SPAN>. There are surely many more.)
+</P>
+
+<A NAME='implementation'></A>
+<H2>Implementation</H2>
+
+<P>
+	<SPAN CLASS='code'>select_by_size</SPAN> is implemented by explicit specialization for the values 
+<PRE>    sizeof(case_&lt;-1&gt;), sizeof(case_&lt;0&gt;), sizeof(case_&lt;1&gt;), sizeof(case_&lt;2&gt;), ... .</PRE>
+    As a result, there is a limit to the number of cases which can be used by default. 
+</P>
+
+<P>
+    There are several ways to remove this restriction. For instance:
+	<UL>
+        <LI STYLE='list-style-type: square'><SPAN CLASS='code'>select_by_size</SPAN> could be implemented to 
+        iterate through the sequence <SPAN CLASS='code'>case_&lt;-1&gt;, case_&lt;0&gt;, case_&lt;1&gt;, ... </SPAN> until it finds 
+        a specialization whose size is equal to its template argument, or
+        <LI STYLE='list-style-type: square'>The template <SPAN CLASS='code'>case_</SPAN> could be designed so
+        that its size is easy to compute, taking alignment issues into account.
+    </UL>
+    This first approach is computationally too expensive for a widely used utility. The second approach is feasable; a sample implementation using <A HREF='http://www.boost.org/boost/type_traits/alignment_of.hpp'><SPAN CLASS='code'>alignment_of</SPAN></A> and <A HREF='http://www.boost.org/boost/type_traits/type_with_alignment.hpp'><SPAN CLASS='code'>max_align</SPAN></A> from the <A HREF='http://www.boost.org/libs/config/config.htm'>Type Traits</A> library is given in the <A HREF='../../boost/utility/select_by_size.hpp'>source code</A>. 
+</P>
+<P>
+    The present implementation was chosen to
+    reduce dependencies on other libraries. If defining the macro <SPAN CLASS='code'>BOOST_SELECT_BY_SIZE_MAX_CASE</SPAN> is considered too inconvenient, the default number of cases could be set to <SPAN CLASS='code'>10</SPAN> or <SPAN CLASS='code'>20</SPAN> with little noticeable overhead.
+</P>
+
+<A NAME='dependencies'></A>
+<H2>Dependencies</H2>
+
+The header <A HREF='../../boost/utility/select_by_size.hpp'><SPAN CLASS='code'>&lt;boost/utility/select_by_size.hpp&gt;</SPAN></A> depends on <A HREF='http://www.boost.org/libs/config/config.htm'>Boost.Config</A> and the <A HREF='http://www.boost.org/libs/preprocessor/doc/index.html'>Boost Preprocessor Library</A>.
+
+<A NAME='portability'></A>
+<H2>Portability</H2>
+
+<P>
+	The program <A HREF='select_by_size_test.cpp'><SPAN CLASS='code'>&lt;libs/utility/select_by_size_test.cpp&gt;</SPAN></A> has been tested successfully with the following compilers:
+	<UL>
+		<LI STYLE='list-style-type: square'>Microsoft Visual C++ 6.0, SP 5</LI>
+		<LI STYLE='list-style-type: square'>Microsoft Visual C++ 7.1</LI>
+		<LI STYLE='list-style-type: square'>Metrowerks CodeWarrior 8.0</LI>
+		<LI STYLE='list-style-type: square'>Intel C++ Compiler for Windows 7.1 and 8.0</LI>
+		<LI STYLE='list-style-type: square'>GCC 2.95.3-10 (cygwin special)</LI>
+		<LI STYLE='list-style-type: square'>GCC 3.2 (MinGW)</LI>
+		<LI STYLE='list-style-type: square'>GCC 3.3.1 (cygming special)</LI>
+		<LI STYLE='list-style-type: square'>Comeau C/C++ 4.3.3</LI>
+		<LI STYLE='list-style-type: square'>Borland C++ 5.5.1 and 5.6.4</LI>
+		<LI STYLE='list-style-type: square'>DigitalMars 8.38n</LI>
+	</UL>
+    It should work on any recent compiler for which Boost has been configured.
+</P>
+
+<A NAME='feedback'></A>
+<H2>Feedback</H2>
+
+The author, Jonathan Turkanis, can be contacted at <A CLASS='contact' HREF='mailto:turkanis@kangaroologic.com'>turkanis@kangaroologic.com</A>
+
+<HR STYLE='margin:20,0,0'>
+
+<P STYLE='font-size:8pt'>
+	&copy; Copyright Jonathan Turkanis 2004.
+	Permission to copy, use, modify, sell and distribute this document
+	is granted provided this copyright notice appears in all copies. This
+	document is provided "as is" without express or implied warranty, and
+	with no claim as to its suitability for any purpose.
+</P>
+
+</BODY>

select_by_size_test.cpp

@@ -0,0 +1,60 @@
+// (C) Copyright Jonathan Turkanis 2004.
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies. This
+// software is provided "as is" without express or implied warranty, and
+// with no claim as to its suitability for any purpose.
+
+// Test program for <boost/utility/select_by_size.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/config.hpp>
+
+// Include "select_by_size.hpp" with BOOST_SELECT_BY_SIZE_MAX_CASE undefined.
+#include <boost/utility/select_by_size.hpp>
+using boost::utility::case_;
+
+case_<false> helper(bool);
+case_<true> helper(int);
+
+struct test1 {
+    // Define static bool constants v0 and v1.
+    BOOST_SELECT_BY_SIZE(bool, v0, helper(true));
+    BOOST_SELECT_BY_SIZE(bool, v1, helper(0));
+
+    BOOST_STATIC_ASSERT(v0 == false);
+    BOOST_STATIC_ASSERT(v1 == true);
+};
+
+// Include "select_by_size.hpp" a second time, defining more cases.
+#define BOOST_SELECT_BY_SIZE_MAX_CASE 7
+#include <boost/utility/select_by_size.hpp>
+
+case_<2> helper(unsigned);
+case_<3> helper(long);
+case_<4> helper(unsigned long);
+case_<5> helper(float);
+case_<6> helper(double);
+case_<7> helper(const char*);
+
+struct test2 {
+    // Define static int constants v0 through v7.
+    BOOST_SELECT_BY_SIZE(int, v0, helper(true));
+    BOOST_SELECT_BY_SIZE(int, v1, helper(0));
+    BOOST_SELECT_BY_SIZE(int, v2, helper(0U));
+    BOOST_SELECT_BY_SIZE(int, v3, helper(0L));
+    BOOST_SELECT_BY_SIZE(int, v4, helper(0UL));
+    BOOST_SELECT_BY_SIZE(int, v5, helper(0.0F));
+    BOOST_SELECT_BY_SIZE(int, v6, helper(0.0));
+    BOOST_SELECT_BY_SIZE(int, v7, helper("hello"));
+
+    BOOST_STATIC_ASSERT(v0 == 0);
+    BOOST_STATIC_ASSERT(v1 == 1);
+    BOOST_STATIC_ASSERT(v2 == 2);
+    BOOST_STATIC_ASSERT(v3 == 3);
+    BOOST_STATIC_ASSERT(v4 == 4);
+    BOOST_STATIC_ASSERT(v5 == 5);
+    BOOST_STATIC_ASSERT(v6 == 6);
+    BOOST_STATIC_ASSERT(v7 == 7);
+};
+
+int main() { return 0; }

src/obj_id.cpp

@@ -0,0 +1,10 @@
+#include "boost/utility/obj_id.hpp"
+using namespace utility;
+//          static
+obj_id::
+        id_type&
+obj_id::
+      the_last_id(void)
+        { static id_type last_id=0
+        ; return last_id
+        ;}

src/object_tracked.cpp

@@ -0,0 +1,6 @@
+#include "boost/utility/object_tracked.hpp"
+using namespace utility;
+
+  utility::object_tracked::set_of_objects_tracked
+utility::object_tracked::our_members
+;

src/trace_scope_stk.cpp

@@ -0,0 +1,12 @@
+#include "boost/utility/trace_scope_stk.hpp"
+//        static
+      std::vector<std::string>
+utility::trace_scope_stk::
+    c_scope_names
+      ;
+//        static
+      std::string const
+utility::trace_scope_stk::
+    c_test_results[2]
+      = {"failed", "passed"}
+      ;

sublibs

@@ -1 +0,0 @@
-The existance of this file tells the regression reporting programs that the directory contains sub-directories which are libraries.

test/Jamfile

@@ -0,0 +1,22 @@
+# Boost Utility Library test Jamfile
+
+subproject libs/utility/test ;
+
+# bring in rules for testing
+import testing ;
+
+{
+    test-suite "lexicographic"
+       : [ run lexicographic_test.cpp ]
+         [ run lex_performance_test.cpp ]
+           ;
+    
+    test-suite "named_params"
+      :  [ run named_params_test.cpp ]
+         [ run named_params_sfinae.cpp ]
+       ;
+
+    test-suite "result_check"
+      :  [ compile result_check_test.cpp ]
+       ;
+}

test/Jamfile.v2

@@ -1,46 +0,0 @@
-# Copyright David Abrahams 2003.
-
-# Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-
-# For more information, see http://www.boost.org/
-
-# bring in rules for testing
-import testing ;
-
-run base_from_member_test.cpp ;
-run base_from_member_ref_test.cpp ;
-
-run binary_test.cpp ;
-
-run call_traits_test.cpp : -u ;
-
-run compressed_pair_test.cpp ;
-run compressed_pair_final_test.cpp ;
-
-run iterators_test.cpp ;
-
-run operators_test.cpp ;
-
-compile result_of_test.cpp ;
-
-# compile-fail string_ref_from_rvalue.cpp ;
-run string_ref_test1.cpp ;
-run string_ref_test2.cpp ;
-run string_ref_test_io.cpp ;
-# compile-fail string_view_from_rvalue.cpp ;
-compile string_view_constexpr_test1.cpp ;
-run string_view_test1.cpp ;
-run string_view_test2.cpp ;
-run string_view_test_io.cpp ;
-
-run value_init_test.cpp ;
-run value_init_workaround_test.cpp ;
-run initialized_test.cpp ;
-compile-fail value_init_test_fail1.cpp ;
-compile-fail value_init_test_fail2.cpp ;
-compile-fail value_init_test_fail3.cpp ;
-compile-fail initialized_test_fail1.cpp ;
-compile-fail initialized_test_fail2.cpp ;
-
-run ostream_string_test.cpp ;

test/base_from_member_ref_test.cpp

@@ -1,29 +0,0 @@
-//
-// Test that a base_from_member<T&> can be properly constructed
-//
-// Copyright 2014 Agustin Berge
-//
-// 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/utility/base_from_member.hpp>
-
-#include <boost/core/lightweight_test.hpp>
-
-struct foo : boost::base_from_member<int&>
-{
-    explicit foo(int& ref) : boost::base_from_member<int&>(ref)
-    {
-        BOOST_TEST(&member == &ref);
-    }
-};
-
-int main()
-{
-    int i = 0;
-    foo f(i);
-
-    return boost::report_errors();
-}

test/base_from_member_test.cpp

@@ -1,593 +0,0 @@
-//  Boost test program for base-from-member class templates  -----------------//
-
-//  Copyright 2001, 2003 Daryle Walker.  Use, modification, and distribution are
-//  subject to the Boost Software License, Version 1.0.  (See accompanying file
-//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-//  See <http://www.boost.org/libs/utility/> for the library's home page.
-
-//  Revision History
-//  14 Jun 2003  Adjusted code for Boost.Test changes (Daryle Walker)
-//  29 Aug 2001  Initial Version (Daryle Walker)
-
-#include <boost/core/lightweight_test.hpp>
-
-#include <boost/config.hpp>       // for BOOST_NO_MEMBER_TEMPLATES
-#include <boost/noncopyable.hpp>  // for boost::noncopyable
-
-#include <boost/utility/base_from_member.hpp>  // for boost::base_from_member
-
-#include <functional>  // for std::less
-#include <iostream>    // for std::cout (std::ostream, std::endl indirectly)
-#include <set>         // for std::set
-#include <typeinfo>    // for std::type_info
-#include <utility>     // for std::pair, std::make_pair
-#include <vector>      // for std::vector
-
-
-// Control if extra information is printed
-#ifndef CONTROL_EXTRA_PRINTING
-#define CONTROL_EXTRA_PRINTING  1
-#endif
-
-
-// A (sub)object can be identified by its memory location and its type.
-// Both are needed since an object can start at the same place as its
-// first base class subobject and/or contained subobject.
-typedef std::pair< void *, std::type_info const * >  object_id;
-
-// Object IDs need to be printed
-std::ostream &  operator <<( std::ostream &os, object_id const &oi );
-
-// A way to generate an object ID
-template < typename T >
-  object_id  identify( T &obj );
-
-// A custom comparison type is needed
-struct object_id_compare
-{
-    bool  operator ()( object_id const &a, object_id const &b ) const;
-
-};  // object_id_compare
-
-// A singleton of this type coordinates the acknowledgements
-// of objects being created and used.
-class object_registrar
-    : private boost::noncopyable
-{
-public:
-
-    #ifndef BOOST_NO_MEMBER_TEMPLATES
-    template < typename T >
-        void  register_object( T &obj )
-            { this->register_object_imp( identify(obj) ); }
-    template < typename T, typename U >
-        void  register_use( T &owner, U &owned )
-            { this->register_use_imp( identify(owner), identify(owned) ); }
-    template < typename T, typename U >
-        void  unregister_use( T &owner, U &owned )
-            { this->unregister_use_imp( identify(owner), identify(owned) ); }
-    template < typename T >
-        void  unregister_object( T &obj )
-            { this->unregister_object_imp( identify(obj) ); }
-    #endif
-
-    void  register_object_imp( object_id obj );
-    void  register_use_imp( object_id owner, object_id owned );
-    void  unregister_use_imp( object_id owner, object_id owned );
-    void  unregister_object_imp( object_id obj );
-
-    typedef std::set<object_id, object_id_compare>  set_type;
-
-    typedef std::vector<object_id>  error_record_type;
-    typedef std::vector< std::pair<object_id, object_id> >  error_pair_type;
-
-    set_type  db_;
-
-    error_pair_type    defrauders_in_, defrauders_out_;
-    error_record_type  overeager_, overkilled_;
-
-};  // object_registrar
-
-// A sample type to be used by containing types
-class base_or_member
-{
-public:
-    explicit  base_or_member( int x = 1, double y = -0.25 );
-             ~base_or_member();
-
-};  // base_or_member
-
-// A sample type that uses base_or_member, used
-// as a base for the main demonstration classes
-class base_class
-{
-public:
-    explicit  base_class( base_or_member &x, base_or_member *y = 0,
-     base_or_member *z = 0 );
-
-    ~base_class();
-
-private:
-    base_or_member  *x_, *y_, *z_;
-
-};  // base_class
-
-// This bad class demonstrates the direct method of a base class needing
-// to be initialized by a member.  This is improper since the member
-// isn't initialized until after the base class.
-class bad_class
-    : public base_class
-{
-public:
-     bad_class();
-    ~bad_class();
-
-private:
-    base_or_member  x_;
-
-};  // bad_class
-
-// The first good class demonstrates the correct way to initialize a
-// base class with a member.  The member is changed to another base
-// class, one that is initialized before the base that needs it.
-class good_class_1
-    : private boost::base_from_member<base_or_member>
-    , public base_class
-{
-    typedef boost::base_from_member<base_or_member>  pbase_type;
-    typedef base_class                                base_type;
-
-public:
-     good_class_1();
-    ~good_class_1();
-
-};  // good_class_1
-
-// The second good class also demonstrates the correct way to initialize
-// base classes with other subobjects.  This class uses the other helpers
-// in the library, and shows the technique of using two base subobjects
-// of the "same" type.
-class good_class_2
-    : private boost::base_from_member<base_or_member, 0>
-    , private boost::base_from_member<base_or_member, 1>
-    , private boost::base_from_member<base_or_member, 2>
-    , public base_class
-{
-    typedef boost::base_from_member<base_or_member, 0>  pbase_type0;
-    typedef boost::base_from_member<base_or_member, 1>  pbase_type1;
-    typedef boost::base_from_member<base_or_member, 2>  pbase_type2;
-    typedef base_class                                   base_type;
-
-public:
-     good_class_2();
-    ~good_class_2();
-
-};  // good_class_2
-
-// Declare/define the single object registrar
-object_registrar  obj_reg;
-
-
-// Main functionality
-int
-main()
-{
-    BOOST_TEST( obj_reg.db_.empty() );
-    BOOST_TEST( obj_reg.defrauders_in_.empty() );
-    BOOST_TEST( obj_reg.defrauders_out_.empty() );
-    BOOST_TEST( obj_reg.overeager_.empty() );
-    BOOST_TEST( obj_reg.overkilled_.empty() );
-
-    // Make a separate block to examine pre- and post-effects
-    {
-        using std::cout;
-        using std::endl;
-
-        bad_class  bc;
-        BOOST_TEST( obj_reg.db_.size() == 3 );
-        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
-
-        good_class_1  gc1;
-        BOOST_TEST( obj_reg.db_.size() == 6 );
-        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
-
-        good_class_2  gc2;
-        BOOST_TEST( obj_reg.db_.size() == 11 );
-        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
-
-        BOOST_TEST( obj_reg.defrauders_out_.empty() );
-        BOOST_TEST( obj_reg.overeager_.empty() );
-        BOOST_TEST( obj_reg.overkilled_.empty() );
-
-        // Getting the addresses of the objects ensure
-        // that they're used, and not optimized away.
-        cout << "Object 'bc' is at " << &bc << '.' << endl;
-        cout << "Object 'gc1' is at " << &gc1 << '.' << endl;
-        cout << "Object 'gc2' is at " << &gc2 << '.' << endl;
-    }
-
-    BOOST_TEST( obj_reg.db_.empty() );
-    BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
-    BOOST_TEST( obj_reg.defrauders_out_.size() == 1 );
-    BOOST_TEST( obj_reg.overeager_.empty() );
-    BOOST_TEST( obj_reg.overkilled_.empty() );
-
-    return boost::report_errors();
-}
-
-
-// Print an object's ID
-std::ostream &
-operator <<
-(
-    std::ostream &     os,
-    object_id const &  oi
-)
-{
-    // I had an std::ostringstream to help, but I did not need it since
-    // the program never screws around with formatting.  Worse, using
-    // std::ostringstream is an issue with some compilers.
-
-    return os << '[' << ( oi.second ? oi.second->name() : "NOTHING" )
-     << " at " << oi.first << ']';
-}
-
-// Get an object ID given an object
-template < typename T >
-inline
-object_id
-identify
-(
-    T &  obj
-)
-{
-    return std::make_pair( static_cast<void *>(&obj), &(typeid( obj )) );
-}
-
-// Compare two object IDs
-bool
-object_id_compare::operator ()
-(
-    object_id const &  a,
-    object_id const &  b
-) const
-{
-    std::less<void *>  vp_cmp;
-    if ( vp_cmp(a.first, b.first) )
-    {
-        return true;
-    }
-    else if ( vp_cmp(b.first, a.first) )
-    {
-        return false;
-    }
-    else
-    {
-        // object pointers are equal, compare the types
-        if ( a.second == b.second )
-        {
-            return false;
-        }
-        else if ( !a.second )
-        {
-            return true;   // NULL preceeds anything else
-        }
-        else if ( !b.second )
-        {
-            return false;  // NULL preceeds anything else
-        }
-        else
-        {
-            return a.second->before( *b.second ) != 0;
-        }
-    }
-}
-
-// Let an object register its existence
-void
-object_registrar::register_object_imp
-(
-    object_id  obj
-)
-{
-    if ( db_.count(obj) <= 0 )
-    {
-        db_.insert( obj );
-
-        #if CONTROL_EXTRA_PRINTING
-        std::cout << "Registered " << obj << '.' << std::endl;
-        #endif
-    }
-    else
-    {
-        overeager_.push_back( obj );
-
-        #if CONTROL_EXTRA_PRINTING
-        std::cout << "Attempted to register a non-existant " << obj
-         << '.' << std::endl;
-        #endif
-    }
-}
-
-// Let an object register its use of another object
-void
-object_registrar::register_use_imp
-(
-    object_id  owner,
-    object_id  owned
-)
-{
-    if ( db_.count(owned) > 0 )
-    {
-        // We don't care to record usage registrations
-    }
-    else
-    {
-        defrauders_in_.push_back( std::make_pair(owner, owned) );
-
-        #if CONTROL_EXTRA_PRINTING
-        std::cout << "Attempted to own a non-existant " << owned
-         << " by " << owner << '.' << std::endl;
-        #endif
-    }
-}
-
-// Let an object un-register its use of another object
-void
-object_registrar::unregister_use_imp
-(
-    object_id  owner,
-    object_id  owned
-)
-{
-    if ( db_.count(owned) > 0 )
-    {
-        // We don't care to record usage un-registrations
-    }
-    else
-    {
-        defrauders_out_.push_back( std::make_pair(owner, owned) );
-
-        #if CONTROL_EXTRA_PRINTING
-        std::cout << "Attempted to disown a non-existant " << owned
-         << " by " << owner << '.' << std::endl;
-        #endif
-    }
-}
-
-// Let an object un-register its existence
-void
-object_registrar::unregister_object_imp
-(
-    object_id  obj
-)
-{
-    set_type::iterator const  i = db_.find( obj );
-
-    if ( i != db_.end() )
-    {
-        db_.erase( i );
-
-        #if CONTROL_EXTRA_PRINTING
-        std::cout << "Unregistered " << obj << '.' << std::endl;
-        #endif
-    }
-    else
-    {
-        overkilled_.push_back( obj );
-
-        #if CONTROL_EXTRA_PRINTING
-        std::cout << "Attempted to unregister a non-existant " << obj
-         << '.' << std::endl;
-        #endif
-    }
-}
-
-// Macros to abstract the registration of objects
-#ifndef BOOST_NO_MEMBER_TEMPLATES
-#define PRIVATE_REGISTER_BIRTH(o)     obj_reg.register_object( (o) )
-#define PRIVATE_REGISTER_DEATH(o)     obj_reg.unregister_object( (o) )
-#define PRIVATE_REGISTER_USE(o, w)    obj_reg.register_use( (o), (w) )
-#define PRIVATE_UNREGISTER_USE(o, w)  obj_reg.unregister_use( (o), (w) )
-#else
-#define PRIVATE_REGISTER_BIRTH(o)     obj_reg.register_object_imp( \
- identify((o)) )
-#define PRIVATE_REGISTER_DEATH(o)     obj_reg.unregister_object_imp( \
- identify((o)) )
-#define PRIVATE_REGISTER_USE(o, w)    obj_reg.register_use_imp( identify((o)), \
- identify((w)) )
-#define PRIVATE_UNREGISTER_USE(o, w)  obj_reg.unregister_use_imp( \
- identify((o)), identify((w)) )
-#endif
-
-// Create a base_or_member, with arguments to simulate member initializations
-base_or_member::base_or_member
-(
-    int     x,  // = 1
-    double  y   // = -0.25
-)
-{
-    PRIVATE_REGISTER_BIRTH( *this );
-
-    #if CONTROL_EXTRA_PRINTING
-    std::cout << "\tMy x-factor is " << x << " and my y-factor is " << y
-     << '.' << std::endl;
-    #endif
-}
-
-// Destroy a base_or_member
-inline
-base_or_member::~base_or_member
-(
-)
-{
-    PRIVATE_REGISTER_DEATH( *this );
-}
-
-// Create a base_class, registering any objects used
-base_class::base_class
-(
-    base_or_member &  x,
-    base_or_member *  y,  // = 0
-    base_or_member *  z   // = 0
-)
-    : x_( &x ), y_( y ), z_( z )
-{
-    PRIVATE_REGISTER_BIRTH( *this );
-
-    #if CONTROL_EXTRA_PRINTING
-    std::cout << "\tMy x-factor is " << x_;
-    #endif
-
-    PRIVATE_REGISTER_USE( *this, *x_ );
-
-    if ( y_ )
-    {
-        #if CONTROL_EXTRA_PRINTING
-        std::cout << ", my y-factor is " << y_;
-        #endif
-
-        PRIVATE_REGISTER_USE( *this, *y_ );
-    }
-
-    if ( z_ )
-    {
-        #if CONTROL_EXTRA_PRINTING
-        std::cout << ", my z-factor is " << z_;
-        #endif
-
-        PRIVATE_REGISTER_USE( *this, *z_ );
-    }
-
-    #if CONTROL_EXTRA_PRINTING
-    std::cout << '.' << std::endl;
-    #endif
-}
-
-// Destroy a base_class, unregistering the objects it uses
-base_class::~base_class
-(
-)
-{
-    PRIVATE_REGISTER_DEATH( *this );
-
-    #if CONTROL_EXTRA_PRINTING
-    std::cout << "\tMy x-factor was " << x_;
-    #endif
-
-    PRIVATE_UNREGISTER_USE( *this, *x_ );
-
-    if ( y_ )
-    {
-        #if CONTROL_EXTRA_PRINTING
-        std::cout << ", my y-factor was " << y_;
-        #endif
-
-        PRIVATE_UNREGISTER_USE( *this, *y_ );
-    }
-
-    if ( z_ )
-    {
-        #if CONTROL_EXTRA_PRINTING
-        std::cout << ", my z-factor was " << z_;
-        #endif
-
-        PRIVATE_UNREGISTER_USE( *this, *z_ );
-    }
-
-    #if CONTROL_EXTRA_PRINTING
-    std::cout << '.' << std::endl;
-    #endif
-}
-
-// Create a bad_class, noting the improper construction order
-bad_class::bad_class
-(
-)
-    : x_( -7, 16.75 ), base_class( x_ )  // this order doesn't matter
-{
-    PRIVATE_REGISTER_BIRTH( *this );
-
-    #if CONTROL_EXTRA_PRINTING
-    std::cout << "\tMy factor is at " << &x_
-     << " and my base is at " << static_cast<base_class *>(this) << '.'
-     << std::endl;
-    #endif
-}
-
-// Destroy a bad_class, noting the improper destruction order
-bad_class::~bad_class
-(
-)
-{
-    PRIVATE_REGISTER_DEATH( *this );
-
-    #if CONTROL_EXTRA_PRINTING
-    std::cout << "\tMy factor was at " << &x_
-     << " and my base was at " << static_cast<base_class *>(this)
-     << '.' << std::endl;
-    #endif
-}
-
-// Create a good_class_1, noting the proper construction order
-good_class_1::good_class_1
-(
-)
-    : pbase_type( 8 ), base_type( member )
-{
-    PRIVATE_REGISTER_BIRTH( *this );
-
-    #if CONTROL_EXTRA_PRINTING
-    std::cout << "\tMy factor is at " << &member
-     << " and my base is at " << static_cast<base_class *>(this) << '.'
-     << std::endl;
-    #endif
-}
-
-// Destroy a good_class_1, noting the proper destruction order
-good_class_1::~good_class_1
-(
-)
-{
-    PRIVATE_REGISTER_DEATH( *this );
-
-    #if CONTROL_EXTRA_PRINTING
-    std::cout << "\tMy factor was at " << &member
-     << " and my base was at " << static_cast<base_class *>(this)
-     << '.' << std::endl;
-    #endif
-}
-
-// Create a good_class_2, noting the proper construction order
-good_class_2::good_class_2
-(
-)
-    : pbase_type0(), pbase_type1(-16, 0.125), pbase_type2(2, -3)
-    , base_type( pbase_type1::member, &this->pbase_type0::member,
-       &this->pbase_type2::member )
-{
-    PRIVATE_REGISTER_BIRTH( *this );
-
-    #if CONTROL_EXTRA_PRINTING
-    std::cout << "\tMy factors are at " << &this->pbase_type0::member
-     << ", " << &this->pbase_type1::member << ", "
-     << &this->pbase_type2::member << ", and my base is at "
-     << static_cast<base_class *>(this) << '.' << std::endl;
-    #endif
-}
-
-// Destroy a good_class_2, noting the proper destruction order
-good_class_2::~good_class_2
-(
-)
-{
-    PRIVATE_REGISTER_DEATH( *this );
-
-    #if CONTROL_EXTRA_PRINTING
-    std::cout << "\tMy factors were at " << &this->pbase_type0::member
-     << ", " << &this->pbase_type1::member << ", "
-     << &this->pbase_type2::member << ", and my base was at "
-     << static_cast<base_class *>(this) << '.' << std::endl;
-    #endif
-}

test/binary_test.cpp

@@ -1,647 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2006, 2007 Matthew Calabrese
-
-    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 <boost/core/lightweight_test.hpp>
-#include <boost/utility/binary.hpp>
-#include <algorithm>
-#include <cstddef>
-
-#ifdef BOOST_MSVC
-#pragma warning(disable:4996) // warning C4996: 'std::equal': Function call with parameters that may be unsafe - this call relies on the caller to check that the passed values are correct. To disable this warning, use -D_SCL_SECURE_NO_WARNINGS. See documentation on how to use Visual C++ 'Checked Iterators'
-#endif
-
-/*
-Note: This file tests every single valid bit-grouping on its own, and some
-      random combinations of bit-groupings.
-*/
-
-std::size_t const num_random_test_values = 32;
-
-// Note: These hex values should all correspond with the binary array below
-unsigned int const random_unsigned_ints_hex[num_random_test_values]
-  = { 0x0103u, 0x77ebu, 0x5f36u, 0x1f18u, 0xc530u, 0xa73au, 0xd6f8u, 0x0919u
-    , 0xfbb0u, 0x3e7cu, 0xd0e9u, 0x22c8u, 0x724eu, 0x14fau, 0xd98eu, 0x40b5
-    , 0xeba0u, 0xfe50u, 0x688au, 0x1b05u, 0x5f9cu, 0xe4fcu, 0xa7b8u, 0xd3acu
-    , 0x1dddu, 0xbf04u, 0x8352u, 0xe89cu, 0x7506u, 0xe767u, 0xf489u, 0xe167
-    };
-
-unsigned int const random_unsigned_ints_binary[num_random_test_values]
-  = { BOOST_BINARY( 0 00010000 0011 ), BOOST_BINARY( 0 11101 1111  101011 )
-    , BOOST_BINARY( 010111 1100110 1 1 0 ), BOOST_BINARY( 000 1 11110 00 11000 )
-    , BOOST_BINARY( 110 001010 0110 000 ), BOOST_BINARY( 1010 01110011 1010 )
-    , BOOST_BINARY( 11 010 1 101111 1000 ), BOOST_BINARY( 0000 100100 0110 01 )
-    , BOOST_BINARY( 1111 101110 11 0000 ), BOOST_BINARY( 00111110 01111100 )
-    , BOOST_BINARY( 11  010 000111 01001 ), BOOST_BINARY( 00100 010110   01000 )
-    , BOOST_BINARY( 01 11001001 001110 ), BOOST_BINARY( 0010 1001111 1010 )
-    , BOOST_BINARY( 1101 1 00110 0 01110 ), BOOST_BINARY( 100 000 01011010 1 )
-    , BOOST_BINARY( 11 1010 1110 1000 00 ), BOOST_BINARY( 11111 110010 10000 )
-    , BOOST_BINARY( 01101 00010 001010 ), BOOST_BINARY( 000 11011 000001 01 )
-    , BOOST_BINARY( 01 01111 1100111 00 ), BOOST_BINARY( 1 110010 0111111 00 )
-    , BOOST_BINARY( 101 0011 11 01110 00 ), BOOST_BINARY( 110100 1 110101 100 )
-    , BOOST_BINARY( 00 1110111 011 101 ), BOOST_BINARY( 1011 1111 00000 100 )
-    , BOOST_BINARY( 1000 00110 101 0010 ), BOOST_BINARY( 1110  10001 001110 0 )
-    , BOOST_BINARY( 011 1010100 000 110 ), BOOST_BINARY( 1110 0111 01100 111 )
-    , BOOST_BINARY( 11110 10010 001001 ), BOOST_BINARY( 11 1000010 1100 111 )
-    };
-
-unsigned int const unsigned_ints_1_bit[2] =
-{ BOOST_BINARY( 0 )
-, BOOST_BINARY( 1 )
-};
-
-unsigned int const unsigned_ints_2_bits[4] =
-{ BOOST_BINARY( 00 )
-, BOOST_BINARY( 01 )
-, BOOST_BINARY( 10 )
-, BOOST_BINARY( 11 )
-};
-
-unsigned int const unsigned_ints_3_bits[8] =
-{ BOOST_BINARY( 000 )
-, BOOST_BINARY( 001 )
-, BOOST_BINARY( 010 )
-, BOOST_BINARY( 011 )
-, BOOST_BINARY( 100 )
-, BOOST_BINARY( 101 )
-, BOOST_BINARY( 110 )
-, BOOST_BINARY( 111 )
-};
-
-unsigned int const unsigned_ints_4_bits[16] =
-{ BOOST_BINARY( 0000 )
-, BOOST_BINARY( 0001 )
-, BOOST_BINARY( 0010 )
-, BOOST_BINARY( 0011 )
-, BOOST_BINARY( 0100 )
-, BOOST_BINARY( 0101 )
-, BOOST_BINARY( 0110 )
-, BOOST_BINARY( 0111 )
-, BOOST_BINARY( 1000 )
-, BOOST_BINARY( 1001 )
-, BOOST_BINARY( 1010 )
-, BOOST_BINARY( 1011 )
-, BOOST_BINARY( 1100 )
-, BOOST_BINARY( 1101 )
-, BOOST_BINARY( 1110 )
-, BOOST_BINARY( 1111 )
-};
-
-unsigned int const unsigned_ints_5_bits[32] =
-{ BOOST_BINARY( 00000 )
-, BOOST_BINARY( 00001 )
-, BOOST_BINARY( 00010 )
-, BOOST_BINARY( 00011 )
-, BOOST_BINARY( 00100 )
-, BOOST_BINARY( 00101 )
-, BOOST_BINARY( 00110 )
-, BOOST_BINARY( 00111 )
-, BOOST_BINARY( 01000 )
-, BOOST_BINARY( 01001 )
-, BOOST_BINARY( 01010 )
-, BOOST_BINARY( 01011 )
-, BOOST_BINARY( 01100 )
-, BOOST_BINARY( 01101 )
-, BOOST_BINARY( 01110 )
-, BOOST_BINARY( 01111 )
-, BOOST_BINARY( 10000 )
-, BOOST_BINARY( 10001 )
-, BOOST_BINARY( 10010 )
-, BOOST_BINARY( 10011 )
-, BOOST_BINARY( 10100 )
-, BOOST_BINARY( 10101 )
-, BOOST_BINARY( 10110 )
-, BOOST_BINARY( 10111 )
-, BOOST_BINARY( 11000 )
-, BOOST_BINARY( 11001 )
-, BOOST_BINARY( 11010 )
-, BOOST_BINARY( 11011 )
-, BOOST_BINARY( 11100 )
-, BOOST_BINARY( 11101 )
-, BOOST_BINARY( 11110 )
-, BOOST_BINARY( 11111 )
-};
-
-unsigned int const unsigned_ints_6_bits[64] =
-{ BOOST_BINARY( 000000 )
-, BOOST_BINARY( 000001 )
-, BOOST_BINARY( 000010 )
-, BOOST_BINARY( 000011 )
-, BOOST_BINARY( 000100 )
-, BOOST_BINARY( 000101 )
-, BOOST_BINARY( 000110 )
-, BOOST_BINARY( 000111 )
-, BOOST_BINARY( 001000 )
-, BOOST_BINARY( 001001 )
-, BOOST_BINARY( 001010 )
-, BOOST_BINARY( 001011 )
-, BOOST_BINARY( 001100 )
-, BOOST_BINARY( 001101 )
-, BOOST_BINARY( 001110 )
-, BOOST_BINARY( 001111 )
-, BOOST_BINARY( 010000 )
-, BOOST_BINARY( 010001 )
-, BOOST_BINARY( 010010 )
-, BOOST_BINARY( 010011 )
-, BOOST_BINARY( 010100 )
-, BOOST_BINARY( 010101 )
-, BOOST_BINARY( 010110 )
-, BOOST_BINARY( 010111 )
-, BOOST_BINARY( 011000 )
-, BOOST_BINARY( 011001 )
-, BOOST_BINARY( 011010 )
-, BOOST_BINARY( 011011 )
-, BOOST_BINARY( 011100 )
-, BOOST_BINARY( 011101 )
-, BOOST_BINARY( 011110 )
-, BOOST_BINARY( 011111 )
-, BOOST_BINARY( 100000 )
-, BOOST_BINARY( 100001 )
-, BOOST_BINARY( 100010 )
-, BOOST_BINARY( 100011 )
-, BOOST_BINARY( 100100 )
-, BOOST_BINARY( 100101 )
-, BOOST_BINARY( 100110 )
-, BOOST_BINARY( 100111 )
-, BOOST_BINARY( 101000 )
-, BOOST_BINARY( 101001 )
-, BOOST_BINARY( 101010 )
-, BOOST_BINARY( 101011 )
-, BOOST_BINARY( 101100 )
-, BOOST_BINARY( 101101 )
-, BOOST_BINARY( 101110 )
-, BOOST_BINARY( 101111 )
-, BOOST_BINARY( 110000 )
-, BOOST_BINARY( 110001 )
-, BOOST_BINARY( 110010 )
-, BOOST_BINARY( 110011 )
-, BOOST_BINARY( 110100 )
-, BOOST_BINARY( 110101 )
-, BOOST_BINARY( 110110 )
-, BOOST_BINARY( 110111 )
-, BOOST_BINARY( 111000 )
-, BOOST_BINARY( 111001 )
-, BOOST_BINARY( 111010 )
-, BOOST_BINARY( 111011 )
-, BOOST_BINARY( 111100 )
-, BOOST_BINARY( 111101 )
-, BOOST_BINARY( 111110 )
-, BOOST_BINARY( 111111 )
-};
-
-unsigned int const unsigned_ints_7_bits[128] =
-{ BOOST_BINARY( 0000000 )
-, BOOST_BINARY( 0000001 )
-, BOOST_BINARY( 0000010 )
-, BOOST_BINARY( 0000011 )
-, BOOST_BINARY( 0000100 )
-, BOOST_BINARY( 0000101 )
-, BOOST_BINARY( 0000110 )
-, BOOST_BINARY( 0000111 )
-, BOOST_BINARY( 0001000 )
-, BOOST_BINARY( 0001001 )
-, BOOST_BINARY( 0001010 )
-, BOOST_BINARY( 0001011 )
-, BOOST_BINARY( 0001100 )
-, BOOST_BINARY( 0001101 )
-, BOOST_BINARY( 0001110 )
-, BOOST_BINARY( 0001111 )
-, BOOST_BINARY( 0010000 )
-, BOOST_BINARY( 0010001 )
-, BOOST_BINARY( 0010010 )
-, BOOST_BINARY( 0010011 )
-, BOOST_BINARY( 0010100 )
-, BOOST_BINARY( 0010101 )
-, BOOST_BINARY( 0010110 )
-, BOOST_BINARY( 0010111 )
-, BOOST_BINARY( 0011000 )
-, BOOST_BINARY( 0011001 )
-, BOOST_BINARY( 0011010 )
-, BOOST_BINARY( 0011011 )
-, BOOST_BINARY( 0011100 )
-, BOOST_BINARY( 0011101 )
-, BOOST_BINARY( 0011110 )
-, BOOST_BINARY( 0011111 )
-, BOOST_BINARY( 0100000 )
-, BOOST_BINARY( 0100001 )
-, BOOST_BINARY( 0100010 )
-, BOOST_BINARY( 0100011 )
-, BOOST_BINARY( 0100100 )
-, BOOST_BINARY( 0100101 )
-, BOOST_BINARY( 0100110 )
-, BOOST_BINARY( 0100111 )
-, BOOST_BINARY( 0101000 )
-, BOOST_BINARY( 0101001 )
-, BOOST_BINARY( 0101010 )
-, BOOST_BINARY( 0101011 )
-, BOOST_BINARY( 0101100 )
-, BOOST_BINARY( 0101101 )
-, BOOST_BINARY( 0101110 )
-, BOOST_BINARY( 0101111 )
-, BOOST_BINARY( 0110000 )
-, BOOST_BINARY( 0110001 )
-, BOOST_BINARY( 0110010 )
-, BOOST_BINARY( 0110011 )
-, BOOST_BINARY( 0110100 )
-, BOOST_BINARY( 0110101 )
-, BOOST_BINARY( 0110110 )
-, BOOST_BINARY( 0110111 )
-, BOOST_BINARY( 0111000 )
-, BOOST_BINARY( 0111001 )
-, BOOST_BINARY( 0111010 )
-, BOOST_BINARY( 0111011 )
-, BOOST_BINARY( 0111100 )
-, BOOST_BINARY( 0111101 )
-, BOOST_BINARY( 0111110 )
-, BOOST_BINARY( 0111111 )
-, BOOST_BINARY( 1000000 )
-, BOOST_BINARY( 1000001 )
-, BOOST_BINARY( 1000010 )
-, BOOST_BINARY( 1000011 )
-, BOOST_BINARY( 1000100 )
-, BOOST_BINARY( 1000101 )
-, BOOST_BINARY( 1000110 )
-, BOOST_BINARY( 1000111 )
-, BOOST_BINARY( 1001000 )
-, BOOST_BINARY( 1001001 )
-, BOOST_BINARY( 1001010 )
-, BOOST_BINARY( 1001011 )
-, BOOST_BINARY( 1001100 )
-, BOOST_BINARY( 1001101 )
-, BOOST_BINARY( 1001110 )
-, BOOST_BINARY( 1001111 )
-, BOOST_BINARY( 1010000 )
-, BOOST_BINARY( 1010001 )
-, BOOST_BINARY( 1010010 )
-, BOOST_BINARY( 1010011 )
-, BOOST_BINARY( 1010100 )
-, BOOST_BINARY( 1010101 )
-, BOOST_BINARY( 1010110 )
-, BOOST_BINARY( 1010111 )
-, BOOST_BINARY( 1011000 )
-, BOOST_BINARY( 1011001 )
-, BOOST_BINARY( 1011010 )
-, BOOST_BINARY( 1011011 )
-, BOOST_BINARY( 1011100 )
-, BOOST_BINARY( 1011101 )
-, BOOST_BINARY( 1011110 )
-, BOOST_BINARY( 1011111 )
-, BOOST_BINARY( 1100000 )
-, BOOST_BINARY( 1100001 )
-, BOOST_BINARY( 1100010 )
-, BOOST_BINARY( 1100011 )
-, BOOST_BINARY( 1100100 )
-, BOOST_BINARY( 1100101 )
-, BOOST_BINARY( 1100110 )
-, BOOST_BINARY( 1100111 )
-, BOOST_BINARY( 1101000 )
-, BOOST_BINARY( 1101001 )
-, BOOST_BINARY( 1101010 )
-, BOOST_BINARY( 1101011 )
-, BOOST_BINARY( 1101100 )
-, BOOST_BINARY( 1101101 )
-, BOOST_BINARY( 1101110 )
-, BOOST_BINARY( 1101111 )
-, BOOST_BINARY( 1110000 )
-, BOOST_BINARY( 1110001 )
-, BOOST_BINARY( 1110010 )
-, BOOST_BINARY( 1110011 )
-, BOOST_BINARY( 1110100 )
-, BOOST_BINARY( 1110101 )
-, BOOST_BINARY( 1110110 )
-, BOOST_BINARY( 1110111 )
-, BOOST_BINARY( 1111000 )
-, BOOST_BINARY( 1111001 )
-, BOOST_BINARY( 1111010 )
-, BOOST_BINARY( 1111011 )
-, BOOST_BINARY( 1111100 )
-, BOOST_BINARY( 1111101 )
-, BOOST_BINARY( 1111110 )
-, BOOST_BINARY( 1111111 )
-};
-unsigned int const unsigned_ints_8_bits[256] =
-{ BOOST_BINARY( 00000000 )
-, BOOST_BINARY( 00000001 )
-, BOOST_BINARY( 00000010 )
-, BOOST_BINARY( 00000011 )
-, BOOST_BINARY( 00000100 )
-, BOOST_BINARY( 00000101 )
-, BOOST_BINARY( 00000110 )
-, BOOST_BINARY( 00000111 )
-, BOOST_BINARY( 00001000 )
-, BOOST_BINARY( 00001001 )
-, BOOST_BINARY( 00001010 )
-, BOOST_BINARY( 00001011 )
-, BOOST_BINARY( 00001100 )
-, BOOST_BINARY( 00001101 )
-, BOOST_BINARY( 00001110 )
-, BOOST_BINARY( 00001111 )
-, BOOST_BINARY( 00010000 )
-, BOOST_BINARY( 00010001 )
-, BOOST_BINARY( 00010010 )
-, BOOST_BINARY( 00010011 )
-, BOOST_BINARY( 00010100 )
-, BOOST_BINARY( 00010101 )
-, BOOST_BINARY( 00010110 )
-, BOOST_BINARY( 00010111 )
-, BOOST_BINARY( 00011000 )
-, BOOST_BINARY( 00011001 )
-, BOOST_BINARY( 00011010 )
-, BOOST_BINARY( 00011011 )
-, BOOST_BINARY( 00011100 )
-, BOOST_BINARY( 00011101 )
-, BOOST_BINARY( 00011110 )
-, BOOST_BINARY( 00011111 )
-, BOOST_BINARY( 00100000 )
-, BOOST_BINARY( 00100001 )
-, BOOST_BINARY( 00100010 )
-, BOOST_BINARY( 00100011 )
-, BOOST_BINARY( 00100100 )
-, BOOST_BINARY( 00100101 )
-, BOOST_BINARY( 00100110 )
-, BOOST_BINARY( 00100111 )
-, BOOST_BINARY( 00101000 )
-, BOOST_BINARY( 00101001 )
-, BOOST_BINARY( 00101010 )
-, BOOST_BINARY( 00101011 )
-, BOOST_BINARY( 00101100 )
-, BOOST_BINARY( 00101101 )
-, BOOST_BINARY( 00101110 )
-, BOOST_BINARY( 00101111 )
-, BOOST_BINARY( 00110000 )
-, BOOST_BINARY( 00110001 )
-, BOOST_BINARY( 00110010 )
-, BOOST_BINARY( 00110011 )
-, BOOST_BINARY( 00110100 )
-, BOOST_BINARY( 00110101 )
-, BOOST_BINARY( 00110110 )
-, BOOST_BINARY( 00110111 )
-, BOOST_BINARY( 00111000 )
-, BOOST_BINARY( 00111001 )
-, BOOST_BINARY( 00111010 )
-, BOOST_BINARY( 00111011 )
-, BOOST_BINARY( 00111100 )
-, BOOST_BINARY( 00111101 )
-, BOOST_BINARY( 00111110 )
-, BOOST_BINARY( 00111111 )
-, BOOST_BINARY( 01000000 )
-, BOOST_BINARY( 01000001 )
-, BOOST_BINARY( 01000010 )
-, BOOST_BINARY( 01000011 )
-, BOOST_BINARY( 01000100 )
-, BOOST_BINARY( 01000101 )
-, BOOST_BINARY( 01000110 )
-, BOOST_BINARY( 01000111 )
-, BOOST_BINARY( 01001000 )
-, BOOST_BINARY( 01001001 )
-, BOOST_BINARY( 01001010 )
-, BOOST_BINARY( 01001011 )
-, BOOST_BINARY( 01001100 )
-, BOOST_BINARY( 01001101 )
-, BOOST_BINARY( 01001110 )
-, BOOST_BINARY( 01001111 )
-, BOOST_BINARY( 01010000 )
-, BOOST_BINARY( 01010001 )
-, BOOST_BINARY( 01010010 )
-, BOOST_BINARY( 01010011 )
-, BOOST_BINARY( 01010100 )
-, BOOST_BINARY( 01010101 )
-, BOOST_BINARY( 01010110 )
-, BOOST_BINARY( 01010111 )
-, BOOST_BINARY( 01011000 )
-, BOOST_BINARY( 01011001 )
-, BOOST_BINARY( 01011010 )
-, BOOST_BINARY( 01011011 )
-, BOOST_BINARY( 01011100 )
-, BOOST_BINARY( 01011101 )
-, BOOST_BINARY( 01011110 )
-, BOOST_BINARY( 01011111 )
-, BOOST_BINARY( 01100000 )
-, BOOST_BINARY( 01100001 )
-, BOOST_BINARY( 01100010 )
-, BOOST_BINARY( 01100011 )
-, BOOST_BINARY( 01100100 )
-, BOOST_BINARY( 01100101 )
-, BOOST_BINARY( 01100110 )
-, BOOST_BINARY( 01100111 )
-, BOOST_BINARY( 01101000 )
-, BOOST_BINARY( 01101001 )
-, BOOST_BINARY( 01101010 )
-, BOOST_BINARY( 01101011 )
-, BOOST_BINARY( 01101100 )
-, BOOST_BINARY( 01101101 )
-, BOOST_BINARY( 01101110 )
-, BOOST_BINARY( 01101111 )
-, BOOST_BINARY( 01110000 )
-, BOOST_BINARY( 01110001 )
-, BOOST_BINARY( 01110010 )
-, BOOST_BINARY( 01110011 )
-, BOOST_BINARY( 01110100 )
-, BOOST_BINARY( 01110101 )
-, BOOST_BINARY( 01110110 )
-, BOOST_BINARY( 01110111 )
-, BOOST_BINARY( 01111000 )
-, BOOST_BINARY( 01111001 )
-, BOOST_BINARY( 01111010 )
-, BOOST_BINARY( 01111011 )
-, BOOST_BINARY( 01111100 )
-, BOOST_BINARY( 01111101 )
-, BOOST_BINARY( 01111110 )
-, BOOST_BINARY( 01111111 )
-, BOOST_BINARY( 10000000 )
-, BOOST_BINARY( 10000001 )
-, BOOST_BINARY( 10000010 )
-, BOOST_BINARY( 10000011 )
-, BOOST_BINARY( 10000100 )
-, BOOST_BINARY( 10000101 )
-, BOOST_BINARY( 10000110 )
-, BOOST_BINARY( 10000111 )
-, BOOST_BINARY( 10001000 )
-, BOOST_BINARY( 10001001 )
-, BOOST_BINARY( 10001010 )
-, BOOST_BINARY( 10001011 )
-, BOOST_BINARY( 10001100 )
-, BOOST_BINARY( 10001101 )
-, BOOST_BINARY( 10001110 )
-, BOOST_BINARY( 10001111 )
-, BOOST_BINARY( 10010000 )
-, BOOST_BINARY( 10010001 )
-, BOOST_BINARY( 10010010 )
-, BOOST_BINARY( 10010011 )
-, BOOST_BINARY( 10010100 )
-, BOOST_BINARY( 10010101 )
-, BOOST_BINARY( 10010110 )
-, BOOST_BINARY( 10010111 )
-, BOOST_BINARY( 10011000 )
-, BOOST_BINARY( 10011001 )
-, BOOST_BINARY( 10011010 )
-, BOOST_BINARY( 10011011 )
-, BOOST_BINARY( 10011100 )
-, BOOST_BINARY( 10011101 )
-, BOOST_BINARY( 10011110 )
-, BOOST_BINARY( 10011111 )
-, BOOST_BINARY( 10100000 )
-, BOOST_BINARY( 10100001 )
-, BOOST_BINARY( 10100010 )
-, BOOST_BINARY( 10100011 )
-, BOOST_BINARY( 10100100 )
-, BOOST_BINARY( 10100101 )
-, BOOST_BINARY( 10100110 )
-, BOOST_BINARY( 10100111 )
-, BOOST_BINARY( 10101000 )
-, BOOST_BINARY( 10101001 )
-, BOOST_BINARY( 10101010 )
-, BOOST_BINARY( 10101011 )
-, BOOST_BINARY( 10101100 )
-, BOOST_BINARY( 10101101 )
-, BOOST_BINARY( 10101110 )
-, BOOST_BINARY( 10101111 )
-, BOOST_BINARY( 10110000 )
-, BOOST_BINARY( 10110001 )
-, BOOST_BINARY( 10110010 )
-, BOOST_BINARY( 10110011 )
-, BOOST_BINARY( 10110100 )
-, BOOST_BINARY( 10110101 )
-, BOOST_BINARY( 10110110 )
-, BOOST_BINARY( 10110111 )
-, BOOST_BINARY( 10111000 )
-, BOOST_BINARY( 10111001 )
-, BOOST_BINARY( 10111010 )
-, BOOST_BINARY( 10111011 )
-, BOOST_BINARY( 10111100 )
-, BOOST_BINARY( 10111101 )
-, BOOST_BINARY( 10111110 )
-, BOOST_BINARY( 10111111 )
-, BOOST_BINARY( 11000000 )
-, BOOST_BINARY( 11000001 )
-, BOOST_BINARY( 11000010 )
-, BOOST_BINARY( 11000011 )
-, BOOST_BINARY( 11000100 )
-, BOOST_BINARY( 11000101 )
-, BOOST_BINARY( 11000110 )
-, BOOST_BINARY( 11000111 )
-, BOOST_BINARY( 11001000 )
-, BOOST_BINARY( 11001001 )
-, BOOST_BINARY( 11001010 )
-, BOOST_BINARY( 11001011 )
-, BOOST_BINARY( 11001100 )
-, BOOST_BINARY( 11001101 )
-, BOOST_BINARY( 11001110 )
-, BOOST_BINARY( 11001111 )
-, BOOST_BINARY( 11010000 )
-, BOOST_BINARY( 11010001 )
-, BOOST_BINARY( 11010010 )
-, BOOST_BINARY( 11010011 )
-, BOOST_BINARY( 11010100 )
-, BOOST_BINARY( 11010101 )
-, BOOST_BINARY( 11010110 )
-, BOOST_BINARY( 11010111 )
-, BOOST_BINARY( 11011000 )
-, BOOST_BINARY( 11011001 )
-, BOOST_BINARY( 11011010 )
-, BOOST_BINARY( 11011011 )
-, BOOST_BINARY( 11011100 )
-, BOOST_BINARY( 11011101 )
-, BOOST_BINARY( 11011110 )
-, BOOST_BINARY( 11011111 )
-, BOOST_BINARY( 11100000 )
-, BOOST_BINARY( 11100001 )
-, BOOST_BINARY( 11100010 )
-, BOOST_BINARY( 11100011 )
-, BOOST_BINARY( 11100100 )
-, BOOST_BINARY( 11100101 )
-, BOOST_BINARY( 11100110 )
-, BOOST_BINARY( 11100111 )
-, BOOST_BINARY( 11101000 )
-, BOOST_BINARY( 11101001 )
-, BOOST_BINARY( 11101010 )
-, BOOST_BINARY( 11101011 )
-, BOOST_BINARY( 11101100 )
-, BOOST_BINARY( 11101101 )
-, BOOST_BINARY( 11101110 )
-, BOOST_BINARY( 11101111 )
-, BOOST_BINARY( 11110000 )
-, BOOST_BINARY( 11110001 )
-, BOOST_BINARY( 11110010 )
-, BOOST_BINARY( 11110011 )
-, BOOST_BINARY( 11110100 )
-, BOOST_BINARY( 11110101 )
-, BOOST_BINARY( 11110110 )
-, BOOST_BINARY( 11110111 )
-, BOOST_BINARY( 11111000 )
-, BOOST_BINARY( 11111001 )
-, BOOST_BINARY( 11111010 )
-, BOOST_BINARY( 11111011 )
-, BOOST_BINARY( 11111100 )
-, BOOST_BINARY( 11111101 )
-, BOOST_BINARY( 11111110 )
-, BOOST_BINARY( 11111111 )
-};
-
-struct left_is_not_one_less_than_right
-{
-  bool operator ()( unsigned int left, unsigned int right ) const
-  {
-    return right != left + 1;
-  }
-};
-
-template< std::size_t Size >
-bool is_ascending_from_0_array( unsigned int const (&array)[Size] )
-{
-  unsigned int const* const curr = array,
-                    * const end  = array + Size;
-
-  return    ( *curr == 0 )
-         && (    std::adjacent_find( curr, end
-                                   , left_is_not_one_less_than_right()
-                                   )
-              == end
-            );
-}
-
-std::size_t const unsigned_int_id = 1,
-                  unsigned_long_int_id = 2;
-
-typedef char (&unsigned_int_id_type)[unsigned_int_id];
-typedef char (&unsigned_long_int_id_type)[unsigned_long_int_id];
-
-// Note: Functions only used for type checking
-unsigned_int_id_type      binary_type_checker( unsigned int );
-unsigned_long_int_id_type binary_type_checker( unsigned long int );
-
-int main()
-{
-  BOOST_TEST( is_ascending_from_0_array( unsigned_ints_1_bit ) );
-  BOOST_TEST( is_ascending_from_0_array( unsigned_ints_2_bits ) );
-  BOOST_TEST( is_ascending_from_0_array( unsigned_ints_3_bits ) );
-  BOOST_TEST( is_ascending_from_0_array( unsigned_ints_4_bits ) );
-  BOOST_TEST( is_ascending_from_0_array( unsigned_ints_5_bits ) );
-  BOOST_TEST( is_ascending_from_0_array( unsigned_ints_6_bits ) );
-  BOOST_TEST( is_ascending_from_0_array( unsigned_ints_7_bits ) );
-  BOOST_TEST( is_ascending_from_0_array( unsigned_ints_8_bits ) );
-
-  BOOST_TEST( std::equal( &random_unsigned_ints_hex[0]
-                         , random_unsigned_ints_hex + num_random_test_values
-                         , &random_unsigned_ints_binary[0]
-                         )
-             );
-
-  BOOST_TEST(    sizeof( binary_type_checker( BOOST_BINARY_U( 110100 1010 ) ) )
-               == unsigned_int_id
-             );
-
-  BOOST_TEST(    sizeof( binary_type_checker( BOOST_BINARY_UL( 11110 ) ) )
-               == unsigned_long_int_id
-             );
-
-  BOOST_TEST(    sizeof( binary_type_checker( BOOST_BINARY_LU( 10 0001 ) ) )
-               == unsigned_long_int_id
-             );
-
-  return boost::report_errors();
-}

test/call_traits_test.cpp

@@ -1,418 +0,0 @@
-//  boost::compressed_pair test program   
-    
-//  (C) Copyright John Maddock 2000. 
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-
-
-// standalone test program for <boost/call_traits.hpp>
-// 18 Mar 2002:
-//    Changed some names to prevent conflicts with some new type_traits additions.
-// 03 Oct 2000:
-//    Enabled extra tests for VC6.
-
-#include <iostream>
-#include <iomanip>
-#include <algorithm>
-#include <typeinfo>
-#include <boost/call_traits.hpp>
-
-#include <libs/type_traits/test/test.hpp>
-#include <libs/type_traits/test/check_type.hpp>
-
-#ifdef BOOST_MSVC
-#pragma warning(disable:4181) // : warning C4181: qualifier applied to reference type; ignored
-#endif
-
-// a way prevent warnings for unused variables
-template<class T> inline void unused_variable(const T&) {}
-
-//
-// struct contained models a type that contains a type (for example std::pair)
-// arrays are contained by value, and have to be treated as a special case:
-//
-template <class T>
-struct contained
-{
-   // define our typedefs first, arrays are stored by value
-   // so value_type is not the same as result_type:
-   typedef typename boost::call_traits<T>::param_type       param_type;
-   typedef typename boost::call_traits<T>::reference        reference;
-   typedef typename boost::call_traits<T>::const_reference  const_reference;
-   typedef T                                                value_type;
-   typedef typename boost::call_traits<T>::value_type       result_type;
-
-   // stored value:
-   value_type v_;
-   
-   // constructors:
-   contained() {}
-   contained(param_type p) : v_(p){}
-   // return byval:
-   result_type value()const { return v_; }
-   // return by_ref:
-   reference get() { return v_; }
-   const_reference const_get()const { return v_; }
-   // pass value:
-   void call(param_type){}
-private:
-   contained& operator=(const contained&);
-};
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T, std::size_t N>
-struct contained<T[N]>
-{
-   typedef typename boost::call_traits<T[N]>::param_type       param_type;
-   typedef typename boost::call_traits<T[N]>::reference        reference;
-   typedef typename boost::call_traits<T[N]>::const_reference  const_reference;
-   typedef T                                                   value_type[N];
-   typedef typename boost::call_traits<T[N]>::value_type       result_type;
-
-   value_type v_;
-
-   contained(param_type p)
-   {
-      std::copy(p, p+N, v_);
-   }
-   // return byval:
-   result_type value()const { return v_; }
-   // return by_ref:
-   reference get() { return v_; }
-   const_reference const_get()const { return v_; }
-   void call(param_type){}
-private:
-   contained& operator=(const contained&);
-};
-#endif
-
-template <class T>
-contained<typename boost::call_traits<T>::value_type> test_wrap_type(const T& t)
-{
-   typedef typename boost::call_traits<T>::value_type ct;
-   return contained<ct>(t);
-}
-
-namespace test{
-
-template <class T1, class T2>
-std::pair<
-   typename boost::call_traits<T1>::value_type,
-   typename boost::call_traits<T2>::value_type>
-      make_pair(const T1& t1, const T2& t2)
-{
-   return std::pair<
-      typename boost::call_traits<T1>::value_type,
-      typename boost::call_traits<T2>::value_type>(t1, t2);
-}
-
-} // namespace test
-
-using namespace std;
-
-//
-// struct call_traits_checker:
-// verifies behaviour of contained example:
-//
-template <class T>
-struct call_traits_checker
-{
-   typedef typename boost::call_traits<T>::param_type param_type;
-   void operator()(param_type);
-};
-
-template <class T>
-void call_traits_checker<T>::operator()(param_type p)
-{
-   T t(p);
-   contained<T> c(t);
-   cout << "checking contained<" << typeid(T).name() << ">..." << endl;
-   BOOST_CHECK(t == c.value());
-   BOOST_CHECK(t == c.get());
-   BOOST_CHECK(t == c.const_get());
-#ifndef __ICL
-   //cout << "typeof contained<" << typeid(T).name() << ">::v_ is:           " << typeid(&contained<T>::v_).name() << endl;
-   cout << "typeof contained<" << typeid(T).name() << ">::value() is:      " << typeid(&contained<T>::value).name() << endl;
-   cout << "typeof contained<" << typeid(T).name() << ">::get() is:        " << typeid(&contained<T>::get).name() << endl;
-   cout << "typeof contained<" << typeid(T).name() << ">::const_get() is:  " << typeid(&contained<T>::const_get).name() << endl;
-   cout << "typeof contained<" << typeid(T).name() << ">::call() is:       " << typeid(&contained<T>::call).name() << endl;
-   cout << endl;
-#endif
-}
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T, std::size_t N>
-struct call_traits_checker<T[N]>
-{
-   typedef typename boost::call_traits<T[N]>::param_type param_type;
-   void operator()(param_type t)
-   {
-      contained<T[N]> c(t);
-      cout << "checking contained<" << typeid(T[N]).name() << ">..." << endl;
-      unsigned int i = 0;
-      for(i = 0; i < N; ++i)
-         BOOST_CHECK(t[i] == c.value()[i]);
-      for(i = 0; i < N; ++i)
-         BOOST_CHECK(t[i] == c.get()[i]);
-      for(i = 0; i < N; ++i)
-         BOOST_CHECK(t[i] == c.const_get()[i]);
-
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::v_ is:         " << typeid(&contained<T[N]>::v_).name() << endl;
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::value is:      " << typeid(&contained<T[N]>::value).name() << endl;
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::get is:        " << typeid(&contained<T[N]>::get).name() << endl;
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::const_get is:  " << typeid(&contained<T[N]>::const_get).name() << endl;
-      cout << "typeof contained<" << typeid(T[N]).name() << ">::call is:       " << typeid(&contained<T[N]>::call).name() << endl;
-      cout << endl;
-   }
-};
-#endif
-
-//
-// check_wrap:
-template <class W, class U>
-void check_wrap(const W& w, const U& u)
-{
-   cout << "checking " << typeid(W).name() << "..." << endl;
-   BOOST_CHECK(w.value() == u);
-}
-
-//
-// check_make_pair:
-// verifies behaviour of "make_pair":
-//
-template <class T, class U, class V>
-void check_make_pair(T c, U u, V v)
-{
-   cout << "checking std::pair<" << typeid(c.first).name() << ", " << typeid(c.second).name() << ">..." << endl;
-   BOOST_CHECK(c.first == u);
-   BOOST_CHECK(c.second == v);
-   cout << endl;
-}
-
-
-struct comparible_UDT
-{
-   int i_;
-   comparible_UDT() : i_(2){}
-   comparible_UDT(const comparible_UDT& other) : i_(other.i_){}
-   comparible_UDT& operator=(const comparible_UDT& other)
-   { 
-      i_ = other.i_;
-      return *this;
-   }
-   bool operator == (const comparible_UDT& v){ return v.i_ == i_; }
-};
-
-int main()
-{
-   call_traits_checker<comparible_UDT> c1;
-   comparible_UDT u;
-   c1(u);
-   call_traits_checker<int> c2;
-   call_traits_checker<enum_UDT> c2b;
-   int i = 2;
-   c2(i);
-   c2b(one);
-   int* pi = &i;
-   int a[2] = {1,2};
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) && !defined(__ICL)
-   call_traits_checker<int*> c3;
-   c3(pi);
-   call_traits_checker<int&> c4;
-   c4(i);
-   call_traits_checker<const int&> c5;
-   c5(i);
-#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__MWERKS__) && !defined(__SUNPRO_CC)
-   call_traits_checker<int[2]> c6;
-   c6(a);
-#endif
-#endif
-
-   check_wrap(test_wrap_type(2), 2);
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC)
-   check_wrap(test_wrap_type(a), a);
-   check_make_pair(test::make_pair(a, a), a, a);
-#endif
-
-   // cv-qualifiers applied to reference types should have no effect
-   // declare these here for later use with is_reference and remove_reference:
-   typedef int& r_type;
-   typedef const r_type cr_type;
-
-   BOOST_CHECK_TYPE(comparible_UDT, boost::call_traits<comparible_UDT>::value_type);
-   BOOST_CHECK_TYPE(comparible_UDT&, boost::call_traits<comparible_UDT>::reference);
-   BOOST_CHECK_TYPE(const comparible_UDT&, boost::call_traits<comparible_UDT>::const_reference);
-   BOOST_CHECK_TYPE(const comparible_UDT&, boost::call_traits<comparible_UDT>::param_type);
-   BOOST_CHECK_TYPE(int, boost::call_traits<int>::value_type);
-   BOOST_CHECK_TYPE(int&, boost::call_traits<int>::reference);
-   BOOST_CHECK_TYPE(const int&, boost::call_traits<int>::const_reference);
-   BOOST_CHECK_TYPE(const int, boost::call_traits<int>::param_type);
-   BOOST_CHECK_TYPE(int*, boost::call_traits<int*>::value_type);
-   BOOST_CHECK_TYPE(int*&, boost::call_traits<int*>::reference);
-   BOOST_CHECK_TYPE(int*const&, boost::call_traits<int*>::const_reference);
-   BOOST_CHECK_TYPE(int*const, boost::call_traits<int*>::param_type);
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-   BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::value_type);
-   BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::reference);
-   BOOST_CHECK_TYPE(const int&, boost::call_traits<int&>::const_reference);
-   BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::param_type);
-#if !(defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC__ == 3) && (__GNUC_MINOR__ < 1)))
-   BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::value_type);
-   BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::reference);
-   BOOST_CHECK_TYPE(const int&, boost::call_traits<cr_type>::const_reference);
-   BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::param_type);
-#else
-   std::cout << "Your compiler cannot instantiate call_traits<int&const>, skipping four tests (4 errors)" << std::endl;
-#endif
-   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::value_type);
-   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::reference);
-   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::const_reference);
-   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::param_type);
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   BOOST_CHECK_TYPE(const int*, boost::call_traits<int[3]>::value_type);
-   BOOST_CHECK_TYPE(int(&)[3], boost::call_traits<int[3]>::reference);
-   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<int[3]>::const_reference);
-   BOOST_CHECK_TYPE(const int*const, boost::call_traits<int[3]>::param_type);
-   BOOST_CHECK_TYPE(const int*, boost::call_traits<const int[3]>::value_type);
-   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<const int[3]>::reference);
-   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<const int[3]>::const_reference);
-   BOOST_CHECK_TYPE(const int*const, boost::call_traits<const int[3]>::param_type);
-   // test with abstract base class:
-   BOOST_CHECK_TYPE(test_abc1, boost::call_traits<test_abc1>::value_type);
-   BOOST_CHECK_TYPE(test_abc1&, boost::call_traits<test_abc1>::reference);
-   BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::const_reference);
-   BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::param_type);
-#else
-   std::cout << "You're compiler does not support partial template specialiation, skipping 8 tests (8 errors)" << std::endl;
-#endif
-#else
-   std::cout << "You're compiler does not support partial template specialiation, skipping 20 tests (20 errors)" << std::endl;
-#endif
-   // test with an incomplete type:
-   BOOST_CHECK_TYPE(incomplete_type, boost::call_traits<incomplete_type>::value_type);
-   BOOST_CHECK_TYPE(incomplete_type&, boost::call_traits<incomplete_type>::reference);
-   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference);
-   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::param_type);
-   // test enum:
-   BOOST_CHECK_TYPE(enum_UDT, boost::call_traits<enum_UDT>::value_type);
-   BOOST_CHECK_TYPE(enum_UDT&, boost::call_traits<enum_UDT>::reference);
-   BOOST_CHECK_TYPE(const enum_UDT&, boost::call_traits<enum_UDT>::const_reference);
-   BOOST_CHECK_TYPE(const enum_UDT, boost::call_traits<enum_UDT>::param_type);
-   return 0;
-}
-
-//
-// define call_traits tests to check that the assertions in the docs do actually work
-// this is an compile-time only set of tests:
-//
-template <typename T, bool isarray = false>
-struct call_traits_test
-{
-   typedef ::boost::call_traits<T> ct;
-   typedef typename ct::param_type param_type;
-   typedef typename ct::reference reference;
-   typedef typename ct::const_reference const_reference;
-   typedef typename ct::value_type value_type;
-   static void assert_construct(param_type val);
-};
-
-template <typename T, bool isarray>
-void call_traits_test<T, isarray>::assert_construct(typename call_traits_test<T, isarray>::param_type val)
-{
-   //
-   // this is to check that the call_traits assertions are valid:
-   T t(val);
-   value_type v(t);
-   reference r(t);
-   const_reference cr(t);
-   param_type p(t);
-   value_type v2(v);
-   value_type v3(r);
-   value_type v4(p);
-   reference r2(v);
-   reference r3(r);
-   const_reference cr2(v);
-   const_reference cr3(r);
-   const_reference cr4(cr);
-   const_reference cr5(p);
-   param_type p2(v);
-   param_type p3(r);
-   param_type p4(p);
-   
-   unused_variable(v2);
-   unused_variable(v3);
-   unused_variable(v4);
-   unused_variable(r2);
-   unused_variable(r3);
-   unused_variable(cr2);
-   unused_variable(cr3);
-   unused_variable(cr4);
-   unused_variable(cr5);
-   unused_variable(p2);
-   unused_variable(p3);
-   unused_variable(p4);
-}
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <typename T>
-struct call_traits_test<T, true>
-{
-   typedef ::boost::call_traits<T> ct;
-   typedef typename ct::param_type param_type;
-   typedef typename ct::reference reference;
-   typedef typename ct::const_reference const_reference;
-   typedef typename ct::value_type value_type;
-   static void assert_construct(param_type val);
-};
-
-template <typename T>
-void call_traits_test<T, true>::assert_construct(typename boost::call_traits<T>::param_type val)
-{
-   //
-   // this is to check that the call_traits assertions are valid:
-   T t;
-   value_type v(t);
-   value_type v5(val);
-   reference r = t;
-   const_reference cr = t;
-   reference r2 = r;
-   #ifndef __BORLANDC__
-   // C++ Builder buglet:
-   const_reference cr2 = r;
-   #endif
-   param_type p(t);
-   value_type v2(v);
-   const_reference cr3 = cr;
-   value_type v3(r);
-   value_type v4(p);
-   param_type p2(v);
-   param_type p3(r);
-   param_type p4(p);
-   
-   unused_variable(v2);
-   unused_variable(v3);
-   unused_variable(v4);
-   unused_variable(v5);
-#ifndef __BORLANDC__
-   unused_variable(r2);
-   unused_variable(cr2);
-#endif
-   unused_variable(cr3);
-   unused_variable(p2);
-   unused_variable(p3);
-   unused_variable(p4);
-}
-#endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//
-// now check call_traits assertions by instantiating call_traits_test:
-template struct call_traits_test<int>;
-template struct call_traits_test<const int>;
-template struct call_traits_test<int*>;
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-template struct call_traits_test<int&>;
-template struct call_traits_test<const int&>;
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC)
-template struct call_traits_test<int[2], true>;
-#endif
-#endif
-

test/compressed_pair_final_test.cpp

@@ -1,55 +0,0 @@
-/*
-Copyright 2018 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_FINAL)
-#include <boost/compressed_pair.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-struct type1 {
-    operator bool() const {
-        return false;
-    }
-};
-
-struct type2 final {
-    operator bool() const {
-        return false;
-    }
-};
-
-#if !defined(BOOST_IS_FINAL)
-namespace boost {
-
-template<>
-struct is_final<type2>
-    : true_type { };
-
-} /* boost*/
-#endif
-
-template<class T1, class T2>
-void test()
-{
-    boost::compressed_pair<T1, T2> p;
-    BOOST_TEST(!p.first());
-    BOOST_TEST(!p.second());
-}
-
-int main()
-{
-    test<type1, type2>();
-    test<type2, type1>();
-    test<type2, type2>();
-    return boost::report_errors();
-}
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/compressed_pair_test.cpp

@@ -1,387 +0,0 @@
-//  boost::compressed_pair test program   
-    
-//  (C) Copyright John Maddock 2000. 
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-
-// standalone test program for <boost/compressed_pair.hpp>
-// Revised 03 Oct 2000: 
-//    Enabled tests for VC6.
-
-#include <iostream>
-#include <typeinfo>
-#include <cassert>
-
-#include <boost/compressed_pair.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-using namespace boost;
-
-struct empty_UDT
-{
-   ~empty_UDT(){};
-   empty_UDT& operator=(const empty_UDT&){ return *this; }
-   bool operator==(const empty_UDT&)const
-   { return true; }
-};
-struct empty_POD_UDT
-{
-   empty_POD_UDT& operator=(const empty_POD_UDT&){ return *this; }
-   bool operator==(const empty_POD_UDT&)const
-   { return true; }
-};
-
-struct non_empty1
-{ 
-   int i;
-   non_empty1() : i(1){}
-   non_empty1(int v) : i(v){}
-   friend bool operator==(const non_empty1& a, const non_empty1& b)
-   { return a.i == b.i; }
-};
-
-struct non_empty2
-{ 
-   int i;
-   non_empty2() : i(3){}
-   non_empty2(int v) : i(v){}
-   friend bool operator==(const non_empty2& a, const non_empty2& b)
-   { return a.i == b.i; }
-};
-
-#ifdef __GNUC__
-using std::swap;
-#endif
-
-template <class T1, class T2>
-struct compressed_pair_tester
-{
-   // define the types we need:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   // define our test proc:
-   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
-};
-
-template <class T1, class T2>
-void compressed_pair_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4)
-{
-#ifndef __GNUC__
-   // gcc 2.90 can't cope with function scope using
-   // declarations, and generates an internal compiler error...
-   using std::swap;
-#endif
-   // default construct:
-   boost::compressed_pair<T1,T2> cp1;
-   // first param construct:
-   boost::compressed_pair<T1,T2> cp2(p1);
-   cp2.second() = p2;
-   BOOST_TEST(cp2.first() == p1);
-   BOOST_TEST(cp2.second() == p2);
-   // second param construct:
-   boost::compressed_pair<T1,T2> cp3(p2);
-   cp3.first() = p1;
-   BOOST_TEST(cp3.second() == p2);
-   BOOST_TEST(cp3.first() == p1);
-   // both param construct:
-   boost::compressed_pair<T1,T2> cp4(p1, p2);
-   BOOST_TEST(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
-   boost::compressed_pair<T1,T2> cp5(p3, p4);
-   BOOST_TEST(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
-   // check const members:
-   const boost::compressed_pair<T1,T2>& cpr1 = cp4;
-   BOOST_TEST(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second() == p2);
-
-   // copy construct:
-   boost::compressed_pair<T1,T2> cp6(cp4);
-   BOOST_TEST(cp6.first() == p1);
-   BOOST_TEST(cp6.second() == p2);
-   // assignment:
-   cp1 = cp4;
-   BOOST_TEST(cp1.first() == p1);
-   BOOST_TEST(cp1.second() == p2);
-   cp1 = cp5;
-   BOOST_TEST(cp1.first() == p3);
-   BOOST_TEST(cp1.second() == p4);
-   // swap:
-   cp4.swap(cp5);
-   BOOST_TEST(cp4.first() == p3);
-   BOOST_TEST(cp4.second() == p4);
-   BOOST_TEST(cp5.first() == p1);
-   BOOST_TEST(cp5.second() == p2);
-   swap(cp4,cp5);
-   BOOST_TEST(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
-   BOOST_TEST(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
-}
-
-//
-// tests for case where one or both 
-// parameters are reference types:
-//
-template <class T1, class T2>
-struct compressed_pair_reference_tester
-{
-   // define the types we need:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   // define our test proc:
-   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
-};
-
-template <class T1, class T2>
-void compressed_pair_reference_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4)
-{
-#ifndef __GNUC__
-   // gcc 2.90 can't cope with function scope using
-   // declarations, and generates an internal compiler error...
-   using std::swap;
-#endif
-   // both param construct:
-   boost::compressed_pair<T1,T2> cp4(p1, p2);
-   BOOST_TEST(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
-   boost::compressed_pair<T1,T2> cp5(p3, p4);
-   BOOST_TEST(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
-   // check const members:
-   const boost::compressed_pair<T1,T2>& cpr1 = cp4;
-   BOOST_TEST(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second() == p2);
-
-   // copy construct:
-   boost::compressed_pair<T1,T2> cp6(cp4);
-   BOOST_TEST(cp6.first() == p1);
-   BOOST_TEST(cp6.second() == p2);
-   // assignment:
-   // VC6 bug:
-   // When second() is an empty class, VC6 performs the
-   // assignment by doing a memcpy - even though the empty
-   // class is really a zero sized base class, the result
-   // is that the memory of first() gets trampled over.
-   // Similar arguments apply to the case that first() is 
-   // an empty base class.
-   // Strangely the problem is dependent upon the compiler
-   // settings - some generate the problem others do not.
-   cp4.first() = p3;
-   cp4.second() = p4;
-   BOOST_TEST(cp4.first() == p3);
-   BOOST_TEST(cp4.second() == p4);
-}
-//
-// supplimentary tests for case where first arg only is a reference type:
-//
-template <class T1, class T2>
-struct compressed_pair_reference1_tester
-{
-   // define the types we need:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   // define our test proc:
-   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
-};
-
-template <class T1, class T2>
-void compressed_pair_reference1_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
-{
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   // first param construct:
-   boost::compressed_pair<T1,T2> cp2(p1);
-   cp2.second() = p2;
-   BOOST_TEST(cp2.first() == p1);
-   BOOST_TEST(cp2.second() == p2);
-#endif
-}
-//
-// supplimentary tests for case where second arg only is a reference type:
-//
-template <class T1, class T2>
-struct compressed_pair_reference2_tester
-{
-   // define the types we need:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   // define our test proc:
-   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
-};
-
-template <class T1, class T2>
-void compressed_pair_reference2_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
-{
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   // second param construct:
-   boost::compressed_pair<T1,T2> cp3(p2);
-   cp3.first() = p1;
-   BOOST_TEST(cp3.second() == p2);
-   BOOST_TEST(cp3.first() == p1);
-#endif
-}
-
-//
-// tests for where one or the other parameter is an array:
-//
-template <class T1, class T2>
-struct compressed_pair_array1_tester
-{
-   // define the types we need:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   // define our test proc:
-   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
-};
-
-template <class T1, class T2>
-void compressed_pair_array1_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
-{
-  // default construct:
-   boost::compressed_pair<T1,T2> cp1;
-   // second param construct:
-   boost::compressed_pair<T1,T2> cp3(p2);
-   cp3.first()[0] = p1[0];
-   BOOST_TEST(cp3.second() == p2);
-   BOOST_TEST(cp3.first()[0] == p1[0]);
-   // check const members:
-   const boost::compressed_pair<T1,T2>& cpr1 = cp3;
-   BOOST_TEST(cpr1.first()[0] == p1[0]);
-   BOOST_TEST(cpr1.second() == p2);
-
-   BOOST_TEST(sizeof(T1) == sizeof(cp1.first()));
-}
-
-template <class T1, class T2>
-struct compressed_pair_array2_tester
-{
-   // define the types we need:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   // define our test proc:
-   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
-};
-
-template <class T1, class T2>
-void compressed_pair_array2_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
-{
-   // default construct:
-   boost::compressed_pair<T1,T2> cp1;
-   // first param construct:
-   boost::compressed_pair<T1,T2> cp2(p1);
-   cp2.second()[0] = p2[0];
-   BOOST_TEST(cp2.first() == p1);
-   BOOST_TEST(cp2.second()[0] == p2[0]);
-   // check const members:
-   const boost::compressed_pair<T1,T2>& cpr1 = cp2;
-   BOOST_TEST(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second()[0] == p2[0]);
-
-   BOOST_TEST(sizeof(T2) == sizeof(cp1.second()));
-}
-
-template <class T1, class T2>
-struct compressed_pair_array_tester
-{
-   // define the types we need:
-   typedef T1                                                 first_type;
-   typedef T2                                                 second_type;
-   typedef typename call_traits<first_type>::param_type       first_param_type;
-   typedef typename call_traits<second_type>::param_type      second_param_type;
-   // define our test proc:
-   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
-};
-
-template <class T1, class T2>
-void compressed_pair_array_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
-{
-   // default construct:
-   boost::compressed_pair<T1,T2> cp1;
-   cp1.first()[0] = p1[0];
-   cp1.second()[0] = p2[0];
-   BOOST_TEST(cp1.first()[0] == p1[0]);
-   BOOST_TEST(cp1.second()[0] == p2[0]);
-   // check const members:
-   const boost::compressed_pair<T1,T2>& cpr1 = cp1;
-   BOOST_TEST(cpr1.first()[0] == p1[0]);
-   BOOST_TEST(cpr1.second()[0] == p2[0]);
-
-   BOOST_TEST(sizeof(T1) == sizeof(cp1.first()));
-   BOOST_TEST(sizeof(T2) == sizeof(cp1.second()));
-}
-
-int main()
-{
-   // declare some variables to pass to the tester:
-   non_empty1 ne1(2);
-   non_empty1 ne2(3);
-   non_empty2 ne3(4);
-   non_empty2 ne4(5);
-   empty_POD_UDT  e1;
-   empty_UDT      e2;
-
-   // T1 != T2, both non-empty
-   compressed_pair_tester<non_empty1,non_empty2>::test(ne1, ne3, ne2, ne4);
-   // T1 != T2, T2 empty
-   compressed_pair_tester<non_empty1,empty_POD_UDT>::test(ne1, e1, ne2, e1);
-   // T1 != T2, T1 empty
-   compressed_pair_tester<empty_POD_UDT,non_empty2>::test(e1, ne3, e1, ne4);
-   // T1 != T2, both empty
-   compressed_pair_tester<empty_POD_UDT,empty_UDT>::test(e1, e2, e1, e2);
-   // T1 == T2, both non-empty
-   compressed_pair_tester<non_empty1,non_empty1>::test(ne1, ne1, ne2, ne2);
-   // T1 == T2, both empty
-   compressed_pair_tester<empty_UDT,empty_UDT>::test(e2, e2, e2, e2);
-
-
-   // test references:
-
-   // T1 != T2, both non-empty
-   compressed_pair_reference_tester<non_empty1&,non_empty2>::test(ne1, ne3, ne2, ne4);
-   compressed_pair_reference_tester<non_empty1,non_empty2&>::test(ne1, ne3, ne2, ne4);
-   compressed_pair_reference1_tester<non_empty1&,non_empty2>::test(ne1, ne3, ne2, ne4);
-   compressed_pair_reference2_tester<non_empty1,non_empty2&>::test(ne1, ne3, ne2, ne4);
-   // T1 != T2, T2 empty
-   compressed_pair_reference_tester<non_empty1&,empty_POD_UDT>::test(ne1, e1, ne2, e1);
-   compressed_pair_reference1_tester<non_empty1&,empty_POD_UDT>::test(ne1, e1, ne2, e1);
-   // T1 != T2, T1 empty
-   compressed_pair_reference_tester<empty_POD_UDT,non_empty2&>::test(e1, ne3, e1, ne4);
-   compressed_pair_reference2_tester<empty_POD_UDT,non_empty2&>::test(e1, ne3, e1, ne4);
-   // T1 == T2, both non-empty
-   compressed_pair_reference_tester<non_empty1&,non_empty1&>::test(ne1, ne1, ne2, ne2);
-
-   // tests arrays:
-   non_empty1 nea1[2];
-   non_empty1 nea2[2];
-   non_empty2 nea3[2];
-   non_empty2 nea4[2];
-   nea1[0] = non_empty1(5);
-   nea2[0] = non_empty1(6);
-   nea3[0] = non_empty2(7);
-   nea4[0] = non_empty2(8);
-   
-   // T1 != T2, both non-empty
-   compressed_pair_array1_tester<non_empty1[2],non_empty2>::test(nea1, ne3, nea2, ne4);
-   compressed_pair_array2_tester<non_empty1,non_empty2[2]>::test(ne1, nea3, ne2, nea4);
-   compressed_pair_array_tester<non_empty1[2],non_empty2[2]>::test(nea1, nea3, nea2, nea4);
-   // T1 != T2, T2 empty
-   compressed_pair_array1_tester<non_empty1[2],empty_POD_UDT>::test(nea1, e1, nea2, e1);
-   // T1 != T2, T1 empty
-   compressed_pair_array2_tester<empty_POD_UDT,non_empty2[2]>::test(e1, nea3, e1, nea4);
-   // T1 == T2, both non-empty
-   compressed_pair_array_tester<non_empty1[2],non_empty1[2]>::test(nea1, nea1, nea2, nea2);
-   return boost::report_errors();
-}

test/enable_if_LICENSE

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

test/enable_if_constructors.cpp

@@ -0,0 +1,60 @@
+//
+//    Copyright 2003 © The Trustees of Indiana University.
+//
+//    See the file enable_if_LICENSE for licensing conditions.
+//
+//    Authors: Jaakko Järvi (jajarvi at osl.iu.edu)
+//             Jeremiah Willcock (jewillco at osl.iu.edu)
+//             Andrew Lumsdaine (lums at osl.iu.edu)
+//
+
+#include <boost/test/minimal.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits.hpp>
+
+using boost::enable_if;
+using boost::disable_if;
+using boost::is_arithmetic;
+
+struct container {
+  bool my_value;
+
+  template <class T>
+  container(const T&, const typename enable_if<is_arithmetic<T>, T>::type * = 0):
+  my_value(true) {}
+
+  template <class T>
+  container(const T&, const typename disable_if<is_arithmetic<T>, T>::type * = 0):
+  my_value(false) {}
+};
+
+// example from Howard Hinnant (tests enable_if template members of a templated class)
+template <class charT>
+struct xstring
+{
+  template <class It>
+  xstring(It begin, It end, typename 
+	 disable_if<is_arithmetic<It> >::type* = 0)
+    : data(end-begin) {}
+  
+  int data;
+};
+
+
+int test_main(int, char*[])
+{
+ 
+  BOOST_CHECK(container(1).my_value);
+  BOOST_CHECK(container(1.0).my_value);
+
+  BOOST_CHECK(!container("1").my_value);  
+  BOOST_CHECK(!container(static_cast<void*>(0)).my_value);  
+
+  char sa[] = "123456";
+  BOOST_CHECK(xstring<char>(sa, sa+6).data == 6);
+
+
+  return 0;
+}
+

test/enable_if_dummy_arg_disambiguation.cpp

@@ -0,0 +1,44 @@
+//
+//    Copyright 2003 © The Trustees of Indiana University.
+//
+//    See the file enable_if_LICENSE for licensing conditions.
+//
+//    Authors: Jaakko Järvi (jajarvi at osl.iu.edu)
+//             Jeremiah Willcock (jewillco at osl.iu.edu)
+//             Andrew Lumsdaine (lums at osl.iu.edu)
+//
+
+#include <boost/test/minimal.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+
+using boost::enable_if;
+using boost::disable_if;
+using boost::is_arithmetic;
+
+template <int N> struct dummy {
+  dummy(int) {};
+};
+
+template<class T>
+typename enable_if<is_arithmetic<T>, bool>::type
+arithmetic_object(T t, dummy<0> = 0) { return true; }
+
+template<class T>
+typename disable_if<is_arithmetic<T>, bool>::type
+arithmetic_object(T t, dummy<1> = 0) { return false; }
+
+
+int test_main(int, char*[])
+{
+ 
+  BOOST_CHECK(arithmetic_object(1));
+  BOOST_CHECK(arithmetic_object(1.0));
+
+  BOOST_CHECK(!arithmetic_object("1"));  
+  BOOST_CHECK(!arithmetic_object(static_cast<void*>(0)));  
+
+  return 0;
+}
+