Phoenix Reloaded

[SVN r53348]

.travis.yml

@@ -1,206 +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
-      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: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-
-install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
-  - cd ..
-  - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/assert
-  - git submodule update --init libs/config
-  - git submodule update --init libs/core
-  - git submodule update --init libs/preprocessor
-  - git submodule update --init libs/static_assert
-  - git submodule update --init libs/throw_exception
-  - git submodule update --init libs/type_traits
-  - cp -r $TRAVIS_BUILD_DIR/* libs/utility
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - |-
-    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - ./b2 -j3 libs/utility/test toolset=$TOOLSET cxxstd=$CXXSTD
-
-notifications:
-  email:
-    on_success: always

CMakeLists.txt

@@ -0,0 +1,31 @@
+#----------------------------------------------------------------------------
+# This file was automatically generated from the original CMakeLists.txt file
+# Add a variable to hold the headers for the library
+set (lib_headers
+    assert.hpp
+    call_traits.hpp
+    checked_delete.hpp
+    compressed_pair.hpp
+    current_function.hpp
+    operators.hpp
+    throw_exception.hpp
+    utility.hpp
+    utility
+)
+
+# Add a library target to the build system
+boost_library_project(
+  utility
+  #  SRCDIRS 
+  TESTDIRS  test
+  HEADERS ${lib_headers}
+  #  DOCDIRS 
+  DESCRIPTION  "Various small utilities for C++ programming."
+  MODULARIZED 
+  AUTHORS  "David Abrahams <dave -at- boostpro.com>"
+           "Brad King"
+           "Douglas Gregor <doug.gregor -at- gmail.com>"
+  #  MAINTAINERS 
+)
+
+

OptionalPointee.html

@@ -57,7 +57,10 @@ aliasing.
   </TR>
   <TR>
     <TD VAlign=top>Validity Test</TD>
-    <TD VAlign=top>&nbsp;<tt>bool(t)</tt></TD>
+    <TD VAlign=top>&nbsp;<tt>t</tt><br>
+     &nbsp;<tt>t != 0</tt><br>
+     &nbsp;<tt>!!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>
@@ -65,7 +68,9 @@ aliasing.
   </TR>
   <TR>
     <TD VAlign=top>Invalidity Test</TD>
-    <TD VAlign=top>&nbsp;<tt>!t</tt></TD>
+    <TD VAlign=top>&nbsp;<tt>t == 0</tt><br>
+                   &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>
@@ -156,4 +161,4 @@ so direct usage of relational operators with the implied aliasing of shallow sem
 <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
 
 </BODY>
-</HTML>
+</HTML>

addressof_fn_test.cpp

@@ -0,0 +1,76 @@
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable: 4786)  // identifier truncated in debug info
+#pragma warning(disable: 4710)  // function not inlined
+#pragma warning(disable: 4711)  // function selected for automatic inline expansion
+#pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+//  addressof_fn_test.cpp: addressof( f )
+//
+//  Copyright (c) 2008, 2009 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/utility/addressof.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+
+void f0()
+{
+}
+
+void f1(int)
+{
+}
+
+void f2(int, int)
+{
+}
+
+void f3(int, int, int)
+{
+}
+
+void f4(int, int, int, int)
+{
+}
+
+void f5(int, int, int, int, int)
+{
+}
+
+void f6(int, int, int, int, int, int)
+{
+}
+
+void f7(int, int, int, int, int, int, int)
+{
+}
+
+void f8(int, int, int, int, int, int, int, int)
+{
+}
+
+void f9(int, int, int, int, int, int, int, int, int)
+{
+}
+
+int main()
+{
+    BOOST_TEST( boost::addressof( f0 ) == &f0 );
+    BOOST_TEST( boost::addressof( f1 ) == &f1 );
+    BOOST_TEST( boost::addressof( f2 ) == &f2 );
+    BOOST_TEST( boost::addressof( f3 ) == &f3 );
+    BOOST_TEST( boost::addressof( f4 ) == &f4 );
+    BOOST_TEST( boost::addressof( f5 ) == &f5 );
+    BOOST_TEST( boost::addressof( f6 ) == &f6 );
+    BOOST_TEST( boost::addressof( f7 ) == &f7 );
+    BOOST_TEST( boost::addressof( f8 ) == &f8 );
+    BOOST_TEST( boost::addressof( f9 ) == &f9 );
+
+    return boost::report_errors();
+}

addressof_test.cpp

@@ -0,0 +1,94 @@
+// Copyright (C) 2002 Brad King (brad.king@kitware.com) 
+//                    Douglas Gregor (gregod@cs.rpi.edu)
+//
+// 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
+
+
+#include <boost/utility/addressof.hpp>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(push, 3)
+#endif
+
+#include <iostream>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(pop)
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+
+template<class T> void scalar_test( T * = 0 )
+{
+    T* px = new T();
+
+    T& x = *px;
+    BOOST_TEST( boost::addressof(x) == px );
+
+    const T& cx = *px;
+    const T* pcx = boost::addressof(cx);
+    BOOST_TEST( pcx == px );
+
+    volatile T& vx = *px;
+    volatile T* pvx = boost::addressof(vx);
+    BOOST_TEST( pvx == px );
+
+    const volatile T& cvx = *px;
+    const volatile T* pcvx = boost::addressof(cvx);
+    BOOST_TEST( pcvx == px );
+
+    delete px;
+}
+
+template<class T> void array_test( T * = 0 )
+{
+    T nrg[3] = {1,2,3};
+    T (*pnrg)[3] = &nrg;
+    BOOST_TEST( boost::addressof(nrg) == pnrg );
+
+    T const cnrg[3] = {1,2,3};
+    T const (*pcnrg)[3] = &cnrg;
+    BOOST_TEST( boost::addressof(cnrg) == pcnrg );
+}
+
+struct addressable
+{
+    addressable( int = 0 )
+    {
+    }
+};
+
+struct useless_type {};
+
+class nonaddressable {
+public:
+
+    nonaddressable( int = 0 )
+    {
+    }
+
+    void dummy(); // Silence GCC warning: all member of class are private
+
+private:
+
+    useless_type operator&() const;
+};
+
+int main()
+{
+    scalar_test<char>();
+    scalar_test<int>();
+    scalar_test<addressable>();
+    scalar_test<nonaddressable>();
+
+    array_test<char>();
+    array_test<int>();
+    array_test<addressable>();
+    array_test<nonaddressable>();
+
+    return boost::report_errors();
+}

addressof_test2.cpp

@@ -0,0 +1,95 @@
+// Copyright (C) 2002 Brad King (brad.king@kitware.com) 
+//                    Douglas Gregor (gregod@cs.rpi.edu)
+//
+// Copyright 2009 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+
+#include <boost/utility/addressof.hpp>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(push, 3)
+#endif
+
+#include <iostream>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(pop)
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+
+template<class T> void scalar_test( T * = 0 )
+{
+    T* px = new T();
+
+    T& x = *px;
+    BOOST_TEST( boost::addressof(x) == px );
+
+    const T& cx = *px;
+    const T* pcx = boost::addressof(cx);
+    BOOST_TEST( pcx == px );
+
+    volatile T& vx = *px;
+    volatile T* pvx = boost::addressof(vx);
+    BOOST_TEST( pvx == px );
+
+    const volatile T& cvx = *px;
+    const volatile T* pcvx = boost::addressof(cvx);
+    BOOST_TEST( pcvx == px );
+
+    delete px;
+}
+
+template<class T> void array_test( T * = 0 )
+{
+    T nrg[3] = {1,2,3};
+    T (*pnrg)[3] = &nrg;
+    BOOST_TEST( boost::addressof(nrg) == pnrg );
+
+    T const cnrg[3] = {1,2,3};
+    T const (*pcnrg)[3] = &cnrg;
+    BOOST_TEST( boost::addressof(cnrg) == pcnrg );
+}
+
+class convertible {
+public:
+
+    convertible( int = 0 )
+    {
+    }
+
+    template<class U> operator U () const
+    {
+        return U();
+    }
+};
+
+class convertible2 {
+public:
+
+    convertible2( int = 0 )
+    {
+    }
+
+    operator convertible2* () const
+    {
+        return 0;
+    }
+};
+
+int main()
+{
+    scalar_test<convertible>();
+    scalar_test<convertible2>();
+
+    array_test<convertible>();
+    array_test<convertible2>();
+
+    return boost::report_errors();
+}

appveyor.yml

@@ -1,48 +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)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-14.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: 14,17
-
-install:
-  - 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 update --init tools/build
-  - git submodule update --init libs/assert
-  - git submodule update --init libs/config
-  - git submodule update --init libs/core
-  - git submodule update --init libs/preprocessor
-  - git submodule update --init libs/static_assert
-  - git submodule update --init libs/throw_exception
-  - git submodule update --init libs/type_traits
-  - 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%
-  - b2 -j3 libs/utility/test toolset=%TOOLSET% %CXXSTD%

assert.html

@@ -0,0 +1,61 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<html>
+	<head>
+		<title>Boost: assert.hpp documentation</title>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+	</head>
+	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
+		<table border="0" width="100%">
+			<tr>
+				<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
+				</td>
+				<td align="center">
+					<h1>assert.hpp</h1>
+				</td>
+			</tr>
+			<tr>
+				<td colspan="2" height="64">&nbsp;</td>
+			</tr>
+		</table>
+		<p>
+			The header <STRONG>&lt;boost/assert.hpp&gt;</STRONG> defines the macro <b>BOOST_ASSERT</b>, 
+			which is similar to the standard <STRONG>assert</STRONG> macro defined in <STRONG>&lt;cassert&gt;</STRONG>. 
+			The macro is intended to be used in Boost libraries.
+		</p>
+		<P>By default, <tt>BOOST_ASSERT(expr)</tt> is equivalent to <tt>assert(expr)</tt>.</P>
+		<P>When the macro <STRONG>BOOST_DISABLE_ASSERTS</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+			is included, <tt>BOOST_ASSERT(expr)</tt> is defined as <tt>((void)0)</tt>. This 
+			allows users to selectively disable <STRONG>BOOST_ASSERT</STRONG> without 
+			affecting the definition of the standard <STRONG>assert</STRONG>.</P>
+		<P>When the macro <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+			is included, <tt>BOOST_ASSERT(expr)</tt> evaluates <b>expr</b> and, if the 
+			result is false, evaluates the expression</P>
+		<P><tt>::boost::assertion_failed(#expr, <a href="current_function.html">BOOST_CURRENT_FUNCTION</a>, 
+				__FILE__, __LINE__)</tt></P>
+		<P><STRONG>assertion_failed</STRONG> is declared in <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+			as</P>
+		<pre>
+namespace boost
+{
+
+void assertion_failed(char const * expr, char const * function, char const * file, long line);
+
+}
+</pre>
+		<p>but it is never defined. The user is expected to supply an appropriate 
+			definition.</p>
+		<P>As is the case with <STRONG>&lt;cassert&gt;</STRONG>, <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+			can be included multiple times in a single translation unit. <STRONG>BOOST_ASSERT</STRONG>
+			will be redefined each time as specified above.</P>
+		<p><STRONG>&lt;boost/assert.hpp&gt;</STRONG> also defines the macro <STRONG>BOOST_VERIFY</STRONG>. 
+			It has exactly the same behavior as <STRONG>BOOST_ASSERT</STRONG>, except that 
+			the expression that is passed to <STRONG>BOOST_VERIFY</STRONG> is always 
+			evaluated. This is useful when the asserted expression has desirable side 
+			effects; it can also help suppress warnings about unused variables when the 
+			only use of the variable is inside an assertion.</p>
+		<p><br>
+			<small>Copyright <20> 2002, 2007 by Peter Dimov. 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>.</small></p>
+	</body>
+</html>

assert_test.cpp

@@ -0,0 +1,109 @@
+//
+//  assert_test.cpp - a test for boost/assert.hpp
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/assert.hpp>
+
+void test_default()
+{
+    int x = 1;
+
+    BOOST_ASSERT(1);
+    BOOST_ASSERT(x);
+    BOOST_ASSERT(x == 1);
+    BOOST_ASSERT(&x);
+}
+
+#define BOOST_DISABLE_ASSERTS
+#include <boost/assert.hpp>
+
+void test_disabled()
+{
+    int x = 1;
+
+    BOOST_ASSERT(1);
+    BOOST_ASSERT(x);
+    BOOST_ASSERT(x == 1);
+    BOOST_ASSERT(&x);
+
+    BOOST_ASSERT(0);
+    BOOST_ASSERT(!x);
+    BOOST_ASSERT(x == 0);
+
+    void * p = 0;
+
+    BOOST_ASSERT(p);
+
+    // supress warnings
+    p = &x;
+    p = &p;
+}
+
+#undef BOOST_DISABLE_ASSERTS
+
+#define BOOST_ENABLE_ASSERT_HANDLER
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <cstdio>
+
+int handler_invoked = 0;
+
+void boost::assertion_failed(char const * expr, char const * function, char const * file, long line)
+{
+#if !defined(BOOST_NO_STDC_NAMESPACE)
+    using std::printf;
+#endif
+
+    printf("Expression: %s\nFunction: %s\nFile: %s\nLine: %ld\n\n", expr, function, file, line);
+    ++handler_invoked;
+}
+
+struct X
+{
+    static void f()
+    {
+        BOOST_ASSERT(0);
+    }
+};
+
+void test_handler()
+{
+    int x = 1;
+
+    BOOST_ASSERT(1);
+    BOOST_ASSERT(x);
+    BOOST_ASSERT(x == 1);
+    BOOST_ASSERT(&x);
+
+    BOOST_ASSERT(0);
+    BOOST_ASSERT(!x);
+    BOOST_ASSERT(x == 0);
+
+    void * p = 0;
+
+    BOOST_ASSERT(p);
+
+    X::f();
+
+    BOOST_ASSERT(handler_invoked == 5);
+    BOOST_TEST(handler_invoked == 5);
+}
+
+#undef BOOST_ENABLE_ASSERT_HANDLER
+
+int main()
+{
+    test_default();
+    test_disabled();
+    test_handler();
+
+    return boost::report_errors();
+}

base_from_member.html

@@ -0,0 +1,371 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
+<html>
+<head>
+<title>Boost: Base-from-Member Idiom Documentation</title>
+</head>
+
+<body bgcolor="white" link="blue" text="black" vlink="purple" alink="red"> 
+<h1><img src="../../boost.png" alt="C++ Boost" align="middle"
+width="277" height="86">Base-from-Member Idiom</h1>
+
+<p>The class template <code>boost::base_from_member</code> provides
+a workaround for a class that needs to initialize a base class with a
+member.  The class template is in <cite><a
+href="../../boost/utility/base_from_member.hpp">boost/utility/base_from_member.hpp</a></cite>
+which is included in <i><a href="../../boost/utility.hpp">boost/utility.hpp</a></i>.</p>
+
+<p>There is test/example code in <cite><a
+href="base_from_member_test.cpp">base_from_member_test.cpp</a></cite>.</p>
+
+<h2><a name="contents">Contents</a></h2>
+
+<ul>
+	<li><a href="#contents">Contents</a></li>
+	<li><a href="#rationale">Rationale</a></li>
+	<li><a href="#synopsis">Synopsis</a></li>
+	<li><a href="#usage">Usage</a></li>
+	<li><a href="#example">Example</a></li>
+	<li><a href="#credits">Credits</a>
+		<ul>
+			<li><a href="#contributors">Contributors</a></li>
+		</ul></li>
+</ul>
+
+<h2><a name="rationale">Rationale</a></h2>
+
+<p>When developing a class, sometimes a base class needs to be
+initialized with a member of the current class.  As a na&iuml;ve
+example:</p>
+
+<blockquote><pre>
+#include &lt;streambuf&gt;  <i>// for std::streambuf</i>
+#include &lt;ostream&gt;    <i>// for std::ostream</i>
+
+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( &amp;buf )
+        {}
+    //...
+};
+</pre></blockquote>
+
+<p>This is undefined because C++'s initialization order mandates that
+the base class is initialized before the member it uses.  <a
+href="http://www.moocat.org">R. Samuel Klatchko</a> 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.</p>
+
+<p>A custom base class can be made for this idiom:</p>
+
+<blockquote><pre>
+#include &lt;streambuf&gt;  <i>// for std::streambuf</i>
+#include &lt;ostream&gt;    <i>// for std::ostream</i>
+
+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( &amp;sbuffer )
+        {}
+    //...
+};
+</pre></blockquote>
+
+<p>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.</p>
+
+<p>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.</p>
+
+<p>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.</p>
+
+<h2><a name="synopsis">Synopsis</a></h2>
+
+<blockquote><pre>
+#ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY
+#define BOOST_BASE_FROM_MEMBER_MAX_ARITY  10
+#endif
+
+template &lt; typename MemberType, int UniqueID = 0 &gt;
+class boost::base_from_member
+{
+protected:
+    MemberType  member;
+
+    base_from_member();
+
+    template&lt; typename T1 &gt;
+    explicit  base_from_member( T1 x1 );
+
+    template&lt; typename T1, typename T2 &gt;
+    base_from_member( T1 x1, T2 x2 );
+
+    //...
+
+    template&lt; typename T1, typename T2, typename T3, typename T4,
+     typename T5, typename T6, typename T7, typename T8, typename T9,
+     typename T10 &gt;
+    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7,
+     T8 x8, T9 x9, T10 x10 );
+};
+</pre></blockquote>
+
+<p>The class template has a first template parameter
+<var>MemberType</var> representing the type of the based-member.
+It has a last template parameter <var>UniqueID</var>, that is an
+<code>int</code>, 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 <var>member</var> that the derived class can use
+for later base classes (or itself).</p>
+
+<p>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.  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.</p>
+
+<p>The <var>BOOST_BASE_FROM_MEMBER_MAX_ARITY</var> 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.)</p>
+
+<h2><a name="usage">Usage</a></h2>
+
+<p>With the starting example, the <code>fdoutbuf</code> sub-object needs
+to be encapsulated in a base class that is inheirited before
+<code>std::ostream</code>.</p>
+
+<blockquote><pre>
+#include &lt;boost/utility/base_from_member.hpp&gt;
+
+#include &lt;streambuf&gt;  <i>// for std::streambuf</i>
+#include &lt;ostream&gt;    <i>// for std::ostream</i>
+
+class fdoutbuf
+    : public std::streambuf
+{
+public:
+    explicit fdoutbuf( int fd );
+    //...
+};
+
+class fdostream
+    : private boost::base_from_member&lt;fdoutbuf&gt;
+    , public std::ostream
+{
+    // Helper typedef's
+    typedef boost::base_from_member&lt;fdoutbuf&gt;  pbase_type;
+    typedef std::ostream                        base_type;
+
+public:
+    explicit fdostream( int fd )
+        : pbase_type( fd ), base_type( &amp;member )
+        {}
+    //...
+};
+</pre></blockquote>
+
+<p>The base-from-member idiom is an implementation detail, so it
+should not be visible to the clients (or any derived classes) of
+<code>fdostream</code>.  Due to the initialization order, the
+<code>fdoutbuf</code> sub-object will get initialized before the
+<code>std::ostream</code> sub-object does, making the former
+sub-object safe to use in the latter sub-object's construction.  Since the
+<code>fdoutbuf</code> sub-object of the final type is the only sub-object
+with the name &quot;member,&quot; that name can be used
+unqualified within the final class.</p>
+
+<h2><a name="example">Example</a></h2>
+
+<p>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.</p>
+
+<blockquote><pre>
+#include &lt;boost/utility/base_from_member.hpp&gt;
+
+#include &lt;cstddef&gt;  <i>// for NULL</i>
+
+struct an_int
+{
+    int  y;
+
+    an_int( float yf );
+};
+
+class switcher
+{
+public:
+    switcher();
+    switcher( double, int * );
+    //...
+};
+
+class flow_regulator
+{
+public:
+    flow_regulator( switcher &amp;, switcher &amp; );
+    //...
+};
+
+template &lt; unsigned Size &gt;
+class fan
+{
+public:
+    explicit fan( switcher );
+    //...
+};
+
+class system
+    : private boost::base_from_member&lt;an_int&gt;
+    , private boost::base_from_member&lt;switcher&gt;
+    , private boost::base_from_member&lt;switcher, 1&gt;
+    , private boost::base_from_member&lt;switcher, 2&gt;
+    , protected flow_regulator
+    , public fan&lt;6&gt;
+{
+    // Helper typedef's
+    typedef boost::base_from_member&lt;an_int&gt;       pbase0_type;
+    typedef boost::base_from_member&lt;switcher&gt;     pbase1_type;
+    typedef boost::base_from_member&lt;switcher, 1&gt;  pbase2_type;
+    typedef boost::base_from_member&lt;switcher, 2&gt;  pbase3_type;
+
+    typedef flow_regulator  base1_type;
+    typedef fan&lt;6&gt;          base2_type;
+
+public:
+    system( double x );
+    //...
+};
+
+system::system( double x )
+    : pbase0_type( 0.2 )
+    , pbase1_type()
+    , pbase2_type( -16, &amp;this-&gt;pbase0_type::member )
+    , pbase3_type( x, static_cast&lt;int *&gt;(NULL) )
+    , base1_type( pbase3_type::member, pbase1_type::member )
+    , base2_type( pbase2_type::member )
+{
+    //...
+}
+</pre></blockquote>
+
+<p>The final class has multiple sub-objects with the name
+&quot;member,&quot; so any use of that name needs qualification by
+a name of the appropriate base type.  (Using <code>typedef</code>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 <code>an_int boost::base_from_member&lt;an_int,
+0&gt; :: *</code>) instead of a pointer to the member (having a type of
+<code>an_int *</code>).  The new problem is fixed by qualifying the
+sub-object with &quot;<code>this-&gt;</code>,&quot; and is needed just
+for pointers, and not for references or values.</p>
+
+<p>There are some argument conversions in the initialization.  The
+constructor argument for <code>pbase0_type</code> is converted from
+<code>double</code> to <code>float</code>.  The first constructor
+argument for <code>pbase2_type</code> is converted from <code>int</code>
+to <code>double</code>.  The second constructor argument for
+<code>pbase3_type</code> is a special case of necessary conversion; all
+forms of the null-pointer literal in C++ 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 <code>switcher</code>'s constructor.</p>
+
+<h2><a name="credits">Credits</a></h2>
+
+<h3><a name="contributors">Contributors</a></h3>
+
+<dl>
+	<dt><a href="http://www.boost.org/people/ed_brey.htm">Ed Brey</a>
+	<dd>Suggested some interface changes.
+
+	<dt><a href="http://www.moocat.org">R. Samuel Klatchko</a> (<a
+	href="mailto:rsk@moocat.org">rsk@moocat.org</a>, <a
+	href="mailto:rsk@brightmail.com">rsk@brightmail.com</a>)
+	<dd>Invented the idiom of how to use a class member for initializing
+		a base class.
+
+	<dt><a href="http://www.boost.org/people/dietmar_kuehl.htm">Dietmar Kuehl</a>
+	<dd>Popularized the base-from-member idiom in his
+		<a href="http://www.informatik.uni-konstanz.de/~kuehl/c++/iostream/">IOStream
+		example classes</a>.
+
+	<dt>Jonathan Turkanis
+	<dd>Supplied an implementation of generating the constructor templates that
+		can be controlled and automated with macros.  The implementation uses
+		the <a href="../preprocessor/index.html">Preprocessor library</a>.
+
+	<dt><a href="http://www.boost.org/people/daryle_walker.html">Daryle Walker</a>
+	<dd>Started the library.  Contributed the test file <cite><a
+		href="base_from_member_test.cpp">base_from_member_test.cpp</a></cite>.
+</dl>
+
+<hr>
+
+<p>Revised: 28 August 2004</p>
+
+<p>Copyright 2001, 2003, 2004 Daryle Walker.  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 a copy at &lt;<a
+href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
+
+</body>
+</html>

base_from_member_test.cpp

@@ -10,14 +10,15 @@
 //  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/test/minimal.hpp>  // for BOOST_CHECK, main
 
 #include <boost/config.hpp>       // for BOOST_NO_MEMBER_TEMPLATES
+#include <boost/cstdlib.hpp>      // for boost::exit_success
 #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 <functional>  // for std::binary_function, std::less
 #include <iostream>    // for std::cout (std::ostream, std::endl indirectly)
 #include <set>         // for std::set
 #include <typeinfo>    // for std::type_info
@@ -45,6 +46,7 @@ template < typename T >
 
 // A custom comparison type is needed
 struct object_id_compare
+    : std::binary_function<object_id, object_id, bool>
 {
     bool  operator ()( object_id const &a, object_id const &b ) const;
 
@@ -171,13 +173,13 @@ object_registrar  obj_reg;
 
 // Main functionality
 int
-main()
+test_main( int , char * [] )
 {
-    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() );
+    BOOST_CHECK( obj_reg.db_.empty() );
+    BOOST_CHECK( obj_reg.defrauders_in_.empty() );
+    BOOST_CHECK( obj_reg.defrauders_out_.empty() );
+    BOOST_CHECK( obj_reg.overeager_.empty() );
+    BOOST_CHECK( obj_reg.overkilled_.empty() );
 
     // Make a separate block to examine pre- and post-effects
     {
@@ -185,20 +187,20 @@ main()
         using std::endl;
 
         bad_class  bc;
-        BOOST_TEST( obj_reg.db_.size() == 3 );
-        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
+        BOOST_CHECK( obj_reg.db_.size() == 3 );
+        BOOST_CHECK( 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 );
+        BOOST_CHECK( obj_reg.db_.size() == 6 );
+        BOOST_CHECK( 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_CHECK( obj_reg.db_.size() == 11 );
+        BOOST_CHECK( 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() );
+        BOOST_CHECK( obj_reg.defrauders_out_.empty() );
+        BOOST_CHECK( obj_reg.overeager_.empty() );
+        BOOST_CHECK( obj_reg.overkilled_.empty() );
 
         // Getting the addresses of the objects ensure
         // that they're used, and not optimized away.
@@ -207,13 +209,13 @@ main()
         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() );
+    BOOST_CHECK( obj_reg.db_.empty() );
+    BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
+    BOOST_CHECK( obj_reg.defrauders_out_.size() == 1 );
+    BOOST_CHECK( obj_reg.overeager_.empty() );
+    BOOST_CHECK( obj_reg.overkilled_.empty() );
 
-    return boost::report_errors();
+    return boost::exit_success;
 }
 
 
@@ -279,7 +281,7 @@ object_id_compare::operator ()
         }
         else
         {
-            return a.second->before( *b.second ) != 0;
+            return a.second->before( *b.second );
         }
     }
 }

binary_search_test.cpp

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

binary_test.cpp

@@ -6,15 +6,11 @@
     http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/test/minimal.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.
@@ -614,34 +610,34 @@ typedef char (&unsigned_long_int_id_type)[unsigned_long_int_id];
 unsigned_int_id_type      binary_type_checker( unsigned int );
 unsigned_long_int_id_type binary_type_checker( unsigned long int );
 
-int main()
+int test_main( int, char *[] )
 {
-  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_CHECK( is_ascending_from_0_array( unsigned_ints_1_bit ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_2_bits ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_3_bits ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_4_bits ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_5_bits ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_6_bits ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_7_bits ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_8_bits ) );
 
-  BOOST_TEST( std::equal( &random_unsigned_ints_hex[0]
+  BOOST_CHECK( 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 ) ) )
+  BOOST_CHECK(    sizeof( binary_type_checker( BOOST_BINARY_U( 110100 1010 ) ) )
                == unsigned_int_id
              );
 
-  BOOST_TEST(    sizeof( binary_type_checker( BOOST_BINARY_UL( 11110 ) ) )
+  BOOST_CHECK(    sizeof( binary_type_checker( BOOST_BINARY_UL( 11110 ) ) )
                == unsigned_long_int_id
              );
 
-  BOOST_TEST(    sizeof( binary_type_checker( BOOST_BINARY_LU( 10 0001 ) ) )
+  BOOST_CHECK(    sizeof( binary_type_checker( BOOST_BINARY_LU( 10 0001 ) ) )
                == unsigned_long_int_id
              );
 
-  return boost::report_errors();
+  return 0;
 }

call_traits_test.cpp

@@ -21,10 +21,6 @@
 #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&) {}
 
@@ -56,8 +52,7 @@ struct contained
    const_reference const_get()const { return v_; }
    // pass value:
    void call(param_type){}
-private:
-   contained& operator=(const contained&);
+
 };
 
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@@ -82,8 +77,6 @@ struct contained<T[N]>
    reference get() { return v_; }
    const_reference const_get()const { return v_; }
    void call(param_type){}
-private:
-   contained& operator=(const contained&);
 };
 #endif
 
@@ -204,16 +197,14 @@ struct comparible_UDT
    bool operator == (const comparible_UDT& v){ return v.i_ == i_; }
 };
 
-int main()
+int main(int argc, char *argv[ ])
 {
    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)
@@ -294,11 +285,7 @@ int main()
    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;
 }
 

checked_delete.html

@@ -1,15 +1,122 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
 <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><EFBFBD> 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>
+	<head>
+		<title>Boost: checked_delete.hpp documentation</title>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+	</head>
+	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
+		<table border="0" width="100%">
+			<tr>
+				<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
+				</td>
+				<td align="center">
+					<h1>checked_delete.hpp</h1>
+				</td>
+			</tr>
+			<tr>
+				<td colspan="2" height="64">&nbsp;</td>
+			</tr>
+		</table>
+		<p>
+			The header <STRONG>&lt;boost/checked_delete.hpp&gt;</STRONG> defines two 
+			function templates, <STRONG>checked_delete</STRONG> and <STRONG>checked_array_delete</STRONG>, 
+			and two class templates, <STRONG>checked_deleter</STRONG> and <STRONG>checked_array_deleter</STRONG>.
+		</p>
+		<P>The C++ Standard allows, in 5.3.5/5, pointers to incomplete class types to be 
+			deleted with a <EM>delete-expression</EM>. When the class has a non-trivial 
+			destructor, or a class-specific operator delete, the behavior is undefined. 
+			Some compilers issue a warning when an incomplete type is deleted, but 
+			unfortunately, not all do, and programmers sometimes ignore or disable 
+			warnings.</P>
+		<P>A particularly troublesome case is when a smart pointer's destructor, such as <STRONG>
+				boost::scoped_ptr&lt;T&gt;::~scoped_ptr</STRONG>, is instantiated with an 
+			incomplete type. This can often lead to silent, hard to track failures.</P>
+		<P>The supplied function and class templates can be used to prevent these problems, 
+			as they require a complete type, and cause a compilation error otherwise.</P>
+		<h3><a name="Synopsis">Synopsis</a></h3>
+		<pre>
+namespace boost
+{
+
+template&lt;class T&gt; void checked_delete(T * p);
+template&lt;class T&gt; void checked_array_delete(T * p);
+template&lt;class T&gt; struct checked_deleter;
+template&lt;class T&gt; struct checked_array_deleter;
+
+}
+</pre>
+		<h3>checked_delete</h3>
+		<h4><a name="checked_delete">template&lt;class T&gt; void checked_delete(T * p);</a></h4>
+		<blockquote>
+			<p>
+				<b>Requires:</b> <b>T</b> must be a complete type. The expression <tt>delete p</tt>
+				must be well-formed.
+			</p>
+			<p>
+				<b>Effects:</b> <tt>delete p;</tt>
+			</p>
+		</blockquote>
+		<h3>checked_array_delete</h3>
+		<h4><a name="checked_array_delete">template&lt;class T&gt; void checked_array_delete(T 
+				* p);</a></h4>
+		<blockquote>
+			<p>
+				<b>Requires:</b> <b>T</b> must be a complete type. The expression <tt>delete [] p</tt>
+				must be well-formed.
+			</p>
+			<p>
+				<b>Effects:</b> <tt>delete [] p;</tt>
+			</p>
+		</blockquote>
+		<h3>checked_deleter</h3>
+		<pre>
+template&lt;class T&gt; struct checked_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+    void operator()(T * p) const;
+};
+</pre>
+		<h4>void checked_deleter&lt;T&gt;::operator()(T * p) const;</h4>
+		<blockquote>
+			<p>
+				<b>Requires:</b> <b>T</b> must be a complete type. The expression <tt>delete p</tt>
+				must be well-formed.
+			</p>
+			<p>
+				<b>Effects:</b> <tt>delete p;</tt>
+			</p>
+		</blockquote>
+		<h3>checked_array_deleter</h3>
+		<pre>
+template&lt;class T&gt; struct checked_array_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+    void operator()(T * p) const;
+};
+</pre>
+		<h4>void checked_array_deleter&lt;T&gt;::operator()(T * p) const;</h4>
+		<blockquote>
+			<p>
+				<b>Requires:</b> <b>T</b> must be a complete type. The expression <tt>delete [] p</tt>
+				must be well-formed.
+			</p>
+			<p>
+				<b>Effects:</b> <tt>delete [] p;</tt>
+			</p>
+		</blockquote>
+		<h3><a name="Acknowledgements">Acknowledgements</a></h3>
+		<p>
+			The function templates <STRONG>checked_delete</STRONG> and <STRONG>checked_array_delete</STRONG>
+			were originally part of <STRONG>&lt;boost/utility.hpp&gt;</STRONG>, and the 
+			documentation acknowledged Beman Dawes, Dave Abrahams, Vladimir Prus, Rainer 
+			Deyke, John Maddock, and others as contributors.
+		</p>
+		<p>
+			<br>
+			<small>Copyright <20> 2002 by Peter Dimov. 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>.</small></p>
+	</body>
 </html>

checked_delete_test.cpp

@@ -0,0 +1,28 @@
+//  Boost checked_delete test program  ---------------------------------------//
+
+//  Copyright Beman Dawes 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 for documentation.
+
+//  Revision History
+//  21 May 01  Initial version (Beman Dawes)
+
+#include <boost/checked_delete.hpp>  // for checked_delete
+
+//  This program demonstrates compiler errors when trying to delete an
+//  incomplete type.
+
+namespace
+{
+    class Incomplete;
+}
+
+int main()
+{
+    Incomplete * p = 0;
+    boost::checked_delete(p);          // should cause compile time error
+    boost::checked_array_delete(p);    // should cause compile time error
+    return 0;
+}   // main

compressed_pair.htm

@@ -1,16 +1,76 @@
-
-<!--
-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>
+   <head>
+      <title>Header </title>
+      <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 5.0">
+      <boostcompressed_pair.hpp>
+   </head>
+   <body bgcolor="#ffffff" text="#000000" link="#0000ff" vlink="#800080">
+      <h2><img src="../../boost.png" width="276" height="86">Header &lt;<a href="../../boost/detail/compressed_pair.hpp">boost/compressed_pair.hpp</a>&gt;</h2>
+      <p>All of the contents of &lt;boost/compressed_pair.hpp&gt; are defined inside 
+         namespace boost.</p>
+      <p>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.</p>
+      <pre>template &lt;class T1, class T2&gt;
+class compressed_pair
+{
+public:
+	typedef T1                                                 first_type;
+	typedef T2                                                 second_type;
+	typedef typename call_traits&lt;first_type&gt;::param_type       first_param_type;
+	typedef typename call_traits&lt;second_type&gt;::param_type      second_param_type;
+	typedef typename call_traits&lt;first_type&gt;::reference        first_reference;
+	typedef typename call_traits&lt;second_type&gt;::reference       second_reference;
+	typedef typename call_traits&lt;first_type&gt;::const_reference  first_const_reference;
+	typedef typename call_traits&lt;second_type&gt;::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&amp; operator=(const compressed_pair&amp;);
+
+	first_reference       first();
+	first_const_reference first() const;
+
+	second_reference       second();
+	second_const_reference second() const;
+
+	void swap(compressed_pair&amp; y);
+};</pre>
+      <p>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.</p>
+      <P>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.</P>
+      <p>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.</p>
+      <p>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.</p>
+      <h3>Acknowledgements</h3>
+      <p>Based on contributions by Steve Cleary, Beman Dawes, Howard Hinnant and John 
+         Maddock.</p>
+      <p>Maintained by <a href="mailto:john@johnmaddock.co.uk">John Maddock</a>, the 
+         latest version of this file can be found at <a href="http://www.boost.org">www.boost.org</a>, 
+         and the boost discussion list at <a href="http://www.yahoogroups.com/list/boost">www.yahoogroups.com/list/boost</a>.</p>
+      <hr>
+      <p>Revised
+      <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->07 November 2007<!--webbot bot="Timestamp" endspan i-checksum="40338" --></p>
+      <p><EFBFBD> Copyright Beman Dawes, 2000.</p>
+<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>

compressed_pair_test.cpp

@@ -14,7 +14,7 @@
 #include <cassert>
 
 #include <boost/compressed_pair.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/test/test_tools.hpp>
 
 using namespace boost;
 
@@ -79,47 +79,47 @@ void compressed_pair_tester<T1, T2>::test(first_param_type p1, second_param_type
    // first param construct:
    boost::compressed_pair<T1,T2> cp2(p1);
    cp2.second() = p2;
-   BOOST_TEST(cp2.first() == p1);
-   BOOST_TEST(cp2.second() == p2);
+   BOOST_CHECK(cp2.first() == p1);
+   BOOST_CHECK(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);
+   BOOST_CHECK(cp3.second() == p2);
+   BOOST_CHECK(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_CHECK(cp4.first() == p1);
+   BOOST_CHECK(cp4.second() == p2);
    boost::compressed_pair<T1,T2> cp5(p3, p4);
-   BOOST_TEST(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
+   BOOST_CHECK(cp5.first() == p3);
+   BOOST_CHECK(cp5.second() == p4);
    // check const members:
    const boost::compressed_pair<T1,T2>& cpr1 = cp4;
-   BOOST_TEST(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second() == p2);
+   BOOST_CHECK(cpr1.first() == p1);
+   BOOST_CHECK(cpr1.second() == p2);
 
    // copy construct:
    boost::compressed_pair<T1,T2> cp6(cp4);
-   BOOST_TEST(cp6.first() == p1);
-   BOOST_TEST(cp6.second() == p2);
+   BOOST_CHECK(cp6.first() == p1);
+   BOOST_CHECK(cp6.second() == p2);
    // assignment:
    cp1 = cp4;
-   BOOST_TEST(cp1.first() == p1);
-   BOOST_TEST(cp1.second() == p2);
+   BOOST_CHECK(cp1.first() == p1);
+   BOOST_CHECK(cp1.second() == p2);
    cp1 = cp5;
-   BOOST_TEST(cp1.first() == p3);
-   BOOST_TEST(cp1.second() == p4);
+   BOOST_CHECK(cp1.first() == p3);
+   BOOST_CHECK(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);
+   BOOST_CHECK(cp4.first() == p3);
+   BOOST_CHECK(cp4.second() == p4);
+   BOOST_CHECK(cp5.first() == p1);
+   BOOST_CHECK(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);
+   BOOST_CHECK(cp4.first() == p1);
+   BOOST_CHECK(cp4.second() == p2);
+   BOOST_CHECK(cp5.first() == p3);
+   BOOST_CHECK(cp5.second() == p4);
 }
 
 //
@@ -148,20 +148,20 @@ void compressed_pair_reference_tester<T1, T2>::test(first_param_type p1, second_
 #endif
    // both param construct:
    boost::compressed_pair<T1,T2> cp4(p1, p2);
-   BOOST_TEST(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
+   BOOST_CHECK(cp4.first() == p1);
+   BOOST_CHECK(cp4.second() == p2);
    boost::compressed_pair<T1,T2> cp5(p3, p4);
-   BOOST_TEST(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
+   BOOST_CHECK(cp5.first() == p3);
+   BOOST_CHECK(cp5.second() == p4);
    // check const members:
    const boost::compressed_pair<T1,T2>& cpr1 = cp4;
-   BOOST_TEST(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second() == p2);
+   BOOST_CHECK(cpr1.first() == p1);
+   BOOST_CHECK(cpr1.second() == p2);
 
    // copy construct:
    boost::compressed_pair<T1,T2> cp6(cp4);
-   BOOST_TEST(cp6.first() == p1);
-   BOOST_TEST(cp6.second() == p2);
+   BOOST_CHECK(cp6.first() == p1);
+   BOOST_CHECK(cp6.second() == p2);
    // assignment:
    // VC6 bug:
    // When second() is an empty class, VC6 performs the
@@ -174,8 +174,8 @@ void compressed_pair_reference_tester<T1, T2>::test(first_param_type p1, second_
    // settings - some generate the problem others do not.
    cp4.first() = p3;
    cp4.second() = p4;
-   BOOST_TEST(cp4.first() == p3);
-   BOOST_TEST(cp4.second() == p4);
+   BOOST_CHECK(cp4.first() == p3);
+   BOOST_CHECK(cp4.second() == p4);
 }
 //
 // supplimentary tests for case where first arg only is a reference type:
@@ -199,8 +199,8 @@ void compressed_pair_reference1_tester<T1, T2>::test(first_param_type p1, second
    // first param construct:
    boost::compressed_pair<T1,T2> cp2(p1);
    cp2.second() = p2;
-   BOOST_TEST(cp2.first() == p1);
-   BOOST_TEST(cp2.second() == p2);
+   BOOST_CHECK(cp2.first() == p1);
+   BOOST_CHECK(cp2.second() == p2);
 #endif
 }
 //
@@ -225,8 +225,8 @@ void compressed_pair_reference2_tester<T1, T2>::test(first_param_type p1, second
    // second param construct:
    boost::compressed_pair<T1,T2> cp3(p2);
    cp3.first() = p1;
-   BOOST_TEST(cp3.second() == p2);
-   BOOST_TEST(cp3.first() == p1);
+   BOOST_CHECK(cp3.second() == p2);
+   BOOST_CHECK(cp3.first() == p1);
 #endif
 }
 
@@ -253,14 +253,14 @@ void compressed_pair_array1_tester<T1, T2>::test(first_param_type p1, second_par
    // 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]);
+   BOOST_CHECK(cp3.second() == p2);
+   BOOST_CHECK(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_CHECK(cpr1.first()[0] == p1[0]);
+   BOOST_CHECK(cpr1.second() == p2);
 
-   BOOST_TEST(sizeof(T1) == sizeof(cp1.first()));
+   BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
 }
 
 template <class T1, class T2>
@@ -283,14 +283,14 @@ void compressed_pair_array2_tester<T1, T2>::test(first_param_type p1, second_par
    // 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]);
+   BOOST_CHECK(cp2.first() == p1);
+   BOOST_CHECK(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_CHECK(cpr1.first() == p1);
+   BOOST_CHECK(cpr1.second()[0] == p2[0]);
 
-   BOOST_TEST(sizeof(T2) == sizeof(cp1.second()));
+   BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
 }
 
 template <class T1, class T2>
@@ -312,18 +312,18 @@ void compressed_pair_array_tester<T1, T2>::test(first_param_type p1, second_para
    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]);
+   BOOST_CHECK(cp1.first()[0] == p1[0]);
+   BOOST_CHECK(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_CHECK(cpr1.first()[0] == p1[0]);
+   BOOST_CHECK(cpr1.second()[0] == p2[0]);
 
-   BOOST_TEST(sizeof(T1) == sizeof(cp1.first()));
-   BOOST_TEST(sizeof(T2) == sizeof(cp1.second()));
+   BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
+   BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
 }
 
-int main()
+int test_main(int, char *[])
 {
    // declare some variables to pass to the tester:
    non_empty1 ne1(2);
@@ -383,5 +383,13 @@ int main()
    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();
+   return 0;
 }
+
+
+unsigned int expected_failures = 0;
+
+
+
+
+

current_function.html

@@ -0,0 +1,36 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<html>
+	<head>
+		<title>Boost: current_function.hpp documentation</title>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+	</head>
+	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
+		<table border="0" width="100%">
+			<tr>
+				<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
+				</td>
+				<td align="center">
+					<h1>current_function.hpp</h1>
+				</td>
+			</tr>
+			<tr>
+				<td colspan="2" height="64">&nbsp;</td>
+			</tr>
+		</table>
+		<p>
+			The header <STRONG>&lt;boost/current_function.hpp&gt;</STRONG> defines a single 
+			macro, <STRONG>BOOST_CURRENT_FUNCTION</STRONG>,<STRONG> </STRONG>similar to the 
+			C99 predefined identifier <STRONG>__func__</STRONG>.
+		</p>
+		<P><STRONG>BOOST_CURRENT_FUNCTION</STRONG> expands to a string literal containing 
+			the (fully qualified, if possible) name of the enclosing function. If there is 
+			no enclosing function, the behavior is undefined.</P>
+		<p>Some compilers do not provide a way to obtain the name of the current enclosing 
+			function. On such compilers, the string literal has an unspecified value.</p>
+		<p>
+			<br>
+			<small>Copyright <20> 2002 by Peter Dimov. 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>.</small></p>
+	</body>
+</html>

current_function_test.cpp

@@ -0,0 +1,40 @@
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable: 4786)  // identifier truncated in debug info
+#pragma warning(disable: 4710)  // function not inlined
+#pragma warning(disable: 4711)  // function selected for automatic inline expansion
+#pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+//
+//  current_function_test.cpp - a test for boost/current_function.hpp
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//
+// 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/current_function.hpp>
+#include <boost/config.hpp>
+#include <cstdio>
+
+void message(char const * file, long line, char const * func, char const * msg)
+{
+#if !defined(BOOST_NO_STDC_NAMESPACE)
+    using std::printf;
+#endif
+
+    printf("%s(%ld): %s in function '%s'\n", file, line, msg, func);
+}
+
+#define MESSAGE(msg) message(__FILE__, __LINE__, BOOST_CURRENT_FUNCTION, msg)
+
+int main()
+{
+    MESSAGE("assertion failed");
+
+    return 0;
+}

doc/Jamfile.v2

@@ -1,127 +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 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_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 [@../../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/string_ref.qbk

@@ -1,167 +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.53]
-* Introduced
-    
-
-[endsect]
-
-
-
-

enable_if.html

@@ -1,15 +1,389 @@
-<!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><EFBFBD> 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>
+<!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="Microsoft FrontPage 5.0">
+</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="../../boost.png" 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="../type_traits/index.html">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;int&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/>
+   <p>Copyright 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<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>
+<!--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>

enable_if/test/Jamfile.v2

@@ -0,0 +1,23 @@
+# Copyright David Abrahams 2003.
+# Distributed under the Boost Software License, Version 1.0. 
+# (See accompanying file LICENSE_1_0.txt or copy at 
+# http://www.boost.org/LICENSE_1_0.txt)
+
+# For more information, see http://www.boost.org/
+
+project
+    : requirements <library>/boost/test//boost_test_exec_monitor
+    ;
+
+test-suite utility/enable_if
+        :
+        [ run constructors.cpp ]
+        [ run dummy_arg_disambiguation.cpp ]
+        [ run lazy.cpp ]
+        [ run lazy_test.cpp ]
+        [ run member_templates.cpp ]
+        [ run namespace_disambiguation.cpp ]
+        [ run no_disambiguation.cpp ]
+        [ run partial_specializations.cpp ]
+    ;
+

enable_if/test/constructors.cpp

@@ -0,0 +1,62 @@
+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// 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)
+
+//    Authors: Jaakko Jarvi (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;
+}
+

enable_if/test/dummy_arg_disambiguation.cpp

@@ -0,0 +1,46 @@
+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// 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)
+
+//    Authors: Jaakko Jarvi (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;
+}
+

enable_if/test/lazy.cpp

@@ -0,0 +1,82 @@
+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// 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)
+
+//    Authors: Jaakko Jarvi (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_same.hpp>
+
+using boost::enable_if_c;
+using boost::lazy_enable_if_c;
+
+// This class provides a reduced example of a traits class for
+// computing the result of multiplying two types.  The member typedef
+// 'type' in this traits class defines the return type of this
+// operator.  The return type member is invalid unless both arguments
+// for mult_traits are values that mult_traits expects (ints in this
+// case).  This kind of situation may arise if a traits class only
+// makes sense for some set of types, not all C++ types.
+
+template <class T> struct is_int {
+  BOOST_STATIC_CONSTANT(bool, value = (boost::is_same<T, int>::value));
+};
+
+template <class T, class U>
+struct mult_traits {
+  typedef typename T::does_not_exist type;
+};
+
+template <>
+struct mult_traits<int, int> {
+  typedef int type;
+};
+
+
+// Next, a forwarding function mult() is defined.  It is enabled only
+// when both arguments are of type int.  The first version, using
+// non-lazy enable_if_c does not work.
+
+#if 0
+template <class T, class U>
+typename enable_if_c<
+  is_int<T>::value && is_int<U>::value,
+  typename mult_traits<T, U>::type
+>::type
+mult(const T& x, const U& y) {return x * y;}
+#endif
+
+// A correct version uses lazy_enable_if_c.
+// This template removes compiler errors from invalid code used as an
+// argument to enable_if_c.
+
+#if 1
+template <class T, class U>
+typename lazy_enable_if_c<
+  is_int<T>::value & is_int<U>::value,
+  mult_traits<T, U> 
+>::type
+mult(const T& x, const U& y) {return x * y;}
+#endif
+
+double mult(int i, double d) { return (double)i * d; }
+
+int test_main(int, char*[])
+{
+
+
+  BOOST_CHECK(mult(1, 2) == 2);
+
+  BOOST_CHECK(mult(1, 3.0) == 3.0);
+
+  return 0;
+}
+

enable_if/test/lazy_test.cpp

@@ -0,0 +1,100 @@
+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// 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)
+
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
+//             Jeremiah Willcock (jewillco at osl.iu.edu)
+//             Andrew Lumsdaine (lums at osl.iu.edu)
+
+// Testing all variations of lazy_enable_if.
+
+#include <boost/test/minimal.hpp>
+#include <boost/mpl/not.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+using boost::lazy_enable_if;
+using boost::lazy_disable_if;
+
+using boost::lazy_enable_if_c;
+using boost::lazy_disable_if_c;
+
+
+template <class T>
+struct is_int_or_double {
+  BOOST_STATIC_CONSTANT(bool, 
+    value = (boost::is_same<T, int>::value || 
+             boost::is_same<T, double>::value));
+};
+
+template <class T>
+struct some_traits {
+  typedef typename T::does_not_exist type;
+};
+
+template <>
+struct some_traits<int> {
+  typedef bool type;
+};
+
+template <>
+struct some_traits<double> {
+  typedef bool type;
+};
+
+template <class T>
+struct make_bool {
+  typedef bool type;
+};
+
+template <>
+struct make_bool<int> {};
+
+template <>
+struct make_bool<double> {};
+
+namespace A {
+
+  template<class T>
+  typename lazy_enable_if<is_int_or_double<T>, some_traits<T> >::type
+  foo(T t) { return true; }
+
+  template<class T>
+  typename lazy_enable_if_c<is_int_or_double<T>::value, some_traits<T> >::type
+  foo2(T t) { return true; }
+}
+
+namespace B {
+  template<class T>
+  typename lazy_disable_if<is_int_or_double<T>, make_bool<T> >::type
+  foo(T t) { return false; }
+
+  template<class T>
+  typename lazy_disable_if_c<is_int_or_double<T>::value, make_bool<T> >::type
+  foo2(T t) { return false; }
+}
+
+int test_main(int, char*[])
+{
+  using namespace A;
+  using namespace B;
+  BOOST_CHECK(foo(1));
+  BOOST_CHECK(foo(1.0));
+
+  BOOST_CHECK(!foo("1"));  
+  BOOST_CHECK(!foo(static_cast<void*>(0)));  
+
+  BOOST_CHECK(foo2(1));
+  BOOST_CHECK(foo2(1.0));
+
+  BOOST_CHECK(!foo2("1"));  
+  BOOST_CHECK(!foo2(static_cast<void*>(0)));  
+
+  return 0;
+}
+

enable_if/test/member_templates.cpp

@@ -0,0 +1,43 @@
+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// 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)
+
+//    Authors: Jaakko Jarvi (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;
+
+struct container {
+  template <class T>
+  typename enable_if<is_arithmetic<T>, bool>::type
+  arithmetic_object(const T&, const int* /* disambiguate */ = 0) {return true;}
+
+  template <class T>
+  typename disable_if<is_arithmetic<T>, bool>::type
+  arithmetic_object(const T&) {return false;}
+};
+
+int test_main(int, char*[])
+{
+ 
+  BOOST_CHECK(container().arithmetic_object(1));
+  BOOST_CHECK(container().arithmetic_object(1.0));
+
+  BOOST_CHECK(!container().arithmetic_object("1"));  
+  BOOST_CHECK(!container().arithmetic_object(static_cast<void*>(0)));  
+
+  return 0;
+}
+

