Quickbook: Merge from trunk.

Includes blocks in lists fixes, and some documentation changes. [SVN r77347]
Fixed test indentation and updated docs.
2025-10-05 21:40:59 +02:00 · 2012-03-16 08:48:10 +00:00 · 2012-02-20 20:17:07 +00:00 · 2012-02-18 19:29:35 +00:00 · 2012-02-17 21:02:00 +00:00 · 2012-02-17 01:55:33 +00:00
22 changed files with 390 additions and 921 deletions
--- a/base_from_member.html
+++ b/base_from_member.html
@@ -129,6 +129,8 @@ particular member type does not need to concern itself with the integer.</p>
 <h2><a name="synopsis">Synopsis</a></h2>

 <blockquote><pre>
+#include &lt;type_traits&gt;  <i>// exposition only</i>
+
 #ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY
 #define BOOST_BASE_FROM_MEMBER_MAX_ARITY  10
 #endif
@@ -139,6 +141,11 @@ class boost::base_from_member
 protected:
    MemberType  member;

+#if <i>C++2011 is in use</i>
+    template&lt; typename ...T &gt;
+    explicit constexpr   base_from_member( T&amp;&amp; ...x )
+     noexcept( std::is_nothrow_constructible&lt;MemberType, T...&gt;::value );
+#else
    base_from_member();

    template&lt; typename T1 &gt;
@@ -154,6 +161,7 @@ protected:
     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 );
+#endif
 };
 </pre></blockquote>

@@ -166,13 +174,29 @@ 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
+<p>If the appropriate features of C++2011 are present, there will be a single
+constructor template.  It implements &quot;perfect forwarding&quot; to the best
+constructor call of <code>member</code> (if any).  The constructor template is
+marked both <code>constexpr</code> and <code>explicit</code>.  The former will
+be ignored if the corresponding inner constructor call (of <code>member</code>)
+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 <code>noexcept</code> 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 <code>base_from_member</code>.)</p>
+
+<p>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.</p>
+
+<p>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>
+the data member's desired constructor.  Explicit conversions may be
+necessary.</p>

 <p>The <var>BOOST_BASE_FROM_MEMBER_MAX_ARITY</var> macro constant specifies
 the maximum argument length for the constructor templates.  The constant
@@ -180,7 +204,7 @@ 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>
+constructors.)  This constant is ignored when C++2011 features are present.</p>

 <h2><a name="usage">Usage</a></h2>

@@ -323,11 +347,14 @@ constructor argument for <code>pbase0_type</code> is converted from
 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>
+forms of the null-pointer literal in C++ (except <code>nullptr</code> from
+C++2011) 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.  (If C++2011's <code>nullptr</code> is
+used, it still needs a conversion if multiple pointer types can be accepted in
+a constructor call but <code>std::nullptr_t</code> cannot.)</p>

 <h2><a name="credits">Credits</a></h2>

@@ -360,9 +387,9 @@ with the exact pointer type used in <code>switcher</code>'s constructor.</p>

 <hr>

-<p>Revised: 28 August 2004</p>
+<p>Revised: 16 February 2012</p>

-<p>Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and distribution
+<p>Copyright 2001, 2003, 2004, 2012 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>
--- a/call_traits_test.cpp
+++ b/call_traits_test.cpp
@@ -210,8 +210,10 @@ int main()
   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)
@@ -292,7 +294,11 @@ 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;
 }

--- a/doc/declval.qbk
+++ b/doc/declval.qbk
@@ -1,6 +1,7 @@
 [/
 / Copyright (c) 2008 Howard Hinnant
- / Copyright (c) 2009-20012 Vicente J. Botet Escriba
+ / Copyright (c) 2008 Beman Dawes
+ / Copyright (c) 2009-20010 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)
@@ -9,9 +10,11 @@
 [article Declval
    [quickbook 1.5]
    [authors [Hinnant, Howard]]
+    [authors [Dawes, Beman]]
    [authors [Botet Escriba, Vicente J.]]
    [copyright 2008 Howard Hinnant]
-    [copyright 2009-2012 Vicente J. Botet Escriba]
+    [copyright 2008 Beman Dawes]
+    [copyright 2009-2010 Vicente J. Botet Escriba]
    [license
        Distributed under the Boost Software License, Version 1.0.
        (See accompanying file LICENSE_1_0.txt or copy at
@@ -74,7 +77,7 @@ This extremely light-weight function is expected to be part of the daily tool-bo
    namespace boost {

        template <typename T>
-        typename add_rvalue_reference<T>::type declval() noexcept; // as unevaluated operand
+        typename add_rvalue_reference<T>::type declval(); //noexcept; // as unevaluated operand

    }  // namespace boost

@@ -97,19 +100,5 @@ Declares a function template convert which only participates in overloading if t

 [endsect]

-[/===============]
-[section History]
-[/===============]
-
-[heading boost 1.50]
-
-Fixes:
-
-* [@http://svn.boost.org/trac/boost/ticket/6570 #6570] Adding noexcept to boost::declval.
- 	
-
-[endsect]
-
-


--- a/doc/html/declval.html
+++ b/doc/html/declval.html
@@ -3,7 +3,7 @@
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Declval</title>
 <link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="declval.html" title="Declval">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -27,13 +27,17 @@
 <span class="firstname">Howard</span> <span class="surname">Hinnant</span>
 </h3></div>
 <div class="author"><h3 class="author">
+<span class="firstname">Beman</span> <span class="surname">Dawes</span>
+</h3></div>
+<div class="author"><h3 class="author">
 <span class="firstname">Vicente J.</span> <span class="surname">Botet Escriba</span>
 </h3></div>
 </div></div>
 <div><p class="copyright">Copyright &#169; 2008 Howard Hinnant</p></div>
-<div><p class="copyright">Copyright &#169; 2009 -2012 Vicente J. Botet Escriba</p></div>
+<div><p class="copyright">Copyright &#169; 2008 Beman Dawes</p></div>
+<div><p class="copyright">Copyright &#169; 2009, 2010 Vicente J. Botet Escriba</p></div>
 <div><div class="legalnotice">
-<a name="idp13449552"></a><p>
+<a name="id3354293"></a><p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
@@ -46,7 +50,6 @@
 <dl>
 <dt><span class="section"><a href="declval.html#declval.overview">Overview</a></span></dt>
 <dt><span class="section"><a href="declval.html#declval.reference">Reference </a></span></dt>
-<dt><span class="section"><a href="declval.html#declval.history">History</a></span></dt>
 </dl>
 </div>
 <div class="section">
@@ -119,7 +122,7 @@
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>

    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-    <span class="keyword">typename</span> <span class="identifier">add_rvalue_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">declval</span><span class="special">()</span> <span class="identifier">noexcept</span><span class="special">;</span> <span class="comment">// as unevaluated operand
+    <span class="keyword">typename</span> <span class="identifier">add_rvalue_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">declval</span><span class="special">();</span> <span class="comment">//noexcept; // as unevaluated operand
 </span>
 <span class="special">}</span>  <span class="comment">// namespace boost
 </span></pre>
@@ -149,25 +152,9 @@
      if the type From can be explicitly converted to type To.
    </p>
 </div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="declval.history"></a><a class="link" href="declval.html#declval.history" title="History">History</a>
-</h2></div></div></div>
-<a name="declval.history.boost_1_50"></a><h4>
-<a name="idp13553216"></a>
-      <a class="link" href="declval.html#declval.history.boost_1_50">boost 1.50</a>
-    </h4>
-<p>
-      Fixes:
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
-          <a href="http://svn.boost.org/trac/boost/ticket/6570" target="_top">#6570</a>
-          Adding noexcept to boost::declval.
-        </li></ul></div>
-</div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: May 28, 2012 at 18:59:06 GMT</small></p></td>
+<td align="left"><p><small>Last revised: April 06, 2011 at 20:06:10 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
--- a/identity_type/doc/Jamfile.v2
+++ b/identity_type/doc/Jamfile.v2
@@ -15,7 +15,7 @@ doxygen reference : ../../../../boost/utility/identity_type.hpp
        <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\" "
+        <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{1}=\"\\xmlonly<link linkend='boost_utility_identitytype.\\1'>\\1</link>\\endxmlonly\" RefSectId{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.
@@ -29,16 +29,3 @@ boostbook doc : index
        <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 ;
--- a/identity_type/doc/html/index.html
+++ b/identity_type/doc/html/index.html
@@ -4,8 +4,8 @@
        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.
+    This library allows to wrap type expressions within round parenthesis so they
+    can be passed to macros even when they contain commas.
  </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
@@ -36,23 +36,21 @@
          <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.
+      round parameters <code class="computeroutput"><span class="special">()</span></code>. Angular
+      <code class="computeroutput"><span class="special">&lt;&gt;</span></code> or squared <code class="computeroutput"><span class="special">[]</span></code> parenthesis are not used by the preprocessor
+      when parsing the 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>):
+      pass the type expression to the macro all together. For example, in some cases
+      a <code class="computeroutput"><span class="keyword">typedef</span></code> can be 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>
+      When this is not possible or desired (e.g., see the function template <code class="computeroutput"><span class="identifier">f</span></code> in the section below), the 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>).
@@ -62,21 +60,15 @@
 <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
+      This 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.
+      compiler (because 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>
    </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
@@ -102,12 +94,11 @@
 </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,
+      must be manually specified when invoking the function <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
+      as in <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>. <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
@@ -127,14 +118,15 @@
    </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.
+      be worked around 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>):
+      and removing a reference to it (see also <a href="../../test/tmp_assert.cpp" target="_top"><code class="literal">tmp_assert.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>
@@ -158,36 +150,31 @@
    </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>):
+      so far), or internally in the definition of 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 user macro definition, the call of the user macro will only
+      have to specify the extra parenthesis (see also <a href="../../test/tmp_assert.cpp" target="_top"><code class="literal">tmp_assert.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
+      However, note that the user 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>
+      within the user macro definition might provide the best syntax for the user.
+      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>:
@@ -210,9 +197,7 @@
      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>).
