Release 1.51.0

[SVN r80098]

assert.html

@@ -17,36 +17,89 @@
 				<td colspan="2" height="64">&nbsp;</td>
 			</tr>
 		</table>
+		<p>
+			<a href="#BOOST_ASSERT">BOOST_ASSERT</a><br>
+            <a href="#BOOST_ASSERT_MSG">BOOST_ASSERT_MSG</a><br>
+            <a href="#BOOST_VERIFY">BOOST_VERIFY</a></p>
+            
+<h2><a name="BOOST_ASSERT">BOOST_ASSERT</a></h2>
 		<p>
 			The header <STRONG>&lt;boost/assert.hpp&gt;</STRONG> defines the macro <b>BOOST_ASSERT</b>, 
 			which is similar to the standard <STRONG>assert</STRONG> macro defined in <STRONG>&lt;cassert&gt;</STRONG>. 
-			The macro is intended to be used in Boost libraries.
+			The macro is intended to be used in both Boost libraries and user 
+            code.
 		</p>
 		<P>By default, <tt>BOOST_ASSERT(expr)</tt> is equivalent to <tt>assert(expr)</tt>.</P>
-		<P>When the macro <STRONG>BOOST_DISABLE_ASSERTS</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+		<P>If the macro <STRONG>BOOST_DISABLE_ASSERTS</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			is included, <tt>BOOST_ASSERT(expr)</tt> is defined as <tt>((void)0)</tt>. This 
 			allows users to selectively disable <STRONG>BOOST_ASSERT</STRONG> without 
 			affecting the definition of the standard <STRONG>assert</STRONG>.</P>
-		<P>When the macro <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+		<P>If the macro <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			is included, <tt>BOOST_ASSERT(expr)</tt> evaluates <b>expr</b> and, if the 
 			result is false, evaluates the expression</P>
+		<blockquote>
 		<P><tt>::boost::assertion_failed(#expr, <a href="current_function.html">BOOST_CURRENT_FUNCTION</a>, 
 				__FILE__, __LINE__)</tt></P>
+		</blockquote>
 		<P><STRONG>assertion_failed</STRONG> is declared in <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			as</P>
-		<pre>
-namespace boost
+		<blockquote>
+		<pre>namespace boost
 {
-
-void assertion_failed(char const * expr, char const * function, char const * file, long line);
-
+  void assertion_failed(char const * expr, char const * function, char const * file, long line);
 }
 </pre>
+		</blockquote>
 		<p>but it is never defined. The user is expected to supply an appropriate 
 			definition.</p>
 		<P>As is the case with <STRONG>&lt;cassert&gt;</STRONG>, <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			can be included multiple times in a single translation unit. <STRONG>BOOST_ASSERT</STRONG>
 			will be redefined each time as specified above.</P>