enable_if/test/namespace_disambiguation.cpp

@@ -0,0 +1,47 @@
+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// 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)
+
+//    Authors: Jaakko Jarvi (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/mpl/not.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+
+using boost::enable_if;
+using boost::mpl::not_;
+using boost::is_arithmetic;
+
+namespace A {
+  template<class T>
+  typename enable_if<is_arithmetic<T>, bool>::type
+  arithmetic_object(T t) { return true; }
+}
+
+namespace B {
+  template<class T>
+  typename enable_if<not_<is_arithmetic<T> >, bool>::type
+  arithmetic_object(T t) { return false; }
+}
+
+int test_main(int, char*[])
+{
+  using namespace A;
+  using namespace B;
+  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;
+}
+

enable_if/test/no_disambiguation.cpp

@@ -0,0 +1,43 @@
+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// 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)
+
+//    Authors: Jaakko Jarvi (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/mpl/not.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+
+using boost::mpl::not_;
+using boost::enable_if;
+using boost::is_arithmetic;
+
+template<class T>
+typename enable_if<is_arithmetic<T>, bool>::type
+arithmetic_object(T t) { return true; }
+
+template<class T>
+typename enable_if<not_<is_arithmetic<T> >, bool>::type
+arithmetic_object(T t) { 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;
+}
+