+      contain no comma.
    </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>
@@ -236,8 +221,8 @@

 <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>
+</span>BOOST_IDENTITY_TYPE(parenthesized_type)</pre></div><div class="refsect1" title="Description"><a name="id512092"></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 require variadic macros).</p><p>This macro must be prefixed by <code class="computeroutput">typename</code> when used within templates. However, 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 an abstract types requires to add and remove a reference to the 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
@@ -247,6 +232,6 @@
        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.
+        the code listed in this documentation. This code is for explanatory purposes
+        only.
      </p></div></div></div></body></html>
--- a/identity_type/doc/identity_type.qbk
+++ b/identity_type/doc/identity_type.qbk
@@ -19,13 +19,12 @@
    [category Utilities]
 ]

-This library allows to wrap types within round parenthesis so they can always be passed as macro parameters.
+This library allows to wrap type expressions within round parenthesis so they can be passed to macros even when they contain commas.

 [import ../test/var_error.cpp]
 [import ../test/var.cpp]
 [import ../test/template.cpp]
-[import ../test/abstract.cpp]
-[import ../test/paren.cpp]
+[import ../test/tmp_assert.cpp]

 [section Motivation]

@@ -47,32 +46,30 @@ The preprocessor interprets that unwrapped comma as a separation between macro p
 # `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.
