Branch to work on filename handling without disturbing trunk.

[SVN r68345]

assert.html

@@ -17,89 +17,36 @@
 				<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 both Boost libraries and user 
+			The macro is intended to be used in Boost libraries.
-            code.
 		</p>
 		<P>By default, <tt>BOOST_ASSERT(expr)</tt> is equivalent to <tt>assert(expr)</tt>.</P>
-		<P>If the macro <STRONG>BOOST_DISABLE_ASSERTS</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+		<P>When the macro <STRONG>BOOST_DISABLE_ASSERTS</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			is included, <tt>BOOST_ASSERT(expr)</tt> is defined as <tt>((void)0)</tt>. This 
 			allows users to selectively disable <STRONG>BOOST_ASSERT</STRONG> without 
 			affecting the definition of the standard <STRONG>assert</STRONG>.</P>
-		<P>If the macro <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+		<P>When the macro <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			is included, <tt>BOOST_ASSERT(expr)</tt> evaluates <b>expr</b> and, if the 
 			result is false, evaluates the expression</P>
-		<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>
-		<blockquote>
+		<pre>
-		<pre>namespace boost
+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 
@@ -107,9 +54,8 @@
 			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.&nbsp; Copyright <20> 2011 
+			<small>Copyright <20> 2002, 2007 by Peter Dimov. Distributed under the Boost Software 
-        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,7 +2,6 @@
 //  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
@@ -21,11 +20,6 @@ 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
@@ -40,23 +34,13 @@ 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;
@@ -71,7 +55,6 @@ 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)
 {
@@ -83,24 +66,11 @@ 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()");
     }
 };
 
@@ -113,35 +83,21 @@ 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()
 {

enable_if.html

@@ -21,7 +21,6 @@
 <BR>
 <BR>
 Copyright 2003 Jaakko J&auml;rvi, Jeremiah Willcock, Andrew Lumsdaine.<BR>
-Copyright 2011 Matt Calabrese.<BR>
 <BR>
 <!--TOC section Introduction-->
 
@@ -82,7 +81,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 were an error, adding an unrelated function template 
+where the return type is invalid. If this was an error, adding an unrelated function template 
 (that was never called) could break otherwise valid code.
 Due to the SFINAE principle the above example is not, however, erroneous. 
 The latter definition of <TT>negate</TT> is simply removed from the overload resolution set.<BR>
@@ -155,7 +154,6 @@ 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 -->
@@ -164,19 +162,8 @@ 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>
-With respect to function templates, <TT>enable_if</TT> can be used in multiple different ways:
+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
-<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); 
@@ -186,80 +173,18 @@ 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>
-Which way to write the enabler is largely a matter of taste, but for certain functions, only a
+Whether to write the enabler as an argument or within the return type is
-subset of the options is possible:
+largely a matter of taste, but for certain functions, only one
+alternative is possible:
 <UL><LI>
-Many operators have a fixed number of arguments, thus <TT>enable_if</TT> must be used either in the
+Operators have a fixed number of arguments, thus <TT>enable_if</TT> must be used in the return type.
-return type or in an extra template parameter.
+<LI>Constructors and destructors do not have a return type; an extra argument is the only option.
-<LI>Functions that have a variadic parameter list must use either the return type form or an extra
+<LI>There does not seem to be a way to specify an enabler for a conversion operator. Converting constructors,
-template parameter.
+however, can have enablers as extra default arguments.
-<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="htoc7">3.2</A>&nbsp;&nbsp;Enabling template class specializations</H3><!--SEC END -->
+<H3><A NAME="htoc6">3.1</A>&nbsp;&nbsp;Enabling template class specializations</H3><!--SEC END -->
 
 <A NAME="sec:enable_if_classes"></A>
 Class template specializations can be enabled or disabled with <TT>enable_if</TT>.
@@ -285,7 +210,7 @@ is the correct value.<BR>
 <BR>
 <!--TOC subsection Overlapping enabler conditions-->
 
-<H3><A NAME="htoc8">3.3</A>&nbsp;&nbsp;Overlapping enabler conditions</H3><!--SEC END -->
+<H3><A NAME="htoc7">3.2</A>&nbsp;&nbsp;Overlapping enabler conditions</H3><!--SEC END -->
 
 <A NAME="sec:overlapping_conditions"></A>
 Once the compiler has examined the enabling conditions and included the
@@ -314,7 +239,7 @@ partial specializations as well.<BR>
 <BR>
 <!--TOC subsection Lazy <TT>enable_if</TT>-->
 
-<H3><A NAME="htoc9">3.4</A>&nbsp;&nbsp;Lazy <TT>enable_if</TT></H3><!--SEC END -->
+<H3><A NAME="htoc8">3.3</A>&nbsp;&nbsp;Lazy <TT>enable_if</TT></H3><!--SEC END -->
 
 <A NAME="sec:enable_if_lazy"></A>
 In some cases it is necessary to avoid instantiating part of a