enable_if/test/partial_specializations.cpp

@@ -0,0 +1,67 @@
+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// 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)
+
+//    Authors: Jaakko Jarvi (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_c;
+using boost::disable_if_c;
+using boost::enable_if;
+using boost::disable_if;
+using boost::is_arithmetic;
+
+template <class T, class Enable = void>
+struct tester;
+
+template <class T>
+struct tester<T, typename enable_if_c<is_arithmetic<T>::value>::type> {
+  BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <class T>
+struct tester<T, typename disable_if_c<is_arithmetic<T>::value>::type> {
+  BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T, class Enable = void>
+struct tester2;
+
+template <class T>
+struct tester2<T, typename enable_if<is_arithmetic<T> >::type> {
+  BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <class T>
+struct tester2<T, typename disable_if<is_arithmetic<T> >::type> {
+  BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+int test_main(int, char*[])
+{
+ 
+  BOOST_CHECK(tester<int>::value);
+  BOOST_CHECK(tester<double>::value);
+
+  BOOST_CHECK(!tester<char*>::value);
+  BOOST_CHECK(!tester<void*>::value);
+
+  BOOST_CHECK(tester2<int>::value);
+  BOOST_CHECK(tester2<double>::value);
+
+  BOOST_CHECK(!tester2<char*>::value);
+  BOOST_CHECK(!tester2<void*>::value);
+
+  return 0;
+}
+

generator_iterator.htm

@@ -0,0 +1,163 @@
+<!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>Generator Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+  <img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle"
+  width="277" height="86">
+
+  <h1>Generator Iterator Adaptor</h1>
+
+  <p>Defined in header <a href=
+  "../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a></p>
+
+  <p>The generator iterator adaptor makes it easier to create custom input
+  iterators from 0-ary functions and function objects. The adaptor takes a
+  <a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a> and
+  creates a model of <a href=
+  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>. Each
+  increment retrieves an item from the generator and makes it available to be
+  retrieved by dereferencing. The motivation for this iterator is that some
+  concepts can be more naturally expressed as a generator, while most STL
+  algorithms expect an iterator. An example is the <a href=
+  "../random/index.html">Random Number</a> library.</p>
+
+  <h2>Synopsis</h2>
+
+  <blockquote>
+    <pre>
+namespace boost {
+  template &lt;class Generator&gt;
+  class generator_iterator_policies;
+
+  template &lt;class Generator&gt;
+  class generator_iterator_generator;
+
+  template &lt;class Generator&gt;
+  typename generator_iterator_generator&lt;Generator&gt;::type
+  make_generator_iterator(Generator &amp; gen);
+}
+</pre>
+  </blockquote>
+  <hr>
+
+  <h2>The Generator Iterator Generator Class</h2>
+
+  <p>The class generator_iterator_generator is a helper class whose purpose
+  is to construct a generator iterator type. The template parameter for this
+  class is the Generator function object type that is being wrapped. The
+  generator iterator adaptor only holds a reference (or pointer) to the
+  function object, therefore the function object must outlive the generator
+  iterator adaptor constructed from it.</p>
+  <pre>
+template &lt;class Generator&gt;
+class generator_iterator_generator
+{
+public:
+  typedef <i>unspecified</i> type; // the resulting generator iterator type 
+}
+</pre>
+
+  <h3>Template Parameters</h3>
+
+  <table border summary="">
+    <tr>
+      <th>Parameter</th>
+
+      <th>Description</th>
+    </tr>
+
+    <tr>
+      <td><tt><a href=
+      "http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt></td>
+
+      <td>The generator (0-ary function object) type being wrapped. The
+      return type of the function must be defined as
+      <tt>Generator::result_type</tt>. The function object must be a model of
+      <a href=
+      "http://www.sgi.com/tech/stl/Generator.html">Generator</a>.</td>
+    </tr>
+  </table>
+
+  <h3>Concept Model</h3>
+
+  <p>The generator iterator class is a model of <a href=
+  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.</p>
+
+  <h3>Members</h3>
+
+  <p>The generator iterator implements the member functions and operators
+  required of the <a href=
+  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
+  concept.<br></p>
+  <hr>
+
+  <h2><a name="make_generator_iterator" id="make_generator_iterator">The
+  Generator Iterator Object Generator</a></h2>
+
+  <p>The <tt>make_generator_iterator()</tt> function provides a convenient
+  way to create generator iterator objects. The function saves the user the
+  trouble of explicitly writing out the iterator types.</p>
+
+  <blockquote>
+    <pre>
+template &lt;class Generator&gt;
+typename generator_iterator_generator&lt;Generator&gt;::type
+make_generator_iterator(Generator &amp; gen);
+</pre>
+  </blockquote>
+  <hr>
+
+  <h3>Example</h3>
+
+  <p>The following program shows how <code>generator_iterator</code>
+  transforms a generator into an input iterator.</p>
+
+  <blockquote>
+    <pre>
+#include &lt;iostream&gt;
+#include &lt;boost/generator_iterator.hpp&gt;
+
+class my_generator
+{
+public:
+  typedef int result_type;
+  my_generator() : state(0) { }
+  int operator()() { return ++state; }
+private:
+  int state;
+};
+
+int main()
+{
+  my_generator gen;
+  boost::generator_iterator_generator&lt;my_generator&gt;::type it = boost::make_generator_iterator(gen);
+  for(int i = 0; i &lt; 10; ++i, ++it)
+    std::cout &lt;&lt; *it &lt;&lt; std::endl;
+}
+</pre>
+  </blockquote>
+  <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>
+
+  <p><i>Copyright &copy; 2001 <a href=
+  "http://www.boost.org/people/jens_maurer.htm">Jens Maurer</a></i></p>
+
+  <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>

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><EFBFBD> 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

@@ -46,7 +46,7 @@ HREF="../../boost/utility/typed_in_place_factory.hpp">boost/utility/typed_in_pla
 <p>Suppose we have a class</p>
 <pre>struct X
 {
-  X ( int, std::string ) ;
+  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

include/boost/assert.hpp

@@ -0,0 +1,50 @@
+//
+//  boost/assert.hpp - BOOST_ASSERT(expr)
+//
+//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2007 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)
+//
+//  Note: There are no include guards. This is intentional.
+//
+//  See http://www.boost.org/libs/utility/assert.html for documentation.
+//
+
+#undef BOOST_ASSERT
+
+#if defined(BOOST_DISABLE_ASSERTS)
+
+# define BOOST_ASSERT(expr) ((void)0)
+
+#elif defined(BOOST_ENABLE_ASSERT_HANDLER)
+
+#include <boost/current_function.hpp>
+
+namespace boost
+{
+
+void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
+
+} // namespace boost
+
+#define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+
+#else
+# include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
+# define BOOST_ASSERT(expr) assert(expr)
+#endif
+
+#undef BOOST_VERIFY
+
+#if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) )
+
+# define BOOST_VERIFY(expr) ((void)(expr))
+
+#else
+
+# define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
+
+#endif

include/boost/call_traits.hpp

@@ -5,7 +5,7 @@
 //
 //  See http://www.boost.org/libs/utility for most recent version including documentation.
 
-//  See boost/detail/call_traits.hpp
+//  See boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp
 //  for full copyright notices.
 
 #ifndef BOOST_CALL_TRAITS_HPP
@@ -15,6 +15,10 @@
 #include <boost/config.hpp>
 #endif
 
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#include <boost/detail/ob_call_traits.hpp>
+#else
 #include <boost/detail/call_traits.hpp>
+#endif
 
 #endif // BOOST_CALL_TRAITS_HPP

include/boost/checked_delete.hpp

@@ -0,0 +1,69 @@
+#ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
+#define BOOST_CHECKED_DELETE_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/checked_delete.hpp
+//
+//  Copyright (c) 2002, 2003 Peter Dimov
+//  Copyright (c) 2003 Daniel Frey
+//  Copyright (c) 2003 Howard Hinnant
+//
+//  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/checked_delete.html for documentation.
+//
+
+namespace boost
+{
+
+// verify that types are complete for increased safety
+
+template<class T> inline void checked_delete(T * x)
+{
+    // intentionally complex - simplification causes regressions
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete x;
+}
+
+template<class T> inline void checked_array_delete(T * x)
+{
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete [] x;
+}
+
+template<class T> struct checked_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const
+    {
+        // boost:: disables ADL
+        boost::checked_delete(x);
+    }
+};
+
+template<class T> struct checked_array_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const
+    {
+        boost::checked_array_delete(x);
+    }
+};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED

include/boost/compressed_pair.hpp

@@ -5,7 +5,7 @@
 //
 //  See http://www.boost.org/libs/utility for most recent version including documentation.
 
-//  See boost/detail/compressed_pair.hpp
+//  See boost/detail/compressed_pair.hpp and boost/detail/ob_compressed_pair.hpp
 //  for full copyright notices.
 
 #ifndef BOOST_COMPRESSED_PAIR_HPP
@@ -15,6 +15,10 @@
 #include <boost/config.hpp>
 #endif
 
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#include <boost/detail/ob_compressed_pair.hpp>
+#else
 #include <boost/detail/compressed_pair.hpp>
+#endif
 
 #endif // BOOST_COMPRESSED_PAIR_HPP

include/boost/current_function.hpp

@@ -0,0 +1,67 @@
+#ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
+#define BOOST_CURRENT_FUNCTION_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/current_function.hpp - BOOST_CURRENT_FUNCTION
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//
+// 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)
+//
+//  http://www.boost.org/libs/utility/current_function.html
+//
+
+namespace boost
+{
+
+namespace detail
+{
+
+inline void current_function_helper()
+{
+
+#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600))
+
+# define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
+
+#elif defined(__DMC__) && (__DMC__ >= 0x810)
+
+# define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
+
+#elif defined(__FUNCSIG__)
+
+# define BOOST_CURRENT_FUNCTION __FUNCSIG__
+
+#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || (defined(__IBMCPP__) && (__IBMCPP__ >= 500))
+
+# define BOOST_CURRENT_FUNCTION __FUNCTION__
+
+#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550)
+
+# define BOOST_CURRENT_FUNCTION __FUNC__
+
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
+
+# define BOOST_CURRENT_FUNCTION __func__
+
+#else
+
+# define BOOST_CURRENT_FUNCTION "(unknown)"
+
+#endif
+
+}
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED

include/boost/detail/call_traits.hpp

@@ -24,7 +24,6 @@
 #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>
 
@@ -44,26 +43,20 @@ struct ct_imp2<T, true>
    typedef const T param_type;
 };
 
-template <typename T, bool isp, bool b1, bool b2>
+template <typename T, bool isp, bool b1>
 struct ct_imp
 {
    typedef const T& param_type;
 };
 
-template <typename T, bool isp, bool b2>
-struct ct_imp<T, isp, true, b2>
+template <typename T, bool isp>
+struct ct_imp<T, isp, true>
 {
    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>
+template <typename T, bool b1>
+struct ct_imp<T, true, b1>
 {
    typedef const T param_type;
 };
@@ -86,8 +79,7 @@ public:
    typedef typename boost::detail::ct_imp<
       T,
       ::boost::is_pointer<T>::value,
-      ::boost::is_arithmetic<T>::value,
-      ::boost::is_enum<T>::value
+      ::boost::is_arithmetic<T>::value
    >::param_type param_type;
 };
 

include/boost/detail/compressed_pair.hpp

@@ -6,7 +6,7 @@
 //  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)
+// (see libs/utility/compressed_pair.htm)
 //
 // JM changes 25 Jan 2004:
 // For the case where T1 == T2 and both are empty, then first() and second()

include/boost/detail/ob_call_traits.hpp

@@ -0,0 +1,168 @@
+//  (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.
+//
+//  Crippled version for crippled compilers:
+//  see libs/utility/call_traits.htm
+//
+
+/* Release notes:
+   01st October 2000:
+      Fixed call_traits on VC6, using "poor man's partial specialisation",
+      using ideas taken from "Generative programming" by Krzysztof Czarnecki 
+      & Ulrich Eisenecker.
+*/
+
+#ifndef BOOST_OB_CALL_TRAITS_HPP
+#define BOOST_OB_CALL_TRAITS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#include <boost/config.hpp>
+#endif
+
+#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
+#include <boost/type_traits/arithmetic_traits.hpp>
+#endif
+#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP
+#include <boost/type_traits/composite_traits.hpp>
+#endif
+
+namespace boost{
+
+#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
+//
+// use member templates to emulate
+// partial specialisation:
+//
+namespace detail{
+
+template <class T>
+struct standard_call_traits
+{
+   typedef T value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef const T& param_type;
+};
+template <class T>
+struct simple_call_traits
+{
+   typedef T value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef const T param_type;
+};
+template <class T>
+struct reference_call_traits
+{
+   typedef T value_type;
+   typedef T reference;
+   typedef T const_reference;
+   typedef T param_type;
+};
+
+template <bool pointer, bool arithmetic, bool reference>
+struct call_traits_chooser
+{
+   template <class T>
+   struct rebind
+   {
+      typedef standard_call_traits<T> type;
+   };
+};
+
+template <>
+struct call_traits_chooser<true, false, false>
+{
+   template <class T>
+   struct rebind
+   {
+      typedef simple_call_traits<T> type;
+   };
+};
+
+template <>
+struct call_traits_chooser<false, false, true>
+{
+   template <class T>
+   struct rebind
+   {
+      typedef reference_call_traits<T> type;
+   };
+};
+
+template <bool size_is_small> 
+struct call_traits_sizeof_chooser2
+{
+   template <class T>
+   struct small_rebind
+   {
+      typedef simple_call_traits<T> small_type;
+   };
+};
+
+template<> 
+struct call_traits_sizeof_chooser2<false>
+{
+   template <class T>
+   struct small_rebind
+   {
+      typedef standard_call_traits<T> small_type;
+   };
+};
+
+template <>
+struct call_traits_chooser<false, true, false>
+{
+   template <class T>
+   struct rebind
+   {
+      enum { sizeof_choice = (sizeof(T) <= sizeof(void*)) };
+      typedef call_traits_sizeof_chooser2<(sizeof(T) <= sizeof(void*))> chooser;
+      typedef typename chooser::template small_rebind<T> bound_type;
+      typedef typename bound_type::small_type type;
+   };
+};
+
+} // namespace detail
+template <typename T>
+struct call_traits
+{
+private:
+    typedef detail::call_traits_chooser<
+         ::boost::is_pointer<T>::value,
+         ::boost::is_arithmetic<T>::value, 
+         ::boost::is_reference<T>::value
+      > chooser;
+   typedef typename chooser::template rebind<T> bound_type;
+   typedef typename bound_type::type call_traits_type;
+public:
+   typedef typename call_traits_type::value_type       value_type;
+   typedef typename call_traits_type::reference        reference;
+   typedef typename call_traits_type::const_reference  const_reference;
+   typedef typename call_traits_type::param_type       param_type;
+};
+
+#else
+//
+// sorry call_traits is completely non-functional
+// blame your broken compiler:
+//
+
+template <typename T>
+struct call_traits
+{
+   typedef T value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef const T& param_type;
+};
+
+#endif // member templates
+
+}
+
+#endif // BOOST_OB_CALL_TRAITS_HPP

include/boost/detail/ob_compressed_pair.hpp

@@ -167,6 +167,17 @@ public:
    compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x)
       : T2(x.second()), _first(x.first()) {}
 
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
+  // Total weirdness. If the assignment to _first is moved after
+  // the call to the inherited operator=, then this breaks graph/test/graph.cpp
+  // by way of iterator_adaptor.
+  compressed_pair_1& operator=(const compressed_pair_1& x) {
+    _first = x._first;
+    T2::operator=(x);
+    return *this;
+  }
+#endif
+
    first_reference       first()       { return _first; }
    first_const_reference first() const { return _first; }
 

include/boost/exception.hpp

@@ -0,0 +1,19 @@
+//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+
+//Distributed under the Boost Software License, Version 1.0. (See accompanying
+//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef UUID_1D94A7C6054E11DB9804B622A1EF5492
+#define UUID_1D94A7C6054E11DB9804B622A1EF5492
+
+#include <boost/exception/diagnostic_information.hpp>
+#include <boost/exception/error_info.hpp>
+#include <boost/exception/exception.hpp>
+#include <boost/exception/get_error_info.hpp>
+#include <boost/exception/info.hpp>
+#include <boost/exception/info_tuple.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <boost/exception_ptr.hpp>
+#endif
+
+#endif

include/boost/generator_iterator.hpp

@@ -0,0 +1,80 @@
+// (C) Copyright Jens Maurer 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)
+//
+// Revision History:
+
+// 15 Nov 2001   Jens Maurer
+//      created.
+
+//  See http://www.boost.org/libs/utility/iterator_adaptors.htm for documentation.
+
+#ifndef BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
+#define BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
+
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/ref.hpp>
+
+namespace boost {
+
+template<class Generator>
+class generator_iterator
+  : public iterator_facade<
+        generator_iterator<Generator>
+      , typename Generator::result_type
+      , single_pass_traversal_tag
+      , typename Generator::result_type const&
+    >
+{
+    typedef iterator_facade<
+        generator_iterator<Generator>
+      , typename Generator::result_type
+      , single_pass_traversal_tag
+      , typename Generator::result_type const&
+    > super_t;
+    
+ public:
+    generator_iterator() {}
+    generator_iterator(Generator* g) : m_g(g), m_value((*m_g)()) {}
+
+    void increment()
+    {
+        m_value = (*m_g)();
+    }
+
+    const typename Generator::result_type&
+    dereference() const
+    {
+        return m_value;
+    }
+
+    bool equal(generator_iterator const& y) const
+    {
+        return this->m_g == y.m_g && this->m_value == y.m_value;
+    }
+
+ private:
+    Generator* m_g;
+    typename Generator::result_type m_value;
+};
+
+template<class Generator>
+struct generator_iterator_generator
+{
+  typedef generator_iterator<Generator> type;
+};
+
+template <class Generator>
+inline generator_iterator<Generator>
+make_generator_iterator(Generator & gen)
+{
+  typedef generator_iterator<Generator> result_t;
+  return result_t(&gen);
+}
+
+} // namespace boost
+
+
+#endif // BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
+

include/boost/next_prior.hpp

@@ -0,0 +1,51 @@
+//  Boost next_prior.hpp header file  ---------------------------------------//
+
+//  (C) Copyright Dave Abrahams and Daniel Walker 1999-2003. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/libs/utility for documentation.
+
+//  Revision History
+//  13 Dec 2003  Added next(x, n) and prior(x, n) (Daniel Walker)
+
+#ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
+#define BOOST_NEXT_PRIOR_HPP_INCLUDED
+
+#include <iterator>
+
+namespace boost {
+
+//  Helper functions for classes like bidirectional iterators not supporting
+//  operator+ and operator-
+//
+//  Usage:
+//    const std::list<T>::iterator p = get_some_iterator();
+//    const std::list<T>::iterator prev = boost::prior(p);
+//    const std::list<T>::iterator next = boost::next(prev, 2);
+
+//  Contributed by Dave Abrahams
+
+template <class T>
+inline T next(T x) { return ++x; }
+
+template <class T, class Distance>
+inline T next(T x, Distance n)
+{
+    std::advance(x, n);
+    return x;
+}
+
+template <class T>
+inline T prior(T x) { return --x; }
+
+template <class T, class Distance>
+inline T prior(T x, Distance n)
+{
+    std::advance(x, -n);
+    return x;
+}
+
+} // namespace boost
+
+#endif  // BOOST_NEXT_PRIOR_HPP_INCLUDED

include/boost/noncopyable.hpp

@@ -0,0 +1,36 @@
+//  Boost noncopyable.hpp header file  --------------------------------------//
+
+//  (C) Copyright Beman Dawes 1999-2003. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/libs/utility for documentation.
+
+#ifndef BOOST_NONCOPYABLE_HPP_INCLUDED
+#define BOOST_NONCOPYABLE_HPP_INCLUDED
+
+namespace boost {
+
+//  Private copy constructor and copy assignment ensure classes derived from
+//  class noncopyable cannot be copied.
+
+//  Contributed by Dave Abrahams
+
+namespace noncopyable_  // protection from unintended ADL
+{
+  class noncopyable
+  {
+   protected:
+      noncopyable() {}
+      ~noncopyable() {}
+   private:  // emphasize the following members are private
+      noncopyable( const noncopyable& );
+      const noncopyable& operator=( const noncopyable& );
+  };
+}
+
+typedef noncopyable_::noncopyable noncopyable;
+
+} // namespace boost
+
+#endif  // BOOST_NONCOPYABLE_HPP_INCLUDED

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/ref.hpp

@@ -0,0 +1,189 @@
+#ifndef BOOST_REF_HPP_INCLUDED
+#define BOOST_REF_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/detail/workaround.hpp>
+
+//
+//  ref.hpp - ref/cref, useful helper functions
+//
+//  Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//  Copyright (C) 2001, 2002 Peter Dimov
+//  Copyright (C) 2002 David Abrahams
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See http://www.boost.org/libs/bind/ref.html for documentation.
+//
+
+namespace boost
+{
+
+template<class T> class reference_wrapper
+{ 
+public:
+    typedef T type;
+
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1300 )
+
+    explicit reference_wrapper(T& t): t_(&t) {}
+
+#else
+
+    explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
+
+#endif
+
+    operator T& () const { return *t_; }
+
+    T& get() const { return *t_; }
+
+    T* get_pointer() const { return t_; }
+
+private:
+
+    T* t_;
+};
+
+# if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
+#  define BOOST_REF_CONST
+# else
+#  define BOOST_REF_CONST const
+# endif
+
+template<class T> inline reference_wrapper<T> BOOST_REF_CONST ref(T & t)
+{ 
+    return reference_wrapper<T>(t);
+}
+
+template<class T> inline reference_wrapper<T const> BOOST_REF_CONST cref(T const & t)
+{
+    return reference_wrapper<T const>(t);
+}
+
+# undef BOOST_REF_CONST
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+template<typename T>
+class is_reference_wrapper
+    : public mpl::false_
+{
+};
+
+template<typename T>
+class unwrap_reference
+{
+ public:
+    typedef T type;
+};
+
+#  define AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(X) \
+template<typename T> \
+class is_reference_wrapper< X > \
+    : public mpl::true_ \
+{ \
+}; \
+\
+template<typename T> \
+class unwrap_reference< X > \
+{ \
+ public: \
+    typedef T type; \
+}; \
+/**/
+
+AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T>)
+#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
+AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const)
+AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> volatile)
+AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const volatile)
+#endif
+
+#  undef AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF
+
+# else // no partial specialization
+
+} // namespace boost
+
+#include <boost/type.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+  typedef char (&yes_reference_wrapper_t)[1];
+  typedef char (&no_reference_wrapper_t)[2];
+      
+  no_reference_wrapper_t is_reference_wrapper_test(...);
+
+  template<typename T>
+  yes_reference_wrapper_t is_reference_wrapper_test(type< reference_wrapper<T> >);
+
+  template<bool wrapped>
+  struct reference_unwrapper
+  {
+      template <class T>
+      struct apply
+      {
+          typedef T type;
+      };
+  };
+
+  template<>
+  struct reference_unwrapper<true>
+  {
+      template <class T>
+      struct apply
+      {
+          typedef typename T::type type;
+      };
+  };
+}
+
+template<typename T>
+class is_reference_wrapper
+{
+ public:
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+             sizeof(detail::is_reference_wrapper_test(type<T>()))
+            == sizeof(detail::yes_reference_wrapper_t)));
+    
+    typedef ::boost::mpl::bool_<value> type;
+};
+
+template <typename T>
+class unwrap_reference
+    : public detail::reference_unwrapper<
+        is_reference_wrapper<T>::value
+      >::template apply<T>
+{};
+
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+template <class T> inline typename unwrap_reference<T>::type&
+unwrap_ref(T& t)
+{
+    return t;
+}
+
+template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
+{
+    return r.get_pointer();
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_REF_HPP_INCLUDED

include/boost/swap.hpp

@@ -0,0 +1,12 @@
+// Copyright (C) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_SWAP_HPP
+#define BOOST_SWAP_HPP
+
+#include "boost/utility/swap.hpp"
+
+#endif

include/boost/utility.hpp

@@ -9,16 +9,12 @@
 #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/addressof.hpp>
 #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>
+#include <boost/utility/enable_if.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/next_prior.hpp>
+#include <boost/noncopyable.hpp>
 
 #endif  // BOOST_UTILITY_HPP

include/boost/utility/addressof.hpp

@@ -0,0 +1,102 @@
+// Copyright (C) 2002 Brad King (brad.king@kitware.com) 
+//                    Douglas Gregor (gregod@cs.rpi.edu)
+//
+// Copyright (C) 2002, 2008 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+#ifndef BOOST_UTILITY_ADDRESSOF_HPP
+# define BOOST_UTILITY_ADDRESSOF_HPP
+
+# include <boost/config.hpp>
+# include <boost/detail/workaround.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template<class T> struct addr_impl_ref
+{
+    T & v_;
+
+    inline addr_impl_ref( T & v ): v_( v ) {}
+    inline operator T& () const { return v_; }
+
+private:
+    addr_impl_ref & operator=(const addr_impl_ref &);
+};
+
+template<class T> struct addressof_impl
+{
+    static inline T * f( T & v, long )
+    {
+        return reinterpret_cast<T*>(
+            &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+    }
+
+    static inline T * f( T * v, int )
+    {
+        return v;
+    }
+};
+
+} // namespace detail
+
+template<class T> T * addressof( T & v )
+{
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) )
+
+    return boost::detail::addressof_impl<T>::f( v, 0 );
+
+#else
+
+    return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
+
+#endif
+}
+
+#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) )
+
+namespace detail
+{
+
+template<class T> struct addressof_addp
+{
+    typedef T * type;
+};
+
+} // namespace detail
+
+template< class T, std::size_t N >
+typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] )
+{
+    return &t;
+}
+
+#endif
+
+// Borland doesn't like casting an array reference to a char reference
+// but these overloads work around the problem.
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template<typename T,std::size_t N>
+T (*addressof(T (&t)[N]))[N]
+{
+   return reinterpret_cast<T(*)[N]>(&t);
+}
+
+template<typename T,std::size_t N>
+const T (*addressof(const T (&t)[N]))[N]
+{
+   return reinterpret_cast<const T(*)[N]>(&t);
+}
+#endif
+
+} // namespace boost
+
+#endif // BOOST_UTILITY_ADDRESSOF_HPP