+			
+<h2><a name="BOOST_ASSERT_MSG">BOOST_ASSERT_MSG</a></h2>
+		<p>
+			The header <STRONG>&lt;boost/assert.hpp&gt;</STRONG> defines the macro <b>BOOST_ASSERT_MSG</b>, 
+			which is similar to the standard <STRONG>assert</STRONG> macro defined in <STRONG>&lt;cassert&gt;</STRONG>, 
+            but with an additional macro parameter supplying an error message. The macro is intended to be used in both Boost libraries 
+            and user code.
+		</p>
+		<P> <tt>BOOST_ASSERT_MSG(expr, msg)</tt> is equivalent to <code>
+        ((void)0)</code> if <b>BOOST_DISABLE_ASSERTS</b> or <b>NDEBUG</b> are 
+        defined or <code>expr</code> evaluates to <code>true</code>. If those 
+        macros and <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> are not 
+        defined, and <code>expr</code> evaluates to <code>false</code>, an error 
+        message that includes <tt>#expr</tt>, <tt>msg</tt>, <tt> <a href="current_function.html">BOOST_CURRENT_FUNCTION</a></tt>, <tt>
+        __FILE__</tt>, and <tt>__LINE__</tt> is sent to output stream <b>
+        BOOST_ASSERT_MSG_OSTREAM</b> 
+        and <code>std::abort()</code> is called.</P>
+		<P> <b>BOOST_ASSERT_MSG_OSTREAM</b> defines the output stream. It defaults to <code>std::cerr</code>. 
+        Integrated development environments (IDE's) like Microsoft Visual Studio 
+        may produce easier to understand output if messages go to a different 
+        stream, such as <code>std::cout</code>. Users may define <b>BOOST_ASSERT_MSG_OSTREAM</b> before including <STRONG>&lt;boost/assert.hpp&gt;</STRONG> 
+        to specify a different output stream.&nbsp; </P>
+		<P>If the macro <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+			is included, instead of sending a error message to an output 
+        stream, this expression is evaluated</P>
+		<blockquote>
+		<P><tt>::boost::assertion_failed_msg(#expr, msg, <a href="current_function.html">BOOST_CURRENT_FUNCTION</a>, 
+				__FILE__, __LINE__)</tt></P>
+		</blockquote>
+		<P><STRONG>assertion_failed_msg</STRONG> is declared in <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+			as</P>
+		<blockquote>
+		<pre>namespace boost
+{
+  void assertion_failed_msg(char const * expr, char const * msg, char const * function, char const * file, long line);
+}
+</pre>
+		</blockquote>
+		<p>but it is never defined. The user is expected to supply an appropriate 
+			definition.</p>
+		<P>As is the case with <STRONG>&lt;cassert&gt;</STRONG>, <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+			can be included multiple times in a single translation unit. <STRONG>BOOST_ASSERT_MSG</STRONG>
+			will be redefined each time as specified above.</P>
+			
+<h2><a name="BOOST_VERIFY">BOOST_VERIFY</a></h2>
 		<p><STRONG>&lt;boost/assert.hpp&gt;</STRONG> also defines the macro <STRONG>BOOST_VERIFY</STRONG>. 
 			It has exactly the same behavior as <STRONG>BOOST_ASSERT</STRONG>, except that 
 			the expression that is passed to <STRONG>BOOST_VERIFY</STRONG> is always 
@@ -54,8 +107,9 @@ void assertion_failed(char const * expr, char const * function, char const * fil
 			effects; it can also help suppress warnings about unused variables when the 
 			only use of the variable is inside an assertion.</p>
 		<p><br>
-			<small>Copyright <20> 2002, 2007 by Peter Dimov. Distributed under the Boost Software 
+			<small>Copyright <20> 2002, 2007 by Peter Dimov.&nbsp; Copyright <20> 2011 
+        by Beman Dawes. Distributed under the Boost Software 
 				License, Version 1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A>
 				or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
 	</body>
-</html>
+</html>

assert_test.cpp

@@ -2,6 +2,7 @@
 //  assert_test.cpp - a test for boost/assert.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (2) Beman Dawes 2011
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -20,6 +21,11 @@ void test_default()
     BOOST_ASSERT(x);
     BOOST_ASSERT(x == 1);
     BOOST_ASSERT(&x);
+
+    BOOST_ASSERT_MSG(1, "msg");
+    BOOST_ASSERT_MSG(x, "msg");
+    BOOST_ASSERT_MSG(x == 1, "msg");
+    BOOST_ASSERT_MSG(&x, "msg");
 }
 
 #define BOOST_DISABLE_ASSERTS
@@ -34,13 +40,23 @@ void test_disabled()
     BOOST_ASSERT(x == 1);
     BOOST_ASSERT(&x);
 
+    BOOST_ASSERT_MSG(1, "msg");
+    BOOST_ASSERT_MSG(x, "msg");
+    BOOST_ASSERT_MSG(x == 1, "msg");
+    BOOST_ASSERT_MSG(&x, "msg");
+
     BOOST_ASSERT(0);
     BOOST_ASSERT(!x);
     BOOST_ASSERT(x == 0);
 
+    BOOST_ASSERT_MSG(0, "msg");
+    BOOST_ASSERT_MSG(!x, "msg");
+    BOOST_ASSERT_MSG(x == 0, "msg");
+
     void * p = 0;
 
     BOOST_ASSERT(p);
+    BOOST_ASSERT_MSG(p, "msg");
 
     // supress warnings
     p = &x;
@@ -55,6 +71,7 @@ void test_disabled()
 #include <cstdio>
 
 int handler_invoked = 0;
+int msg_handler_invoked = 0;
 
 void boost::assertion_failed(char const * expr, char const * function, char const * file, long line)
 {
@@ -66,11 +83,24 @@ void boost::assertion_failed(char const * expr, char const * function, char cons
     ++handler_invoked;
 }
 
+void boost::assertion_failed_msg(char const * expr, char const * msg, char const * function,
+  char const * file, long line)
+{
+#if !defined(BOOST_NO_STDC_NAMESPACE)
+    using std::printf;
+#endif
+
+    printf("Expression: %s Message: %s\nFunction: %s\nFile: %s\nLine: %ld\n\n",
+      expr, msg, function, file, line);
+    ++msg_handler_invoked;
+}
+
 struct X
 {
     static void f()
     {
         BOOST_ASSERT(0);
+        BOOST_ASSERT_MSG(0, "msg f()");
     }
 };
 
@@ -83,21 +113,35 @@ void test_handler()
     BOOST_ASSERT(x == 1);
     BOOST_ASSERT(&x);
 
+    BOOST_ASSERT_MSG(1, "msg2");
+    BOOST_ASSERT_MSG(x, "msg3");
+    BOOST_ASSERT_MSG(x == 1, "msg4");
+    BOOST_ASSERT_MSG(&x, "msg5");
+
     BOOST_ASSERT(0);
     BOOST_ASSERT(!x);
     BOOST_ASSERT(x == 0);
 
+    BOOST_ASSERT_MSG(0,"msg 0");
+    BOOST_ASSERT_MSG(!x, "msg !x");
+    BOOST_ASSERT_MSG(x == 0, "msg x == 0");
+
     void * p = 0;
 
     BOOST_ASSERT(p);
+    BOOST_ASSERT_MSG(p, "msg p");
 
     X::f();
 
     BOOST_ASSERT(handler_invoked == 5);
     BOOST_TEST(handler_invoked == 5);
+
+    BOOST_ASSERT_MSG(msg_handler_invoked == 5, "msg_handler_invoked count is wrong");
+    BOOST_TEST(msg_handler_invoked == 5);
 }
 
 #undef BOOST_ENABLE_ASSERT_HANDLER
+#undef BOOST_ENABLE_ASSERT_MSG_HANDLER
 
 int main()
 {

doc/Jamfile.v2

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

doc/declval.qbk

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

doc/html/declval.html

@@ -0,0 +1,176 @@
+<html>
+<head>
+<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">
+<link rel="home" href="declval.html" title="Declval">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
+<td align="center"><a href="../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"></div>
+<div class="article">
+<div class="titlepage">
+<div>
+<div><h2 class="title">
+<a name="declval"></a>Declval</h2></div>
+<div><div class="authorgroup">
+<div class="author"><h3 class="author">
+<span class="firstname">Howard</span> <span class="surname">Hinnant</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><div class="legalnotice">
+<a name="idp13449552"></a><p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></div>
+</div>
+<hr>
+</div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<dl>
+<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">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="declval.overview"></a><a class="link" href="declval.html#declval.overview" title="Overview">Overview</a>
+</h2></div></div></div>
+<p>
+      The motivation for <code class="computeroutput"><span class="identifier">declval</span></code>
+      was introduced in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2958.html#Value" target="_top">N2958:
+      Moving Swap Forward</a>. Here follows a rewording of this chapter.
+    </p>
+<p>
+      With the provision of decltype, late-specified return types, and default template-arguments
+      for function templates a new generation of SFINAE patterns will emerge to at
+      least partially compensate the lack of concepts on the C++0x timescale. Using
+      this technique, it is sometimes necessary to obtain an object of a known type
+      in a non-using context, e.g. given the declaration
+    </p>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">declval</span><span class="special">();</span> <span class="comment">// not used
+</span></pre>
+<p>
+      as part of the function template declaration
+    </p>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">To</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">From</span><span class="special">&gt;</span>
+<span class="identifier">decltype</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">To</span><span class="special">&gt;(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">From</span><span class="special">&gt;()))</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">From</span><span class="special">&amp;&amp;);</span>
+</pre>
+<p>
+      or as part of a class template definition
+    </p>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">result_of</span><span class="special">;</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Fn</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">ArgTypes</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">result_of</span><span class="special">&lt;</span><span class="identifier">Fn</span><span class="special">(</span><span class="identifier">ArgTypes</span><span class="special">...)&gt;</span> 
+<span class="special">{</span>
+  <span class="keyword">typedef</span> <span class="identifier">decltype</span><span class="special">(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">Fn</span><span class="special">&gt;()(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">ArgTypes</span><span class="special">&gt;()...))</span> <span class="identifier">type</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<p>
+      The role of the function template declval() is a transformation of a type T
+      into a value without using or evaluating this function. The name is supposed
+      to direct the reader's attention to the fact that the expression <code class="computeroutput"><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span></code> is
+      an lvalue if and only if T is an lvalue-reference, otherwise an rvalue. To
+      extend the domain of this function we can do a bit better by changing its declaration
+      to
+    </p>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</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">// not used
+</span></pre>
+<p>
+      which ensures that we can also use cv void as template parameter. The careful
+      reader might have noticed that <code class="computeroutput"><span class="identifier">declval</span><span class="special">()</span></code> already exists under the name create() as
+      part of the definition of the semantics of the type trait is_convertible in
+      the C++0x standard.
+    </p>
+<p>
+      The provision of a new library component that allows the production of values
+      in unevaluated expressions is considered important to realize constrained templates
+      in C++0x where concepts are not available. This extremely light-weight function
+      is expected to be part of the daily tool-box of the C++0x programmer.
+    </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="declval.reference"></a><a class="link" href="declval.html#declval.reference" title="Reference">Reference </a>
+</h2></div></div></div>
+<p>
+      <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">/</span><span class="identifier">declval</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+    </p>
+<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>
+<span class="special">}</span>  <span class="comment">// namespace boost
+</span></pre>
+<p>
+      The library provides the function template declval to simplify the definition
+      of expressions which occur as unevaluated operands.
+    </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">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>
+</pre>
+<p>
+      <span class="bold"><strong>Remarks:</strong></span> If this function is used, the program
+      is ill-formed.
+    </p>
+<p>
+      <span class="bold"><strong>Remarks:</strong></span> The template parameter T of declval
+      may be an incomplete type.
+    </p>
+<p>
+      <span class="bold"><strong>Example:</strong></span>
+    </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">To</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">From</span><span class="special">&gt;</span>
+<span class="identifier">decltype</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">To</span><span class="special">&gt;(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">From</span><span class="special">&gt;()))</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">From</span><span class="special">&amp;&amp;);</span>
+</pre>
+<p>
+      Declares a function template convert which only participates in overloading
+      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="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"></div>
+</body>
+</html>