@@ -360,7 +285,7 @@ above example, <TT>is_multipliable&lt;T, U&gt;::value</TT> defines when
 <BR>
 <!--TOC subsection Compiler workarounds-->
 
-<H3><A NAME="htoc10">3.5</A>&nbsp;&nbsp;Compiler workarounds</H3><!--SEC END -->
+<H3><A NAME="htoc9">3.4</A>&nbsp;&nbsp;Compiler workarounds</H3><!--SEC END -->
 
 <A NAME="sec:workarounds"></A>
 Some compilers flag functions as ambiguous if the only distinguishing factor is a different 
@@ -442,9 +367,9 @@ David Vandevoorde and Nicolai&nbsp;M. Josuttis.
 Addison-Wesley, 2002.</DL>
 
 <hr/>
-   <p>Copyright Jaakko J&auml;rvi<sup>*</sup>, Jeremiah Willcock<sup>*</sup>, Andrew Lumsdaine<sup>*</sup>, Matt Calabrese<BR>
+   <p>Copyright Jaakko J&auml;rvi, Jeremiah Willcock and Andrew Lumsdaine<BR>
-<EM>{jajarvi|jewillco|lums}@osl.iu.edu, rivorus@gmail.com</EM><BR>
+<EM>{jajarvi|jewillco|lums}@osl.iu.edu</EM><BR>
-<sup>*</sup>Indiana University<BR>
+Indiana University<BR>
 Open Systems Lab<br/>
 Use, modification and distribution are subject to the
 Boost Software License, Version 1.0.
@@ -461,4 +386,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>

include/boost/assert.hpp

@@ -1,11 +1,8 @@
 //
 //  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
@@ -22,10 +19,6 @@
 // boostinspect:naassert_macro
 //
 
-//--------------------------------------------------------------------------------------//
-//                                     BOOST_ASSERT                                     //
-//--------------------------------------------------------------------------------------//
-
 #undef BOOST_ASSERT
 
 #if defined(BOOST_DISABLE_ASSERTS)
@@ -38,86 +31,18 @@
 
 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) \
+#define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
-  ? ((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)) || defined(__ghs__)
+#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600))
 
 # define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
 
@@ -65,4 +65,3 @@ inline void current_function_helper()
 } // namespace boost
 
 #endif // #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
-

include/boost/utility/detail/result_of_iterate.hpp

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

include/boost/utility/result_of.hpp

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

index.html

@@ -14,21 +14,28 @@
 		<p>But that doesn't mean there isn't useful stuff here. Take a look:</p>
 		<blockquote>
 			<p>
+				<a href="utility.htm#addressof">addressof</a><br>
 				<a href="assert.html">assert</a><br>
 				<a href="base_from_member.html">base_from_member</a><br>
+				<a href="utility.htm#BOOST_BINARY">BOOST_BINARY</a><br>
 				<a href="call_traits.htm">call_traits</a><br>
 				<a href="checked_delete.html">checked_delete</a><br>
 				<a href="compressed_pair.htm">compressed_pair</a><br>
 				<a href="current_function.html">current_function</a><br>
-				<a href="doc/html/declval.html">declval</a><br>
+            <a href="doc/html/declval.html">declval</a><br>
-				<a href="enable_if.html">enable_if</a><br>
+            <a href="enable_if.html">enable_if</a><br>
+				<a href="in_place_factories.html">in_place_factory</a><br>
             <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
             <a href="generator_iterator.htm">generator iterator adaptors</a><br>
+				<a href="utility.htm#functions_next_prior">next/prior</a><br>
+				<a href="utility.htm#Class_noncopyable">noncopyable</a><br>
 				<a href="operators.htm">operators</a><br>
+				<a href="utility.htm#result_of">result_of</a><br>
 				<a href="swap.html">swap</a><br>
 				<a href="throw_exception.html">throw_exception</a><br>
 				<a href="utility.htm">utility</a><br>
-                <a href="value_init.htm">value_init</a></p>
+            <a href="value_init.htm">value_init</a>
+         </p>
 		</blockquote>
 		<hr>
 		<p>&copy; Copyright Beman Dawes, 2001</p>
@@ -41,4 +48,3 @@
 			<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->07 November, 2006<!--webbot bot="Timestamp" endspan i-checksum="39368" --></p>
 		</body>
 </html>
-

test/result_of_test.cpp

@@ -98,11 +98,6 @@ 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>
@@ -113,11 +108,6 @@ 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 {};
@@ -242,14 +232,6 @@ 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

@@ -224,20 +224,6 @@ typedef boost::result_of<
 &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

value_init_test.cpp

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