include/boost/utility/base_from_member.hpp

@@ -1,6 +1,6 @@
 //  boost utility/base_from_member.hpp header file  --------------------------//
 
-//  Copyright 2001, 2003, 2004, 2012 Daryle Walker.  Use, modification, and
+//  Copyright 2001, 2003, 2004 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>.)
@@ -10,15 +10,10 @@
 #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  ------------------------------//
@@ -47,70 +42,17 @@
 //         {}
 // 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) )                \
-        {}                                                    \
+#define BOOST_PRIVATE_CTR_DEF( z, n, data )                            \
+    template < BOOST_PP_ENUM_PARAMS(n, typename T) >                   \
+    explicit 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
@@ -126,39 +68,12 @@ 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_PP_REPEAT_FROM_TO( 1, 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
 

include/boost/utility/compare_pointees.hpp

@@ -4,7 +4,7 @@
 // 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.
+// See http://www.boost.org/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
@@ -33,12 +33,8 @@ bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
 }
 
 template<class OptionalPointee>
-struct equal_pointees_t
+struct equal_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
 {
-  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) ; }
 } ;
@@ -60,12 +56,8 @@ bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
 }
 
 template<class OptionalPointee>
-struct less_pointees_t
+struct less_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
 {
-  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) ; }
 } ;