enable_if.html

@@ -21,6 +21,7 @@
 <BR>
 <BR>
 Copyright 2003 Jaakko J&auml;rvi, Jeremiah Willcock, Andrew Lumsdaine.<BR>
+Copyright 2011 Matt Calabrese.<BR>
 <BR>
 <!--TOC section Introduction-->
 
@@ -81,7 +82,7 @@ definitions to find this out. Instantiating the latter definition with
 <PRE>int::result_type negate(const int&amp;);
 
 </PRE>
-where the return type is invalid. If this was an error, adding an unrelated function template 
+where the return type is invalid. If this were an error, adding an unrelated function template 
 (that was never called) could break otherwise valid code.
 Due to the SFINAE principle the above example is not, however, erroneous. 
 The latter definition of <TT>negate</TT> is simply removed from the overload resolution set.<BR>
@@ -154,6 +155,7 @@ typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type
 foo(T t) { return t; }
 
 </PRE>
+
 <!--TOC section Using <TT>enable_if</TT>-->
 
 <H2><A NAME="htoc5">3</A>&nbsp;&nbsp;Using <TT>enable_if</TT></H2><!--SEC END -->
@@ -162,8 +164,19 @@ foo(T t) { return t; }
 The <TT>enable_if</TT> templates are defined in
 <TT>boost/utility/enable_if.hpp</TT>, which is included by <TT>boost/utility.hpp</TT>.<BR>
 <BR>
-The <TT>enable_if</TT> template can be used either as the return type, or as an 
-extra argument. For example, the <TT>foo</TT> function in the previous section could also be written
+With respect to function templates, <TT>enable_if</TT> can be used in multiple different ways:
+
+<UL>
+<LI>As the return type of an instantiatied function
+<LI>As an extra parameter of an instantiated function
+<LI>As an extra template parameter (useful only in a compiler that supports C++0x default
+arguments for function template parameters, see <A href="#sec:enable_if_0x">Enabling function
+templates in C++0x</a> for details)
+</UL>
+
+In the previous section, the return type form of <TT>enable_if</TT> was shown. As an example
+of using the form of <TT>enable_if</TT> that works via an extra function parameter, the
+<TT>foo</TT> function in the previous section could also be written
 as:
 <PRE>template &lt;class T&gt;
 T foo(T t, typename enable_if&lt;boost::is_arithmetic&lt;T&gt; &gt;::type* dummy = 0); 
@@ -173,18 +186,80 @@ a default value to keep the parameter hidden from client code.
 Note that the second template argument was not given to <TT>enable_if</TT>, as the default 
 <TT>void</TT> gives the desired behavior.<BR>
 <BR>
-Whether to write the enabler as an argument or within the return type is
-largely a matter of taste, but for certain functions, only one
-alternative is possible:
+Which way to write the enabler is largely a matter of taste, but for certain functions, only a
+subset of the options is possible:
 <UL><LI>
-Operators have a fixed number of arguments, thus <TT>enable_if</TT> must be used in the return type.
-<LI>Constructors and destructors do not have a return type; an extra argument is the only option.
-<LI>There does not seem to be a way to specify an enabler for a conversion operator. Converting constructors,
-however, can have enablers as extra default arguments.
+Many operators have a fixed number of arguments, thus <TT>enable_if</TT> must be used either in the
+return type or in an extra template parameter.
+<LI>Functions that have a variadic parameter list must use either the return type form or an extra
+template parameter.
+<LI>Constructors do not have a return type so you must use either an extra function parameter or an
+extra template parameter.
+<LI>Constructors that have a variadic parameter list must an extra template parameter.
+<LI>Conversion operators can only be written with an extra template parameter.
 </UL>