+Note that, differently from the compiler, the preprocessor only recognizes round parameters `()`.
+Angular `<>` or squared `[]` parenthesis are not used by the preprocessor when parsing the 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=]):
+For example, in some cases a `typedef` can be 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=]).
+When this is not possible or desired (e.g., see the function template `f` in the section below), the 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.
+This 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]).
+This macro works on any [@http://www.open-std.org/JTC1/SC22/WG21/docs/standards C++03] compiler (because 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]

@@ -84,8 +81,8 @@ For example, let's program a macro that declares a function parameter named `arg
 [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.
+However, note that the template parameter `char` must be manually specified when invoking the function `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 in `f(a)`.
 [footnote
 This is because the implementation of [macroref BOOST_IDENTITY_TYPE] wraps the specified type within a meta-function.
 ]
@@ -100,28 +97,28 @@ In other words, without using the [macroref BOOST_IDENTITY_TYPE] macro, C++ woul
 [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.
+This can be worked around 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=]):
+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/tmp_assert.cpp =tmp_assert.cpp=]):

-[abstract]
+[tmp_assert_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=]):
+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 in the definition of a user-defined macro (as shown below).
+When [macroref BOOST_IDENTITY_TYPE] is used in the user macro definition, the call of the user macro will only have to specify the extra parenthesis (see also [@../../test/tmp_assert.cpp =tmp_assert.cpp=]):

-[paren]
+[tmp_assert_alternative]

-However, note that the caller will /always/ have to specify the extra parenthesis even when the macro parameters contain no comma:
+However, note that the user will /always/ have to specify the extra parenthesis even when the macro parameters contain no comma:

-[paren_always]
+[tmp_assert_alternative_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.
+In some cases, using [macroref BOOST_IDENTITY_TYPE] within the user macro definition might provide the best syntax for the user.
 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.
@@ -138,7 +135,7 @@ For example, this is the case for [@http://www.boost.org/libs/local_function `BO
        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)`).
+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.

 [endsect]

@@ -147,7 +144,7 @@ Instead requiring the user to specify [macroref BOOST_IDENTITY_TYPE] only when n
 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.
+This code is for explanatory purposes only.
 ]

    #include <boost/type_traits/function_traits.hpp>
--- a/identity_type/test/Jamfile.v2
+++ b/identity_type/test/Jamfile.v2
@@ -10,7 +10,5 @@ import testing ;
 compile-fail var_error.cpp ;
 run var.cpp ;
 run template.cpp ;
-run abstract.cpp ;
-run noncopyable.cpp ;
-run paren.cpp ;
+run tmp_assert.cpp ;

--- a/identity_type/test/abstract.cpp
+++ b/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; }
-
--- a/identity_type/test/noncopyable.cpp
+++ b/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; }
-
--- a/identity_type/test/tmp_assert.cpp
+++ b/identity_type/test/tmp_assert.cpp
@@ -8,26 +8,44 @@
 #include <boost/utility/identity_type.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 #include <map>

-//[paren
+//[tmp_assert_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
+);
+//]
+
+//[tmp_assert_alternative
 #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_alternative_always
 TMP_ASSERT_PAREN((boost::is_const<int const>)); // Always extra `((...))`.
-
 TMP_ASSERT(boost::is_const<int const>); // No extra `((...))` and no macro.
 //]

--- a/include/boost/assert.hpp
+++ b/include/boost/assert.hpp
@@ -101,7 +101,12 @@ namespace boost
              << "***** Internal Program Error - assertion (" << expr << ") failed in "
              << function << ":\n"
              << file << '(' << line << "): " << msg << std::endl;
-            std::abort();
+			#ifdef UNDER_CE
+				// The Windows CE CRT library does not have abort() so use exit(-1) instead.
+				std::exit(-1);
+			#else
+				std::abort();
+			#endif
          }
        } // detail
      } // assertion
--- a/include/boost/utility.hpp
+++ b/include/boost/utility.hpp
@@ -13,7 +13,6 @@
 #include <boost/utility/base_from_member.hpp>
 #include <boost/utility/binary.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <boost/utility/identity_type.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/next_prior.hpp>
 #include <boost/noncopyable.hpp>
--- a/include/boost/utility/base_from_member.hpp
+++ b/include/boost/utility/base_from_member.hpp
@@ -1,6 +1,6 @@
 //  boost utility/base_from_member.hpp header file  --------------------------//

-//  Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and
+//  Copyright 2001, 2003, 2004, 2012 Daryle Walker.  Use, modification, and
 //  distribution are subject to the Boost Software License, Version 1.0.  (See
 //  accompanying file LICENSE_1_0.txt or a copy at
 //  <http://www.boost.org/LICENSE_1_0.txt>.)
@@ -10,10 +10,15 @@
 #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  ------------------------------//
@@ -53,6 +58,59 @@
 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_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
@@ -68,12 +126,24 @@ class base_from_member
 protected:
    MemberType  member;

+#if !defined(BOOST_NO_RVALUE_REFERENCES) && \
+    !defined(BOOST_NO_VARIADIC_TEMPLATES) && \
+    !defined(BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+    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()
        {}

    BOOST_PP_REPEAT_FROM_TO( 1, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
     BOOST_PRIVATE_CTR_DEF, _ )
+#endif

 };  // boost::base_from_member

--- a/include/boost/utility/declval.hpp
+++ b/include/boost/utility/declval.hpp
@@ -13,7 +13,6 @@
 //----------------------------------------------------------------------------//

 #include <boost/type_traits/add_rvalue_reference.hpp>
-//#include <boost/type_traits/add_lvalue_reference.hpp>

 //----------------------------------------------------------------------------//
 //                                                                            //
@@ -37,13 +36,9 @@

 namespace boost {

-//#if !defined(BOOST_NO_RVALUE_REFERENCES)
    template <typename T>
-    typename add_rvalue_reference<T>::type declval() BOOST_NOEXCEPT; // as unevaluated operand
-//#else
-//    template <typename T>
-//    typename add_lvalue_reference<T>::type declval() BOOST_NOEXCEPT; // as unevaluated operand
-//#endif
+    typename add_rvalue_reference<T>::type declval(); //noexcept; // as unevaluated operand
+
 }  // namespace boost

 #endif  // BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP
--- a/include/boost/utility/detail/result_of_iterate.hpp
+++ b/include/boost/utility/detail/result_of_iterate.hpp
@@ -5,11 +5,6 @@
 //  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!
@@ -23,29 +18,31 @@
 #endif

 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of<F(BOOST_RESULT_OF_ARGS)>
    : mpl::if_<
          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
        , boost::detail::tr1_result_of_impl<
-            typename remove_cv<F>::type,
-            typename remove_cv<F>::type(BOOST_RESULT_OF_ARGS),
+            typename remove_cv<F>::type, 
+            typename remove_cv<F>::type(BOOST_RESULT_OF_ARGS), 
            (boost::detail::has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
-            F(BOOST_RESULT_OF_ARGS),
+            F(BOOST_RESULT_OF_ARGS), 
            (boost::detail::has_result_type<F>::value)> >::type { };
 #endif

-#ifdef BOOST_RESULT_OF_USE_DECLTYPE
+#if !defined(BOOST_NO_DECLTYPE) && defined(BOOST_RESULT_OF_USE_DECLTYPE)

 // Uses declval following N3225 20.7.7.6 when F is not a pointer.
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+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_<
-          is_member_function_pointer<F>
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
        , detail::tr1_result_of_impl<
-            typename remove_cv<F>::type,
+            typename remove_cv<F>::type, 
            typename remove_cv<F>::type(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
          >
        , detail::cpp0x_result_of_impl<
@@ -56,119 +53,53 @@ struct result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>

 namespace detail {

-#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());
-
-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_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())
-  : mpl::eval_if<
-        is_class<typename remove_reference<F>::type>,
-        result_of_wrap_callable_class<F>,
-        mpl::identity<BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<typename remove_cv<F>::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 mpl::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>
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
 {
  typedef decltype(
    boost::declval<F>()(
-      BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
+      BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), declval<T, >() BOOST_PP_INTERCEPT)
    )
  ) type;
 };

-#else // BOOST_NO_SFINAE_EXPR
+} // namespace detail 

-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)
+#else // defined(BOOST_NO_DECLTYPE)

 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+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)>
    : tr1_result_of<F(BOOST_RESULT_OF_ARGS)> { };
 #endif

-#endif // defined(BOOST_RESULT_OF_USE_DECLTYPE)
+#endif // defined(BOOST_NO_DECLTYPE)

 #undef BOOST_RESULT_OF_ARGS

-#if BOOST_PP_ITERATION() >= 1
+#if BOOST_PP_ITERATION() >= 1 

 namespace detail {

-template<typename R,  typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
 {
  typedef R type;
 };

-template<typename R,  typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (&)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
 {
  typedef R type;
 };

 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T)),
                 FArgs, false>
@@ -176,7 +107,8 @@ 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)>
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                     const,
@@ -185,7 +117,8 @@ 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)>
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                     volatile,
@@ -194,7 +127,8 @@ 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)>
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                     const volatile,
--- a/include/boost/utility/identity_type.hpp
+++ b/include/boost/utility/identity_type.hpp
@@ -28,15 +28,14 @@ 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 works on any C++03 compiler (it does not require 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).
+However, 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.
+On some compilers (like GCC), using this macro on an abstract types requires to
+add and remove a reference to the type.
 */
 #define BOOST_IDENTITY_TYPE(parenthesized_type) \
    /* must NOT prefix this with `::` to work with parenthesized syntax */ \
--- a/include/boost/utility/result_of.hpp
+++ b/include/boost/utility/result_of.hpp
@@ -10,50 +10,26 @@
 #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_binary_params.hpp> 
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp> 
+#include <boost/preprocessor/facilities/intercept.hpp> 
 #include <boost/detail/workaround.hpp>
 #include <boost/mpl/has_xxx.hpp>
 #include <boost/mpl/if.hpp>
-#include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/bool.hpp>
-#include <boost/mpl/identity.hpp>
 #include <boost/mpl/or.hpp>
-#include <boost/type_traits/is_class.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/type_traits/is_member_function_pointer.hpp>
 #include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_reference.hpp>
 #include <boost/utility/declval.hpp>
-#include <boost/utility/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 either BOOST_RESULT_OF_USE_DECLTYPE or
-// BOOST_RESULT_OF_USE_TR1, but not both!
-#if defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_RESULT_OF_USE_TR1)
-#  error Both BOOST_RESULT_OF_USE_DECLTYPE and BOOST_RESULT_OF_USE_TR1 cannot be defined at the same time.
-#endif
-
-#ifndef BOOST_RESULT_OF_USE_TR1
-#  ifndef BOOST_RESULT_OF_USE_DECLTYPE
-#    ifndef BOOST_NO_DECLTYPE_N3276 // this implies !defined(BOOST_NO_DECLTYPE)
-#      define BOOST_RESULT_OF_USE_DECLTYPE
-#    else
-#      define BOOST_RESULT_OF_USE_TR1
-#    endif
-#  endif
-#endif
-
 namespace boost {

 template<typename F> struct result_of;
@@ -65,67 +41,7 @@ namespace detail {
 BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)

 template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
-
-#ifdef BOOST_NO_SFINAE_EXPR
-
-struct result_of_private_type {};
-
-struct result_of_weird_type {
-  friend result_of_private_type operator,(result_of_private_type, result_of_weird_type);
-};
-
-typedef char result_of_yes_type;      // sizeof(result_of_yes_type) == 1
-typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type)  == 2
-
-template<typename T>
-result_of_no_type result_of_is_private_type(T const &);
-result_of_yes_type result_of_is_private_type(result_of_private_type);
-
-template<typename C>
-struct result_of_callable_class : C {
-    result_of_callable_class();
-    typedef result_of_private_type const &(*pfn_t)(...);
-    operator pfn_t() const volatile;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class {
-  typedef result_of_callable_class<C> type;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class<C const> {
-  typedef result_of_callable_class<C> const type;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class<C volatile> {
-  typedef result_of_callable_class<C> volatile type;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class<C const volatile> {
-  typedef result_of_callable_class<C> const volatile type;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class<C &> {
-  typedef typename result_of_wrap_callable_class<C>::type &type;
-};
-
-template<typename F, bool TestCallability = true> struct cpp0x_result_of_impl;
-
-#else // BOOST_NO_SFINAE_EXPR
-
-template<typename T>
-struct result_of_always_void
-{
-  typedef void type;
-};
-
-template<typename F, typename Enable = void> struct cpp0x_result_of_impl {};
-
-#endif // BOOST_NO_SFINAE_EXPR
+template<typename F> struct cpp0x_result_of_impl;

 template<typename F>
 struct result_of_void_impl
--- a/index.html
+++ b/index.html
@@ -14,21 +14,28 @@
 		<p>But that doesn't mean there isn't useful stuff here. Take a look:</p>
 		<blockquote>
 			<p>
+				<a href="utility.htm#addressof">addressof</a><br>
 				<a href="assert.html">assert</a><br>
 				<a href="base_from_member.html">base_from_member</a><br>
+				<a href="utility.htm#BOOST_BINARY">BOOST_BINARY</a><br>
 				<a href="call_traits.htm">call_traits</a><br>
 				<a href="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="doc/html/declval.html">declval</a><br>
-				<a href="enable_if.html">enable_if</a><br>
+            <a href="doc/html/declval.html">declval</a><br>
+            <a href="enable_if.html">enable_if</a><br>
+				<a href="in_place_factories.html">in_place_factory</a><br>
            <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
            <a href="generator_iterator.htm">generator iterator adaptors</a><br>
+				<a href="utility.htm#functions_next_prior">next/prior</a><br>
+				<a href="utility.htm#Class_noncopyable">noncopyable</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="value_init.htm">value_init</a></p>
+            <a href="value_init.htm">value_init</a>
+         </p>
 		</blockquote>
 		<hr>
 		<p>&copy; Copyright Beman Dawes, 2001</p>
@@ -41,4 +48,3 @@
 			<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->07 November, 2006<!--webbot bot="Timestamp" endspan i-checksum="39368" --></p>
 		</body>
 </html>
-
--- a/test/result_of_test.cpp
+++ b/test/result_of_test.cpp
@@ -5,7 +5,7 @@
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)

-#include <boost/config.hpp>
+#define BOOST_RESULT_OF_USE_DECLTYPE

 // For more information, see http://www.boost.org/libs/utility
 #include <boost/utility/result_of.hpp>
@@ -62,9 +62,6 @@ struct int_result_type_and_float_result_of_and_char_return_template
  char operator()(char);
 };

-template<typename T>
-struct cv_overload_check {};
-
 struct result_of_member_function_template
 {
  template<typename F> struct result;
@@ -72,13 +69,13 @@ struct result_of_member_function_template
  template<typename This, typename That> struct result<This(That)> { typedef That type; };
  template<class T> typename result<result_of_member_function_template(T)>::type operator()(T);

-  template<typename This, typename That> struct result<const This(That)> { typedef cv_overload_check<const That> type; };
+  template<typename This, typename That> struct result<const This(That)> { typedef const That type; };
  template<class T> typename result<const result_of_member_function_template(T)>::type operator()(T) const;

-  template<typename This, typename That> struct result<volatile This(That)> { typedef cv_overload_check<volatile That> type; };
+  template<typename This, typename That> struct result<volatile This(That)> { typedef volatile That type; };
  template<class T> typename result<volatile result_of_member_function_template(T)>::type operator()(T) volatile;

-  template<typename This, typename That> struct result<const volatile This(That)> { typedef cv_overload_check<const volatile That> type; };
+  template<typename This, typename That> struct result<const volatile This(That)> { typedef const volatile That type; };
  template<class T> typename result<const volatile result_of_member_function_template(T)>::type operator()(T) const volatile;

  template<typename This, typename That> struct result<This(That &, That)> { typedef That & type; };
@@ -94,16 +91,13 @@ struct result_of_member_function_template
  template<class T> typename result<result_of_member_function_template(T const volatile &, T)>::type operator()(T const volatile &, T);
 };

-struct no_result_type_or_result
+struct no_result_type_or_result_of
 {
-  short operator()(double);
-  cv_overload_check<const short> operator()(double) const;
-  cv_overload_check<volatile short> operator()(double) volatile;
-  cv_overload_check<const volatile short> operator()(double) const volatile;
-  int operator()();
-  cv_overload_check<const int> operator()() const;
-  cv_overload_check<volatile int> operator()() volatile;
-  cv_overload_check<const volatile int> operator()() const volatile;
+  int operator()(double);
+  short operator()(double) const;
+  unsigned int operator()();
+  unsigned short operator()() volatile;
+  const unsigned short operator()() const volatile;
 #if !defined(BOOST_NO_RVALUE_REFERENCES)
  short operator()(int&&);
  int operator()(int&);
@@ -112,16 +106,13 @@ struct no_result_type_or_result
 };

 template<typename T>
-struct no_result_type_or_result_template
+struct no_result_type_or_result_of_template
 {
-  short operator()(double);
-  cv_overload_check<const short> operator()(double) const;
-  cv_overload_check<volatile short> operator()(double) volatile;
-  cv_overload_check<const volatile short> operator()(double) const volatile;
-  int operator()();
-  cv_overload_check<const int> operator()() const;
-  cv_overload_check<volatile int> operator()() volatile;
-  cv_overload_check<const volatile int> operator()() const volatile;
+  int operator()(double);
+  short operator()(double) const;
+  unsigned int operator()();
+  unsigned short operator()() volatile;
+  const unsigned short operator()() const volatile;
 #if !defined(BOOST_NO_RVALUE_REFERENCES)
  short operator()(int&&);
  int operator()(int&);
@@ -129,27 +120,6 @@ struct no_result_type_or_result_template
 #endif
 };

-// sfinae_tests are derived from example code from Joel de Guzman,
-// which demonstrated the interaction between result_of and SFINAE.
-template <typename F, typename Arg>
-typename boost::result_of<F(Arg const&)>::type
-sfinae_test(F f, Arg const& arg)
-{
-    return f(arg);
-}
-
-template <typename F, typename Arg>
-typename boost::result_of<F(Arg&)>::type
-sfinae_test(F f, Arg& arg)
-{
-    return f(arg);
-}
-
-int sfinae_test_f(int& i)
-{
-    return i;
-}
-
 struct X {};

 int main()
@@ -160,10 +130,6 @@ int main()
  typedef int (&func_ref)(float, double);
  typedef int (*func_ptr_0)();
  typedef int (&func_ref_0)();
-  typedef void (*func_ptr_void)(float, double);
-  typedef void (&func_ref_void)(float, double);
-  typedef void (*func_ptr_void_0)();
-  typedef void (&func_ref_void_0)();
  typedef int (X::*mem_func_ptr)(float);
  typedef int (X::*mem_func_ptr_c)(float) const;
  typedef int (X::*mem_func_ptr_v)(float) volatile;
@@ -191,7 +157,7 @@ int main()

  // Prior to decltype, result_of could not deduce the return type
  // nullary function objects unless they exposed a result_type.
-#if defined(BOOST_RESULT_OF_USE_DECLTYPE)
+#if !defined(BOOST_NO_DECLTYPE)
  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(void)>::type, int>::value));
@@ -203,11 +169,14 @@ int main()
  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of_template<void>(void)>::type, void>::value));
 #endif

+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, int>::value));
+
  // Prior to decltype, result_of ignored a nested result<> if
  // result_type was defined. After decltype, result_of deduces the
  // actual return type of the function object, ignoring both
  // result<> and result_type.
-#if defined(BOOST_RESULT_OF_USE_DECLTYPE)
+#if !defined(BOOST_NO_DECLTYPE)
  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, char>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, char>::value));
 #else
@@ -215,52 +184,41 @@ int main()
  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, int>::value));
 #endif

-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, int>::value));
-
  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(char, float)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<func_ref(char, float)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr_0()>::type, int>::value)); 
  BOOST_STATIC_ASSERT((is_same<result_of<func_ref_0()>::type, int>::value)); 
-  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr_void(char, float)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<func_ref_void(char, float)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr_void_0()>::type, void>::value)); 
-  BOOST_STATIC_ASSERT((is_same<result_of<func_ref_void_0()>::type, void>::value)); 
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_c(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_v(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_cv(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_0(X)>::type, int>::value)); 
+  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(void)>::type, int>::value));

  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr(char, float)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref(char, float)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr_0()>::type, int>::value)); 
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref_0()>::type, int>::value)); 
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr_void(char, float)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref_void(char, float)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr_void_0()>::type, void>::value)); 
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref_void_0()>::type, void>::value)); 
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_c(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_v(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_cv(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_0(X)>::type, int>::value)); 
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr(void)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref(void)>::type, int>::value));

  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(double)>::type, double>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const result_of_member_function_template(double)>::type, cv_overload_check<const double> >::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<volatile result_of_member_function_template(double)>::type, cv_overload_check<volatile double> >::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const volatile result_of_member_function_template(double)>::type, cv_overload_check<const volatile double> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const result_of_member_function_template(double)>::type, const double>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile result_of_member_function_template(double)>::type, volatile double>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const volatile result_of_member_function_template(double)>::type, const volatile double>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int &, int)>::type, int &>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int const &, int)>::type, int const &>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int volatile &, int)>::type, int volatile &>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int const volatile &, int)>::type, int const volatile &>::value));

  BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(double)>::type, double>::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<const result_of_member_function_template(double)>::type, cv_overload_check<const double> >::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<volatile result_of_member_function_template(double)>::type, cv_overload_check<volatile double> >::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<const volatile result_of_member_function_template(double)>::type, cv_overload_check<const volatile double> >::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<const result_of_member_function_template(double)>::type, const double>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<volatile result_of_member_function_template(double)>::type, volatile double>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<const volatile result_of_member_function_template(double)>::type, const volatile double>::value));
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int &, int)>::type, int &>::value));
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int const &, int)>::type, int const &>::value));
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int volatile &, int)>::type, int volatile &>::value));
@@ -273,38 +231,26 @@ int main()
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<pf_t(int)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<tr1_result_of<pf_t const(int)>::type,int>::value));

-#if defined(BOOST_RESULT_OF_USE_DECLTYPE)
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(double)>::type, short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result(double)>::type, cv_overload_check<const short> >::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result(double)>::type, cv_overload_check<volatile short> >::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result(double)>::type, cv_overload_check<const volatile short> >::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(void)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result(void)>::type, cv_overload_check<const int> >::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result(void)>::type, cv_overload_check<volatile int> >::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result(void)>::type, cv_overload_check<const volatile int> >::value));
-
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(double)>::type, short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_template<void>(double)>::type, cv_overload_check<const short> >::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_template<void>(double)>::type, cv_overload_check<volatile short> >::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_template<void>(double)>::type, cv_overload_check<const volatile short> >::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(void)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_template<void>(void)>::type, cv_overload_check<const int> >::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_template<void>(void)>::type, cv_overload_check<volatile int> >::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_template<void>(void)>::type, cv_overload_check<const volatile int> >::value));
+#if !defined(BOOST_NO_DECLTYPE)
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(void)>::type, unsigned int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_of(double)>::type, short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_of(void)>::type, unsigned short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_of(void)>::type, const unsigned short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(void)>::type, unsigned int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_of_template<void>(double)>::type, short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_of_template<void>(void)>::type, unsigned short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_of_template<void>(void)>::type, const unsigned short>::value));
 #if !defined(BOOST_NO_RVALUE_REFERENCES)
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(int&&)>::type, short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(int&)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(int const&)>::type, long>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(int&&)>::type, short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(int&)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(int const&)>::type, long>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(int&&)>::type, short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(int&)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(int const&)>::type, long>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(int&&)>::type, short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(int&)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(int const&)>::type, long>::value));
 #endif
 #endif

-#if defined(BOOST_RESULT_OF_USE_DECLTYPE)
-  int i = 123;
-  sfinae_test(sfinae_test_f, i);
-#endif // defined(BOOST_RESULT_OF_USE_DECLTYPE)
-
  return 0;
 }
--- a/utility.htm
+++ b/utility.htm
@@ -143,7 +143,7 @@ void f() {
                <h2><a name="result_of">Class template
                result_of</a></h2> <p>The class template
                <code>result_of</code> helps determine the type of a
-                call expression. For example, given an lvalue <code>f</code> of
+                call expression. Given an lvalue <code>f</code> of
                type <code>F</code> and lvalues <code>t1</code>,
                <code>t2</code>, ..., <code>t<em>N</em></code> of
                types <code>T1</code>, <code>T2</code>, ...,
@@ -161,18 +161,16 @@ void f() {
                resides in the header <code>&lt;<a
                href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>&gt;</code>.</p>

-                <p>If your compiler's support for <code>decltype</code> is
-                adequate, <code>result_of</code> automatically uses it to
-                deduce the type of the call expression, in which case
-                <code>result_of&lt;F(T1, T2, ...,
-                T<em>N</em>)&gt;::type</code> names the type
-                <code>decltype(boost::declval&lt;F&gt;()(boost::declval&lt;T1&gt;(),
-                boost::declval&lt;T2&gt;(), ...,
-                boost::declval&lt;T<em>N</em>&gt;()))</code>, as in the
-                following example.</p>
+                <p>If your compiler supports <code>decltype</code>,
+                then you can enable automatic result type deduction by
+                defining the macro <code>BOOST_RESULT_OF_USE_DECLTYPE</code>,
+                as in the following example.</p>

                <blockquote>
-                <pre>struct functor {
+                <pre>#define BOOST_RESULT_OF_USE_DECLTYPE
+#include &lt;boost/utility/result_of.hpp&gt;
+
+struct functor {
    template&lt;class T&gt;
    T operator()(T x)
    {
@@ -182,29 +180,21 @@ void f() {

 typedef boost::result_of&lt;
    functor(int)
-&gt;::type type; // type is int</pre>
+&gt;::type type;</pre>
                </blockquote>

-                <p>You can test whether <code>result_of</code> is using
-                <code>decltype</code> by checking if the macro
-                <code>BOOST_RESULT_OF_USE_DECLTYPE</code> is defined after
-                including <code>result_of.hpp</code>. You can also force
-                <code>result_of</code> to use <code>decltype</code> by
-                defining <code>BOOST_RESULT_OF_USE_DECLTYPE</code> prior
-                to including <code>result_of.hpp</code>.</p>
-
-                <p>If <code>decltype</code> is not used,
+                <p>If <code>decltype</code> is not enabled,
                then automatic result type deduction of function
                objects is not possible. Instead, <code>result_of</code>
                uses the following protocol to allow the programmer to
                specify a type. When <code>F</code> is a class type with a
                member type <code>result_type</code>,
                <code>result_of&lt;F(T1, T2, ...,
-                T<em>N</em>)&gt;::type</code> is
+                T<em>N</em>)&gt;</code> is
                <code>F::result_type</code>. When <code>F</code> does
                not contain <code>result_type</code>,
                <code>result_of&lt;F(T1, T2, ...,
-                T<em>N</em>)&gt;::type</code> is <code>F::result&lt;F(T1,
+                T<em>N</em>)&gt;</code> is <code>F::result&lt;F(T1,
                T2, ..., T<em>N</em>)&gt;::type</code> when
                <code><em>N</em> &gt; 0</code> or <code>void</code>
                when <code><em>N</em> = 0</code>. Note that it is the
@@ -231,29 +221,22 @@ typedef boost::result_of&lt;

 typedef boost::result_of&lt;
    functor(int)
-&gt;::type type; // type is int</pre>
+&gt;::type type;</pre>
                </blockquote>

-                <p>Since <code>decltype</code> is a new language
-                feature recently standardized in C++11,
-                if you are writing a function object
-                to be used with <code>result_of</code>, for
-                maximum portability, you might consider following
-                the above protocol even if your compiler has
-                proper <code>decltype</code> support. If you wish to continue to
+                <p>In a future
+                release, <code>BOOST_RESULT_OF_USE_DECLTYPE</code>
+                may be enabled by default on compilers that
+                support <code>decltype</code>, so if you use the above
+                protocol please take care to ensure that
+                the <code>result_type</code>
+                and <code>result&lt;&gt;</code> members accurately
+                represent the result type. If you wish to continue to
                use the protocol on compilers that
-                support <code>decltype</code>, there are two options:
-                You can use <code>boost::tr1_result_of</code>, which is also
-                defined in <code>&lt;<a href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>&gt;</code>.
-                Alternatively, you can define the macro
-                <code>BOOST_RESULT_OF_USE_TR1</code>, which causes
-                <code>result_of</code> to use the protocol described
-                above instead of <code>decltype</code>. If you choose to
-                follow the protocol, take care to ensure that the
-                <code>result_type</code> and
-                <code>result&lt;&gt;</code> members accurately
-                represent the return type of
-                <code>operator()</code> given a call expression.</p>
+                support <code>decltype</code>,
+                use <code>boost::tr1_result_of</code>, which is also
+                defined
+                in <code>&lt;<a href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>&gt;</code>.</p>

                <a name="BOOST_NO_RESULT_OF"></a>
                <p>This implementation of <code>result_of</code>
@@ -270,322 +253,7 @@ typedef boost::result_of&lt;
                <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf">N1836</a>,
                or, for motivation and design rationale,
                the <code>result_of</code> <a href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1454.html">proposal</a>.</p>
-
-                <a name="result_of_guidelines">
-                <h3>Usage guidelines for boost::result_of</h3>
-                </a>
-
-                <p>The following are general suggestions about when
-                and how to use <code>boost::result_of</code>.</p>
-
-                <ol>
-                <li> If you are targeting C++11 and are not concerned
-                about portability to non-compliant compilers or
-                previous versions of the standard, then use
-                <code>std::result_of</code>. If <code>std::result_of</code>
-                meets your needs, then there's no reason to stop using
-                it.</li>
-
-                <li> If you are targeting C++11 but may port your code
-                to legacy compilers at some time in the future, then
-                use <code>boost::result_of</code> with
-                <code>decltype</code>. When <code>decltype</code> is
-                used <code>boost::result_of</code>
-                and <code>std::result_of</code> are usually
-                interchangeable. See the documentation on
-                known <a href="#result_of_cxx11_diff">differences</a>
-                between boost::result_of and C++11 result_of.</li>
-
-                <li> If compiler portability is required,
-                use <code>boost::result_of</code> with the TR1 protocol.</li>
-                </ol>
-
-                <p>Regardless of how you
-                configure <code>boost::result_of</code>, it is
-                important to bear in mind that the return type of a
-                function may change depending on its arguments, and
-                additionally, the return type of a member function may
-                change depending on the cv-qualification of the
-                object. <code>boost::result_of</code> must be passed
-                the appropriately cv-qualified types in order to
-                deduce the corresponding return type. For example:
-
-                <blockquote>
-                <pre>struct functor {
-    int& operator()(int);
-    int const& operator()(int) const;
-
-    float& operator()(float&);
-    float const& operator()(float const&);
-};
-
-typedef boost::result_of&lt;
-    functor(int)
-&gt;::type type1; // type1 is int &
-
-typedef boost::result_of&lt;
-    const functor(int)
-&gt;::type type2; // type2 is int const &
-
-typedef boost::result_of&lt;
-    functor(float&)
-&gt;::type type3; // type3 is float &
-
-typedef boost::result_of&lt;
-    functor(float const&)
-&gt;::type type4; // type4 is float const &</pre>
-                </blockquote>
-
-                <a name="result_of_tr1_protocol_guidelines">
-                <h3>Usage guidelines for the TR1 result_of protocol</h3>
-                </a>
-
-                <p>On compliant C++11
-                compilers, <code>boost::result_of</code> can
-                use <code>decltype</code> to deduce the type of any
-                call expression, including calls to function
-                objects. However, on pre-C++11 compilers or on
-                compilers without adequate decltype support,
-                additional scaffolding is needed from function
-                objects as described above. The following are
-                suggestions about how to use the TR1 protocol.</p>
-
-                <ul>
-                    <li>When the return type does not depend on the
-                    argument types or the cv-qualification of the
-                    function object, simply
-                    define <code>result_type</code>. There is no need
-                    to use the <code>result</code> template unless the
-                    return type varies.</li>
-
-                    <li>Use the protocol specified type when defining
-                    function prototypes. This can help ensure the
-                    actual return type does not get out of sync with
-                    the protocol specification. For example:
-
-                   <blockquote>
-                   <pre>struct functor {
-    typedef int result_type;
-    result_type operator()(int);
-};</pre>
-                   </blockquote> </li>
-
-                   <li>Always specify the <code>result</code>
-                   specialization near the corresponding
-                   <code>operator()</code> overload. This can make it
-                   easier to keep the specializations in sync with the
-                   overloads. For example:
-
-                   <blockquote>
-                   <pre>struct functor {
-    template&lt;class&gt; struct result;
-
-    template&lt;class F&gt;
-    struct result&lt;F(int)&gt; {
-        typedef int& type;
-    };
-    result&lt;functor(int)&gt;::type operator()(int);
-
-    template&lt;class F&gt;
-    struct result&lt;const F(int)&gt; {
-        typedef int const& type;
-    };
-    result&lt;const functor(int)&gt;::type operator()(int) const;
-};</pre>
-                   </blockquote> </li>
-
-                   <li>Use type transformations to simplify
-                   the <code>result</code> template specialization. For
-                   example, the following uses
-                   <a href="../type_traits/doc/html/index.html">Boost.TypeTraits</a>
-                   to specialize the <code>result</code> template for
-                   a single <code>operator()</code> that can be called on
-                   both a const and non-const function object with
-                   either an lvalue or rvalue argument.
-
-                   <blockquote>
-                   <pre>struct functor {
-    template&lt;class&gt; struct result;
-
-    template&lt;class F, class T&gt;
-    struct result&lt;F(T)&gt; 
-        : boost::remove_cv&lt;
-              typename boost::remove_reference&lt;T&gt;::type
-          &gt;
-    {};
-
-    template&lt;class T&gt;
-    T operator()(T const&amp; x) const;
-};</pre>
-                   </blockquote></li>
-                </ul>
-
-                <a name="result_of_tr1_diff">
-                <h3>Known differences between boost::result_of and TR1 result_of</h3>
-                </a>
-
-                When using <code>decltype</code>, <code>boost::result_of</code>
-                ignores the TR1 protocol and instead deduces the
-                return type of function objects directly
-                via <code>decltype</code>. In most situations, users
-                will not notice a difference, so long as they use the
-                protocol correctly. The following are situations in
-                which the type deduced
-                by <code>boost::result_of</code> is known to differ depending on
-                whether <code>decltype</code> or the TR1 protocol is
-                used.
-
-                <ul>
-                <li> TR1 protocol misusage
-
-                     <p>When using the TR1
-                     protocol, <code>boost::result_of</code> cannot
-                     detect whether the actual type of a call to a
-                     function object is the same as the type specified
-                     by the protocol, which allows for the possibility
-                     of inadvertent mismatches between the specified
-                     type and the actual type. When
-                     using <code>decltype</code>, these subtle bugs
-                     may result in compilation errors. For example:</p>
-
-                     <blockquote>
-                     <pre>struct functor {
-   typedef short result_type;
-   int operator()(short);
-};
-
-#ifdef BOOST_RESULT_OF_USE_DECLTYPE
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;boost::result_of&lt;functor(short)&gt;::type, int&gt;::value
-)); 
-
-#else
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;boost::result_of&lt;functor(short)&gt;::type, short&gt;::value
-));
-
-#endif</pre>
-                   </blockquote>
-
-                  <p>Note that the user can
-                  force <code>boost::result_of</code> to use the TR1
-                  protocol even on platforms that
-                  support <code>decltype</code> by
-                  defining <code>BOOST_RESULT_OF_USE_TR1</code>.</p></li>
-
-                  <li> Nullary function objects
-
-                       <p>When using the TR1 protocol, <code>boost::result_of</code>
-                       cannot always deduce the type of calls to
-                       nullary function objects, in which case the
-                       type defaults to void. When using <code>decltype</code>,
-                       <code>boost::result_of</code> always gives the actual type of the
-                       call expression. For example:</p>
-
-                       <blockquote>
-                       <pre>struct functor {
-   template&lt;class&gt; struct result {
-       typedef int type;
-   };
-   int operator()();
-};
-
-#ifdef BOOST_RESULT_OF_USE_DECLTYPE
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;boost::result_of&lt;functor()&gt;::type, int&gt;::value
-));
-
-#else
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;boost::result_of&lt;functor()&gt;::type, void&gt;::value
-));
-
-#endif</pre>
-                       </blockquote>
-
-                       <p>Note that there are some workarounds for the
-                       nullary function problem. So long as the return
-                       type does not vary,
-                       <code>result_type</code> can always be used to
-                       specify the return type regardless of arity. If the
-                       return type does vary, then the user can
-                       specialize <code>boost::result_of</code> itself for
-                       nullary calls.</p></li>
-
-                  <li> Non-class prvalues and cv-qualification
-
-                       <p>When using the TR1
-                       protocol, <code>boost::result_of</code> will
-                       report the cv-qualified type specified
-                       by <code>result_type</code> or
-                       the <code>result</code> template regardless of
-                       the actual cv-qualification of the call
-                       expression. When using
-                       <code>decltype</code>, <code>boost::result_of</code>
-                       will report the actual type of the call expression,
-                       which is not cv-qualified when the expression is a
-                       non-class prvalue. For example:</p>
-
-                       <blockquote>
-                       <pre>struct functor {
-   template&lt;class&gt; struct result;
-   template&lt;class F, class T&gt; struct result&lt;F(const T)&gt; {
-       typedef const T type;
-   };
-
-   const short operator()(const short);
-   int const & operator()(int const &);
-};
-
-// Non-prvalue call expressions work the same with or without decltype.
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;
-       boost::result_of&lt;functor(int const &)&gt;::type,
-       int const &
-::value
-));
-
-// Non-class prvalue call expressions are not actually cv-qualified,
-// but only the decltype-based result_of reports this accurately.
-
-#ifdef BOOST_RESULT_OF_USE_DECLTYPE
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;
-       boost::result_of&lt;functor(const short)&gt;::type,
-       short
-::value
-));
-
-#else
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;
-       boost::result_of&lt;functor(const short)&gt;::type,
-       const short
-::value
-));
-
-#endif</pre>
-                       </blockquote></li>
-                </ul>
-
-                <a name="result_of_cxx11_diff">
-                <h3>Known differences between boost::result_of and C++11 result_of</h3>
-                </a>
-
-                <p>When using <code>decltype</code>, <code>boost::result_of</code>
-                implements most of the C++11 result_of
-                specification. One known exception is that
-                <code>boost::result_of</code> does not implement the
-                requirements regarding pointers to member data.</p>
-
-                <p>Created by Doug Gregor. Contributions from Daniel Walker, Eric Niebler, Michel Morin and others</p>
+                Contributed by Doug Gregor.</p>

 		<h2>Class templates for the Base-from-Member Idiom</h2>
 		<p>See <a href="base_from_member.html">separate documentation</a>.</p>
--- a/value_init_test.cpp
+++ b/value_init_test.cpp
@@ -22,7 +22,7 @@
 #pragma hdrstop
 #endif

-#include "boost/test/minimal.hpp"
+#include <boost/detail/lightweight_test.hpp>

 //
 // Sample POD type
@@ -215,7 +215,7 @@ template<class T>
 void check_initialized_value ( T const& y )
 {
  T initializedValue = boost::initialized_value ;
-  BOOST_CHECK ( y == initializedValue ) ;
+  BOOST_TEST ( y == initializedValue ) ;
 }

 #ifdef  __BORLANDC__
@@ -245,128 +245,125 @@ void check_initialized_value( NonPOD const& )
 template<class T>
 bool test ( T const& y, T const& z )
 {
-  const boost::unit_test::counter_t counter_before_test = boost::minimal_test::errors_counter();
+  const int errors_before_test = boost::detail::test_errors();

  check_initialized_value(y);

  boost::value_initialized<T> x ;
-  BOOST_CHECK ( y == x ) ;
-  BOOST_CHECK ( y == boost::get(x) ) ;
+  BOOST_TEST ( y == x ) ;
+  BOOST_TEST ( y == boost::get(x) ) ;

  static_cast<T&>(x) = z ;
  boost::get(x) = z ;
-  BOOST_CHECK ( x == z ) ;
+  BOOST_TEST ( x == z ) ;

  boost::value_initialized<T> const x_c ;
-  BOOST_CHECK ( y == x_c ) ;
-  BOOST_CHECK ( y == boost::get(x_c) ) ;
+  BOOST_TEST ( y == x_c ) ;
+  BOOST_TEST ( y == boost::get(x_c) ) ;
  T& x_c_ref = const_cast<T&>( boost::get(x_c) ) ;
  x_c_ref = z ;
-  BOOST_CHECK ( x_c == z ) ;
+  BOOST_TEST ( x_c == z ) ;

  boost::value_initialized<T> const copy1 = x;
-  BOOST_CHECK ( boost::get(copy1) == boost::get(x) ) ;
+  BOOST_TEST ( boost::get(copy1) == boost::get(x) ) ;

  boost::value_initialized<T> copy2;
  copy2 = x;
-  BOOST_CHECK ( boost::get(copy2) == boost::get(x) ) ;
+  BOOST_TEST ( boost::get(copy2) == boost::get(x) ) ;
  
  boost::shared_ptr<boost::value_initialized<T> > ptr( new boost::value_initialized<T> );
-  BOOST_CHECK ( y == *ptr ) ;
+  BOOST_TEST ( y == *ptr ) ;

 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
  boost::value_initialized<T const> cx ;
-  BOOST_CHECK ( y == cx ) ;
-  BOOST_CHECK ( y == boost::get(cx) ) ;
+  BOOST_TEST ( y == cx ) ;
+  BOOST_TEST ( y == boost::get(cx) ) ;

  boost::value_initialized<T const> const cx_c ;
-  BOOST_CHECK ( y == cx_c ) ;
-  BOOST_CHECK ( y == boost::get(cx_c) ) ;
+  BOOST_TEST ( y == cx_c ) ;
+  BOOST_TEST ( y == boost::get(cx_c) ) ;
 #endif

-  return boost::minimal_test::errors_counter() == counter_before_test ;
+  return boost::detail::test_errors() == errors_before_test ;
 }

-int test_main(int, char **)
+int main(int, char **)
 {
-  BOOST_CHECK ( test( 0,1234 ) ) ;
-  BOOST_CHECK ( test( 0.0,12.34 ) ) ;
-  BOOST_CHECK ( test( POD(0,0,0.0), POD('a',1234,56.78f) ) ) ;
-  BOOST_CHECK ( test( NonPOD( std::string() ), NonPOD( std::string("something") ) ) ) ;
+  BOOST_TEST ( test( 0,1234 ) ) ;
+  BOOST_TEST ( test( 0.0,12.34 ) ) ;
+  BOOST_TEST ( test( POD(0,0,0.0), POD('a',1234,56.78f) ) ) ;
+  BOOST_TEST ( test( NonPOD( std::string() ), NonPOD( std::string("something") ) ) ) ;

  NonPOD NonPOD_object( std::string("NonPOD_object") );
-  BOOST_CHECK ( test<NonPOD *>( 0, &NonPOD_object ) ) ;
+  BOOST_TEST ( test<NonPOD *>( 0, &NonPOD_object ) ) ;

  AggregatePODStruct zeroInitializedAggregatePODStruct = { 0.0f, '\0', 0 };
  AggregatePODStruct nonZeroInitializedAggregatePODStruct = { 1.25f, 'a', -1 };
-  BOOST_CHECK ( test(zeroInitializedAggregatePODStruct, nonZeroInitializedAggregatePODStruct) );
+  BOOST_TEST ( test(zeroInitializedAggregatePODStruct, nonZeroInitializedAggregatePODStruct) );

  StringAndInt stringAndInt0;
  StringAndInt stringAndInt1;
  stringAndInt0.i = 0;
  stringAndInt1.i = 1;
  stringAndInt1.s = std::string("1");
-  BOOST_CHECK ( test(stringAndInt0, stringAndInt1) );
+  BOOST_TEST ( test(stringAndInt0, stringAndInt1) );

  StructWithDestructor structWithDestructor0;
  StructWithDestructor structWithDestructor1;
  structWithDestructor0.i = 0;
  structWithDestructor1.i = 1;
-  BOOST_CHECK ( test(structWithDestructor0, structWithDestructor1) );
+  BOOST_TEST ( test(structWithDestructor0, structWithDestructor1) );

  StructWithVirtualFunction structWithVirtualFunction0;
  StructWithVirtualFunction structWithVirtualFunction1;
  structWithVirtualFunction0.i = 0;
  structWithVirtualFunction1.i = 1;
-  BOOST_CHECK ( test(structWithVirtualFunction0, structWithVirtualFunction1) );
+  BOOST_TEST ( test(structWithVirtualFunction0, structWithVirtualFunction1) );

  DerivedFromAggregatePODStruct derivedFromAggregatePODStruct0;
  DerivedFromAggregatePODStruct derivedFromAggregatePODStruct1;
  static_cast<AggregatePODStruct &>(derivedFromAggregatePODStruct0) = zeroInitializedAggregatePODStruct;
  static_cast<AggregatePODStruct &>(derivedFromAggregatePODStruct1) = nonZeroInitializedAggregatePODStruct;
-  BOOST_CHECK ( test(derivedFromAggregatePODStruct0, derivedFromAggregatePODStruct1) );
+  BOOST_TEST ( test(derivedFromAggregatePODStruct0, derivedFromAggregatePODStruct1) );

  AggregatePODStructWrapper aggregatePODStructWrapper0;
  AggregatePODStructWrapper aggregatePODStructWrapper1;
  aggregatePODStructWrapper0.dataMember = zeroInitializedAggregatePODStruct;
  aggregatePODStructWrapper1.dataMember = nonZeroInitializedAggregatePODStruct;
-  BOOST_CHECK ( test(aggregatePODStructWrapper0, aggregatePODStructWrapper1) );
+  BOOST_TEST ( test(aggregatePODStructWrapper0, aggregatePODStructWrapper1) );

  ArrayOfBytes zeroInitializedArrayOfBytes = { 0 };
  boost::value_initialized<ArrayOfBytes> valueInitializedArrayOfBytes;
-  BOOST_CHECK (std::memcmp(get(valueInitializedArrayOfBytes), zeroInitializedArrayOfBytes, sizeof(ArrayOfBytes)) == 0);
+  BOOST_TEST (std::memcmp(get(valueInitializedArrayOfBytes), zeroInitializedArrayOfBytes, sizeof(ArrayOfBytes)) == 0);

  boost::value_initialized<ArrayOfBytes> valueInitializedArrayOfBytes2;
  valueInitializedArrayOfBytes2 = valueInitializedArrayOfBytes;
-  BOOST_CHECK (std::memcmp(get(valueInitializedArrayOfBytes), get(valueInitializedArrayOfBytes2), sizeof(ArrayOfBytes)) == 0);
+  BOOST_TEST (std::memcmp(get(valueInitializedArrayOfBytes), get(valueInitializedArrayOfBytes2), sizeof(ArrayOfBytes)) == 0);

  boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester1;
-  BOOST_CHECK ( ! get(copyFunctionCallTester1).is_copy_constructed);
-  BOOST_CHECK ( ! get(copyFunctionCallTester1).is_assignment_called);
+  BOOST_TEST ( ! get(copyFunctionCallTester1).is_copy_constructed);
+  BOOST_TEST ( ! get(copyFunctionCallTester1).is_assignment_called);

  boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester2 = boost::value_initialized<CopyFunctionCallTester>(copyFunctionCallTester1);
-  BOOST_CHECK ( get(copyFunctionCallTester2).is_copy_constructed);
-  BOOST_CHECK ( ! get(copyFunctionCallTester2).is_assignment_called);
+  BOOST_TEST ( get(copyFunctionCallTester2).is_copy_constructed);
+  BOOST_TEST ( ! get(copyFunctionCallTester2).is_assignment_called);

  boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester3;
  copyFunctionCallTester3 = boost::value_initialized<CopyFunctionCallTester>(copyFunctionCallTester1);
-  BOOST_CHECK ( ! get(copyFunctionCallTester3).is_copy_constructed);
-  BOOST_CHECK ( get(copyFunctionCallTester3).is_assignment_called);
+  BOOST_TEST ( ! get(copyFunctionCallTester3).is_copy_constructed);
+  BOOST_TEST ( get(copyFunctionCallTester3).is_assignment_called);

  boost::value_initialized<SwapFunctionCallTester> swapFunctionCallTester1;
  boost::value_initialized<SwapFunctionCallTester> swapFunctionCallTester2;
  get(swapFunctionCallTester1).data = 1;
  get(swapFunctionCallTester2).data = 2;
  boost::swap(swapFunctionCallTester1, swapFunctionCallTester2);
-  BOOST_CHECK( get(swapFunctionCallTester1).data == 2 );
-  BOOST_CHECK( get(swapFunctionCallTester2).data == 1 );
-  BOOST_CHECK( get(swapFunctionCallTester1).is_custom_swap_called );
-  BOOST_CHECK( get(swapFunctionCallTester2).is_custom_swap_called );
+  BOOST_TEST( get(swapFunctionCallTester1).data == 2 );
+  BOOST_TEST( get(swapFunctionCallTester2).data == 1 );
+  BOOST_TEST( get(swapFunctionCallTester1).is_custom_swap_called );
+  BOOST_TEST( get(swapFunctionCallTester2).is_custom_swap_called );

-  return 0;
+  return boost::report_errors();
 }


-unsigned int expected_failures = 0;
-
-
Author	SHA1	Message	Date
Daniel James	bd926863ae	Quickbook: Merge from trunk. Includes blocks in lists fixes, and some documentation changes. [SVN r77347]	2012-03-16 08:48:10 +00:00
Lorenzo Caminiti	5825b6c329	Fixed test indentation and updated docs. [SVN r77080]	2012-02-20 20:17:07 +00:00
Lorenzo Caminiti	54c78121c2	Updated ScopeExit "world" tests making person a struct instead of a class. Added a code comment to Utility/IdentityType tmp_assert test. [SVN r77071]	2012-02-18 19:29:35 +00:00
Lorenzo Caminiti	2891cb52d6	Added Boost.Utility/IdentityType and Boost.Functional/OverloadedFunction to status/Jamfile.v2 list of regression tests. Updated Boost.ScopeExit documentation. [SVN r77059]	2012-02-17 21:02:00 +00:00
Daryle Walker	0db9276e8c	Fixed (hopefully) conflict between boost::base_from_member's C++11 constructor template and the automatically defined non-template copy- and/or move-constructors. [SVN r77046]	2012-02-17 01:55:33 +00:00
Lorenzo Caminiti	d6cb9a9176	Fixed a bug in BOOST_LOCAL_FUNCTION_DETAIL_PP_VOID_LIST: a typo VOId -> VOID. Fixed a bug in scope_exit.hpp: An extra trailing \ in a macro definition (compiled only when BOOST_NO_VARIADIC_MACROS is defined). Renamed LocalFunction and ScopeExit tests and examples from _err to _error. Updated LocalFunction docs. [SVN r77042]	2012-02-16 18:24:34 +00:00
Daniel James	71e00b0508	Quickbook: Copy trunk libs into quickbook-dev branch. [SVN r75213]	2011-11-01 13:04:29 +00:00
Daniel James	74c609a98b	Quickbook: Copy trunk headers into quickbook-dev. [SVN r75212]	2011-11-01 13:03:44 +00:00
Daniel James	936c2294a4	Quickbook: New branch for development. From now on this will be my development branch. [SVN r70613]	2011-03-27 10:17:05 +00:00