include/boost/utility/detail/in_place_factory_prefix.hpp

@@ -5,7 +5,7 @@
 // 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.
+// See http://www.boost.org/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com

include/boost/utility/detail/in_place_factory_suffix.hpp

@@ -5,7 +5,7 @@
 // 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.
+// See http://www.boost.org/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com

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

@@ -5,16 +5,52 @@
 //  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
 
+#if defined(BOOST_HAS_DECLTYPE)
+
+// As of N2588, C++0x result_of only supports function call
+// expressions of the form f(x). This precludes support for member
+// function pointers, which are invoked with expressions of the form
+// o->*f(x). This implementation supports both.
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , detail::result_of_impl<
+            typename remove_cv<F>::type, 
+            typename remove_cv<F>::type(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
+          >
+        , detail::result_of_decltype_impl<
+              F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))
+          >
+      >::type
+{};
+
+namespace detail {
+
+# define BOOST_RESULT_OF_STATIC_MEMBERS(z, n, _) \
+     static T ## n t ## n; \
+  /**/
+
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+class result_of_decltype_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
+{
+  static F f;
+  BOOST_PP_REPEAT(BOOST_PP_ITERATION(), BOOST_RESULT_OF_STATIC_MEMBERS, _)
+public:
+  typedef decltype(f(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),t))) type;
+};
+
+} // namespace detail 
+
+#else // defined(BOOST_HAS_DECLTYPE)
+
 // 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
@@ -23,171 +59,56 @@
 #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<
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of<F(BOOST_RESULT_OF_ARGS)>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::result_of_impl<
+            typename remove_cv<F>::type, 
+            typename remove_cv<F>::type(BOOST_RESULT_OF_ARGS), 
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::result_of_impl<
             F,