+<!--TOC subsection Enabling function templates in C++0x-->
+
+<A NAME="sec:enable_if_0x"></A>
+<H3><A NAME="htoc7">3.1</A>&nbsp;&nbsp;Enabling function templates in C++0x</H3><!--SEC END -->
+
+In a compiler which supports C++0x default arguments for function template parameters, you can
+enable and disable function templates by adding an additional template parameter. This approach
+works in all situations where you would use either the return type form of <TT>enable_if</TT> or
+the function parameter form, including operators, constructors, variadic function templates, and
+even overloaded conversion operations.
+
+As an example:
+
+<PRE>#include &lt;boost/type_traits/is_arithmetic.hpp&gt;
+#include &lt;boost/type_traits/is_pointer.hpp&gt;
+#include &lt;boost/utility/enable_if.hpp&gt;
+
+class test
+{
+public:
+  // A constructor that works for any argument list of size 10
+  template&lt; class... T
+          , typename boost::enable_if_c&lt; sizeof...( T ) == 10, int &gt;::type = 0
+          &gt;
+  test( T&amp;&amp;... );
+
+  // A conversion operation that can convert to any arithmetic type
+  template&lt; class T
+          , typename boost::enable_if&lt; boost::is_arithmetic&lt; T &gt;, int &gt;::type = 0
+          &gt;
+  operator T() const;
+
+  // A conversion operation that can convert to any pointer type
+  template&lt; class T
+          , typename boost::enable_if&lt; boost::is_pointer&lt; T &gt;, int &gt;::type = 0
+          &gt;
+  operator T() const;
+};
+
+int main()
+{
+  // Works
+  test test_( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 );
+
+  // Fails as expected
+  test fail_construction( 1, 2, 3, 4, 5 );
+
+  // Works by calling the conversion operator enabled for arithmetic types
+  int arithmetic_object = test_;
+
+  // Works by calling the conversion operator enabled for pointer types
+  int* pointer_object = test_;
+
+  // Fails as expected
+  struct {} fail_conversion = test_;
+}
+
+</PRE>
+
 <!--TOC subsection Enabling template class specializations-->
 
-<H3><A NAME="htoc6">3.1</A>&nbsp;&nbsp;Enabling template class specializations</H3><!--SEC END -->
+<H3><A NAME="htoc7">3.2</A>&nbsp;&nbsp;Enabling template class specializations</H3><!--SEC END -->
 
 <A NAME="sec:enable_if_classes"></A>
 Class template specializations can be enabled or disabled with <TT>enable_if</TT>.
@@ -210,7 +285,7 @@ is the correct value.<BR>
 <BR>
 <!--TOC subsection Overlapping enabler conditions-->
 
-<H3><A NAME="htoc7">3.2</A>&nbsp;&nbsp;Overlapping enabler conditions</H3><!--SEC END -->
+<H3><A NAME="htoc8">3.3</A>&nbsp;&nbsp;Overlapping enabler conditions</H3><!--SEC END -->
 
 <A NAME="sec:overlapping_conditions"></A>
 Once the compiler has examined the enabling conditions and included the
@@ -239,7 +314,7 @@ partial specializations as well.<BR>
 <BR>
 <!--TOC subsection Lazy <TT>enable_if</TT>-->
 
-<H3><A NAME="htoc8">3.3</A>&nbsp;&nbsp;Lazy <TT>enable_if</TT></H3><!--SEC END -->
+<H3><A NAME="htoc9">3.4</A>&nbsp;&nbsp;Lazy <TT>enable_if</TT></H3><!--SEC END -->
 
 <A NAME="sec:enable_if_lazy"></A>
 In some cases it is necessary to avoid instantiating part of a
@@ -285,7 +360,7 @@ above example, <TT>is_multipliable&lt;T, U&gt;::value</TT> defines when
 <BR>
 <!--TOC subsection Compiler workarounds-->
 
-<H3><A NAME="htoc9">3.4</A>&nbsp;&nbsp;Compiler workarounds</H3><!--SEC END -->
+<H3><A NAME="htoc10">3.5</A>&nbsp;&nbsp;Compiler workarounds</H3><!--SEC END -->
 
 <A NAME="sec:workarounds"></A>
 Some compilers flag functions as ambiguous if the only distinguishing factor is a different 
@@ -367,9 +442,9 @@ David Vandevoorde and Nicolai&nbsp;M. Josuttis.
 Addison-Wesley, 2002.</DL>
 
 <hr/>
-   <p>Copyright Jaakko J&auml;rvi, Jeremiah Willcock and Andrew Lumsdaine<BR>
-<EM>{jajarvi|jewillco|lums}@osl.iu.edu</EM><BR>
-Indiana University<BR>
+   <p>Copyright Jaakko J&auml;rvi<sup>*</sup>, Jeremiah Willcock<sup>*</sup>, Andrew Lumsdaine<sup>*</sup>, Matt Calabrese<BR>
+<EM>{jajarvi|jewillco|lums}@osl.iu.edu, rivorus@gmail.com</EM><BR>
+<sup>*</sup>Indiana University<BR>
 Open Systems Lab<br/>
 Use, modification and distribution are subject to the
 Boost Software License, Version 1.0.
@@ -386,4 +461,4 @@ or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
 </EM><A HREF="http://pauillac.inria.fr/~maranget/hevea/index.html"><EM>H<FONT SIZE=2><sup>E</sup></FONT>V<FONT SIZE=2><sup>E</sup></FONT>A</EM></A><EM>.
 </EM></BLOCKQUOTE>
 </BODY>
-</HTML>
+</HTML>

identity_type/doc/Jamfile.v2

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

identity_type/doc/html/index.html

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

identity_type/doc/identity_type.qbk

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

identity_type/index.html

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

identity_type/test/Jamfile.v2

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

identity_type/test/abstract.cpp

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

identity_type/test/noncopyable.cpp

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

identity_type/test/paren.cpp

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

identity_type/test/template.cpp

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

identity_type/test/var.cpp

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

identity_type/test/var_error.cpp

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

include/boost/assert.hpp

@@ -1,8 +1,11 @@
 //
 //  boost/assert.hpp - BOOST_ASSERT(expr)
+//                     BOOST_ASSERT_MSG(expr, msg)
+//                     BOOST_VERIFY(expr)
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2007 Peter Dimov
+//  Copyright (c) Beman Dawes 2011
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,6 +16,16 @@
 //  See http://www.boost.org/libs/utility/assert.html for documentation.
 //
 
+//
+// Stop inspect complaining about use of 'assert':
+//
+// boostinspect:naassert_macro
+//
+
+//--------------------------------------------------------------------------------------//
+//                                     BOOST_ASSERT                                     //
+//--------------------------------------------------------------------------------------//
+
 #undef BOOST_ASSERT
 
 #if defined(BOOST_DISABLE_ASSERTS)
