[Boost-commit] svn:boost r77904 - in trunk: boost/utility boost/utility/detail libs/utility

Subject: [Boost-commit] svn:boost r77904 - in trunk: boost/utility boost/utility/detail libs/utility
From: eric_at_[hidden]
Date: 2012-04-10 20:13:14

Author: eric_niebler
Date: 2012-04-10 20:13:10 EDT (Tue, 10 Apr 2012)
New Revision: 77904
URL: http://svn.boost.org/trac/boost/changeset/77904

Log:
whoops
Text files modified: 
   trunk/boost/utility/detail/result_of_iterate.hpp |     6 ++--                                    
   trunk/boost/utility/result_of.hpp                |    18 -------------                           
   trunk/libs/utility/utility.htm                   |    53 +++++++++++++++------------------------ 
   3 files changed, 23 insertions(+), 54 deletions(-)

Modified: trunk/boost/utility/detail/result_of_iterate.hpp
==============================================================================
--- trunk/boost/utility/detail/result_of_iterate.hpp	(original)
+++ trunk/boost/utility/detail/result_of_iterate.hpp	2012-04-10 20:13:10 EDT (Tue, 10 Apr 2012)
@@ -38,7 +38,7 @@
             (boost::detail::has_result_type<F>::value)> >::type { };
 #endif
 
-#ifdef BOOST_RESULT_OF_USE_DECLTYPE
+#if !defined(BOOST_NO_DECLTYPE) && defined(BOOST_RESULT_OF_USE_DECLTYPE)
 
 // Uses declval following N3225 20.7.7.6 when F is not a pointer.
 template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
@@ -71,7 +71,7 @@
 
 } // namespace detail 
 
-#else // defined(BOOST_RESULT_OF_USE_DECLTYPE)
+#else // defined(BOOST_NO_DECLTYPE)
 
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
@@ -80,7 +80,7 @@
     : tr1_result_of<F(BOOST_RESULT_OF_ARGS)> { };
 #endif
 
-#endif // defined(BOOST_RESULT_OF_USE_DECLTYPE)
+#endif // defined(BOOST_NO_DECLTYPE)
 
 #undef BOOST_RESULT_OF_ARGS
 

Modified: trunk/boost/utility/result_of.hpp
==============================================================================
--- trunk/boost/utility/result_of.hpp	(original)
+++ trunk/boost/utility/result_of.hpp	2012-04-10 20:13:10 EDT (Tue, 10 Apr 2012)
@@ -30,24 +30,6 @@
 #  define BOOST_RESULT_OF_NUM_ARGS 16
 #endif
 