-            F(BOOST_RESULT_OF_ARGS),
-            (boost::detail::result_of_has_result_type<F>::value)> >::type { };
+            F(BOOST_RESULT_OF_ARGS), 
+            (boost::detail::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
+#endif // defined(BOOST_HAS_DECLTYPE)
+
+#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>
+template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct 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>
+template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct 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::*)
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct 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::*)
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of_impl<R (T0::*)
                      (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                      const,
                  FArgs, false>
@@ -195,8 +116,9 @@ struct tr1_result_of_impl<R (T0::*)
   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::*)
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of_impl<R (T0::*)
                      (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                      volatile,
                  FArgs, false>
@@ -204,8 +126,9 @@ struct tr1_result_of_impl<R (T0::*)
   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::*)
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of_impl<R (T0::*)
                      (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                      const volatile,
                  FArgs, false>

include/boost/utility/enable_if.hpp

@@ -0,0 +1,119 @@
+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// 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)
+
+//    Authors: Jaakko Jarvi (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
+
+#include "boost/config.hpp"
+
+// Even the definition of enable_if causes problems on some compilers,
+// so it's macroed out for all compilers that do not support SFINAE
+
+#ifndef BOOST_NO_SFINAE
+
+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
+
+#else
+
+namespace boost {
+
+  namespace detail { typedef void enable_if_default_T; }
+
+  template <typename T>
+  struct enable_if_does_not_work_on_this_compiler;
+
+  template <bool B, class T = detail::enable_if_default_T>
+  struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <bool B, class T = detail::enable_if_default_T> 
+  struct disable_if_c : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <bool B, class T = detail::enable_if_default_T> 
+  struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <bool B, class T = detail::enable_if_default_T> 
+  struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <class Cond, class T = detail::enable_if_default_T> 
+  struct enable_if : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <class Cond, class T = detail::enable_if_default_T> 
+  struct disable_if : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <class Cond, class T = detail::enable_if_default_T> 
+  struct lazy_enable_if : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <class Cond, class T = detail::enable_if_default_T> 
+  struct lazy_disable_if : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+} // namespace boost
+
+#endif // BOOST_NO_SFINAE
+
+#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

@@ -5,7 +5,7 @@
 // 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.
+// See http://www.boost.org/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
@@ -48,13 +48,15 @@ public:
   {}
 
   template<class T>
-  void* apply(void* address) const
+  void* apply(void* address
+      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) const
   {
     return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
   }
 
   template<class T>
-  void* apply(void* address, std::size_t n) const
+  void* apply(void* address, std::size_t n
+      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) const
   {
     for(char* next = address = this->BOOST_NESTED_TEMPLATE apply<T>(address);
         !! --n;)

include/boost/utility/result_of.hpp

@@ -10,164 +10,34 @@
 #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/preprocessor/iteration/iterate.hpp> 
+#include <boost/preprocessor/punctuation/comma_if.hpp> 
+#include <boost/preprocessor/repetition/enum_params.hpp> 
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp> 
 #include <boost/detail/workaround.hpp>
-#include <boost/type_traits/is_class.hpp>
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/or.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
+#  define BOOST_RESULT_OF_NUM_ARGS 10
 #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)
+#if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 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
+BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
 
-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, typename FArgs, bool HasResultType> struct result_of_impl;
+template<typename F> struct result_of_decltype_impl;
 
 template<typename F>
 struct result_of_void_impl
@@ -190,27 +60,27 @@ struct result_of_void_impl<R (&)(void)>
 // 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> { };
+  : result_of_impl<typename remove_cv<F>::type, FArgs, false> { };
 
 template<typename F, typename FArgs>
-struct tr1_result_of_impl<F, FArgs, true>
+struct result_of_impl<F, FArgs, true>
 {
   typedef typename F::result_type type;
 };
 
 template<typename FArgs>
-struct is_function_with_no_args : false_type {};
+struct is_function_with_no_args : mpl::false_ {};
 
 template<typename F>
-struct is_function_with_no_args<F(void)> : true_type {};
+struct is_function_with_no_args<F(void)> : mpl::true_ {};
 
 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,
+struct result_of_impl<F, FArgs, false>
+  : mpl::if_<is_function_with_no_args<FArgs>,
              result_of_void_impl<F>,
              result_of_nested_result<F, FArgs> >::type
 {};
@@ -220,11 +90,6 @@ struct tr1_result_of_impl<F, FArgs, false>
 #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

include/boost/utility/string_ref.hpp

@@ -1,553 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2012-2015.
-
-   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/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 {
-            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 {
-            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;
-        }
-
-    namespace detail {
-
-        template<class charT, class traits>
-        inline void sr_insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
-            enum { chunk_size = 8 };
-            charT fill_chars[chunk_size];
-            std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill());
-            for (; n >= chunk_size && os.good(); n -= chunk_size)
-                os.write(fill_chars, static_cast< std::size_t >(chunk_size));
-            if (n > 0 && os.good())
-                os.write(fill_chars, n);
-            }
-
-        template<class charT, class traits>
-        void sr_insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
-            const std::size_t size = str.size();
-            const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size;
-            const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left;
-            if (!align_left) {
-                detail::sr_insert_fill_chars(os, alignment_size);
-                if (os.good())
-                    os.write(str.data(), size);
-                }
-            else {
-                os.write(str.data(), size);
-                if (os.good())
-                    detail::sr_insert_fill_chars(os, alignment_size);
-                }
-            }
-
-        } // namespace detail
-
-    // 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) {
-        if (os.good()) {
-            const std::size_t size = str.size();
-            const std::size_t w = static_cast< std::size_t >(os.width());
-            if (w <= size)
-                os.write(str.data(), size);
-            else
-                detail::sr_insert_aligned(os, str);
-            os.width(0);
-            }
-        return os;
-        }
-
-#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,705 +0,0 @@
-/*
-   Copyright (c) Marshall Clow 2012-2015.
-   Copyright (c) Beman Dawes 2015
-
-   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/string_view_fwd.hpp>
-#include <boost/throw_exception.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;
-        }
-
-    namespace detail {
-
-        template<class charT, class traits>
-        inline void sv_insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
-            enum { chunk_size = 8 };
-            charT fill_chars[chunk_size];
-            std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill());
-            for (; n >= chunk_size && os.good(); n -= chunk_size)
-                os.write(fill_chars, static_cast< std::size_t >(chunk_size));
-            if (n > 0 && os.good())
-                os.write(fill_chars, n);
-            }
-
-        template<class charT, class traits>
-        void sv_insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_view<charT,traits>& str) {
-            const std::size_t size = str.size();
-            const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size;
-            const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left;
-            if (!align_left) {
-                detail::sv_insert_fill_chars(os, alignment_size);
-                if (os.good())
-                    os.write(str.data(), size);
-                }
-            else {
-                os.write(str.data(), size);
-                if (os.good())
-                    detail::sv_insert_fill_chars(os, alignment_size);
-                }
-            }
-
-        } // namespace detail
-
-    // 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) {
-        if (os.good()) {
-            const std::size_t size = str.size();
-            const std::size_t w = static_cast< std::size_t >(os.width());
-            if (w <= size)
-                os.write(str.data(), size);
-            else
-                detail::sv_insert_aligned(os, str);
-            os.width(0);
-            }
-        return os;
-        }
-
-#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
-
-}
-
-#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/swap.hpp

@@ -0,0 +1,55 @@
+// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker
+//
+// 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
+
+
+#ifndef BOOST_UTILITY_SWAP_HPP
+#define BOOST_UTILITY_SWAP_HPP
+
+// Note: the implementation of this utility contains various workarounds:
+// - swap_impl is put outside the boost namespace, to avoid infinite
+// recursion (causing stack overflow) when swapping objects of a primitive
+// type.
+// - swap_impl has a using-directive, rather than a using-declaration,
+// because some compilers (including MSVC 7.1, Borland 5.9.3, and
+// Intel 8.1) don't do argument-dependent lookup when it has a
+// using-declaration instead.
+// - boost::swap has two template arguments, instead of one, to
+// avoid ambiguity when swapping objects of a Boost type that does
+// not have its own boost::swap overload.
+
+#include <algorithm> //for std::swap
+#include <cstddef> //for std::size_t
+
+namespace boost_swap_impl
+{
+  template<class T>
+  void swap_impl(T& left, T& right)
+  {
+    using namespace std;//use std::swap if argument dependent lookup fails
+    swap(left,right);
+  }
+
+  template<class T, std::size_t N>
+  void swap_impl(T (& left)[N], T (& right)[N])
+  {
+    for (std::size_t i = 0; i < N; ++i)
+    {
+      ::boost_swap_impl::swap_impl(left[i], right[i]);
+    }
+  }
+}
+
+namespace boost
+{
+  template<class T1, class T2>
+  void swap(T1& left, T2& right)
+  {
+    ::boost_swap_impl::swap_impl(left, right);
+  }
+}
+
+#endif

include/boost/utility/typed_in_place_factory.hpp

@@ -5,7 +5,7 @@
 // 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.
+// See http://www.boost.org/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com

include/boost/utility/value_init.hpp

@@ -9,8 +9,6 @@
 // 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
@@ -22,7 +20,6 @@
 // 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>
@@ -31,37 +28,10 @@
 #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
+class value_initialized
 {
   private :
     struct wrapper
@@ -70,20 +40,6 @@ class initialized
       typename
 #endif 
       remove_const<T>::type data;
-
-      BOOST_GPU_ENABLED
-      wrapper()
-      :
-      data()
-      {
-      }
-
-      BOOST_GPU_ENABLED
-      wrapper(T const & arg)
-      :
-      data(arg)
-      {
-      }
     };
 
     mutable
@@ -92,7 +48,6 @@ class initialized
 #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));
@@ -100,29 +55,30 @@ class initialized
 
   public :
 
-    BOOST_GPU_ENABLED
-    initialized()
+    value_initialized()
     {
-#if BOOST_DETAIL_VALUE_INIT_WORKAROUND
       std::memset(&x, 0, sizeof(x));
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#if _MSC_VER >= 1310
+// When using MSVC 7.1 or higher, the following placement new expression may trigger warning C4345:
+// "behavior change: an object of POD type constructed with an initializer of the form ()
+// will be default-initialized".  It is safe to ignore this warning when using value_initialized.
+#pragma warning(disable: 4345)
+#endif
 #endif
       new (wrapper_address()) wrapper();
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
     }
 
-    BOOST_GPU_ENABLED
-    initialized(initialized const & arg)
+    value_initialized(value_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)
+    value_initialized & operator=(value_initialized const & arg)
     {
       // Assignment is only allowed when T is non-const.
       BOOST_STATIC_ASSERT( ! is_const<T>::value );
@@ -130,129 +86,46 @@ class initialized
       return *this;
     }
 
-    BOOST_GPU_ENABLED
-    ~initialized()
+    ~value_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)
+    void swap(value_initialized & arg)
     {
       ::boost::swap( this->data(), arg.data() );
     }
 
-    BOOST_GPU_ENABLED
-    operator T const &() const
-    {
-      return wrapper_address()->data;
-    }
+    operator T const &() const { return this->data(); }
 
-    BOOST_GPU_ENABLED
-    operator T&()
-    {
-      return wrapper_address()->data;
-    }
+    operator T&() { return this->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) ;
@@ -263,9 +136,9 @@ class initialized_value_t
 {
   public :
     
-    template <class T> BOOST_GPU_ENABLED operator T() const
+    template <class T> operator T() const
     {
-      return initialized<T>().data();
+      return get( value_initialized<T>() );
     }
 };
 
@@ -274,8 +147,5 @@ initialized_value_t const initialized_value = {} ;
 
 } // namespace boost
 
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
 
 #endif

index.html

@@ -14,26 +14,20 @@
 		<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="assert.html">assert</a><br>
+				<a href="base_from_member.html">base_from_member</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="checked_delete.html">checked_delete</a><br>
+				<a href="compressed_pair.htm">compressed_pair</a><br>
+				<a href="current_function.html">current_function</a><br>
+				<a href="enable_if.html">enable_if</a><br>
+            <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
+            <a href="generator_iterator.htm">generator iterator adaptors</a><br>
 				<a href="operators.htm">operators</a><br>
-				<a href="utility.htm#result_of">result_of</a><br>
+				<a href="swap.html">swap</a><br>
 				<a href="throw_exception.html">throw_exception</a><br>
 				<a href="utility.htm">utility</a><br>
-            <a href="doc/html/string_ref.html">string_ref</a><br>
-            <a href="value_init.htm">value_init</a><br>
-         </p>
+                <a href="value_init.htm">value_init</a></p>
 		</blockquote>
 		<hr>
 		<p>&copy; Copyright Beman Dawes, 2001</p>

iterators_test.cpp

@@ -12,9 +12,11 @@
 //            library (Daryle Walker)
 //  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
 
-#include <boost/core/lightweight_test.hpp>
+#define  BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>  // for main
 
 #include <boost/config.hpp>     // for BOOST_STATIC_CONSTANT
+#include <boost/cstdlib.hpp>    // for boost::exit_success
 #include <boost/operators.hpp>  // for boost::random_access_iterator_helper
 
 #include <cstddef>    // for std::ptrdiff_t, std::size_t
@@ -124,7 +126,7 @@ typename test_opr<T, R, P>::iter_type const
 
 // Main testing function
 int
-main()
+test_main( int , char * [] )
 {
     using std::string;
 
@@ -134,7 +136,7 @@ main()
     test1_type::master_test( "non-const string" );
     test2_type::master_test( "const string" );
 
-    return boost::report_errors();
+    return boost::exit_success;
 }
 
 // Tests for all of the operators added by random_access_iterator_helper
@@ -172,7 +174,7 @@ test_opr<T, R, P>::post_increment_test
         oss << *i++ << ' ';
     }
 
-    BOOST_TEST( oss.str() == "apple orange pear peach grape plum ");
+    BOOST_CHECK( oss.str() == "apple orange pear peach grape plum ");
 }
 
 // Test post-decrement
@@ -191,7 +193,7 @@ test_opr<T, R, P>::post_decrement_test
         oss << *i << ' ';
     }
 
-    BOOST_TEST( oss.str() == "plum grape peach pear orange apple ");
+    BOOST_CHECK( oss.str() == "plum grape peach pear orange apple ");
 }
 
 // Test indirect structure referral
@@ -209,7 +211,7 @@ test_opr<T, R, P>::indirect_referral_test
         oss << i->size() << ' ';
     }
 
-    BOOST_TEST( oss.str() == "5 6 4 5 5 4 ");
+    BOOST_CHECK( oss.str() == "5 6 4 5 5 4 ");
 }
 
 // Test offset addition
@@ -228,7 +230,7 @@ test_opr<T, R, P>::offset_addition_test
         oss << *i << ' ';
     }
 
-    BOOST_TEST( oss.str() == "apple pear grape ");
+    BOOST_CHECK( oss.str() == "apple pear grape ");
 }
 
 // Test offset addition, in reverse order
@@ -247,7 +249,7 @@ test_opr<T, R, P>::reverse_offset_addition_test
         oss << *i << ' ';
     }
 
-    BOOST_TEST( oss.str() == "apple pear grape ");
+    BOOST_CHECK( oss.str() == "apple pear grape ");
 }
 
 // Test offset subtraction
@@ -270,7 +272,7 @@ test_opr<T, R, P>::offset_subtraction_test
         }
     }
 
-    BOOST_TEST( oss.str() == "grape pear apple ");
+    BOOST_CHECK( oss.str() == "grape pear apple ");
 }
 
 // Test comparisons
@@ -294,10 +296,10 @@ test_opr<T, R, P>::comparison_test
         {
             ptrdiff_t const  j_offset = j - fruit_begin;
 
-            BOOST_TEST( (i != j) == (i_offset != j_offset) );
-            BOOST_TEST( (i > j) == (i_offset > j_offset) );
-            BOOST_TEST( (i <= j) == (i_offset <= j_offset) );
-            BOOST_TEST( (i >= j) == (i_offset >= j_offset) );
+            BOOST_CHECK( (i != j) == (i_offset != j_offset) );
+            BOOST_CHECK( (i > j) == (i_offset > j_offset) );
+            BOOST_CHECK( (i <= j) == (i_offset <= j_offset) );
+            BOOST_CHECK( (i >= j) == (i_offset >= j_offset) );
         }
     }
     cout << std::endl;
@@ -318,5 +320,5 @@ test_opr<T, R, P>::indexing_test
         oss << fruit_begin[ k ] << ' ';
     }
 
-    BOOST_TEST( oss.str() == "apple orange pear peach grape plum ");
+    BOOST_CHECK( oss.str() == "apple orange pear peach grape plum ");
 }

meta/libraries.json

@@ -1,113 +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/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/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"
-        ]
-    }
-]

module.cmake

@@ -0,0 +1 @@
+boost_module(utility DEPENDS iterator exception detail )

noncopyable_test.cpp

@@ -0,0 +1,36 @@
+//  boost class noncopyable test program  ------------------------------------//
+
+//  (C) Copyright Beman Dawes 1999. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//   9 Jun 99  Add unnamed namespace
+//   2 Jun 99  Initial Version
+
+#include <boost/noncopyable.hpp>
+#include <iostream>
+
+//  This program demonstrates compiler errors resulting from trying to copy
+//  construct or copy assign a class object derived from class noncopyable.
+
+namespace
+{
+    class DontTreadOnMe : private boost::noncopyable
+    {
+    public:
+         DontTreadOnMe() { std::cout << "defanged!" << std::endl; }
+    };   // DontTreadOnMe
+
+}   // unnamed namespace
+
+int main()
+{
+    DontTreadOnMe object1;
+    DontTreadOnMe object2(object1);
+    object1 = object2;
+    return 0;
+}   // main
+  

numeric_traits_test.cpp

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

operators.htm

@@ -1667,8 +1667,8 @@ T operator+( T lhs, const T& rhs )
 
         <td><code>P operator-&gt;() const</code></td>
 
-        <td><code>*i</code>. Address of the returned value convertible
-        to <code>P</code>.</td>
+        <td><code>(&amp;*i)</code>. Return convertible to
+        <code>P</code>.</td>
       </tr>
 
       <tr>

operators_test.cpp

@@ -21,10 +21,13 @@
 //  12 Dec 99 Minor update, output confirmation message.
 //  15 Nov 99 Initial version
 
+#define BOOST_INCLUDE_MAIN
+
 #include <boost/config.hpp>                      // for BOOST_MSVC
+#include <boost/cstdlib.hpp>                     // for boost::exit_success
 #include <boost/operators.hpp>                   // for the tested items
-#include <boost/utility/detail/minstd_rand.hpp>  // for boost::detail::minstd_rand
-#include <boost/core/lightweight_test.hpp>
+#include <boost/random/linear_congruential.hpp>  // for boost::minstd_rand
+#include <boost/test/test_tools.hpp>             // for main
 
 #include <iostream>  // for std::cout (std::endl indirectly)
 
@@ -35,9 +38,11 @@ namespace
     int true_value(int x) { return x; }
     long true_value(long x) { return x; }
     signed char true_value(signed char x) { return x; }
+    short true_value(short x) { return x; }
     unsigned int true_value(unsigned int x) { return x; }
     unsigned long true_value(unsigned long x) { return x; }
     unsigned char true_value(unsigned char x) { return x; }
+    unsigned short true_value(unsigned short x) { return x; }
 
     // verify the minimum requirements for some operators
     class convertible_to_bool
@@ -308,17 +313,17 @@ namespace
     template <class X1, class Y1, class X2, class Y2>
     void sanity_check(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        BOOST_TEST( true_value(y1) == true_value(y2) );
-        BOOST_TEST( true_value(x1) == true_value(x2) );
+        BOOST_CHECK( true_value(y1) == true_value(y2) );
+        BOOST_CHECK( true_value(x1) == true_value(x2) );
     }
 
     template <class X1, class Y1, class X2, class Y2>
     void test_less_than_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        BOOST_TEST( static_cast<bool>(x1 < y1) == static_cast<bool>(x2 < y2) );
-        BOOST_TEST( static_cast<bool>(x1 <= y1) == static_cast<bool>(x2 <= y2) );
-        BOOST_TEST( static_cast<bool>(x1 >= y1) == static_cast<bool>(x2 >= y2) );
-        BOOST_TEST( static_cast<bool>(x1 > y1) == static_cast<bool>(x2 > y2) );
+        BOOST_CHECK( static_cast<bool>(x1 < y1) == static_cast<bool>(x2 < y2) );
+        BOOST_CHECK( static_cast<bool>(x1 <= y1) == static_cast<bool>(x2 <= y2) );
+        BOOST_CHECK( static_cast<bool>(x1 >= y1) == static_cast<bool>(x2 >= y2) );
+        BOOST_CHECK( static_cast<bool>(x1 > y1) == static_cast<bool>(x2 > y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -332,8 +337,8 @@ namespace
     template <class X1, class Y1, class X2, class Y2>
     void test_equality_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        BOOST_TEST( static_cast<bool>(x1 == y1) == static_cast<bool>(x2 == y2) );
-        BOOST_TEST( static_cast<bool>(x1 != y1) == static_cast<bool>(x2 != y2) );
+        BOOST_CHECK( static_cast<bool>(x1 == y1) == static_cast<bool>(x2 == y2) );
+        BOOST_CHECK( static_cast<bool>(x1 != y1) == static_cast<bool>(x2 != y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -347,7 +352,7 @@ namespace
     template <class X1, class Y1, class X2, class Y2>
     void test_multipliable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        BOOST_TEST( (x1 * y1).value() == (x2 * y2) );
+        BOOST_CHECK( (x1 * y1).value() == (x2 * y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -361,7 +366,7 @@ namespace
   template <class A, class B>
   void test_value_equality(A a, B b)
   {
-      BOOST_TEST(a.value() == b);
+      BOOST_CHECK(a.value() == b);
   }
   
 #define TEST_OP_R(op) test_value_equality(x1 op y1, x2 op y2)
@@ -487,16 +492,16 @@ namespace
     void test_incrementable(X1 x1, X2 x2)
     {
         sanity_check( x1, x1, x2, x2 );
-        BOOST_TEST( (x1++).value() == x2++ );
-        BOOST_TEST( x1.value() == x2 );
+        BOOST_CHECK( (x1++).value() == x2++ );
+        BOOST_CHECK( x1.value() == x2 );
     }
     
     template <class X1, class X2>
     void test_decrementable(X1 x1, X2 x2)
     {
         sanity_check( x1, x1, x2, x2 );
-        BOOST_TEST( (x1--).value() == x2-- );
-        BOOST_TEST( x1.value() == x2 );
+        BOOST_CHECK( (x1--).value() == x2-- );
+        BOOST_CHECK( x1.value() == x2 );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -529,7 +534,7 @@ namespace
     template <class Big, class Small>
     struct tester
     {
-        void operator()(boost::detail::minstd_rand& randomizer) const
+        void operator()(boost::minstd_rand& randomizer) const
         {
             Big    b1 = Big( randomizer() );
             Big    b2 = Big( randomizer() );
@@ -543,7 +548,7 @@ namespace
     template <class Big, class Small>
     struct tester_left
     {
-        void operator()(boost::detail::minstd_rand& randomizer) const
+        void operator()(boost::minstd_rand& randomizer) const
         {
             Big    b1 = Big( randomizer() );
             Small  s = Small( randomizer() );
@@ -600,10 +605,10 @@ template Wrapped6<unsigned long, unsigned char>;
 template Wrapped6<unsigned int, unsigned char>;
 #endif
 
-#define PRIVATE_EXPR_TEST(e, t)  BOOST_TEST( ((e), (t)) )
+#define PRIVATE_EXPR_TEST(e, t)  BOOST_CHECK( ((e), (t)) )
 
 int
-main()
+test_main( int , char * [] )
 {
     using std::cout;
     using std::endl;
@@ -617,7 +622,7 @@ main()
     
     for (int n = 0; n < 1000; ++n)  // was 10,000 but took too long (Beman)
     {
-        boost::detail::minstd_rand r;
+        boost::minstd_rand r;
         tester<long, int>()(r);
         tester<long, signed char>()(r);
         tester<long, long>()(r);
@@ -645,22 +650,22 @@ main()
     MyInt i2(2);
     MyInt i;
 
-    BOOST_TEST( i1.value() == 1 );
-    BOOST_TEST( i2.value() == 2 );
-    BOOST_TEST( i.value() == 0 );
+    BOOST_CHECK( i1.value() == 1 );
+    BOOST_CHECK( i2.value() == 2 );
+    BOOST_CHECK( i.value() == 0 );
 
     cout << "Created MyInt objects.\n";
 
     PRIVATE_EXPR_TEST( (i = i2), (i.value() == 2) );
 
-    BOOST_TEST( static_cast<bool>(i2 == i) );
-    BOOST_TEST( static_cast<bool>(i1 != i2) );
-    BOOST_TEST( static_cast<bool>(i1 <  i2) );
-    BOOST_TEST( static_cast<bool>(i1 <= i2) );
-    BOOST_TEST( static_cast<bool>(i <= i2) );
-    BOOST_TEST( static_cast<bool>(i2 >  i1) );
-    BOOST_TEST( static_cast<bool>(i2 >= i1) );
-    BOOST_TEST( static_cast<bool>(i2 >= i) );
+    BOOST_CHECK( static_cast<bool>(i2 == i) );
+    BOOST_CHECK( static_cast<bool>(i1 != i2) );
+    BOOST_CHECK( static_cast<bool>(i1 <  i2) );
+    BOOST_CHECK( static_cast<bool>(i1 <= i2) );
+    BOOST_CHECK( static_cast<bool>(i <= i2) );
+    BOOST_CHECK( static_cast<bool>(i2 >  i1) );
+    BOOST_CHECK( static_cast<bool>(i2 >= i1) );
+    BOOST_CHECK( static_cast<bool>(i2 >= i) );
 
     PRIVATE_EXPR_TEST( (i = i1 + i2), (i.value() == 3) );
     PRIVATE_EXPR_TEST( (i = i + i2), (i.value() == 5) );
@@ -684,86 +689,86 @@ main()
     MyLong j2(2);
     MyLong j;
 
-    BOOST_TEST( j1.value() == 1 );
-    BOOST_TEST( j2.value() == 2 );
-    BOOST_TEST( j.value() == 0 );
+    BOOST_CHECK( j1.value() == 1 );
+    BOOST_CHECK( j2.value() == 2 );
+    BOOST_CHECK( j.value() == 0 );
 
     cout << "Created MyLong objects.\n";
 
     PRIVATE_EXPR_TEST( (j = j2), (j.value() == 2) );
     
-    BOOST_TEST( static_cast<bool>(j2 == j) );
-    BOOST_TEST( static_cast<bool>(2 == j) );
-    BOOST_TEST( static_cast<bool>(j2 == 2) );
-    BOOST_TEST( static_cast<bool>(j == j2) );
-    BOOST_TEST( static_cast<bool>(j1 != j2) );
-    BOOST_TEST( static_cast<bool>(j1 != 2) );
-    BOOST_TEST( static_cast<bool>(1 != j2) );
-    BOOST_TEST( static_cast<bool>(j1 <  j2) );
-    BOOST_TEST( static_cast<bool>(1 <  j2) );
-    BOOST_TEST( static_cast<bool>(j1 <  2) );
-    BOOST_TEST( static_cast<bool>(j1 <= j2) );
-    BOOST_TEST( static_cast<bool>(1 <= j2) );
-    BOOST_TEST( static_cast<bool>(j1 <= j) );
-    BOOST_TEST( static_cast<bool>(j <= j2) );
-    BOOST_TEST( static_cast<bool>(2 <= j2) );
-    BOOST_TEST( static_cast<bool>(j <= 2) );
-    BOOST_TEST( static_cast<bool>(j2 >  j1) );
-    BOOST_TEST( static_cast<bool>(2 >  j1) );
-    BOOST_TEST( static_cast<bool>(j2 >  1) );
-    BOOST_TEST( static_cast<bool>(j2 >= j1) );
-    BOOST_TEST( static_cast<bool>(2 >= j1) );
-    BOOST_TEST( static_cast<bool>(j2 >= 1) );
-    BOOST_TEST( static_cast<bool>(j2 >= j) );
-    BOOST_TEST( static_cast<bool>(2 >= j) );
-    BOOST_TEST( static_cast<bool>(j2 >= 2) );
+    BOOST_CHECK( static_cast<bool>(j2 == j) );
+    BOOST_CHECK( static_cast<bool>(2 == j) );
+    BOOST_CHECK( static_cast<bool>(j2 == 2) );
+    BOOST_CHECK( static_cast<bool>(j == j2) );
+    BOOST_CHECK( static_cast<bool>(j1 != j2) );
+    BOOST_CHECK( static_cast<bool>(j1 != 2) );
+    BOOST_CHECK( static_cast<bool>(1 != j2) );
+    BOOST_CHECK( static_cast<bool>(j1 <  j2) );
+    BOOST_CHECK( static_cast<bool>(1 <  j2) );
+    BOOST_CHECK( static_cast<bool>(j1 <  2) );
+    BOOST_CHECK( static_cast<bool>(j1 <= j2) );
+    BOOST_CHECK( static_cast<bool>(1 <= j2) );
+    BOOST_CHECK( static_cast<bool>(j1 <= j) );
+    BOOST_CHECK( static_cast<bool>(j <= j2) );
+    BOOST_CHECK( static_cast<bool>(2 <= j2) );
+    BOOST_CHECK( static_cast<bool>(j <= 2) );
+    BOOST_CHECK( static_cast<bool>(j2 >  j1) );
+    BOOST_CHECK( static_cast<bool>(2 >  j1) );
+    BOOST_CHECK( static_cast<bool>(j2 >  1) );
+    BOOST_CHECK( static_cast<bool>(j2 >= j1) );
+    BOOST_CHECK( static_cast<bool>(2 >= j1) );
+    BOOST_CHECK( static_cast<bool>(j2 >= 1) );
+    BOOST_CHECK( static_cast<bool>(j2 >= j) );
+    BOOST_CHECK( static_cast<bool>(2 >= j) );
+    BOOST_CHECK( static_cast<bool>(j2 >= 2) );
 
-    BOOST_TEST( static_cast<bool>((j1 + 2) == 3) );
-    BOOST_TEST( static_cast<bool>((1 + j2) == 3) );
+    BOOST_CHECK( static_cast<bool>((j1 + 2) == 3) );
+    BOOST_CHECK( static_cast<bool>((1 + j2) == 3) );
     PRIVATE_EXPR_TEST( (j = j1 + j2), (j.value() == 3) );
     
-    BOOST_TEST( static_cast<bool>((j + 2) == 5) );
-    BOOST_TEST( static_cast<bool>((3 + j2) == 5) );
+    BOOST_CHECK( static_cast<bool>((j + 2) == 5) );
+    BOOST_CHECK( static_cast<bool>((3 + j2) == 5) );
     PRIVATE_EXPR_TEST( (j = j + j2), (j.value() == 5) );
     
-    BOOST_TEST( static_cast<bool>((j - 1) == 4) );
+    BOOST_CHECK( static_cast<bool>((j - 1) == 4) );
     PRIVATE_EXPR_TEST( (j = j - j1), (j.value() == 4) );
     
-    BOOST_TEST( static_cast<bool>((j * 2) == 8) );
-    BOOST_TEST( static_cast<bool>((4 * j2) == 8) );
+    BOOST_CHECK( static_cast<bool>((j * 2) == 8) );
+    BOOST_CHECK( static_cast<bool>((4 * j2) == 8) );
     PRIVATE_EXPR_TEST( (j = j * j2), (j.value() == 8) );
     
-    BOOST_TEST( static_cast<bool>((j / 2) == 4) );
+    BOOST_CHECK( static_cast<bool>((j / 2) == 4) );
     PRIVATE_EXPR_TEST( (j = j / j2), (j.value() == 4) );
     
-    BOOST_TEST( static_cast<bool>((j % 3) == 1) );
+    BOOST_CHECK( static_cast<bool>((j % 3) == 1) );
     PRIVATE_EXPR_TEST( (j = j % ( j - j1 )), (j.value() == 1) );
     
     PRIVATE_EXPR_TEST( (j = j2 + j2), (j.value() == 4) );
     
-    BOOST_TEST( static_cast<bool>((1 | j2 | j) == 7) );
-    BOOST_TEST( static_cast<bool>((j1 | 2 | j) == 7) );
-    BOOST_TEST( static_cast<bool>((j1 | j2 | 4) == 7) );
+    BOOST_CHECK( static_cast<bool>((1 | j2 | j) == 7) );
+    BOOST_CHECK( static_cast<bool>((j1 | 2 | j) == 7) );
+    BOOST_CHECK( static_cast<bool>((j1 | j2 | 4) == 7) );
     PRIVATE_EXPR_TEST( (j = j1 | j2 | j), (j.value() == 7) );
     
-    BOOST_TEST( static_cast<bool>((7 & j2) == 2) );
-    BOOST_TEST( static_cast<bool>((j & 2) == 2) );
+    BOOST_CHECK( static_cast<bool>((7 & j2) == 2) );
+    BOOST_CHECK( static_cast<bool>((j & 2) == 2) );
     PRIVATE_EXPR_TEST( (j = j & j2), (j.value() == 2) );
     
     PRIVATE_EXPR_TEST( (j = j | j1), (j.value() == 3) );
     
-    BOOST_TEST( static_cast<bool>((3 ^ j1) == 2) );
-    BOOST_TEST( static_cast<bool>((j ^ 1) == 2) );
+    BOOST_CHECK( static_cast<bool>((3 ^ j1) == 2) );
+    BOOST_CHECK( static_cast<bool>((j ^ 1) == 2) );
     PRIVATE_EXPR_TEST( (j = j ^ j1), (j.value() == 2) );
     
     PRIVATE_EXPR_TEST( (j = ( j + j1 ) * ( j2 | j1 )), (j.value() == 9) );
 
-    BOOST_TEST( static_cast<bool>((j1 << 2) == 4) );
-    BOOST_TEST( static_cast<bool>((j2 << 1) == 4) );
+    BOOST_CHECK( static_cast<bool>((j1 << 2) == 4) );
+    BOOST_CHECK( static_cast<bool>((j2 << 1) == 4) );
     PRIVATE_EXPR_TEST( (j = j1 << j2), (j.value() == 4) );
 
-    BOOST_TEST( static_cast<bool>((j >> 2) == 1) );
-    BOOST_TEST( static_cast<bool>((j2 >> 1) == 1) );
+    BOOST_CHECK( static_cast<bool>((j >> 2) == 1) );
+    BOOST_CHECK( static_cast<bool>((j2 >> 1) == 1) );
     PRIVATE_EXPR_TEST( (j = j2 >> j1), (j.value() == 1) );
     
     cout << "Performed tests on MyLong objects.\n";
@@ -772,22 +777,22 @@ main()
     MyChar k2(2);
     MyChar k;
 
-    BOOST_TEST( k1.value() == 1 );
-    BOOST_TEST( k2.value() == 2 );
-    BOOST_TEST( k.value() == 0 );
+    BOOST_CHECK( k1.value() == 1 );
+    BOOST_CHECK( k2.value() == 2 );
+    BOOST_CHECK( k.value() == 0 );
 
     cout << "Created MyChar objects.\n";
 
     PRIVATE_EXPR_TEST( (k = k2), (k.value() == 2) );
 
-    BOOST_TEST( static_cast<bool>(k2 == k) );
-    BOOST_TEST( static_cast<bool>(k1 != k2) );
-    BOOST_TEST( static_cast<bool>(k1 <  k2) );
-    BOOST_TEST( static_cast<bool>(k1 <= k2) );
-    BOOST_TEST( static_cast<bool>(k <= k2) );
-    BOOST_TEST( static_cast<bool>(k2 >  k1) );
-    BOOST_TEST( static_cast<bool>(k2 >= k1) );
-    BOOST_TEST( static_cast<bool>(k2 >= k) );
+    BOOST_CHECK( static_cast<bool>(k2 == k) );
+    BOOST_CHECK( static_cast<bool>(k1 != k2) );
+    BOOST_CHECK( static_cast<bool>(k1 <  k2) );
+    BOOST_CHECK( static_cast<bool>(k1 <= k2) );
+    BOOST_CHECK( static_cast<bool>(k <= k2) );
+    BOOST_CHECK( static_cast<bool>(k2 >  k1) );
+    BOOST_CHECK( static_cast<bool>(k2 >= k1) );
+    BOOST_CHECK( static_cast<bool>(k2 >= k) );
     
     cout << "Performed tests on MyChar objects.\n";
 
@@ -795,39 +800,39 @@ main()
     MyShort l2(2);
     MyShort l;
 
-    BOOST_TEST( l1.value() == 1 );
-    BOOST_TEST( l2.value() == 2 );
-    BOOST_TEST( l.value() == 0 );
+    BOOST_CHECK( l1.value() == 1 );
+    BOOST_CHECK( l2.value() == 2 );
+    BOOST_CHECK( l.value() == 0 );
 
     cout << "Created MyShort objects.\n";
 
     PRIVATE_EXPR_TEST( (l = l2), (l.value() == 2) );
     
-    BOOST_TEST( static_cast<bool>(l2 == l) );
-    BOOST_TEST( static_cast<bool>(2 == l) );
-    BOOST_TEST( static_cast<bool>(l2 == 2) );
-    BOOST_TEST( static_cast<bool>(l == l2) );
-    BOOST_TEST( static_cast<bool>(l1 != l2) );
-    BOOST_TEST( static_cast<bool>(l1 != 2) );
-    BOOST_TEST( static_cast<bool>(1 != l2) );
-    BOOST_TEST( static_cast<bool>(l1 <  l2) );
-    BOOST_TEST( static_cast<bool>(1 <  l2) );
-    BOOST_TEST( static_cast<bool>(l1 <  2) );
-    BOOST_TEST( static_cast<bool>(l1 <= l2) );
-    BOOST_TEST( static_cast<bool>(1 <= l2) );
-    BOOST_TEST( static_cast<bool>(l1 <= l) );
-    BOOST_TEST( static_cast<bool>(l <= l2) );
-    BOOST_TEST( static_cast<bool>(2 <= l2) );
-    BOOST_TEST( static_cast<bool>(l <= 2) );
-    BOOST_TEST( static_cast<bool>(l2 >  l1) );
-    BOOST_TEST( static_cast<bool>(2 >  l1) );
-    BOOST_TEST( static_cast<bool>(l2 >  1) );
-    BOOST_TEST( static_cast<bool>(l2 >= l1) );
-    BOOST_TEST( static_cast<bool>(2 >= l1) );
-    BOOST_TEST( static_cast<bool>(l2 >= 1) );
-    BOOST_TEST( static_cast<bool>(l2 >= l) );
-    BOOST_TEST( static_cast<bool>(2 >= l) );
-    BOOST_TEST( static_cast<bool>(l2 >= 2) );
+    BOOST_CHECK( static_cast<bool>(l2 == l) );
+    BOOST_CHECK( static_cast<bool>(2 == l) );
+    BOOST_CHECK( static_cast<bool>(l2 == 2) );
+    BOOST_CHECK( static_cast<bool>(l == l2) );
+    BOOST_CHECK( static_cast<bool>(l1 != l2) );
+    BOOST_CHECK( static_cast<bool>(l1 != 2) );
+    BOOST_CHECK( static_cast<bool>(1 != l2) );
+    BOOST_CHECK( static_cast<bool>(l1 <  l2) );
+    BOOST_CHECK( static_cast<bool>(1 <  l2) );
+    BOOST_CHECK( static_cast<bool>(l1 <  2) );
+    BOOST_CHECK( static_cast<bool>(l1 <= l2) );
+    BOOST_CHECK( static_cast<bool>(1 <= l2) );
+    BOOST_CHECK( static_cast<bool>(l1 <= l) );
+    BOOST_CHECK( static_cast<bool>(l <= l2) );
+    BOOST_CHECK( static_cast<bool>(2 <= l2) );
+    BOOST_CHECK( static_cast<bool>(l <= 2) );
+    BOOST_CHECK( static_cast<bool>(l2 >  l1) );
+    BOOST_CHECK( static_cast<bool>(2 >  l1) );
+    BOOST_CHECK( static_cast<bool>(l2 >  1) );
+    BOOST_CHECK( static_cast<bool>(l2 >= l1) );
+    BOOST_CHECK( static_cast<bool>(2 >= l1) );
+    BOOST_CHECK( static_cast<bool>(l2 >= 1) );
+    BOOST_CHECK( static_cast<bool>(l2 >= l) );
+    BOOST_CHECK( static_cast<bool>(2 >= l) );
+    BOOST_CHECK( static_cast<bool>(l2 >= 2) );
     
     cout << "Performed tests on MyShort objects.\n";
     
@@ -837,44 +842,44 @@ main()
     MyDoubleInt di;
     MyDoubleInt tmp;
 
-    BOOST_TEST( di1.value() == 1 );
-    BOOST_TEST( di2.value() == 2 );
-    BOOST_TEST( di2.value() == 2 );
-    BOOST_TEST( di.value() == 0 );
+    BOOST_CHECK( di1.value() == 1 );
+    BOOST_CHECK( di2.value() == 2 );
+    BOOST_CHECK( di2.value() == 2 );
+    BOOST_CHECK( di.value() == 0 );
 
     cout << "Created MyDoubleInt objects.\n";
 
     PRIVATE_EXPR_TEST( (di = di2), (di.value() == 2) );
     
-    BOOST_TEST( static_cast<bool>(di2 == di) );
-    BOOST_TEST( static_cast<bool>(2 == di) );
-    BOOST_TEST( static_cast<bool>(di == 2) );
-    BOOST_TEST( static_cast<bool>(di1 < di2) );
-    BOOST_TEST( static_cast<bool>(1 < di2) );
-    BOOST_TEST( static_cast<bool>(di1 <= di2) );
-    BOOST_TEST( static_cast<bool>(1 <= di2) );
-    BOOST_TEST( static_cast<bool>(di2 > di1) );
-    BOOST_TEST( static_cast<bool>(di2 > 1) );
-    BOOST_TEST( static_cast<bool>(di2 >= di1) );
-    BOOST_TEST( static_cast<bool>(di2 >= 1) );
-    BOOST_TEST( static_cast<bool>(di1 / di2 == half) );
-    BOOST_TEST( static_cast<bool>(di1 / 2 == half) );
-    BOOST_TEST( static_cast<bool>(1 / di2 == half) );
+    BOOST_CHECK( static_cast<bool>(di2 == di) );
+    BOOST_CHECK( static_cast<bool>(2 == di) );
+    BOOST_CHECK( static_cast<bool>(di == 2) );
+    BOOST_CHECK( static_cast<bool>(di1 < di2) );
+    BOOST_CHECK( static_cast<bool>(1 < di2) );
+    BOOST_CHECK( static_cast<bool>(di1 <= di2) );
+    BOOST_CHECK( static_cast<bool>(1 <= di2) );
+    BOOST_CHECK( static_cast<bool>(di2 > di1) );
+    BOOST_CHECK( static_cast<bool>(di2 > 1) );
+    BOOST_CHECK( static_cast<bool>(di2 >= di1) );
+    BOOST_CHECK( static_cast<bool>(di2 >= 1) );
+    BOOST_CHECK( static_cast<bool>(di1 / di2 == half) );
+    BOOST_CHECK( static_cast<bool>(di1 / 2 == half) );
+    BOOST_CHECK( static_cast<bool>(1 / di2 == half) );
     PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp/=2) == half) );
     PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp/=di2) == half) );
-    BOOST_TEST( static_cast<bool>(di1 * di2 == di2) );
-    BOOST_TEST( static_cast<bool>(di1 * 2 == di2) );
-    BOOST_TEST( static_cast<bool>(1 * di2 == di2) );
+    BOOST_CHECK( static_cast<bool>(di1 * di2 == di2) );
+    BOOST_CHECK( static_cast<bool>(di1 * 2 == di2) );
+    BOOST_CHECK( static_cast<bool>(1 * di2 == di2) );
     PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp*=2) == di2) );
     PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp*=di2) == di2) );
-    BOOST_TEST( static_cast<bool>(di2 - di1 == di1) );
-    BOOST_TEST( static_cast<bool>(di2 - 1 == di1) );
-    BOOST_TEST( static_cast<bool>(2 - di1 == di1) );
+    BOOST_CHECK( static_cast<bool>(di2 - di1 == di1) );
+    BOOST_CHECK( static_cast<bool>(di2 - 1 == di1) );
+    BOOST_CHECK( static_cast<bool>(2 - di1 == di1) );
     PRIVATE_EXPR_TEST( (tmp=di2), static_cast<bool>((tmp-=1) == di1) );
     PRIVATE_EXPR_TEST( (tmp=di2), static_cast<bool>((tmp-=di1) == di1) );
-    BOOST_TEST( static_cast<bool>(di1 + di1 == di2) );
-    BOOST_TEST( static_cast<bool>(di1 + 1 == di2) );
-    BOOST_TEST( static_cast<bool>(1 + di1 == di2) );
+    BOOST_CHECK( static_cast<bool>(di1 + di1 == di2) );
+    BOOST_CHECK( static_cast<bool>(di1 + 1 == di2) );
+    BOOST_CHECK( static_cast<bool>(1 + di1 == di2) );
     PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp+=1) == di2) );
     PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp+=di1) == di2) );
 
@@ -885,52 +890,52 @@ main()
     MyLongInt li;
     MyLongInt tmp2;
 
-    BOOST_TEST( li1.value() == 1 );
-    BOOST_TEST( li2.value() == 2 );
-    BOOST_TEST( li.value() == 0 );
+    BOOST_CHECK( li1.value() == 1 );
+    BOOST_CHECK( li2.value() == 2 );
+    BOOST_CHECK( li.value() == 0 );
 
     cout << "Created MyLongInt objects.\n";
 
     PRIVATE_EXPR_TEST( (li = li2), (li.value() == 2) );
     
-    BOOST_TEST( static_cast<bool>(li2 == li) );
-    BOOST_TEST( static_cast<bool>(2 == li) );
-    BOOST_TEST( static_cast<bool>(li == 2) );
-    BOOST_TEST( static_cast<bool>(li1 < li2) );
-    BOOST_TEST( static_cast<bool>(1 < li2) );
-    BOOST_TEST( static_cast<bool>(li1 <= li2) );
-    BOOST_TEST( static_cast<bool>(1 <= li2) );
-    BOOST_TEST( static_cast<bool>(li2 > li1) );
-    BOOST_TEST( static_cast<bool>(li2 > 1) );
-    BOOST_TEST( static_cast<bool>(li2 >= li1) );
-    BOOST_TEST( static_cast<bool>(li2 >= 1) );
-    BOOST_TEST( static_cast<bool>(li1 % li2 == li1) );
-    BOOST_TEST( static_cast<bool>(li1 % 2 == li1) );
-    BOOST_TEST( static_cast<bool>(1 % li2 == li1) );
+    BOOST_CHECK( static_cast<bool>(li2 == li) );
+    BOOST_CHECK( static_cast<bool>(2 == li) );
+    BOOST_CHECK( static_cast<bool>(li == 2) );
+    BOOST_CHECK( static_cast<bool>(li1 < li2) );
+    BOOST_CHECK( static_cast<bool>(1 < li2) );
+    BOOST_CHECK( static_cast<bool>(li1 <= li2) );
+    BOOST_CHECK( static_cast<bool>(1 <= li2) );
+    BOOST_CHECK( static_cast<bool>(li2 > li1) );
+    BOOST_CHECK( static_cast<bool>(li2 > 1) );
+    BOOST_CHECK( static_cast<bool>(li2 >= li1) );
+    BOOST_CHECK( static_cast<bool>(li2 >= 1) );
+    BOOST_CHECK( static_cast<bool>(li1 % li2 == li1) );
+    BOOST_CHECK( static_cast<bool>(li1 % 2 == li1) );
+    BOOST_CHECK( static_cast<bool>(1 % li2 == li1) );
     PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2%=2) == li1) );
     PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2%=li2) == li1) );
-    BOOST_TEST( static_cast<bool>(li1 / li2 == 0) );
-    BOOST_TEST( static_cast<bool>(li1 / 2 == 0) );
-    BOOST_TEST( static_cast<bool>(1 / li2 == 0) );
+    BOOST_CHECK( static_cast<bool>(li1 / li2 == 0) );
+    BOOST_CHECK( static_cast<bool>(li1 / 2 == 0) );
+    BOOST_CHECK( static_cast<bool>(1 / li2 == 0) );
     PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2/=2) == 0) );
     PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2/=li2) == 0) );
-    BOOST_TEST( static_cast<bool>(li1 * li2 == li2) );
-    BOOST_TEST( static_cast<bool>(li1 * 2 == li2) );
-    BOOST_TEST( static_cast<bool>(1 * li2 == li2) );
+    BOOST_CHECK( static_cast<bool>(li1 * li2 == li2) );
+    BOOST_CHECK( static_cast<bool>(li1 * 2 == li2) );
+    BOOST_CHECK( static_cast<bool>(1 * li2 == li2) );
     PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2*=2) == li2) );
     PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2*=li2) == li2) );
-    BOOST_TEST( static_cast<bool>(li2 - li1 == li1) );
-    BOOST_TEST( static_cast<bool>(li2 - 1 == li1) );
-    BOOST_TEST( static_cast<bool>(2 - li1 == li1) );
+    BOOST_CHECK( static_cast<bool>(li2 - li1 == li1) );
+    BOOST_CHECK( static_cast<bool>(li2 - 1 == li1) );
+    BOOST_CHECK( static_cast<bool>(2 - li1 == li1) );
     PRIVATE_EXPR_TEST( (tmp2=li2), static_cast<bool>((tmp2-=1) == li1) );
     PRIVATE_EXPR_TEST( (tmp2=li2), static_cast<bool>((tmp2-=li1) == li1) );
-    BOOST_TEST( static_cast<bool>(li1 + li1 == li2) );
-    BOOST_TEST( static_cast<bool>(li1 + 1 == li2) );
-    BOOST_TEST( static_cast<bool>(1 + li1 == li2) );
+    BOOST_CHECK( static_cast<bool>(li1 + li1 == li2) );
+    BOOST_CHECK( static_cast<bool>(li1 + 1 == li2) );
+    BOOST_CHECK( static_cast<bool>(1 + li1 == li2) );
     PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2+=1) == li2) );
     PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2+=li1) == li2) );
 
     cout << "Performed tests on MyLongInt objects.\n";
 
-    return boost::report_errors();
+    return boost::exit_success;
 }

ref_ct_test.cpp

@@ -0,0 +1,134 @@
+// Copyright David Abrahams and Aleksey Gurtovoy
+// 2002-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)
+
+// compile-time test for "boost/ref.hpp" header content
+// see 'ref_test.cpp' for run-time part
+
+#include <boost/ref.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/mpl/assert.hpp>
+
+namespace {
+
+template< typename T, typename U >
+void ref_test(boost::reference_wrapper<U>)
+{
+    typedef typename boost::reference_wrapper<U>::type type;
+    BOOST_STATIC_ASSERT((boost::is_same<U,type>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<T,type>::value));
+}
+
+template< typename T >
+void assignable_test(T x)
+{
+    x = x;
+}
+
+template< bool R, typename T >
+void is_reference_wrapper_test(T)
+{
+    BOOST_STATIC_ASSERT(boost::is_reference_wrapper<T>::value == R);
+}
+
+template< typename R, typename Ref >
+void cxx_reference_test(Ref)
+{
+#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+    typedef typename boost::remove_const<Ref>::type ref;
+    BOOST_STATIC_ASSERT((boost::is_same<R,ref>::value));
+#else
+    BOOST_STATIC_ASSERT((boost::is_same<R,Ref>::value));
+#endif
+}
+
+template< typename R, typename Ref >
+void unwrap_reference_test(Ref)
+{
+#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+    typedef typename boost::remove_const<Ref>::type ref;
+    typedef typename boost::unwrap_reference<ref>::type type;
+#else
+    typedef typename boost::unwrap_reference<Ref>::type type;
+#endif
+    BOOST_STATIC_ASSERT((boost::is_same<R,type>::value));
+}
+
+} // namespace
+
+int main()
+{
+    int i = 0;
+    int& ri = i;
+
+    int const ci = 0;
+    int const& rci = ci;
+
+    // 'ref/cref' functions test
+    ref_test<int>(boost::ref(i));
+    ref_test<int>(boost::ref(ri));
+    ref_test<int const>(boost::ref(ci));
+    ref_test<int const>(boost::ref(rci));
+
+    ref_test<int const>(boost::cref(i));
+    ref_test<int const>(boost::cref(ri));
+    ref_test<int const>(boost::cref(ci));
+    ref_test<int const>(boost::cref(rci));
+
+    // test 'assignable' requirement
+    assignable_test(boost::ref(i));
+    assignable_test(boost::ref(ri));
+    assignable_test(boost::cref(i));
+    assignable_test(boost::cref(ci));
+    assignable_test(boost::cref(rci));
+
+    // 'is_reference_wrapper' test
+    is_reference_wrapper_test<true>(boost::ref(i));
+    is_reference_wrapper_test<true>(boost::ref(ri));
+    is_reference_wrapper_test<true>(boost::cref(i));
+    is_reference_wrapper_test<true>(boost::cref(ci));
+    is_reference_wrapper_test<true>(boost::cref(rci));
+
+    is_reference_wrapper_test<false>(i);
+    is_reference_wrapper_test<false, int&>(ri);
+    is_reference_wrapper_test<false>(ci);
+    is_reference_wrapper_test<false, int const&>(rci);
+
+    // ordinary references/function template arguments deduction test
+    cxx_reference_test<int>(i);
+    cxx_reference_test<int>(ri);
+    cxx_reference_test<int>(ci);
+    cxx_reference_test<int>(rci);
+
+    cxx_reference_test<int&, int&>(i);
+    cxx_reference_test<int&, int&>(ri);
+    cxx_reference_test<int const&, int const&>(i);
+    cxx_reference_test<int const&, int const&>(ri);
+    cxx_reference_test<int const&, int const&>(ci);
+    cxx_reference_test<int const&, int const&>(rci);
+
+    // 'unwrap_reference' test
+    unwrap_reference_test<int>(boost::ref(i));
+    unwrap_reference_test<int>(boost::ref(ri));
+    unwrap_reference_test<int const>(boost::cref(i));
+    unwrap_reference_test<int const>(boost::cref(ci));
+    unwrap_reference_test<int const>(boost::cref(rci));
+
+    unwrap_reference_test<int>(i);
+    unwrap_reference_test<int>(ri);
+    unwrap_reference_test<int>(ci);
+    unwrap_reference_test<int>(rci);
+    unwrap_reference_test<int&, int&>(i);
+    unwrap_reference_test<int&, int&>(ri);
+    unwrap_reference_test<int const&, int const&>(i);
+    unwrap_reference_test<int const&, int const&>(ri);
+    unwrap_reference_test<int const&, int const&>(ci);
+    unwrap_reference_test<int const&, int const&>(rci);
+
+    return 0;
+}

ref_test.cpp

@@ -0,0 +1,121 @@
+// Copyright David Abrahams and Aleksey Gurtovoy
+// 2002-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)
+
+// run-time test for "boost/ref.hpp" header content
+// see 'ref_ct_test.cpp' for compile-time part
+
+#if defined(_MSC_VER) && !defined(__ICL)
+# pragma warning(disable: 4786)  // identifier truncated in debug info
+# pragma warning(disable: 4710)  // function not inlined
+# pragma warning(disable: 4711)  // function selected for automatic inline expansion
+# pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+#include <boost/ref.hpp>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+# pragma warning(push, 3)
+#endif
+
+#include <iostream>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+# pragma warning(pop)
+#endif
+
+
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+namespace {
+using namespace boost;
+
+template <class T>
+struct ref_wrapper
+{
+    // Used to verify implicit conversion
+    static T* get_pointer(T& x)
+    {
+        return &x;
+    }
+
+    static T const* get_const_pointer(T const& x)
+    {
+        return &x;
+    }
+
+    template <class Arg>
+    static T* passthru(Arg x)
+    {
+        return get_pointer(x);
+    }
+
+    template <class Arg>
+    static T const* cref_passthru(Arg x)
+    {
+        return get_const_pointer(x);
+    }
+
+    static void test(T x)
+    {
+        BOOST_CHECK(passthru(ref(x)) == &x);
+        BOOST_CHECK(&ref(x).get() == &x);
+
+        BOOST_CHECK(cref_passthru(cref(x)) == &x);
+        BOOST_CHECK(&cref(x).get() == &x);
+    }
+};
+
+struct copy_counter {
+  static int count_;
+  copy_counter(copy_counter const& other) {
+    ++count_;
+  }
+  copy_counter() {}
+  static void reset() { count_ = 0; }
+  static int count() { return copy_counter::count_;  }
+};
+
+int copy_counter::count_ = 0;
+
+} // namespace unnamed
+
+template <class T>
+void do_unwrap(T t) {
+
+  /* typename unwrap_reference<T>::type& lt = */
+  unwrap_ref(t);
+
+}
+
+void unwrap_test() {
+
+  int i = 3;
+  const int ci = 2;
+
+  do_unwrap(i);
+  do_unwrap(ci);
+  do_unwrap(ref(i));
+  do_unwrap(cref(ci));
+  do_unwrap(ref(ci));
+
+  copy_counter cc;
+  BOOST_CHECK(cc.count() == 0);
+
+  do_unwrap(cc);
+  do_unwrap(ref(cc));
+  do_unwrap(cref(cc));
+
+  BOOST_CHECK(cc.count() == 1);
+  BOOST_CHECK(unwrap_ref(ref(cc)).count() == 1); 
+}
+
+int test_main(int, char * [])
+{
+    ref_wrapper<int>::test(1);
+    ref_wrapper<int const>::test(1);
+    unwrap_test();
+    return 0;
+}