@@ -25,18 +38,86 @@
 
 namespace boost
 {
-
-void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
-
+  void assertion_failed(char const * expr,
+                        char const * function, char const * file, long line); // user defined
 } // namespace boost
 
-#define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+#define BOOST_ASSERT(expr) ((expr) \
+  ? ((void)0) \
+  : ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
 
 #else
 # include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
 # define BOOST_ASSERT(expr) assert(expr)
 #endif
 
+//--------------------------------------------------------------------------------------//
+//                                   BOOST_ASSERT_MSG                                   //
+//--------------------------------------------------------------------------------------//
+
+# undef BOOST_ASSERT_MSG
+
+#if defined(BOOST_DISABLE_ASSERTS) || defined(NDEBUG)
+
+  #define BOOST_ASSERT_MSG(expr, msg) ((void)0)
+
+#elif defined(BOOST_ENABLE_ASSERT_HANDLER)
+
+  #include <boost/current_function.hpp>
+
+  namespace boost
+  {
+    void assertion_failed_msg(char const * expr, char const * msg,
+                              char const * function, char const * file, long line); // user defined
+  } // namespace boost
+
+  #define BOOST_ASSERT_MSG(expr, msg) ((expr) \
+    ? ((void)0) \
+    : ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+
+#else
+  #ifndef BOOST_ASSERT_HPP
+    #define BOOST_ASSERT_HPP
+    #include <cstdlib>
+    #include <iostream>
+    #include <boost/current_function.hpp>
+
+    //  IDE's like Visual Studio perform better if output goes to std::cout or
+    //  some other stream, so allow user to configure output stream:
+    #ifndef BOOST_ASSERT_MSG_OSTREAM
+    # define BOOST_ASSERT_MSG_OSTREAM std::cerr
+    #endif
+
+    namespace boost
+    { 
+      namespace assertion 
+      { 
+        namespace detail
+        {
+          inline void assertion_failed_msg(char const * expr, char const * msg, char const * function,
+            char const * file, long line)
+          {
+            BOOST_ASSERT_MSG_OSTREAM
+              << "***** Internal Program Error - assertion (" << expr << ") failed in "
+              << function << ":\n"
+              << file << '(' << line << "): " << msg << std::endl;
+            std::abort();
+          }
+        } // detail
+      } // assertion
+    } // detail
+  #endif
+
+  #define BOOST_ASSERT_MSG(expr, msg) ((expr) \
+    ? ((void)0) \
+    : ::boost::assertion::detail::assertion_failed_msg(#expr, msg, \
+          BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+#endif
+
+//--------------------------------------------------------------------------------------//
+//                                     BOOST_VERIFY                                     //
+//--------------------------------------------------------------------------------------//
+
 #undef BOOST_VERIFY
 
 #if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) )

include/boost/current_function.hpp

@@ -28,7 +28,7 @@ namespace detail
 inline void current_function_helper()
 {
 
-#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600))
+#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__)
 
 # define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
 
@@ -65,3 +65,4 @@ inline void current_function_helper()
 } // namespace boost
 
 #endif // #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
+

include/boost/operators.hpp

@@ -8,6 +8,8 @@
 //  See http://www.boost.org/libs/utility/operators.htm for documentation.
 
 //  Revision History
+//  16 Dec 10 Limit warning suppression for 4284 to older versions of VC++
+//            (Matthew Bradbury, fixes #4432)
 //  07 Aug 08 Added "euclidean" spelling. (Daniel Frey)
 //  03 Apr 08 Make sure "convertible to bool" is sufficient
 //            for T::operator<, etc. (Daniel Frey)
@@ -88,7 +90,7 @@
 #   pragma set woff 1234
 #endif
 
-#if defined(BOOST_MSVC)
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1600)
 #   pragma warning( disable : 4284 ) // complaint about return type of 
 #endif                               // operator-> not begin a UDT
 

include/boost/utility.hpp

@@ -13,6 +13,7 @@
 #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>

include/boost/utility/compare_pointees.hpp

@@ -4,7 +4,7 @@
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// See http://www.boost.org/lib/optional for documentation.
+// See http://www.boost.org/libs/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com

include/boost/utility/declval.hpp

@@ -0,0 +1,49 @@
+//  common_type.hpp  ---------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP
+#define BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP
+
+#include <boost/config.hpp>
+
+//----------------------------------------------------------------------------//
+
+#include <boost/type_traits/add_rvalue_reference.hpp>
+//#include <boost/type_traits/add_lvalue_reference.hpp>
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                           C++03 implementation of                          //
+//                          Written by Vicente J. Botet Escriba               //
+//~ 20.3.4 Function template declval [declval]
+//~ 1 The library provides the function template declval to simplify the definition of expressions which occur as
+//~ unevaluated operands.
+//~ 2 Remarks: If this function is used, the program is ill-formed.
+//~ 3 Remarks: The template parameter T of declval may be an incomplete type.
+//~ [ Example:
+
+//~ template <class To, class From>
+//~ decltype(static_cast<To>(declval<From>())) convert(From&&);
+
+//~ declares a function template convert which only participats in overloading if the type From can be
+//~ explicitly converted to type To. For another example see class template common_type (20.7.6.6). <20>end
+//~ example ]
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+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
+}  // namespace boost
+
+#endif  // BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP

include/boost/utility/detail/in_place_factory_prefix.hpp

@@ -5,7 +5,7 @@
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// See http://www.boost.org/lib/optional for documentation.
+// See http://www.boost.org/libs/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com

include/boost/utility/detail/in_place_factory_suffix.hpp

@@ -5,7 +5,7 @@
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// See http://www.boost.org/lib/optional for documentation.
+// See http://www.boost.org/libs/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com

include/boost/utility/detail/result_of_iterate.hpp

@@ -35,10 +35,7 @@ struct tr1_result_of<F(BOOST_RESULT_OF_ARGS)>
 
 #if !defined(BOOST_NO_DECLTYPE) && defined(BOOST_RESULT_OF_USE_DECLTYPE)
 
-// As of N2588, C++0x result_of only supports function call
-// expressions of the form f(x). This precludes support for member
-// function pointers, which are invoked with expressions of the form
-// o->*f(x). This implementation supports both.
+// Uses declval following N3225 20.7.7.6 when F is not a pointer.
 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))>