-// Use the decltype-based version of result_of by default if the compiler
-// supports N3276 <http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf>.
-// The user can force the choice by defining either BOOST_RESULT_OF_USE_DECLTYPE or
-// BOOST_RESULT_OF_USE_TR1, but not both!
-#if defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_RESULT_OF_USE_TR1)
-#  error Both BOOST_RESULT_OF_USE_DECLTYPE and BOOST_RESULT_OF_USE_TR1 cannot be defined at the same time.
-#endif
-
-#ifndef BOOST_RESULT_OF_USE_TR1
-#  ifndef BOOST_RESULT_OF_USE_DECLTYPE
-#    ifndef BOOST_NO_DECLTYPE_N3276 // this implies !defined(BOOST_NO_DECLTYPE)
-#      define BOOST_RESULT_OF_USE_DECLTYPE
-#    else
-#      define BOOST_RESULT_OF_USE_TR1
-#    endif
-#  endif
-#endif
-
 namespace boost {
 
 template<typename F> struct result_of;

Modified: trunk/libs/utility/utility.htm
==============================================================================
--- trunk/libs/utility/utility.htm	(original)
+++ trunk/libs/utility/utility.htm	2012-04-10 20:13:10 EDT (Tue, 10 Apr 2012)
@@ -161,12 +161,14 @@
                 resides in the header <code>&lt;<a
                 href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>&gt;</code>.</p>
 
-                <p>If your compiler's support for <code>decltype</code> is
-                adequate, <code>result_of</code> automatically uses it to
-                deduce the result type of your callable.</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>#include &lt;boost/utility/result_of.hpp&gt;
+                <pre>#define BOOST_RESULT_OF_USE_DECLTYPE
+#include &lt;boost/utility/result_of.hpp&gt;
 
 struct functor {
     template&lt;class T&gt;
@@ -178,29 +180,21 @@
 
 typedef boost::result_of&lt;
     functor(int)
-&gt;::type type; // type is int</pre>
+&gt;::type type;</pre>
                 </blockquote>
 
-                <p>You can test whether <code>result_of</code> is using
-                <code>decltype</code> checking if the macro
-                <code>BOOST_RESULT_OF_USE_DECLTYPE</code> is defined after
-                including <code>result_of.hpp</code>. You can also force
-                <code>result_of</code> to use <code>decltype</code> by
-                defining <code>BOOST_RESULT_OF_USE_DECLTYPE</code> prior
-                to including <code>result_of.hpp</code>.</p>
-
-                <p>If <code>decltype</code> is not used,
+                <p>If <code>decltype</code> is not enabled,
                 then automatic result type deduction of function
                 objects is not possible. Instead, <code>result_of</code>
                 uses the following protocol to allow the programmer to
                 specify a type. When <code>F</code> is a class type with a
                 member type <code>result_type</code>,
                 <code>result_of&lt;F(T1, T2, ...,
-                T<em>N</em>)&gt;::type</code> is
+                T<em>N</em>)&gt;</code> is
                 <code>F::result_type</code>. When <code>F</code> does
                 not contain <code>result_type</code>,
                 <code>result_of&lt;F(T1, T2, ...,
-                T<em>N</em>)&gt;::type</code> is <code>F::result&lt;F(T1,
+                T<em>N</em>)&gt;</code> is <code>F::result&lt;F(T1,
                 T2, ..., T<em>N</em>)&gt;::type</code> when
                 <code><em>N</em> &gt; 0</code> or <code>void</code>
                 when <code><em>N</em> = 0</code>. Note that it is the
@@ -227,29 +221,22 @@
 
 typedef boost::result_of&lt;
     functor(int)
-&gt;::type type; // type is int</pre>
+&gt;::type type;</pre>
                 </blockquote>
 
-                <p>If you are writing a reusable function object
-                that should work with <code>result_of</code>, for
-                maximum portability, you might consider following
-                the above protocol even if your compiler has
-                proper <code>decltype</code> support. If you do,
-                take care to ensure that the
-                <code>result_type</code> and
-                <code>result&lt;&gt;</code> members accurately
-                represent the return type of
-                <code>operator()</code>.</p>
-
-                <p>If you wish to continue to
+                <p>In a future
+                release, <code>BOOST_RESULT_OF_USE_DECLTYPE</code>
+                may be enabled by default on compilers that
+                support <code>decltype</code>, so if you use the above
+                protocol please take care to ensure that
+                the <code>result_type</code>
+                and <code>result&lt;&gt;</code> members accurately
+                represent the result type. If you wish to continue to
                 use the protocol on compilers that
                 support <code>decltype</code>,
                 use <code>boost::tr1_result_of</code>, which is also
                 defined
-                in <code>&lt;boost/utility/result_of.hpp&gt;</code>. You can also define the macro
-                <code>BOOST_RESULT_OF_USE_TR1</code>, which causes
-                <code>result_of</code> to use the convention described
-                above instead of <code>decltype</code>.</p>
+                in <code>&lt;boost/utility/result_of.hpp&gt;</code>.</p>
 
                 <a name="BOOST_NO_RESULT_OF"></a>
                 <p>This implementation of <code>result_of</code>