shared_container_iterator.html

@@ -0,0 +1,322 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<title>Shared Container Iterator Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<img src="../../boost.png" alt="boost.png (6897 bytes)"
+align="center" width="277" height="86">
+
+<h1>Shared Container Iterator</h1>
+
+Defined in header
+<a href="../../boost/shared_container_iterator.hpp">boost/shared_container_iterator.hpp</a>
+
+<p>
+The purpose of the shared container iterator is to attach the lifetime
+of a container to the lifetime of its iterators. In other words, the
+container will not be deleted until after all its iterators are
+destroyed.  The shared container iterator is typically used to
+implement functions that return iterators over a range of objects that
+only need to exist for the lifetime of the iterators.  By returning a
+pair of shared iterators from a function, the callee can return a
+heap-allocated range of objects whose lifetime is automatically managed.
+<p>
+The shared container iterator augments an iterator over a shared
+container.  It maintains a reference count on the shared 
+container. If only shared container iterators hold references to
+the container, the container's lifetime will end when the last shared
+container iterator over it is destroyed.  In any case, the shared
+container is guaranteed to persist beyond the lifetime of all
+the iterators. In all other ways, the
+shared container iterator behaves the same as its base iterator.
+
+
+<h2>Synopsis</h2>
+
+<pre>
+namespace boost {
+  template &lt;typename <a href="http://www.sgi.com/tech/stl/Container.html">Container</a>&gt;
+  class shared_container_iterator;
+
+  template &lt;typename <a href="http://www.sgi.com/tech/stl/Container.html">Container</a>&gt;
+  shared_container_iterator&lt;Container&gt;
+  make_shared_container_iterator(typename Container::iterator base, 
+    boost::shared_ptr&lt;Container&gt; const&amp; container);
+
+  std::pair&lt;
+    typename shared_container_iterator&lt;Container&gt;,
+    typename shared_container_iterator&lt;Container&gt;
+  &gt;
+  make_shared_container_range(boost::shared_ptr&lt;Container&gt; const&amp; container);
+}
+</pre>
+
+<hr>
+
+<h2><a name="generator">The Shared Container Iterator Type</a></h2>
+
+<pre>
+template &lt;typename Container&gt; class shared_container_iterator;
+</pre>
+
+The class template <tt>shared_container_iterator</tt> 
+is the shared container iterator type.  The <tt>Container</tt> template
+type argument must model the
+<a href="http://www.sgi.com/tech/stl/Container.html">Container</a>
+concept.
+
+<h3>Example</h3>
+
+<p>
+The following example illustrates how to create an iterator that 
+regulates the lifetime of a reference counted <tt>std::vector</tt>.
+Though the original shared pointer <tt>ints</tt> ceases to exist
+after <tt>set_range()</tt> returns, the
+<tt>shared_counter_iterator</tt> objects maintain references to the
+      underlying vector and thereby extend the container's lifetime.
+<p>
+<a href="./shared_iterator_example1.cpp">shared_iterator_example1.cpp</a>:
+<PRE>
+<font color="#008040">#include "shared_container_iterator.hpp"</font>
+<font color="#008040">#include "boost/shared_ptr.hpp"</font>
+<font color="#008040">#include &lt;algorithm&gt;</font>
+<font color="#008040">#include &lt;iostream&gt;</font>
+<font color="#008040">#include &lt;vector&gt;</font>
+
+<B>typedef</B> boost::shared_container_iterator&lt; std::vector&lt;<B>int</B>&gt; &gt; iterator;
+
+
+<B>void</B> set_range(iterator& i, iterator& end)  {
+
+  boost::shared_ptr&lt; std::vector&lt;<B>int</B>&gt; &gt; ints(<B>new</B> std::vector&lt;<B>int</B>&gt;());
+  
+  ints-&gt;push_back(<font color="#0000A0">0</font>);
+  ints-&gt;push_back(<font color="#0000A0">1</font>);
+  ints-&gt;push_back(<font color="#0000A0">2</font>);
+  ints-&gt;push_back(<font color="#0000A0">3</font>);
+  ints-&gt;push_back(<font color="#0000A0">4</font>);
+  ints-&gt;push_back(<font color="#0000A0">5</font>);
+  
+  i = iterator(ints-&gt;begin(),ints);
+  end = iterator(ints-&gt;end(),ints);
+}
+
+
+<B>int</B> main() {
+
+  iterator i,end;
+
+  set_range(i,end);
+
+  std::copy(i,end,std::ostream_iterator&lt;<B>int</B>&gt;(std::cout,<font color="#0000FF">","</font>));
+  std::cout.put(<font color="#0000FF">'\n'</font>);
+
+  <B>return</B> <font color="#0000A0">0</font>;
+}
+</PRE>
+
+The output from this part is:
+<pre>
+0,1,2,3,4,5,
+</pre>
+
+<h3>Template Parameters</h3>
+
+<Table border>
+<TR>
+<TH>Parameter</TH><TH>Description</TH>
+</TR>
+
+<TR>
+<TD><a
+href="http://www.sgi.com/tech/stl/Container.html"><tt>Container</tt></a></TD>
+<TD>The type of the container that we wish to iterate over. It must be 
+a model of the 
+<a href="http://www.sgi.com/tech/stl/Container.html"><tt>Container</tt></a>
+concept.
+</TD>
+</TR>
+</Table>
+
+<h3>Model of</h3>
+
+The <tt>shared_container_iterator<Container></tt> type models the
+same iterator concept as the base iterator
+    (<tt>Container::iterator</tt>).
+
+<h3>Members</h3>
+
+The shared container iterator type implements the member functions and
+operators required of the <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterator</a>
+concept, though only operations defined for the base iterator will be valid.
+In addition it has the following constructor:
+
+<pre>
+shared_container_iterator(Container::iterator const&amp; it,
+                          boost::shared_ptr&lt;Container&gt; const&amp; container)
+</pre>
+
+<p>
+<hr>
+<p>
+
+
+<h2><a name="make_iterator">The Shared Container Iterator Object Generator</a></h2>
+
+<pre>
+template &lt;typename Container&gt;
+shared_container_iterator&lt;Container&gt;
+make_shared_container_iterator(Container::iterator base,
+                               boost::shared_ptr&lt;Container&gt; const&amp; container)
+</pre>
+
+This function provides an alternative to directly constructing a
+shared container iterator.  Using the object generator, a shared
+container iterator can be created and passed to a function without
+explicitly specifying its type.
+
+<h3>Example</h3>
+
+This example, similar to the previous, uses 
+<tt>make_shared_container_iterator()</tt> to create the iterators.
+
+<p>
+<a href="./shared_iterator_example2.cpp">shared_iterator_example2.cpp</a>:
+
+<PRE>
+<font color="#008040">#include "shared_container_iterator.hpp"</font>
+<font color="#008040">#include "boost/shared_ptr.hpp"</font>
+<font color="#008040">#include &lt;algorithm&gt;</font>
+<font color="#008040">#include &lt;iterator&gt;</font>
+<font color="#008040">#include &lt;iostream&gt;</font>
+<font color="#008040">#include &lt;vector&gt;</font>
+
+
+<B>template</B> &lt;<B>typename</B> Iterator&gt;
+<B>void</B> print_range_nl (Iterator begin, Iterator end) {
+  <B>typedef</B> <B>typename</B> std::iterator_traits&lt;Iterator&gt;::value_type val;
+  std::copy(begin,end,std::ostream_iterator&lt;val&gt;(std::cout,<font color="#0000FF">","</font>));
+  std::cout.put(<font color="#0000FF">'\n'</font>);
+}
+
+
+<B>int</B> main() {
+
+  <B>typedef</B> boost::shared_ptr&lt; std::vector&lt;<B>int</B>&gt; &gt; ints_t;
+  {
+    ints_t ints(<B>new</B> std::vector&lt;<B>int</B>&gt;());
+
+    ints-&gt;push_back(<font color="#0000A0">0</font>);
+    ints-&gt;push_back(<font color="#0000A0">1</font>);
+    ints-&gt;push_back(<font color="#0000A0">2</font>);
+    ints-&gt;push_back(<font color="#0000A0">3</font>);
+    ints-&gt;push_back(<font color="#0000A0">4</font>);
+    ints-&gt;push_back(<font color="#0000A0">5</font>);
+
+    print_range_nl(boost::make_shared_container_iterator(ints-&gt;begin(),ints),
+		   boost::make_shared_container_iterator(ints-&gt;end(),ints));
+  }
+  
+
+
+  <B>return</B> <font color="#0000A0">0</font>;
+}
+</PRE>
+
+Observe that the <tt>shared_container_iterator</tt> type is never
+explicitly named. The output from this example is the same as the previous.
+
+<h2><a name="make_range">The Shared Container Iterator Range Generator</a></h2>
+
+<pre>
+template &lt;typename Container&gt;
+std::pair&lt
+  shared_container_iterator&lt;Container&gt;,
+  shared_container_iterator&lt;Container&gt;
+&gt;
+make_shared_container_range(boost::shared_ptr&lt;Container&gt; const&amp; container);
+</pre>
+
+Class <tt>shared_container_iterator</tt> is meant primarily to return,
+using iterators, a range of values that we can guarantee will be alive as 
+long as the iterators are. This is a convenience
+function to do just that. It is equivalent to
+
+<pre>
+std::make_pair(make_shared_container_iterator(container-&gt;begin(),container),
+               make_shared_container_iterator(container-&gt;end(),container));
+</pre>
+
+<h3>Example</h3>
+
+In the following example, a range of values is returned as a pair of
+<tt>shared_container_iterator</tt> objects.  
+
+
+<p>
+<a href="./shared_iterator_example3.cpp">shared_iterator_example3.cpp</a>:
+
+<PRE>
+<font color="#008040">#include "shared_container_iterator.hpp"</font>
+<font color="#008040">#include "boost/shared_ptr.hpp"</font>
+<font color="#008040">#include "boost/tuple/tuple.hpp" // for boost::tie</font>
+<font color="#008040">#include &lt;algorithm&gt;              // for std::copy</font>
+<font color="#008040">#include &lt;iostream&gt;              </font>
+<font color="#008040">#include &lt;vector&gt;</font>
+
+
+<B>typedef</B> boost::shared_container_iterator&lt; std::vector&lt;<B>int</B>&gt; &gt; iterator; 
+
+std::pair&lt;iterator,iterator&gt;
+return_range() {
+  boost::shared_ptr&lt; std::vector&lt;<B>int</B>&gt; &gt; range(<B>new</B> std::vector&lt;<B>int</B>&gt;());
+  range-&gt;push_back(<font color="#0000A0">0</font>);
+  range-&gt;push_back(<font color="#0000A0">1</font>);
+  range-&gt;push_back(<font color="#0000A0">2</font>);
+  range-&gt;push_back(<font color="#0000A0">3</font>);
+  range-&gt;push_back(<font color="#0000A0">4</font>);
+  range-&gt;push_back(<font color="#0000A0">5</font>);
+  <B>return</B> boost::make_shared_container_range(range);
+}
+
+
+<B>int</B> main() {
+
+
+  iterator i,end;
+  
+  boost::tie(i,end) = return_range();
+
+  std::copy(i,end,std::ostream_iterator&lt;<B>int</B>&gt;(std::cout,<font color="#0000FF">","</font>));
+  std::cout.put(<font color="#0000FF">'\n'</font>);
+
+  <B>return</B> <font color="#0000A0">0</font>;
+}
+</PRE>
+
+Though the <tt>range</tt> object only lives for the duration of the
+<tt>return_range</tt> call, the reference counted
+<tt>std::vector</tt> will live until <tt>i</tt> and <tt>end</tt>
+are both destroyed.  The output from this example is the same as
+the previous two.
+
+
+<hr>
+<!-- hhmts start -->
+Last modified: Mon Aug 11 11:27:03 EST 2003
+<!-- hhmts end -->
+<p><EFBFBD> Copyright 2003 The Trustees of Indiana University.
+ 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)</p>
+
+</body>
+
+</html>