@@ -56,18 +53,15 @@ struct result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
 
 namespace detail {
 
-# define BOOST_RESULT_OF_STATIC_MEMBERS(z, n, _) \
-     static T ## n t ## n; \
-  /**/
-
 template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
          BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-class cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
+struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
 {
-  static F f;
-  BOOST_PP_REPEAT(BOOST_PP_ITERATION(), BOOST_RESULT_OF_STATIC_MEMBERS, _)
-public:
-  typedef decltype(f(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),t))) type;
+  typedef decltype(
+    boost::declval<F>()(
+      BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), declval<T, >() BOOST_PP_INTERCEPT)
+    )
+  ) type;
 };
 
 } // namespace detail 

include/boost/utility/identity_type.hpp

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

include/boost/utility/in_place_factory.hpp

@@ -5,7 +5,7 @@
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// See http://www.boost.org/lib/optional for documentation.
+// See http://www.boost.org/libs/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com

include/boost/utility/result_of.hpp

@@ -13,7 +13,9 @@
 #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>
@@ -22,6 +24,7 @@
 #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/utility/declval.hpp>
 
 #ifndef BOOST_RESULT_OF_NUM_ARGS
 #  define BOOST_RESULT_OF_NUM_ARGS 10

include/boost/utility/typed_in_place_factory.hpp

@@ -5,7 +5,7 @@
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// See http://www.boost.org/lib/optional for documentation.
+// See http://www.boost.org/libs/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com

index.html

@@ -20,6 +20,7 @@
 				<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="iterator_adaptors.htm">iterator_adaptors</a><br>
             <a href="generator_iterator.htm">generator iterator adaptors</a><br>
@@ -40,3 +41,4 @@
 			<!--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>
+

test/Jamfile.v2

@@ -32,6 +32,7 @@ test-suite utility
         [ compile result_of_test.cpp ]
         [ run ../shared_iterator_test.cpp ]
         [ run ../value_init_test.cpp ]
+        [ run ../value_init_workaround_test.cpp ]
         [ run ../initialized_test.cpp ]
         [ compile-fail ../value_init_test_fail1.cpp ]
         [ compile-fail ../value_init_test_fail2.cpp ]

test/result_of_test.cpp

@@ -98,6 +98,11 @@ struct no_result_type_or_result_of
   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&);
+  long operator()(int const&);
+#endif
 };
 
 template<typename T>
@@ -108,6 +113,11 @@ struct no_result_type_or_result_of_template
   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&);
+  long operator()(int const&);
+#endif
 };
 
 struct X {};
@@ -232,6 +242,14 @@ int main()
   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_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
 
   return 0;

utility.htm

@@ -151,37 +151,109 @@ void f() {
                 <code>result_of&lt;F(T1, T2, ...,
                 T<em>N</em>)&gt;::type</code> defines the result type
                 of the expression <code>f(t1, t2,
-                ...,t<em>N</em>)</code>. The implementation permits
+                ...,t<em>N</em>)</code>. This implementation permits
                 the type <code>F</code> to be a function pointer,
                 function reference, member function pointer, or class
-                type.</p> <p>If your compiler does not support
-                <code>decltype</code>, then when <code>F</code> is a
-                class type with a member type <code>result_type</code>,
+                type. By default, <em>N</em> may be any value between 0 and
+                10. To change the upper limit, define the macro
+                <code>BOOST_RESULT_OF_NUM_ARGS</code> to the maximum
+                value for <em>N</em>. Class template <code>result_of</code>
+                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 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>#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)
+    {
+        return x;
+    }
+};
+
+typedef boost::result_of&lt;
+    functor(int)
+&gt;::type type;</pre>
+                </blockquote>
+
+                <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;</code> is
-                <code>F::result_type</code>. When <code>F</code>
-                does not contain <code>result_type</code>, 
+                <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;</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>. For additional
-                information about <code>result_of</code>, see the
-                C++ Library Technical Report, <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>
+                when <code><em>N</em> = 0</code>. Note that it is the
+                responsibility of the programmer to ensure that
+                function objects accurately advertise their result
+                type via this protocol, as in the following
+                example.</p>
 
-                <p>Class template <code>result_of</code> resides in
-                the header <code>&lt;<a
-                href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>&gt;</code>. By
-                default, <em>N</em> may be any value between 0 and
-                10. To change the upper limit, define the macro
-                <code>BOOST_RESULT_OF_NUM_ARGS</code> to the maximum
-                value for <em>N</em>.</p>
+                <blockquote>
+                <pre>struct functor {
+    template&lt;class&gt; struct result;
+
+    template&lt;class F, class T&gt;
+    struct result&lt;F(T)&gt; {
+        typedef T type;
+    };
+
+    template&lt;class T&gt;
+    T operator()(T x)
+    {
+        return x;
+    }
+};
+
+typedef boost::result_of&lt;
+    functor(int)
+&gt;::type type;</pre>
+                </blockquote>
+
+                <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>,
+                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> requires class template partial specialization, the ability to parse function types properly, and support for SFINAE. If <code>result_of</code> is not supported by your compiler, including the header <code>boost/utility/result_of.hpp</code> will define the macro <code>BOOST_NO_RESULT_OF</code>. Contributed by Doug Gregor.</p>
+                <p>This implementation of <code>result_of</code>
+                requires class template partial specialization, the
+                ability to parse function types properly, and support
+                for SFINAE. If <code>result_of</code> is not supported
+                by your compiler, including the header 
+                <code>boost/utility/result_of.hpp</code> will
+                define the macro <code>BOOST_NO_RESULT_OF</code>.</p>
+
+                <p>For additional information
+                about <code>result_of</code>, see the C++ Library
+                Technical Report,
+                <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>
+                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>

value_init_test.cpp

@@ -22,7 +22,7 @@
 #pragma hdrstop
 #endif
 
-#include <boost/detail/lightweight_test.hpp>
+#include "boost/test/minimal.hpp"
 
 //
 // Sample POD type
@@ -215,7 +215,7 @@ template<class T>
 void check_initialized_value ( T const& y )
 {
   T initializedValue = boost::initialized_value ;
-  BOOST_TEST ( y == initializedValue ) ;
+  BOOST_CHECK ( y == initializedValue ) ;
 }
 
 #ifdef  __BORLANDC__