shared_iterator_example1.cpp

@@ -0,0 +1,42 @@
+// Copyright 2003 The Trustees of Indiana University.
+
+// 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/shared_container_iterator.hpp"
+#include "boost/shared_ptr.hpp"
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+typedef boost::shared_container_iterator< std::vector<int> > iterator;
+
+
+void set_range(iterator& i, iterator& end)  {
+
+  boost::shared_ptr< std::vector<int> > ints(new std::vector<int>());
+  
+  ints->push_back(0);
+  ints->push_back(1);
+  ints->push_back(2);
+  ints->push_back(3);
+  ints->push_back(4);
+  ints->push_back(5);
+  
+  i = iterator(ints->begin(),ints);
+  end = iterator(ints->end(),ints);
+}
+
+
+int main() {
+
+  iterator i,end;
+
+  set_range(i,end);
+
+  std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
+  std::cout.put('\n');
+
+  return 0;
+}

shared_iterator_example2.cpp

@@ -0,0 +1,43 @@
+// Copyright 2003 The Trustees of Indiana University.
+
+// 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/shared_container_iterator.hpp"
+#include "boost/shared_ptr.hpp"
+#include <algorithm>
+#include <iterator>
+#include <iostream>
+#include <vector>
+
+
+template <typename Iterator>
+void print_range_nl (Iterator begin, Iterator end) {
+  typedef typename std::iterator_traits<Iterator>::value_type val;
+  std::copy(begin,end,std::ostream_iterator<val>(std::cout,","));
+  std::cout.put('\n');
+}
+
+
+int main() {
+
+  typedef boost::shared_ptr< std::vector<int> > ints_t;
+  {
+    ints_t ints(new std::vector<int>());
+
+    ints->push_back(0);
+    ints->push_back(1);
+    ints->push_back(2);
+    ints->push_back(3);
+    ints->push_back(4);
+    ints->push_back(5);
+
+    print_range_nl(boost::make_shared_container_iterator(ints->begin(),ints),
+                   boost::make_shared_container_iterator(ints->end(),ints));
+  }
+  
+
+
+  return 0;
+}

shared_iterator_example3.cpp

@@ -0,0 +1,41 @@
+// Copyright 2003 The Trustees of Indiana University.
+
+// 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/shared_container_iterator.hpp"
+#include "boost/shared_ptr.hpp"
+#include "boost/tuple/tuple.hpp" // for boost::tie
+#include <algorithm>              // for std::copy
+#include <iostream>              
+#include <vector>
+
+
+typedef boost::shared_container_iterator< std::vector<int> > iterator;
+
+std::pair<iterator,iterator>
+return_range() {
+  boost::shared_ptr< std::vector<int> > range(new std::vector<int>());
+  range->push_back(0);
+  range->push_back(1);
+  range->push_back(2);
+  range->push_back(3);
+  range->push_back(4);
+  range->push_back(5);
+  return boost::make_shared_container_range(range);
+}
+
+
+int main() {
+
+
+  iterator i,end;
+  
+  boost::tie(i,end) = return_range();
+
+  std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
+  std::cout.put('\n');
+
+  return 0;
+}

shared_iterator_test.cpp

@@ -0,0 +1,64 @@
+// Copyright 2003 The Trustees of Indiana University.
+
+// 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)
+
+//  Shared container iterator adaptor 
+//  Author: Ronald Garcia
+//  See http://boost.org/libs/utility/shared_container_iterator.html 
+//  for documentation. 
+
+//
+// shared_iterator_test.cpp - Regression tests for shared_container_iterator.
+//
+
+
+#include "boost/shared_container_iterator.hpp"
+#include "boost/shared_ptr.hpp"
+#include <vector>
+#include <cassert>
+
+struct resource {
+  static int count;
+  resource() { ++count; }
+  resource(resource const&) { ++count; }
+  ~resource() { --count; }
+};
+int resource::count = 0;
+
+typedef std::vector<resource> resources_t;
+
+typedef boost::shared_container_iterator< resources_t > iterator;
+
+
+void set_range(iterator& i, iterator& end)  {
+
+  boost::shared_ptr< resources_t > objs(new resources_t());
+
+  for (int j = 0; j != 6; ++j)
+    objs->push_back(resource());
+  
+  i = iterator(objs->begin(),objs);
+  end = iterator(objs->end(),objs);
+  assert(resource::count == 6);
+}
+
+
+int main() {
+
+  assert(resource::count == 0);
+  
+  {
+    iterator i;
+    {
+      iterator end;
+      set_range(i,end);
+      assert(resource::count == 6);
+    }
+    assert(resource::count == 6);
+  }
+  assert(resource::count == 0);
+  
+  return 0;
+}

swap.html

@@ -0,0 +1,94 @@
+<?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" xml:lang="en-US" lang="en-US">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Boost: Swap Documentation</title>
+   </head>
+  <body>
+    <!-- Page header -->
+    <img src="../../boost.png" alt="C++ Boost" align="middle" width="277" height="86"/>
+    <h1>Swap</h1>
+    
+    <p>
+      <tt>template&lt;class T&gt; void swap(T&amp; <em>left</em>, T&amp; <em>right</em>);</tt>
+    </p>
+     
+    <!-- Introduction -->
+    <p>
+      The template function <tt>boost::swap</tt> allows the values of two variables to be swapped, using argument dependent lookup to select a specialized swap function if available. If no specialized swap function is available, <tt>std::swap</tt> is used.
+    </p>
+    
+    <!-- Rationale -->
+    <h2>Rationale</h2>
+    <p>
+      The generic <tt>std::swap</tt> function requires that the elements to be swapped are assignable and copy constructible. It is usually implemented using one copy construction and two assignments - this is often both unnecessarily restrictive and unnecessarily slow. In addition, where the generic swap implementation provides only the basic guarantee, specialized swap functions are often able to provide the no-throw exception guarantee (and it is considered best practice to do so where possible<sup><a href="#ref1">1</a></sup>).</p>
+    <p>
+      The alternative to using argument dependent lookup in this situation is to provide a template specialization of <tt>std::swap</tt> for every type that requires a specialized swap. Although this is legal C++, no Boost libraries use this method, whereas many Boost libraries provide specialized swap functions in their own namespaces.
+    </p>
+    <p>
+      <tt>boost::swap</tt> also supports swapping built-in arrays. Note that <tt>std::swap</tt> originally did not do so, but a request to add an overload of <tt>std::swap</tt> for built-in arrays has been accepted by the C++ Standards Committee<sup><a href="#ref2">2</a></sup>.
+    </p>
+    
+    <!-- Exception Safety -->
+    <h2>Exception Safety</h2>
+    <p>
+      <tt>boost::swap</tt> provides the same exception guarantee as the underlying swap function used, with one exception; for an array of type <tt>T[n]</tt>, where <tt>n > 1</tt> and the underlying swap function for <tt>T</tt> provides the strong exception guarantee, <tt>boost::swap</tt> provides only the basic exception guarantee.
+    </p>
+    
+    <!-- Requirements -->
+    <h2>Requirements</h2>
+    <p>Either:</p>
+    <ul>      
+      <li>T must be assignable</li>
+      <li>T must be copy constructible</li>
+    </ul>
+    <p>Or:</p>
+    <ul>
+      <li>A function with the signature <tt>swap(T&amp;,T&amp;)</tt> is available via argument dependent lookup</li>
+    </ul>
+    <p>Or:</p>
+    <ul>
+      <li>A template specialization of <tt>std::swap</tt> exists for T</li>
+    </ul>
+    <p>Or:</p>
+    <ul>
+      <li>T is a built-in array of swappable elements</li>
+    </ul>
+
+    
+    <!-- Portability -->
+    <h2>Portability</h2>
+    <p>
+      Several older compilers do not support argument dependent lookup &#x2012; on these compilers <tt>boost::swap</tt> will call <tt>std::swap</tt>, ignoring any specialized swap functions that could be found as a result of argument dependent lookup.
+    </p>
+    
+    <!-- Credits -->
+    <h2>Credits</h2>
+    <ul>
+      <li>
+        <em>Niels Dekker</em> - for implementing and documenting support for built-in arrays
+      </li>
+      <li>
+        <em><a href="mailto:Joseph.Gauterin@googlemail.com">Joseph Gauterin</a></em> - for the initial idea, implementation, tests, and documentation
+      </li>
+      <li>
+        <em>Steven Watanabe</em> - for the idea to make <tt>boost::swap</tt> less specialized than <tt>std::swap</tt>, thereby allowing the function to have the name 'swap' without introducing ambiguity
+      </li>      
+    </ul>
+
+    <!-- References -->
+    <hr/>
+    <p><sup><a id="ref1"/>[1]</sup>Scott Meyers, Effective C++ Third Edition, Item 25: "Consider support for a non-throwing swap"</p>
+    <p><sup><a id="ref2"/>[2]</sup><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">LWG Defect Report 809 (std::swap should be overloaded for array types)</a></p>
+
+    <!-- Copyright info -->    
+    <hr/>
+    <p>Revised: 15 November 2008</p>
+    <p>
+      Copyright 2007, 2008 Joseph Gauterin. 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 a copy at &lt;<a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)
+    </p>
+    
+  </body>
+</html>