@@ -245,125 +245,128 @@ void check_initialized_value( NonPOD const& )
 template<class T>
 bool test ( T const& y, T const& z )
 {
-  const int errors_before_test = boost::detail::test_errors();
+  const boost::unit_test::counter_t counter_before_test = boost::minimal_test::errors_counter();
 
   check_initialized_value(y);
 
   boost::value_initialized<T> x ;
-  BOOST_TEST ( y == x ) ;
-  BOOST_TEST ( y == boost::get(x) ) ;
+  BOOST_CHECK ( y == x ) ;
+  BOOST_CHECK ( y == boost::get(x) ) ;
 
   static_cast<T&>(x) = z ;
   boost::get(x) = z ;
-  BOOST_TEST ( x == z ) ;
+  BOOST_CHECK ( x == z ) ;
 
   boost::value_initialized<T> const x_c ;
-  BOOST_TEST ( y == x_c ) ;
-  BOOST_TEST ( y == boost::get(x_c) ) ;
+  BOOST_CHECK ( y == x_c ) ;
+  BOOST_CHECK ( y == boost::get(x_c) ) ;
   T& x_c_ref = const_cast<T&>( boost::get(x_c) ) ;
   x_c_ref = z ;
-  BOOST_TEST ( x_c == z ) ;
+  BOOST_CHECK ( x_c == z ) ;
 
   boost::value_initialized<T> const copy1 = x;
-  BOOST_TEST ( boost::get(copy1) == boost::get(x) ) ;
+  BOOST_CHECK ( boost::get(copy1) == boost::get(x) ) ;
 
   boost::value_initialized<T> copy2;
   copy2 = x;
-  BOOST_TEST ( boost::get(copy2) == boost::get(x) ) ;
+  BOOST_CHECK ( boost::get(copy2) == boost::get(x) ) ;
   
   boost::shared_ptr<boost::value_initialized<T> > ptr( new boost::value_initialized<T> );
-  BOOST_TEST ( y == *ptr ) ;
+  BOOST_CHECK ( y == *ptr ) ;
 
 #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
   boost::value_initialized<T const> cx ;
-  BOOST_TEST ( y == cx ) ;
-  BOOST_TEST ( y == boost::get(cx) ) ;
+  BOOST_CHECK ( y == cx ) ;
+  BOOST_CHECK ( y == boost::get(cx) ) ;
 
   boost::value_initialized<T const> const cx_c ;
-  BOOST_TEST ( y == cx_c ) ;
-  BOOST_TEST ( y == boost::get(cx_c) ) ;
+  BOOST_CHECK ( y == cx_c ) ;
+  BOOST_CHECK ( y == boost::get(cx_c) ) ;
 #endif
 
-  return boost::detail::test_errors() == errors_before_test ;
+  return boost::minimal_test::errors_counter() == counter_before_test ;
 }
 
-int main(int, char **)
+int test_main(int, char **)
 {
-  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") ) ) ) ;
+  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") ) ) ) ;
 
   NonPOD NonPOD_object( std::string("NonPOD_object") );
-  BOOST_TEST ( test<NonPOD *>( 0, &NonPOD_object ) ) ;
+  BOOST_CHECK ( test<NonPOD *>( 0, &NonPOD_object ) ) ;
 
   AggregatePODStruct zeroInitializedAggregatePODStruct = { 0.0f, '\0', 0 };
   AggregatePODStruct nonZeroInitializedAggregatePODStruct = { 1.25f, 'a', -1 };
-  BOOST_TEST ( test(zeroInitializedAggregatePODStruct, nonZeroInitializedAggregatePODStruct) );
+  BOOST_CHECK ( test(zeroInitializedAggregatePODStruct, nonZeroInitializedAggregatePODStruct) );
 
   StringAndInt stringAndInt0;
   StringAndInt stringAndInt1;
   stringAndInt0.i = 0;
   stringAndInt1.i = 1;
   stringAndInt1.s = std::string("1");
-  BOOST_TEST ( test(stringAndInt0, stringAndInt1) );
+  BOOST_CHECK ( test(stringAndInt0, stringAndInt1) );
 
   StructWithDestructor structWithDestructor0;
   StructWithDestructor structWithDestructor1;
   structWithDestructor0.i = 0;
   structWithDestructor1.i = 1;
-  BOOST_TEST ( test(structWithDestructor0, structWithDestructor1) );
+  BOOST_CHECK ( test(structWithDestructor0, structWithDestructor1) );
 
   StructWithVirtualFunction structWithVirtualFunction0;
   StructWithVirtualFunction structWithVirtualFunction1;
   structWithVirtualFunction0.i = 0;
   structWithVirtualFunction1.i = 1;
-  BOOST_TEST ( test(structWithVirtualFunction0, structWithVirtualFunction1) );
+  BOOST_CHECK ( test(structWithVirtualFunction0, structWithVirtualFunction1) );
 
   DerivedFromAggregatePODStruct derivedFromAggregatePODStruct0;
   DerivedFromAggregatePODStruct derivedFromAggregatePODStruct1;
   static_cast<AggregatePODStruct &>(derivedFromAggregatePODStruct0) = zeroInitializedAggregatePODStruct;
   static_cast<AggregatePODStruct &>(derivedFromAggregatePODStruct1) = nonZeroInitializedAggregatePODStruct;
-  BOOST_TEST ( test(derivedFromAggregatePODStruct0, derivedFromAggregatePODStruct1) );
+  BOOST_CHECK ( test(derivedFromAggregatePODStruct0, derivedFromAggregatePODStruct1) );
 
   AggregatePODStructWrapper aggregatePODStructWrapper0;
   AggregatePODStructWrapper aggregatePODStructWrapper1;
   aggregatePODStructWrapper0.dataMember = zeroInitializedAggregatePODStruct;
   aggregatePODStructWrapper1.dataMember = nonZeroInitializedAggregatePODStruct;
-  BOOST_TEST ( test(aggregatePODStructWrapper0, aggregatePODStructWrapper1) );
+  BOOST_CHECK ( test(aggregatePODStructWrapper0, aggregatePODStructWrapper1) );
 
   ArrayOfBytes zeroInitializedArrayOfBytes = { 0 };
   boost::value_initialized<ArrayOfBytes> valueInitializedArrayOfBytes;
-  BOOST_TEST (std::memcmp(get(valueInitializedArrayOfBytes), zeroInitializedArrayOfBytes, sizeof(ArrayOfBytes)) == 0);
+  BOOST_CHECK (std::memcmp(get(valueInitializedArrayOfBytes), zeroInitializedArrayOfBytes, sizeof(ArrayOfBytes)) == 0);
 
   boost::value_initialized<ArrayOfBytes> valueInitializedArrayOfBytes2;
   valueInitializedArrayOfBytes2 = valueInitializedArrayOfBytes;
-  BOOST_TEST (std::memcmp(get(valueInitializedArrayOfBytes), get(valueInitializedArrayOfBytes2), sizeof(ArrayOfBytes)) == 0);
+  BOOST_CHECK (std::memcmp(get(valueInitializedArrayOfBytes), get(valueInitializedArrayOfBytes2), sizeof(ArrayOfBytes)) == 0);
 
   boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester1;
-  BOOST_TEST ( ! get(copyFunctionCallTester1).is_copy_constructed);
-  BOOST_TEST ( ! get(copyFunctionCallTester1).is_assignment_called);
+  BOOST_CHECK ( ! get(copyFunctionCallTester1).is_copy_constructed);
+  BOOST_CHECK ( ! get(copyFunctionCallTester1).is_assignment_called);
 
   boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester2 = boost::value_initialized<CopyFunctionCallTester>(copyFunctionCallTester1);
-  BOOST_TEST ( get(copyFunctionCallTester2).is_copy_constructed);
-  BOOST_TEST ( ! get(copyFunctionCallTester2).is_assignment_called);
+  BOOST_CHECK ( get(copyFunctionCallTester2).is_copy_constructed);
+  BOOST_CHECK ( ! get(copyFunctionCallTester2).is_assignment_called);
 
   boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester3;
   copyFunctionCallTester3 = boost::value_initialized<CopyFunctionCallTester>(copyFunctionCallTester1);
-  BOOST_TEST ( ! get(copyFunctionCallTester3).is_copy_constructed);
-  BOOST_TEST ( get(copyFunctionCallTester3).is_assignment_called);
+  BOOST_CHECK ( ! get(copyFunctionCallTester3).is_copy_constructed);
+  BOOST_CHECK ( 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_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 );
+  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 );
 
-  return boost::report_errors();
+  return 0;
 }
 
 
+unsigned int expected_failures = 0;
+
+

value_init_workaround_test.cpp

@@ -0,0 +1,144 @@
+// Copyright 2010, Niels Dekker.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Test program for the boost::value_initialized<T> workaround.
+//
+// 17 June 2010 (Created) Niels Dekker
+
+// Switch the workaround off, before inluding "value_init.hpp".
+#define BOOST_DETAIL_VALUE_INIT_WORKAROUND 0
+#include <boost/utility/value_init.hpp>
+
+#include <iostream>  // For cout.
+#include <cstdlib>  // For EXIT_SUCCESS and EXIT_FAILURE.
+
+namespace
+{
+  struct empty_struct
+  {
+  };
+
+  // A POD aggregate struct derived from an empty struct.
+  // Similar to struct Foo1 from Microsoft Visual C++ bug report 484295,
+  // "VC++ does not value-initialize members of derived classes without 
+  // user-declared constructor", reported in 2009 by Sylvester Hesp:
+  // https://connect.microsoft.com/VisualStudio/feedback/details/484295
+  struct derived_struct: empty_struct
+  {
+    int data;
+  };
+
+  bool is_value_initialized(const derived_struct& arg)
+  {
+    return arg.data == 0;
+  }
+
+
+  class virtual_destructor_holder
+  {
+  public:
+    int i;
+    virtual ~virtual_destructor_holder()
+    {
+    }
+  };
+
+  bool is_value_initialized(const virtual_destructor_holder& arg)
+  {
+    return arg.i == 0;
+  }
+
+  // Equivalent to the Stats class from GCC Bug 33916,
+  // "Default constructor fails to initialize array members", reported in 2007 by
+  // Michael Elizabeth Chastain: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=33916
+  // and fixed for GCC 4.2.4.
+  class private_int_array_pair
+  {
+    friend bool is_value_initialized(const private_int_array_pair& arg);
+  private:
+    int first[12];
+    int second[12];
+  };
+
+  bool is_value_initialized(const private_int_array_pair& arg)
+  {
+    for ( unsigned i = 0; i < 12; ++i)
+    {
+      if ( (arg.first[i] != 0) || (arg.second[i] != 0) )
+      {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  template <typename T>
+  bool is_value_initialized(const T(& arg)[2])
+  {
+    return
+      is_value_initialized(arg[0]) &&
+      is_value_initialized(arg[1]);
+  }
+
+  template <typename T>
+  bool is_value_initialized(const boost::value_initialized<T>& arg)
+  {
+    return is_value_initialized(arg.data());
+  }
+
+  // Returns zero when the specified object is value-initializated, and one otherwise.
+  // Prints a message to standard output if the value-initialization has failed.
+  template <class T>
+  unsigned failed_to_value_initialized(const T& object, const char *const object_name)
+  {
+    if ( is_value_initialized(object) )
+    {
+      return 0u;
+    }
+    else
+    {
+      std::cout << "Note: Failed to value-initialize " << object_name << '.' << std::endl;
+      return 1u;
+    }
+  }
+
+// A macro that passed both the name and the value of the specified object to
+// the function above here.
+#define FAILED_TO_VALUE_INITIALIZE(value) failed_to_value_initialized(value, #value)
+
+  // Equivalent to the dirty_stack() function from GCC Bug 33916,
+  // "Default constructor fails to initialize array members", reported in 2007 by
+  // Michael Elizabeth Chastain: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=33916
+  void dirty_stack()
+  {
+    unsigned char array_on_stack[4096];
+    for (unsigned i = 0; i < sizeof(array_on_stack); ++i)
+    {
+      array_on_stack[i] = 0x11;
+    }
+  }
+
+}
+
+
+int main()
+{
+  dirty_stack();
+
+  // TODO More types may be added later.
+  const unsigned num_failures =
+    FAILED_TO_VALUE_INITIALIZE(boost::value_initialized<derived_struct>()) +
+    FAILED_TO_VALUE_INITIALIZE(boost::value_initialized<virtual_destructor_holder[2]>()) +
+	FAILED_TO_VALUE_INITIALIZE(boost::value_initialized<private_int_array_pair>());
+
+#ifdef BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
+  // One or more failures are expected.
+  return num_failures > 0 ? EXIT_SUCCESS : EXIT_FAILURE;
+#else
+  // No failures are expected.
+  return num_failures == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
+#endif
+}