Create maintenance branch for 1.55.0

[SVN r86623]

base_from_member.html

@@ -129,6 +129,8 @@ particular member type does not need to concern itself with the integer.</p>
 <h2><a name="synopsis">Synopsis</a></h2>
 
 <blockquote><pre>
+#include &lt;type_traits&gt;  <i>// exposition only</i>
+
 #ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY
 #define BOOST_BASE_FROM_MEMBER_MAX_ARITY  10
 #endif
@@ -139,6 +141,11 @@ class boost::base_from_member
 protected:
     MemberType  member;
 
+#if <i>C++2011 is in use</i>
+    template&lt; typename ...T &gt;
+    explicit constexpr   base_from_member( T&amp;&amp; ...x )
+     noexcept( std::is_nothrow_constructible&lt;MemberType, T...&gt;::value );
+#else
     base_from_member();
 
     template&lt; typename T1 &gt;
@@ -154,6 +161,7 @@ protected:
      typename T10 &gt;
     base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7,
      T8 x8, T9 x9, T10 x10 );
+#endif
 };
 </pre></blockquote>
 
@@ -166,13 +174,29 @@ value of zero if it is omitted.  The class template has a protected
 data member called <var>member</var> that the derived class can use
 for later base classes (or itself).</p>
 
-<p>There is a default constructor and several constructor member
-templates.  These constructor templates can take as many arguments
-(currently up to ten) as possible and pass them to a constructor of
-the data member.  Since C++ does not allow any way to explicitly state
+<p>If the appropriate features of C++2011 are present, there will be a single
+constructor template.  It implements &quot;perfect forwarding&quot; to the best
+constructor call of <code>member</code> (if any).  The constructor template is
+marked both <code>constexpr</code> and <code>explicit</code>.  The former will
+be ignored if the corresponding inner constructor call (of <code>member</code>)
+does not have the marker.  The latter binds the other way; always taking
+effect, even when the inner constructor call does not have the marker.  The
+constructor template propagates the <code>noexcept</code> status of the inner
+constructor call.  (The constructor template has a trailing parameter with a
+default value that disables the template when its signature is too close to the
+signatures of the automatically-defined non-template copy- and/or
+move-constructors of <code>base_from_member</code>.)</p>
+
+<p>On earlier-standard compilers, there is a default constructor and several
+constructor member templates.  These constructor templates can take as many
+arguments (currently up to ten) as possible and pass them to a constructor of
+the data member.</p>
+
+<p>Since C++ does not allow any way to explicitly state
 the template parameters of a templated constructor, make sure that
 the arguments are already close as possible to the actual type used in
-the data member's desired constructor.</p>
+the data member's desired constructor.  Explicit conversions may be
+necessary.</p>
 
 <p>The <var>BOOST_BASE_FROM_MEMBER_MAX_ARITY</var> macro constant specifies
 the maximum argument length for the constructor templates.  The constant
@@ -180,7 +204,7 @@ may be overridden if more (or less) argument configurations are needed.  The
 constant may be read for code that is expandable like the class template and
 needs to maintain the same maximum size.  (Example code would be a class that
 uses this class template as a base class for a member with a flexible set of
-constructors.)</p>
+constructors.)  This constant is ignored when C++2011 features are present.</p>
 
 <h2><a name="usage">Usage</a></h2>
 
@@ -323,11 +347,14 @@ constructor argument for <code>pbase0_type</code> is converted from
 argument for <code>pbase2_type</code> is converted from <code>int</code>
 to <code>double</code>.  The second constructor argument for
 <code>pbase3_type</code> is a special case of necessary conversion; all
-forms of the null-pointer literal in C++ also look like compile-time
-integral expressions, so C++ always interprets such code as an integer
-when it has overloads that can take either an integer or a pointer.  The
-last conversion is necessary for the compiler to call a constructor form
-with the exact pointer type used in <code>switcher</code>'s constructor.</p>
+forms of the null-pointer literal in C++ (except <code>nullptr</code> from
+C++2011) also look like compile-time integral expressions, so C++ always
+interprets such code as an integer when it has overloads that can take either
+an integer or a pointer.  The last conversion is necessary for the compiler to
+call a constructor form with the exact pointer type used in
+<code>switcher</code>'s constructor.  (If C++2011's <code>nullptr</code> is
+used, it still needs a conversion if multiple pointer types can be accepted in
+a constructor call but <code>std::nullptr_t</code> cannot.)</p>
 
 <h2><a name="credits">Credits</a></h2>
 
@@ -360,9 +387,9 @@ with the exact pointer type used in <code>switcher</code>'s constructor.</p>
 
 <hr>
 
-<p>Revised: 28 August 2004</p>
+<p>Revised: 16 February 2012</p>
 
-<p>Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and distribution
+<p>Copyright 2001, 2003, 2004, 2012 Daryle Walker.  Use, modification, and distribution
 are subject to the Boost Software License, Version 1.0.  (See accompanying
 file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
 href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>

call_traits_test.cpp

@@ -210,8 +210,10 @@ int main()
    comparible_UDT u;
    c1(u);
    call_traits_checker<int> c2;
+   call_traits_checker<enum_UDT> c2b;
    int i = 2;
    c2(i);
+   c2b(one);
    int* pi = &i;
    int a[2] = {1,2};
 #if defined(BOOST_MSVC6_MEMBER_TEMPLATES) && !defined(__ICL)
@@ -292,7 +294,11 @@ int main()
    BOOST_CHECK_TYPE(incomplete_type&, boost::call_traits<incomplete_type>::reference);
    BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference);
    BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::param_type);
-
+   // test enum:
+   BOOST_CHECK_TYPE(enum_UDT, boost::call_traits<enum_UDT>::value_type);
+   BOOST_CHECK_TYPE(enum_UDT&, boost::call_traits<enum_UDT>::reference);
+   BOOST_CHECK_TYPE(const enum_UDT&, boost::call_traits<enum_UDT>::const_reference);
+   BOOST_CHECK_TYPE(const enum_UDT, boost::call_traits<enum_UDT>::param_type);
    return 0;
 }
 

doc/Jamfile.v2

@@ -6,7 +6,7 @@
 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
@@ -59,7 +59,6 @@ boostbook standalone_declval
         <xsl:param>toc.max.depth=1
         # How far down we go with TOC's
         <xsl:param>generate.section.toc.level=1
-        
      ;
 
 xml string_ref : string_ref.qbk ;
@@ -79,5 +78,23 @@ boostbook standalone_string_ref
         <xsl:param>toc.max.depth=1
         # How far down we go with TOC's
         <xsl:param>generate.section.toc.level=1
-
+     ;
+
+xml explicit_operator_bool : explicit_operator_bool.qbk ;
+boostbook standalone_explicit_operator_bool
+    :
+        explicit_operator_bool
+    :
+        # File name of HTML output:
+        <xsl:param>root.filename=explicit_operator_bool
+        # 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/explicit_operator_bool.qbk

@@ -0,0 +1,68 @@
+[/
+ / Copyright (c) 2013 Andrey Semashev
+ /
+ / 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 BOOST_EXPLICIT_OPERATOR_BOOL and BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL
+    [quickbook 1.5]
+    [authors [Semashev, Andrey]]
+    [copyright 2013 Andrey Semashev]
+    [license
+        Distributed under the Boost Software License, Version 1.0.
+        (See accompanying file LICENSE_1_0.txt or copy at
+        [@http://www.boost.org/LICENSE_1_0.txt])
+    ]
+]
+
+[/===============]
+[section Overview]
+[/===============]
+
+`BOOST_EXPLICIT_OPERATOR_BOOL()` and `BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()` are compatibility helper macros that expand to an explicit conversion operator to `bool`. For compilers not supporting explicit conversion operators introduced in C++11 the macros expand to a conversion operator that implements the [@http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Safe_bool safe bool idiom]. In case if the compiler is not able to handle safe bool idiom well the macros expand to a regular conversion operator to `bool`.
+
+[endsect]
+
+
+[/===============]
+[section Examples]
+[/===============]
+
+Both macros are intended to be placed within a user's class definition. The generated conversion operators will be implemented in terms of `operator!()` that should be defined by user in this class. In case of `BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()` the generated conversion operator will be declared `constexpr` which requires the corresponding `operator!()` to also be `constexpr`.
+
+    template< typename T >
+    class my_ptr
+    {
+        T* m_p;
+
+    public:
+        BOOST_EXPLICIT_OPERATOR_BOOL()
+
+        bool operator!() const
+        {
+            return !m_p;
+        }
+    };
+
+Now `my_ptr` can be used in conditional expressions, similarly to a regular pointer:
+
+    my_ptr< int > p;
+    if (p)
+        std::cout << "true" << std::endl;
+
+[endsect]
+
+[/===============]
+[section History]
+[/===============]
+
+[heading boost 1.55]
+
+* The macro was extracted from Boost.Log.
+
+[endsect]
+
+
+
+

doc/html/string_ref.html

@@ -44,7 +44,7 @@
 <dt><span class="section"><a href="string_ref.html#string_ref.history">History</a></span></dt>
 </dl>
 </div>
-<div class="section string_ref_overview">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="string_ref.overview"></a><a class="link" href="string_ref.html#string_ref.overview" title="Overview">Overview</a>
 </h2></div></div></div>
@@ -115,7 +115,7 @@
       <code class="computeroutput"><span class="identifier">string_ref</span></code> does.
     </p>
 </div>
-<div class="section string_ref_examples">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="string_ref.examples"></a><a class="link" href="string_ref.html#string_ref.examples" title="Examples">Examples</a>
 </h2></div></div></div>
@@ -130,7 +130,7 @@
     <span class="keyword">return</span> <span class="identifier">bar</span><span class="special">.</span><span class="identifier">substr</span> <span class="special">(</span> <span class="number">2</span><span class="special">,</span> <span class="number">3</span> <span class="special">);</span>
     <span class="special">}</span>
 
-<span class="keyword">if</span> <span class="special">(</span> <span class="identifier">extract_part</span> <span class="special">(</span> <span class="string">"ABCDEFG"</span> <span class="special">).</span><span class="identifier">front</span><span class="special">()</span> <span class="special">==</span> <span class="string">"C"</span> <span class="special">)</span> <span class="special">{</span> <span class="comment">/* do something */</span> <span class="special">}</span>
+<span class="keyword">if</span> <span class="special">(</span> <span class="identifier">extract_part</span> <span class="special">(</span> <span class="string">"ABCDEFG"</span> <span class="special">).</span><span class="identifier">front</span><span class="special">()</span> <span class="special">==</span> <span class="char">'C'</span> <span class="special">)</span> <span class="special">{</span> <span class="comment">/* do something */</span> <span class="special">}</span>
 </pre>
 <p>
       Let's figure out what happens in this (contrived) example.
@@ -166,15 +166,15 @@
       copied, but those are cheap operations.
     </p>
 </div>
-<div class="section string_ref_reference">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="string_ref.reference"></a><a class="link" href="string_ref.html#string_ref.reference" title="Reference">Reference </a>
 </h2></div></div></div>
 <p>
       The header file "string_ref.hpp" defines a template <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">basic_string_ref</span></code>,
       and four specializations - for <code class="computeroutput"><span class="keyword">char</span></code>
-      / <code class="computeroutput"><span class="keyword">wchar_t</span></code> / <code class="computeroutput"><span class="identifier">char16_t</span></code>
-      / <code class="computeroutput"><span class="identifier">char32_t</span></code> .
+      / <code class="computeroutput"><span class="keyword">wchar_t</span></code> / <code class="computeroutput"><span class="keyword">char16_t</span></code>
+      / <code class="computeroutput"><span class="keyword">char32_t</span></code> .
     </p>
 <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">string_ref</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
@@ -256,7 +256,7 @@
 <span class="keyword">bool</span> <span class="identifier">ends_with</span><span class="special">(</span><span class="identifier">basic_string_ref</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
 </pre>
 </div>
-<div class="section string_ref_history">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="string_ref.history"></a><a class="link" href="string_ref.html#string_ref.history" title="History">History</a>
 </h2></div></div></div>
@@ -271,7 +271,7 @@
 </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: January 14, 2013 at 16:24:14 GMT</small></p></td>
+<td align="left"><p><small>Last revised: October 27, 2013 at 21:01:34 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

doc/string_ref.qbk

@@ -54,7 +54,7 @@ Integrating `string_ref` into your code is fairly simple. Wherever you pass a `c
         return bar.substr ( 2, 3 );
         }
         
-    if ( extract_part ( "ABCDEFG" ).front() == "C" ) { /* do something */ }
+    if ( extract_part ( "ABCDEFG" ).front() == 'C' ) { /* do something */ }
     
 Let's figure out what happens in this (contrived) example.
 

in_place_factories.html

@@ -46,7 +46,7 @@ HREF="../../boost/utility/typed_in_place_factory.hpp">boost/utility/typed_in_pla
 <p>Suppose we have a class</p>
 <pre>struct X
 {
-  X ( int, std:::string ) ;
+  X ( int, std::string ) ;
 } ;</pre>
 <p>And a container for it which supports an empty state (that is, which can contain zero objects):</p>
 <pre>struct C

include/boost/assert.hpp

@@ -34,6 +34,7 @@
 
 #elif defined(BOOST_ENABLE_ASSERT_HANDLER)
 
+#include <boost/config.hpp>
 #include <boost/current_function.hpp>
 
 namespace boost
@@ -42,7 +43,7 @@ namespace boost
                         char const * function, char const * file, long line); // user defined
 } // namespace boost
 
-#define BOOST_ASSERT(expr) ((expr) \
+#define BOOST_ASSERT(expr) (BOOST_LIKELY(!!(expr)) \
   ? ((void)0) \
   : ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
 
@@ -63,6 +64,7 @@ namespace boost
 
 #elif defined(BOOST_ENABLE_ASSERT_HANDLER)
 
+  #include <boost/config.hpp>
   #include <boost/current_function.hpp>
 
   namespace boost
@@ -71,7 +73,7 @@ namespace boost
                               char const * function, char const * file, long line); // user defined
   } // namespace boost
 
-  #define BOOST_ASSERT_MSG(expr, msg) ((expr) \
+  #define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr)) \
     ? ((void)0) \
     : ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
 
@@ -80,6 +82,7 @@ namespace boost
     #define BOOST_ASSERT_HPP
     #include <cstdlib>
     #include <iostream>
+    #include <boost/config.hpp>
     #include <boost/current_function.hpp>
 
     //  IDE's like Visual Studio perform better if output goes to std::cout or
@@ -89,26 +92,33 @@ namespace boost
     #endif
 
     namespace boost
-    { 
-      namespace assertion 
-      { 
+    {
+      namespace assertion
+      {
         namespace detail
         {
-          inline void assertion_failed_msg(char const * expr, char const * msg, char const * function,
+          // Note: The template is needed to make the function non-inline and avoid linking errors
+          template< typename CharT >
+          BOOST_NOINLINE void assertion_failed_msg(CharT 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;
+#ifdef UNDER_CE
+            // The Windows CE CRT library does not have abort() so use exit(-1) instead.
+            std::exit(-1);
+#else
             std::abort();
+#endif
           }
         } // detail
       } // assertion
     } // detail
   #endif
 
-  #define BOOST_ASSERT_MSG(expr, msg) ((expr) \
+  #define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr)) \
     ? ((void)0) \
     : ::boost::assertion::detail::assertion_failed_msg(#expr, msg, \
           BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))

include/boost/noncopyable.hpp

@@ -9,6 +9,8 @@
 #ifndef BOOST_NONCOPYABLE_HPP_INCLUDED
 #define BOOST_NONCOPYABLE_HPP_INCLUDED
 
+#include <boost/config.hpp>
+
 namespace boost {
 
 //  Private copy constructor and copy assignment ensure classes derived from
@@ -21,11 +23,21 @@ namespace noncopyable_  // protection from unintended ADL
   class noncopyable
   {
    protected:
-      noncopyable() {}
+#ifndef BOOST_NO_DEFAULTED_FUNCTIONS
+    BOOST_CONSTEXPR noncopyable() = default;
+    ~noncopyable() = default;
+#else
+    noncopyable() {}
       ~noncopyable() {}
-   private:  // emphasize the following members are private
+#endif
+#ifndef BOOST_NO_DELETED_FUNCTIONS
+        noncopyable( const noncopyable& ) = delete;
+        noncopyable& operator=( const noncopyable& ) = delete;
+#else
+    private:  // emphasize the following members are private
       noncopyable( const noncopyable& );
-      const noncopyable& operator=( const noncopyable& );
+      noncopyable& operator=( const noncopyable& );
+#endif
   };
 }
 

include/boost/utility/addressof.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2002 Brad King (brad.king@kitware.com) 
+// Copyright (C) 2002 Brad King (brad.king@kitware.com)
 //                    Douglas Gregor (gregod@cs.rpi.edu)
 //
 // Copyright (C) 2002, 2008 Peter Dimov
@@ -50,7 +50,7 @@ template<class T> struct addressof_impl
 
 template<class T> T * addressof( T & v )
 {
-#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) )
+#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || defined( __SUNPRO_CC )
 
     return boost::detail::addressof_impl<T>::f( v, 0 );
 

include/boost/utility/base_from_member.hpp

@@ -1,6 +1,6 @@
 //  boost utility/base_from_member.hpp header file  --------------------------//
 
-//  Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and
+//  Copyright 2001, 2003, 2004, 2012 Daryle Walker.  Use, modification, and
 //  distribution are subject to the Boost Software License, Version 1.0.  (See
 //  accompanying file LICENSE_1_0.txt or a copy at
 //  <http://www.boost.org/LICENSE_1_0.txt>.)
@@ -10,10 +10,15 @@
 #ifndef BOOST_UTILITY_BASE_FROM_MEMBER_HPP
 #define BOOST_UTILITY_BASE_FROM_MEMBER_HPP
 
+#include <boost/config.hpp>
 #include <boost/preprocessor/arithmetic/inc.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/utility/enable_if.hpp>
 
 
 //  Base-from-member arity configuration macro  ------------------------------//
@@ -53,6 +58,59 @@
 namespace boost
 {
 
+namespace detail
+{
+
+//  Type-unmarking class template  -------------------------------------------//
+
+// Type-trait to get the raw type, i.e. the type without top-level reference nor
+// cv-qualification, from a type expression.  Mainly for function arguments, any
+// reference part is stripped first.
+
+// Contributed by Daryle Walker
+
+template < typename T >
+struct remove_cv_ref
+{
+    typedef typename ::boost::remove_cv<typename
+     ::boost::remove_reference<T>::type>::type  type;
+
+};  // boost::detail::remove_cv_ref
+
+//  Unmarked-type comparison class template  ---------------------------------//
+
+// Type-trait to check if two type expressions have the same raw type.
+
+// Contributed by Daryle Walker, based on a work-around by Luc Danton
+
+template < typename T, typename U >
+struct is_related
+    : public ::boost::is_same<
+     typename ::boost::detail::remove_cv_ref<T>::type,
+     typename ::boost::detail::remove_cv_ref<U>::type >
+{};
+
+//  Enable-if-on-unidentical-unmarked-type class template  -------------------//
+
+// Enable-if on the first two type expressions NOT having the same raw type.
+
+// Contributed by Daryle Walker, based on a work-around by Luc Danton
+
+#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+template<typename ...T>
+struct enable_if_unrelated
+    : public ::boost::enable_if_c<true>
+{};
+
+template<typename T, typename U, typename ...U2>
+struct enable_if_unrelated<T, U, U2...>
+    : public ::boost::disable_if< ::boost::detail::is_related<T, U> >
+{};
+#endif
+
+}  // namespace boost::detail
+
+
 //  Base-from-member class template  -----------------------------------------//
 
 // Helper to initialize a base object so a derived class can use this
@@ -68,12 +126,25 @@ class base_from_member
 protected:
     MemberType  member;
 
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
+    !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && \
+    !(defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 4))
+    template <typename ...T, typename EnableIf = typename
+     ::boost::detail::enable_if_unrelated<base_from_member, T...>::type>
+    explicit BOOST_CONSTEXPR base_from_member( T&& ...x )
+        BOOST_NOEXCEPT_IF( BOOST_NOEXCEPT_EXPR(::new ((void*) 0) MemberType(
+         static_cast<T&&>(x)... )) )  // no std::is_nothrow_constructible...
+        : member( static_cast<T&&>(x)... )     // ...nor std::forward needed
+        {}
+#else
     base_from_member()
         : member()
         {}
 
     BOOST_PP_REPEAT_FROM_TO( 1, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
      BOOST_PRIVATE_CTR_DEF, _ )
+#endif
 
 };  // boost::base_from_member
 

include/boost/utility/declval.hpp

@@ -1,49 +1,44 @@
-//  common_type.hpp  ---------------------------------------------------------//
+//  declval.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
+#ifndef BOOST_UTILITY_DECLVAL_HPP
+#define BOOST_UTILITY_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                          //
+//                   20.2.4 Function template declval [declval]               //
 //                          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 ]
 //                                                                            //
+// 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 participates in overloading
+// if the type From can be explicitly converted to type To. For another example
+// see class template common_type (20.9.7.6). -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
+#endif  // BOOST_UTILITY_DECLVAL_HPP

include/boost/utility/detail/result_of_iterate.hpp

@@ -38,10 +38,25 @@ struct tr1_result_of<F(BOOST_RESULT_OF_ARGS)>
 #endif
 
 #ifdef BOOST_RESULT_OF_USE_DECLTYPE
-
-// Uses declval following N3225 20.7.7.6 when F is not a pointer.
 template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
+struct result_of<F(BOOST_RESULT_OF_ARGS)>
+    : detail::cpp0x_result_of<F(BOOST_RESULT_OF_ARGS)> { };
+#endif // BOOST_RESULT_OF_USE_DECLTYPE
+
+#ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
+template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of<F(BOOST_RESULT_OF_ARGS)>
+    : mpl::if_<mpl::or_<detail::has_result_type<F>, detail::has_result<F> >,
+               tr1_result_of<F(BOOST_RESULT_OF_ARGS)>,
+               detail::cpp0x_result_of<F(BOOST_RESULT_OF_ARGS)> >::type { };
+#endif // BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
+
+#if defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
+
+namespace detail {
+
+template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct cpp0x_result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
     : mpl::if_<
           is_member_function_pointer<F>
         , detail::tr1_result_of_impl<
@@ -54,8 +69,6 @@ struct result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
       >::type
 {};
 
-namespace detail {
-
 #ifdef BOOST_NO_SFINAE_EXPR
 
 template<typename F>
@@ -139,7 +152,7 @@ struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)),
 
 } // namespace detail
 
-#else // defined(BOOST_RESULT_OF_USE_DECLTYPE)
+#else // defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
 
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>

include/boost/utility/empty_deleter.hpp

@@ -0,0 +1,43 @@
+/*
+ *          Copyright Andrey Semashev 2007 - 2013.
+ * 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)
+ */
+/*!
+ * \file   empty_deleter.hpp
+ * \author Andrey Semashev
+ * \date   22.04.2007
+ *
+ * This header contains an \c empty_deleter implementation. This is an empty
+ * function object that receives a pointer and does nothing with it.
+ * Such empty deletion strategy may be convenient, for example, when
+ * constructing <tt>shared_ptr</tt>s that point to some object that should not be
+ * deleted (i.e. a variable on the stack or some global singleton, like <tt>std::cout</tt>).
+ */
+
+#ifndef BOOST_UTILITY_EMPTY_DELETER_HPP_INCLUDED_
+#define BOOST_UTILITY_EMPTY_DELETER_HPP_INCLUDED_
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+//! A function object that does nothing and can be used as an empty deleter for \c shared_ptr
+struct empty_deleter
+{
+    //! Function object result type
+    typedef void result_type;
+    /*!
+     * Does nothing
+     */
+    void operator() (const volatile void*) const BOOST_NOEXCEPT {}
+};
+
+} // namespace boost
+
+#endif // BOOST_UTILITY_EMPTY_DELETER_HPP_INCLUDED_

include/boost/utility/explicit_operator_bool.hpp

@@ -0,0 +1,128 @@
+/*
+ *          Copyright Andrey Semashev 2007 - 2013.
+ * 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)
+ */
+/*!
+ * \file   explicit_operator_bool.hpp
+ * \author Andrey Semashev
+ * \date   08.03.2009
+ *
+ * This header defines a compatibility macro that implements an unspecified
+ * \c bool operator idiom, which is superseded with explicit conversion operators in
+ * C++11.
+ */
+
+#ifndef BOOST_UTILITY_EXPLICIT_OPERATOR_BOOL_HPP_INCLUDED_
+#define BOOST_UTILITY_EXPLICIT_OPERATOR_BOOL_HPP_INCLUDED_
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+
+/*!
+ * \brief The macro defines an explicit operator of conversion to \c bool
+ *
+ * The macro should be used inside the definition of a class that has to
+ * support the conversion. The class should also implement <tt>operator!</tt>,
+ * in terms of which the conversion operator will be implemented.
+ */
+#define BOOST_EXPLICIT_OPERATOR_BOOL()\
+    BOOST_FORCEINLINE explicit operator bool () const\
+    {\
+        return !this->operator! ();\
+    }
+
+/*!
+ * \brief The macro defines a constexpr explicit operator of conversion to \c bool
+ *
+ * The macro should be used inside the definition of a class that has to
+ * support the conversion. The class should also implement <tt>operator!</tt>,
+ * in terms of which the conversion operator will be implemented.
+ */
+#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
+    BOOST_FORCEINLINE BOOST_CONSTEXPR explicit operator bool () const\
+    {\
+        return !this->operator! ();\
+    }
+
+#else // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+
+#if (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG)
+// Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it
+#define BOOST_NO_UNSPECIFIED_BOOL
+#endif // (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG)
+
+#if !defined(BOOST_NO_UNSPECIFIED_BOOL)
+
+namespace boost {
+
+namespace detail {
+
+#if !defined(_MSC_VER) && !defined(__IBMCPP__)
+
+    struct unspecified_bool
+    {
+        // NOTE TO THE USER: If you see this in error messages then you tried
+        // to apply an unsupported operator on the object that supports
+        // explicit conversion to bool.
+        struct OPERATORS_NOT_ALLOWED;
+        static void true_value(OPERATORS_NOT_ALLOWED*) {}
+    };
+    typedef void (*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*);
+
+#else
+
+    // MSVC and VACPP are too eager to convert pointer to function to void* even though they shouldn't
+    struct unspecified_bool
+    {
+        // NOTE TO THE USER: If you see this in error messages then you tried
+        // to apply an unsupported operator on the object that supports
+        // explicit conversion to bool.
+        struct OPERATORS_NOT_ALLOWED;
+        void true_value(OPERATORS_NOT_ALLOWED*) {}
+    };
+    typedef void (unspecified_bool::*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*);
+
+#endif
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_EXPLICIT_OPERATOR_BOOL()\
+    BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const\
+    {\
+        return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
+    }
+
+#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
+    BOOST_FORCEINLINE BOOST_CONSTEXPR operator boost::detail::unspecified_bool_type () const\
+    {\
+        return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
+    }
+
+#else // !defined(BOOST_NO_UNSPECIFIED_BOOL)
+
+#define BOOST_EXPLICIT_OPERATOR_BOOL()\
+    BOOST_FORCEINLINE operator bool () const\
+    {\
+        return !this->operator! ();\
+    }
+
+#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
+    BOOST_FORCEINLINE BOOST_CONSTEXPR operator bool () const\
+    {\
+        return !this->operator! ();\
+    }
+
+#endif // !defined(BOOST_NO_UNSPECIFIED_BOOL)
+
+#endif // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+
+#endif // BOOST_UTILITY_EXPLICIT_OPERATOR_BOOL_HPP_INCLUDED_

include/boost/utility/result_of.hpp

@@ -38,18 +38,27 @@
 
 // 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.
+// The user can force the choice by defining BOOST_RESULT_OF_USE_DECLTYPE,
+// BOOST_RESULT_OF_USE_TR1, or BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK but not more than one!
+#if (defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_RESULT_OF_USE_TR1)) || \
+    (defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)) || \
+    (defined(BOOST_RESULT_OF_USE_TR1) && defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK))
+#  error More than one of BOOST_RESULT_OF_USE_DECLTYPE, BOOST_RESULT_OF_USE_TR1 and \
+  BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK cannot be defined at the same time.
+#endif
+
+#if defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK) && defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
+#  error Cannot fallback to decltype if BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE is not defined.
 #endif
 
 #ifndef BOOST_RESULT_OF_USE_TR1
 #  ifndef BOOST_RESULT_OF_USE_DECLTYPE
-#    ifndef BOOST_NO_CXX11_DECLTYPE_N3276 // this implies !defined(BOOST_NO_CXX11_DECLTYPE)
-#      define BOOST_RESULT_OF_USE_DECLTYPE
-#    else
-#      define BOOST_RESULT_OF_USE_TR1
+#    ifndef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
+#      ifndef BOOST_NO_CXX11_DECLTYPE_N3276 // this implies !defined(BOOST_NO_CXX11_DECLTYPE)
+#        define BOOST_RESULT_OF_USE_DECLTYPE
+#      else
+#        define BOOST_RESULT_OF_USE_TR1
+#      endif
 #    endif
 #  endif
 #endif
@@ -64,10 +73,21 @@ namespace detail {
 
 BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
 
+BOOST_MPL_HAS_XXX_TEMPLATE_DEF(result)
+
 template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
 
+template<typename F> struct cpp0x_result_of;
+
 #ifdef BOOST_NO_SFINAE_EXPR
 
+// There doesn't seem to be any other way to turn this off such that the presence of
+// the user-defined operator,() below doesn't cause spurious warning all over the place,
+// so unconditionally turn it off.
+#if BOOST_MSVC
+#  pragma warning(disable: 4913) // user defined binary operator ',' exists but no overload could convert all operands, default built-in binary operator ',' used
+#endif
+
 struct result_of_private_type {};
 
 struct result_of_weird_type {

include/boost/utility/string_ref.hpp

@@ -1,11 +1,11 @@
-/* 
+/*
    Copyright (c) Marshall Clow 2012-2012.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
     For more information, see http://www.boost.org
-    
+
     Based on the StringRef implementation in LLVM (http://llvm.org) and
     N3422 by Jeffrey Yasskin
         http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
@@ -17,14 +17,18 @@
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/utility/string_ref_fwd.hpp>
+#include <boost/throw_exception.hpp>
 
+#include <cstddef>
 #include <stdexcept>
 #include <algorithm>
-#include <functional>
+#include <iterator>
 #include <string>
+#include <iosfwd>
 
 namespace boost {
-    
+
     namespace detail {
     //  A helper functor because sometimes we don't have lambdas
         template <typename charT, typename traits>
@@ -35,19 +39,7 @@ namespace boost {
             charT ch_;
             };
         }
-    
-    template<typename charT, typename traits> class basic_string_ref;
-    typedef basic_string_ref<char,     std::char_traits<char> >        string_ref;
-    typedef basic_string_ref<wchar_t,  std::char_traits<wchar_t> >    wstring_ref;
 
-#ifndef BOOST_NO_CXX11_CHAR16_T
-    typedef basic_string_ref<char16_t, std::char_traits<char16_t> > u16string_ref;
-#endif
-
-#ifndef BOOST_NO_CXX11_CHAR32_T
-    typedef basic_string_ref<char32_t, std::char_traits<char32_t> > u32string_ref;
-#endif
-    
     template<typename charT, typename traits>
     class basic_string_ref {
     public:
@@ -61,9 +53,9 @@ namespace boost {
         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
         typedef const_reverse_iterator reverse_iterator;
         typedef std::size_t size_type;
-        typedef ptrdiff_t difference_type;
+        typedef std::ptrdiff_t difference_type;
         static BOOST_CONSTEXPR_OR_CONST size_type npos = size_type(-1);
-        
+
         // construct/copy
         BOOST_CONSTEXPR basic_string_ref ()
             : ptr_(NULL), len_(0) {}
@@ -76,7 +68,7 @@ namespace boost {
             len_ = rhs.len_;
             return *this;
             }
-            
+
         basic_string_ref(const charT* str)
             : ptr_(str), len_(traits::length(str)) {}
 
@@ -93,7 +85,11 @@ namespace boost {
             return std::basic_string<charT, traits, Allocator> ( ptr_, len_ );
             }
 #endif
-        
+
+        std::basic_string<charT, traits> to_string () const {
+            return std::basic_string<charT, traits> ( ptr_, len_ );
+            }
+
         // iterators
         BOOST_CONSTEXPR const_iterator   begin() const { return ptr_; }
         BOOST_CONSTEXPR const_iterator  cbegin() const { return ptr_; }
@@ -103,26 +99,26 @@ namespace boost {
                 const_reverse_iterator crbegin() const { return const_reverse_iterator (end()); }
                 const_reverse_iterator    rend() const { return const_reverse_iterator (begin()); }
                 const_reverse_iterator   crend() const { return const_reverse_iterator (begin()); }
-        
+
         // capacity
         BOOST_CONSTEXPR size_type size()     const { return len_; }
         BOOST_CONSTEXPR size_type length()   const { return len_; }
         BOOST_CONSTEXPR size_type max_size() const { return len_; }
         BOOST_CONSTEXPR bool empty()         const { return len_ == 0; }
-        
+
         // element access
         BOOST_CONSTEXPR const charT& operator[](size_type pos) const { return ptr_[pos]; }
 
         const charT& at(size_t pos) const {
             if ( pos >= len_ )
-                throw std::out_of_range ( "boost::string_ref::at" );
+                BOOST_THROW_EXCEPTION( std::out_of_range ( "boost::string_ref::at" ) );
             return ptr_[pos];
             }
-            
+
         BOOST_CONSTEXPR const charT& front() const { return ptr_[0]; }
         BOOST_CONSTEXPR const charT& back()  const { return ptr_[len_-1]; }
         BOOST_CONSTEXPR const charT* data()  const { return ptr_; }
-        
+
         // modifiers
         void clear() { len_ = 0; }
         void remove_prefix(size_type n) {
@@ -131,100 +127,94 @@ namespace boost {
             ptr_ += n;
             len_ -= n;
             }
-            
+
         void remove_suffix(size_type n) {
             if ( n > len_ )
                 n = len_;
             len_ -= n;
             }
-            
-        
+
+
         // basic_string_ref string operations
-        BOOST_CONSTEXPR
         basic_string_ref substr(size_type pos, size_type n=npos) const {
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1600)
-            // Looks like msvc 8 and 9 have a codegen bug when one branch of
-            // a conditional operator is a throw expression. -EAN 2012/12/04
-            if ( pos > size()) throw std::out_of_range ( "string_ref::substr" );
-            if ( n == npos || pos + n > size()) n = size () - pos;
+            if ( pos > size())
+                BOOST_THROW_EXCEPTION( std::out_of_range ( "string_ref::substr" ) );
+            if ( n == npos || pos + n > size())
+                n = size () - pos;
             return basic_string_ref ( data() + pos, n );
-#else
-            return pos > size() ? throw std::out_of_range ( "string_ref::substr" ) :
-                basic_string_ref ( data() + pos, n == npos || pos + n > size() ? size() - pos : n );
-#endif
             }
-        
+
         int compare(basic_string_ref x) const {
-            int cmp = traits::compare ( ptr_, x.ptr_, (std::min)(len_, x.len_));
+            const int cmp = traits::compare ( ptr_, x.ptr_, (std::min)(len_, x.len_));
             return cmp != 0 ? cmp : ( len_ == x.len_ ? 0 : len_ < x.len_ ? -1 : 1 );
             }
-        
+
         bool starts_with(charT c) const { return !empty() && traits::eq ( c, front()); }
         bool starts_with(basic_string_ref x) const {
             return len_ >= x.len_ && traits::compare ( ptr_, x.ptr_, x.len_ ) == 0;
             }
-        
+
         bool ends_with(charT c) const { return !empty() && traits::eq ( c, back()); }
         bool ends_with(basic_string_ref x) const {
             return len_ >= x.len_ && traits::compare ( ptr_ + len_ - x.len_, x.ptr_, x.len_ ) == 0;
             }
 
         size_type find(basic_string_ref s) const {
-            const_iterator iter = std::search ( this->cbegin (), this->cend (), 
+            const_iterator iter = std::search ( this->cbegin (), this->cend (),
                                                 s.cbegin (), s.cend (), traits::eq );
-            return iter = this->cend () ? npos : std::distance ( this->cbegin (), iter );
+            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
             }
-        
+
         size_type find(charT c) const {
-            const_iterator iter = std::find_if ( this->cbegin (), this->cend (), 
+            const_iterator iter = std::find_if ( this->cbegin (), this->cend (),
                                     detail::string_ref_traits_eq<charT, traits> ( c ));
             return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
             }
-                        
+
         size_type rfind(basic_string_ref s) const {
-            const_reverse_iterator iter = std::search ( this->crbegin (), this->crend (), 
+            const_reverse_iterator iter = std::search ( this->crbegin (), this->crend (),
                                                 s.crbegin (), s.crend (), traits::eq );
             return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
             }
 
         size_type rfind(charT c) const {
-            const_reverse_iterator iter = std::find_if ( this->crbegin (), this->crend (), 
+            const_reverse_iterator iter = std::find_if ( this->crbegin (), this->crend (),
                                     detail::string_ref_traits_eq<charT, traits> ( c ));
             return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
             }
-        
+
         size_type find_first_of(charT c) const { return  find (c); }
         size_type find_last_of (charT c) const { return rfind (c); }
-        
+
         size_type find_first_of(basic_string_ref s) const {
-            const_iterator iter = std::find_first_of 
-            	( this->cbegin (), this->cend (), s.cbegin (), s.cend (), traits::eq );
+            const_iterator iter = std::find_first_of
+                ( this->cbegin (), this->cend (), s.cbegin (), s.cend (), traits::eq );
             return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
             }
-        
+
         size_type find_last_of(basic_string_ref s) const {
-            const_reverse_iterator iter = std::find_first_of 
+            const_reverse_iterator iter = std::find_first_of
                 ( this->crbegin (), this->crend (), s.cbegin (), s.cend (), traits::eq );
             return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter);
             }
-        
+
         size_type find_first_not_of(basic_string_ref s) const {
-        	const_iterator iter = find_not_of ( this->cbegin (), this->cend (), s );
+            const_iterator iter = find_not_of ( this->cbegin (), this->cend (), s );
             return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
             }
-        
+
         size_type find_first_not_of(charT c) const {
             for ( const_iterator iter = this->cbegin (); iter != this->cend (); ++iter )
                 if ( !traits::eq ( c, *iter ))
                     return std::distance ( this->cbegin (), iter );
             return npos;
             }
-        
+
         size_type find_last_not_of(basic_string_ref s) const {
-        	const_reverse_iterator iter = find_not_of ( this->crbegin (), this->crend (), s );
+            const_reverse_iterator iter = find_not_of ( this->crbegin (), this->crend (), s );
             return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
             }
-        
+
         size_type find_last_not_of(charT c) const {
             for ( const_reverse_iterator iter = this->crbegin (); iter != this->crend (); ++iter )
                 if ( !traits::eq ( c, *iter ))
@@ -237,136 +227,296 @@ namespace boost {
         size_type reverse_distance ( r_iter first, r_iter last ) const {
             return len_ - 1 - std::distance ( first, last );
             }
-        
+
         template <typename Iterator>
         Iterator find_not_of ( Iterator first, Iterator last, basic_string_ref s ) const {
-			for ( ; first != last ; ++first )
-				if ( 0 == traits::find ( s.ptr_, s.len_, *first ))
-					return first;
-			return last;
-			}
-		
-       		
-        
+            for ( ; first != last ; ++first )
+                if ( 0 == traits::find ( s.ptr_, s.len_, *first ))
+                    return first;
+            return last;
+            }
+
+
+
         const charT *ptr_;
         std::size_t len_;
         };
-    
-    // Comparison operators
+
+
+//  Comparison operators
+//  Equality
     template<typename charT, typename traits>
-    bool operator==(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
+    inline bool operator==(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
         if ( x.size () != y.size ()) return false;
         return x.compare(y) == 0;
         }
-    
+
+    template<typename charT, typename traits, typename Allocator>
+    inline bool operator==(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+        return x == basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits, typename Allocator>
+    inline bool operator==(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) == y;
+        }
+
     template<typename charT, typename traits>
-    bool operator!=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
+    inline bool operator==(basic_string_ref<charT, traits> x, const charT * y) {
+        return x == basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits>
+    inline bool operator==(const charT * x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) == y;
+        }
+
+//  Inequality
+    template<typename charT, typename traits>
+    inline bool operator!=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
         if ( x.size () != y.size ()) return true;
         return x.compare(y) != 0;
         }
 
+    template<typename charT, typename traits, typename Allocator>
+    inline bool operator!=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+        return x != basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits, typename Allocator>
+    inline bool operator!=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) != y;
+        }
+
     template<typename charT, typename traits>
-    bool operator<(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
+    inline bool operator!=(basic_string_ref<charT, traits> x, const charT * y) {
+        return x != basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits>
+    inline bool operator!=(const charT * x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) != y;
+        }
+
+//  Less than
+    template<typename charT, typename traits>
+    inline bool operator<(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
         return x.compare(y) < 0;
         }
 
+    template<typename charT, typename traits, typename Allocator>
+    inline bool operator<(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+        return x < basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits, typename Allocator>
+    inline bool operator<(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) < y;
+        }
+
     template<typename charT, typename traits>
-    bool operator>(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
+    inline bool operator<(basic_string_ref<charT, traits> x, const charT * y) {
+        return x < basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits>
+    inline bool operator<(const charT * x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) < y;
+        }
+
+//  Greater than
+    template<typename charT, typename traits>
+    inline bool operator>(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
         return x.compare(y) > 0;
         }
 
+    template<typename charT, typename traits, typename Allocator>
+    inline bool operator>(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+        return x > basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits, typename Allocator>
+    inline bool operator>(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) > y;
+        }
+
     template<typename charT, typename traits>
-    bool operator<=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
+    inline bool operator>(basic_string_ref<charT, traits> x, const charT * y) {
+        return x > basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits>
+    inline bool operator>(const charT * x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) > y;
+        }
+
+//  Less than or equal to
+    template<typename charT, typename traits>
+    inline bool operator<=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
         return x.compare(y) <= 0;
         }
 
+    template<typename charT, typename traits, typename Allocator>
+    inline bool operator<=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+        return x <= basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits, typename Allocator>
+    inline bool operator<=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) <= y;
+        }
+
     template<typename charT, typename traits>
-    bool operator>=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
+    inline bool operator<=(basic_string_ref<charT, traits> x, const charT * y) {
+        return x <= basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits>
+    inline bool operator<=(const charT * x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) <= y;
+        }
+
+//  Greater than or equal to
+    template<typename charT, typename traits>
+    inline bool operator>=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
         return x.compare(y) >= 0;
         }
 
-    
+    template<typename charT, typename traits, typename Allocator>
+    inline bool operator>=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+        return x >= basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits, typename Allocator>
+    inline bool operator>=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) >= y;
+        }
+
+    template<typename charT, typename traits>
+    inline bool operator>=(basic_string_ref<charT, traits> x, const charT * y) {
+        return x >= basic_string_ref<charT, traits>(y);
+        }
+
+    template<typename charT, typename traits>
+    inline bool operator>=(const charT * x, basic_string_ref<charT, traits> y) {
+        return basic_string_ref<charT, traits>(x) >= y;
+        }
+
+    namespace detail {
+
+        template<class charT, class traits>
+        inline void insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
+            enum { chunk_size = 8 };
+            charT fill_chars[chunk_size];
+            std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill());
+            for (; n >= chunk_size && os.good(); n -= chunk_size)
+                os.write(fill_chars, static_cast< std::size_t >(chunk_size));
+            if (n > 0 && os.good())
+                os.write(fill_chars, n);
+            }
+
+        template<class charT, class traits>
+        void insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
+            const std::size_t size = str.size();
+            const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size;
+            const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left;
+            if (!align_left) {
+                detail::insert_fill_chars(os, alignment_size);
+                if (os.good())
+                    os.write(str.data(), size);
+                }
+            else {
+                os.write(str.data(), size);
+                if (os.good())
+                    detail::insert_fill_chars(os, alignment_size);
+                }
+            }
+
+        } // namespace detail
+
     // Inserter
     template<class charT, class traits>
-    std::basic_ostream<charT, traits>&
+    inline std::basic_ostream<charT, traits>&
     operator<<(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
-#ifdef BOOST_NO_CXX11_RANGE_BASED_FOR
-        for ( typename basic_string_ref<charT, traits>::const_iterator iter = str.begin (); iter != str.end (); ++iter )
-            os << *iter;
-#else
-        for ( charT x : str )
-            os << x;
-#endif
+        if (os.good()) {
+            const std::size_t size = str.size();
+            const std::size_t w = static_cast< std::size_t >(os.width());
+            if (w <= size)
+                os.write(str.data(), size);
+            else
+                detail::insert_aligned(os, str);
+            os.width(0);
+            }
         return os;
         }
-    
+
 #if 0
     // numeric conversions
     //
     //  These are short-term implementations.
     //  In a production environment, I would rather avoid the copying.
     //
-    int stoi (string_ref str, size_t* idx=0, int base=10) {
+    inline int stoi (string_ref str, size_t* idx=0, int base=10) {
         return std::stoi ( std::string(str), idx, base );
         }
-    
-    long stol (string_ref str, size_t* idx=0, int base=10) {
+
+    inline long stol (string_ref str, size_t* idx=0, int base=10) {
         return std::stol ( std::string(str), idx, base );
         }
-        
-    unsigned long stoul (string_ref str, size_t* idx=0, int base=10) {
+
+    inline unsigned long stoul (string_ref str, size_t* idx=0, int base=10) {
         return std::stoul ( std::string(str), idx, base );
         }
-        
-    long long stoll (string_ref str, size_t* idx=0, int base=10) {
+
+    inline long long stoll (string_ref str, size_t* idx=0, int base=10) {
         return std::stoll ( std::string(str), idx, base );
         }
-    
-    unsigned long long stoull (string_ref str, size_t* idx=0, int base=10) {
+
+    inline unsigned long long stoull (string_ref str, size_t* idx=0, int base=10) {
         return std::stoull ( std::string(str), idx, base );
         }
-    
-    float stof (string_ref str, size_t* idx=0) {
+
+    inline float stof (string_ref str, size_t* idx=0) {
         return std::stof ( std::string(str), idx );
         }
-        
-    double stod (string_ref str, size_t* idx=0) {
+
+    inline double stod (string_ref str, size_t* idx=0) {
         return std::stod ( std::string(str), idx );
         }
-        
-    long double stold (string_ref str, size_t* idx=0)  {
+
+    inline long double stold (string_ref str, size_t* idx=0)  {
         return std::stold ( std::string(str), idx );
         }
-    
-    int  stoi (wstring_ref str, size_t* idx=0, int base=10) {
+
+    inline int  stoi (wstring_ref str, size_t* idx=0, int base=10) {
         return std::stoi ( std::wstring(str), idx, base );
         }
-        
-    long stol (wstring_ref str, size_t* idx=0, int base=10) {
+
+    inline long stol (wstring_ref str, size_t* idx=0, int base=10) {
         return std::stol ( std::wstring(str), idx, base );
         }
-        
-    unsigned long stoul (wstring_ref str, size_t* idx=0, int base=10) {
+
+    inline unsigned long stoul (wstring_ref str, size_t* idx=0, int base=10) {
         return std::stoul ( std::wstring(str), idx, base );
         }
-        
-    long long stoll (wstring_ref str, size_t* idx=0, int base=10) {
+
+    inline long long stoll (wstring_ref str, size_t* idx=0, int base=10) {
         return std::stoll ( std::wstring(str), idx, base );
         }
-        
-    unsigned long long stoull (wstring_ref str, size_t* idx=0, int base=10) {
+
+    inline unsigned long long stoull (wstring_ref str, size_t* idx=0, int base=10) {
         return std::stoull ( std::wstring(str), idx, base );
         }
-    
-    float  stof (wstring_ref str, size_t* idx=0) {
+
+    inline float  stof (wstring_ref str, size_t* idx=0) {
         return std::stof ( std::wstring(str), idx );
         }
-        
-    double stod (wstring_ref str, size_t* idx=0) {
+
+    inline double stod (wstring_ref str, size_t* idx=0) {
         return std::stod ( std::wstring(str), idx );
         }
-        
-    long double stold (wstring_ref str, size_t* idx=0) {
+
+    inline long double stold (wstring_ref str, size_t* idx=0) {
         return std::stold ( std::wstring(str), idx );
         }
 #endif

include/boost/utility/string_ref_fwd.hpp

@@ -0,0 +1,37 @@
+/*
+   Copyright (c) Marshall Clow 2012-2012.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    For more information, see http://www.boost.org
+
+    Based on the StringRef implementation in LLVM (http://llvm.org) and
+    N3422 by Jeffrey Yasskin
+        http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
+
+*/
+
+#ifndef BOOST_STRING_REF_FWD_HPP
+#define BOOST_STRING_REF_FWD_HPP
+
+#include <boost/config.hpp>
+#include <string>
+
+namespace boost {
+
+    template<typename charT, typename traits = std::char_traits<charT> > class basic_string_ref;
+    typedef basic_string_ref<char,     std::char_traits<char> >        string_ref;
+    typedef basic_string_ref<wchar_t,  std::char_traits<wchar_t> >    wstring_ref;
+
+#ifndef BOOST_NO_CXX11_CHAR16_T
+    typedef basic_string_ref<char16_t, std::char_traits<char16_t> > u16string_ref;
+#endif
+
+#ifndef BOOST_NO_CXX11_CHAR32_T
+    typedef basic_string_ref<char32_t, std::char_traits<char32_t> > u32string_ref;
+#endif
+
+}
+
+#endif

index.html

@@ -14,22 +14,29 @@
 		<p>But that doesn't mean there isn't useful stuff here. Take a look:</p>
 		<blockquote>
 			<p>
+				<a href="utility.htm#addressof">addressof</a><br>
 				<a href="assert.html">assert</a><br>
 				<a href="base_from_member.html">base_from_member</a><br>
+				<a href="utility.htm#BOOST_BINARY">BOOST_BINARY</a><br>
 				<a href="call_traits.htm">call_traits</a><br>
 				<a href="checked_delete.html">checked_delete</a><br>
 				<a href="compressed_pair.htm">compressed_pair</a><br>
 				<a href="current_function.html">current_function</a><br>
 				<a href="doc/html/declval.html">declval</a><br>
 				<a href="enable_if.html">enable_if</a><br>
-            <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
-            <a href="generator_iterator.htm">generator iterator adaptors</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="doc/html/string_ref.html">string_ref</a><br>
             <a href="value_init.htm">value_init</a>
+            <a href="doc/html/explicit_operator_bool.html">BOOST_EXPLICIT_OPERATOR_BOOL and BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL</a><br>
          </p>
 		</blockquote>
 		<hr>
@@ -43,4 +50,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/Jamfile.v2

@@ -8,6 +8,11 @@
 # bring in rules for testing
 import testing ;
 
+alias unit_test_framework
+    : # sources
+        /boost//unit_test_framework
+    ;        
+
 # Please keep the tests ordered by filename
 test-suite utility
     :
@@ -31,8 +36,9 @@ test-suite utility
         [ run ../ref_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ]
         [ compile result_of_test.cpp ]
         [ run ../shared_iterator_test.cpp ]
-        [ run string_ref_test1.cpp ]
-        [ run string_ref_test2.cpp ]
+        [ run string_ref_test1.cpp unit_test_framework ]
+        [ run string_ref_test2.cpp unit_test_framework ]
+        [ run string_ref_test_io.cpp unit_test_framework ]
         [ run ../value_init_test.cpp ]
         [ run ../value_init_workaround_test.cpp ]
         [ run ../initialized_test.cpp ]
@@ -42,5 +48,10 @@ test-suite utility
         [ compile-fail ../initialized_test_fail1.cpp ]
         [ compile-fail ../initialized_test_fail2.cpp ]
         [ run ../verify_test.cpp ]
+        [ run explicit_operator_bool.cpp ]
+        [ compile-fail explicit_operator_bool_compile_fail_conv_int.cpp ]
+        [ compile-fail explicit_operator_bool_compile_fail_conv_pvoid.cpp ]
+        [ compile-fail explicit_operator_bool_compile_fail_delete.cpp ]
+        [ compile-fail explicit_operator_bool_compile_fail_shift.cpp ]
     ;
 

test/explicit_operator_bool.cpp

@@ -0,0 +1,54 @@
+/*
+ *          Copyright Andrey Semashev 2007 - 2013.
+ * 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)
+ */
+/*!
+ * \file   explicit_operator_bool_compile.cpp
+ * \author Andrey Semashev
+ * \date   17.07.2010
+ *
+ * \brief  This test checks that explicit operator bool can be used in
+ *         the valid contexts.
+ */
+
+#define BOOST_TEST_MODULE explicit_operator_bool_compile
+
+#include <boost/utility/explicit_operator_bool.hpp>
+
+namespace {
+
+    // A test object that has the operator of explicit conversion to bool
+    struct checkable1
+    {
+        BOOST_EXPLICIT_OPERATOR_BOOL()
+        bool operator! () const
+        {
+            return false;
+        }
+    };
+
+    struct checkable2
+    {
+        BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()
+        BOOST_CONSTEXPR bool operator! () const
+        {
+            return false;
+        }
+    };
+
+} // namespace
+
+int main(int, char*[])
+{
+    checkable1 val1;
+    if (val1)
+    {
+        checkable2 val2;
+        if (val2)
+            return 0;
+    }
+
+    return 1;
+}

test/explicit_operator_bool_compile_fail_conv_int.cpp

@@ -0,0 +1,40 @@
+/*
+ *          Copyright Andrey Semashev 2007 - 2013.
+ * 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)
+ */
+/*!
+ * \file   explicit_operator_bool_compile_fail_conv_int.cpp
+ * \author Andrey Semashev
+ * \date   17.07.2010
+ *
+ * \brief  This test checks that explicit operator bool cannot be used in
+ *         an unintended context.
+ */
+
+#define BOOST_TEST_MODULE explicit_operator_bool_compile_fail_conv_int
+
+#include <boost/utility/explicit_operator_bool.hpp>
+
+namespace {
+
+    // A test object that has the operator of explicit conversion to bool
+    struct checkable
+    {
+        BOOST_EXPLICIT_OPERATOR_BOOL()
+        bool operator! () const
+        {
+            return false;
+        }
+    };
+
+} // namespace
+
+int main(int, char*[])
+{
+    checkable val;
+    int n = val;
+
+    return 0;
+}

test/explicit_operator_bool_compile_fail_conv_pvoid.cpp

@@ -0,0 +1,40 @@
+/*
+ *          Copyright Andrey Semashev 2007 - 2013.
+ * 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)
+ */
+/*!
+ * \file   explicit_operator_bool_compile_fail_conv_pvoid.cpp
+ * \author Andrey Semashev
+ * \date   17.07.2010
+ *
+ * \brief  This test checks that explicit operator bool cannot be used in
+ *         an unintended context.
+ */
+
+#define BOOST_TEST_MODULE explicit_operator_bool_compile_fail_conv_pvoid
+
+#include <boost/utility/explicit_operator_bool.hpp>
+
+namespace {
+
+    // A test object that has the operator of explicit conversion to bool
+    struct checkable
+    {
+        BOOST_EXPLICIT_OPERATOR_BOOL()
+        bool operator! () const
+        {
+            return false;
+        }
+    };
+
+} // namespace
+
+int main(int, char*[])
+{
+    checkable val;
+    void* p = val;
+
+    return 0;
+}

test/explicit_operator_bool_compile_fail_delete.cpp

@@ -0,0 +1,40 @@
+/*
+ *          Copyright Andrey Semashev 2007 - 2013.
+ * 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)
+ */
+/*!
+ * \file   explicit_operator_bool_compile_fail_delete.cpp
+ * \author Andrey Semashev
+ * \date   17.07.2010
+ *
+ * \brief  This test checks that explicit operator bool cannot be used in
+ *         an unintended context.
+ */
+
+#define BOOST_TEST_MODULE util_explicit_operator_bool_delete
+
+#include <boost/utility/explicit_operator_bool.hpp>
+
+namespace {
+
+    // A test object that has the operator of explicit conversion to bool
+    struct checkable
+    {
+        BOOST_EXPLICIT_OPERATOR_BOOL()
+        bool operator! () const
+        {
+            return false;
+        }
+    };
+
+} // namespace
+
+int main(int, char*[])
+{
+    checkable val;
+    delete val;
+
+    return 0;
+}

test/explicit_operator_bool_compile_fail_shift.cpp

@@ -0,0 +1,40 @@
+/*
+ *          Copyright Andrey Semashev 2007 - 2013.
+ * 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)
+ */
+/*!
+ * \file   explicit_operator_bool_compile_fail_shift.cpp
+ * \author Andrey Semashev
+ * \date   17.07.2010
+ *
+ * \brief  This test checks that explicit operator bool cannot be used in
+ *         an unintended context.
+ */
+
+#define BOOST_TEST_MODULE explicit_operator_bool_compile_fail_shift
+
+#include <boost/utility/explicit_operator_bool.hpp>
+
+namespace {
+
+    // A test object that has the operator of explicit conversion to bool
+    struct checkable
+    {
+        BOOST_EXPLICIT_OPERATOR_BOOL()
+        bool operator! () const
+        {
+            return false;
+        }
+    };
+
+} // namespace
+
+int main(int, char*[])
+{
+    checkable val;
+    val << 2;
+
+    return 0;
+}

test/result_of_test.cpp

@@ -5,6 +5,12 @@
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
+// Examples:
+//   To run the default test:
+//   $ cd libs/utility/test && bjam
+//   To test decltype on g++ 2.7:
+//   $ cd libs/utility/test && bjam cxxflags="-std=c++11 -D BOOST_RESULT_OF_USE_DECLTYPE"
+
 #include <boost/config.hpp>
 
 // For more information, see http://www.boost.org/libs/utility
@@ -190,7 +196,7 @@ int main()
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<volatile int_result_of_template<void>(void)>::type, void>::value));
 
   // Prior to decltype, result_of could not deduce the return type
-  // nullary function objects unless they exposed a result_type.
+  // of nullary function objects unless they exposed a result_type.
 #if defined(BOOST_RESULT_OF_USE_DECLTYPE)
   BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, int>::value));
@@ -273,7 +279,7 @@ int main()
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<pf_t(int)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<pf_t const(int)>::type,int>::value));
 
-#if defined(BOOST_RESULT_OF_USE_DECLTYPE)
+#if defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
   BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(double)>::type, short>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result(double)>::type, cv_overload_check<const short> >::value));
   BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result(double)>::type, cv_overload_check<volatile short> >::value));
@@ -301,10 +307,10 @@ int main()
 #endif
 #endif
 
-#if defined(BOOST_RESULT_OF_USE_DECLTYPE)
+#if defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
   int i = 123;
   sfinae_test(sfinae_test_f, i);
-#endif // defined(BOOST_RESULT_OF_USE_DECLTYPE)
+#endif // defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
 
   return 0;
 }

test/string_ref_test1.cpp

@@ -1,4 +1,4 @@
-/* 
+/*
    Copyright (c) Marshall Clow 2012-2012.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -13,8 +13,8 @@
 
 #include <boost/utility/string_ref.hpp>
 
-
-#include <boost/test/included/test_exec_monitor.hpp>
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
 
 typedef boost::string_ref string_ref;
 
@@ -33,30 +33,30 @@ void null_tests ( const char *p ) {
     string_ref sr3 ( p, 0 );
     string_ref sr4 ( p );
     sr4.clear ();
-    
+
     BOOST_CHECK ( sr1 == sr2 );
     BOOST_CHECK ( sr1 == sr3 );
     BOOST_CHECK ( sr2 == sr3 );
-    BOOST_CHECK ( sr1 == sr4 );    
+    BOOST_CHECK ( sr1 == sr4 );
     }
 
 //  make sure that substrings work just like strings
 void test_substr ( const std::string &str ) {
     const size_t sz = str.size ();
     string_ref ref ( str );
-    
+
 //  Substrings at the end
     for ( size_t i = 0; i <= sz; ++ i )
         interop ( str.substr ( i ), ref.substr ( i ));
-        
+
 //  Substrings at the beginning
     for ( size_t i = 0; i <= sz; ++ i )
         interop ( str.substr ( 0, i ), ref.substr ( 0, i ));
-        
+
 //  All possible substrings
     for ( size_t i = 0; i < sz; ++i )
         for ( size_t j = i; j < sz; ++j )
-            interop ( str.substr ( i, j ), ref.substr ( i, j ));    
+            interop ( str.substr ( i, j ), ref.substr ( i, j ));
     }
 
 //  make sure that removing prefixes and suffixes work just like strings
@@ -64,20 +64,20 @@ void test_remove ( const std::string &str ) {
     const size_t sz = str.size ();
     std::string work;
     string_ref ref;
-    
+
     for ( size_t i = 1; i <= sz; ++i ) {
       work = str;
-      ref  = str;     
+      ref  = str;
       while ( ref.size () >= i ) {
           interop ( work, ref );
           work.erase ( 0, i );
           ref.remove_prefix (i);
           }
       }
-    
+
     for ( size_t i = 1; i < sz; ++ i ) {
       work = str;
-      ref  = str;     
+      ref  = str;
       while ( ref.size () >= i ) {
           interop ( work, ref );
           work.erase ( work.size () - i, i );
@@ -93,9 +93,9 @@ const char *test_strings [] = {
     "0123456789",
     NULL
     };
-    
-int test_main( int , char* [] ) {
 
+BOOST_AUTO_TEST_CASE( test_main )
+{
     const char **p = &test_strings[0];
 
     while ( *p != NULL ) {
@@ -103,9 +103,7 @@ int test_main( int , char* [] ) {
         test_substr ( *p );
         test_remove ( *p );
         null_tests ( *p );
-    
+
         p++;
         }
-
-    return 0;
-    }
+}

test/string_ref_test2.cpp

@@ -1,4 +1,4 @@
-/* 
+/*
    Copyright (c) Marshall Clow 2012-2012.
 
    Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -12,7 +12,8 @@
 
 #include <boost/utility/string_ref.hpp>
 
-#include <boost/test/included/test_exec_monitor.hpp>
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
 
 typedef boost::string_ref string_ref;
 
@@ -22,7 +23,7 @@ void ends_with ( const char *arg ) {
     string_ref sr2 ( arg );
     const char *p = arg;
 
-    while ( !*p ) {
+    while ( *p ) {
         BOOST_CHECK ( sr.ends_with ( p ));
         ++p;
         }
@@ -45,7 +46,7 @@ void ends_with ( const char *arg ) {
     BOOST_CHECK ( !sr2.ends_with ( ++ch ));
     BOOST_CHECK ( sr2.ends_with ( string_ref ()));
     }
-    
+
 void starts_with ( const char *arg ) {
     const size_t sz = strlen ( arg );
     string_ref sr  ( arg );
@@ -84,9 +85,9 @@ void reverse ( const char *arg ) {
 
 //	This helper function eliminates signed vs. unsigned warnings
 string_ref::size_type ptr_diff ( const char *res, const char *base ) {
-	BOOST_CHECK ( res >= base );
-	return static_cast<string_ref::size_type> ( res - base );
-	}
+    BOOST_CHECK ( res >= base );
+    return static_cast<string_ref::size_type> ( res - base );
+    }
 
 void find ( const char *arg ) {
     string_ref sr1;
@@ -94,22 +95,32 @@ void find ( const char *arg ) {
     const char *p;
 
 //  Look for each character in the string(searching from the start)
-  p = arg;
-  sr1 = arg;
-  while ( *p ) {
-    string_ref::size_type pos = sr1.find(*p);
-    BOOST_CHECK ( pos != string_ref::npos && ( pos <= ptr_diff ( p, arg )));
-    ++p;
-    }
-  
+    p = arg;
+    sr1 = arg;
+    while ( *p ) {
+      string_ref::size_type pos = sr1.find(*p);
+      BOOST_CHECK ( pos != string_ref::npos && ( pos <= ptr_diff ( p, arg )));
+      ++p;
+      }
+
 //  Look for each character in the string (searching from the end)
     p = arg;
     sr1 = arg;
     while ( *p ) {
-    string_ref::size_type pos = sr1.rfind(*p);
-    BOOST_CHECK ( pos != string_ref::npos && pos < sr1.size () && ( pos >= ptr_diff ( p, arg )));
-    ++p;
-    }
+      string_ref::size_type pos = sr1.rfind(*p);
+      BOOST_CHECK ( pos != string_ref::npos && pos < sr1.size () && ( pos >= ptr_diff ( p, arg )));
+      ++p;
+      }
+
+//	Look for pairs on characters (searching from the start)
+    sr1 = arg;
+    p = arg;
+    while ( *p && *(p+1)) {
+        string_ref sr3 ( p, 2 );
+        string_ref::size_type pos = sr1.find ( sr3 );
+        BOOST_CHECK ( pos != string_ref::npos && pos <= static_cast<string_ref::size_type>( p - arg ));
+        p++;
+        }
 
     sr1 = arg;
     p = arg;
@@ -155,7 +166,7 @@ void find ( const char *arg ) {
         sr1.remove_suffix (1);
         --p;
         }
-        
+
 //  Find everything at the start
     sr1  = arg;
     p    = arg;
@@ -176,7 +187,7 @@ void find ( const char *arg ) {
         sr1.remove_suffix (1);
         --p;
         }
-        
+
 //  Basic sanity checking for "find_first_of / find_first_not_of"
     sr1 = arg;
     sr2 = arg;
@@ -201,7 +212,7 @@ void find ( const char *arg ) {
         BOOST_CHECK ( pos2 != pos1 );
         ++p;
         }
-        
+
 //  Basic sanity checking for "find_last_of / find_last_not_of"
     sr1 = arg;
     sr2 = arg;
@@ -223,13 +234,63 @@ void find ( const char *arg ) {
                 BOOST_CHECK ( sr1[i] == *p );
             BOOST_CHECK ( sr1 [ pos2 ] != *p );
             }
-         
+
         BOOST_CHECK ( pos2 != pos1 );
         ++p;
         }
 
     }
 
+
+void to_string ( const char *arg ) {
+    string_ref sr1;
+    std::string str1;
+    std::string str2;
+
+    str1.assign ( arg );
+    sr1 = arg;
+//	str2 = sr1.to_string<std::allocator<char> > ();
+    str2 = sr1.to_string ();
+    BOOST_CHECK ( str1 == str2 );
+
+#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+    std::string str3 = static_cast<std::string> ( sr1 );
+    BOOST_CHECK ( str1 == str3 );
+#endif
+    }
+
+void compare ( const char *arg ) {
+    string_ref sr1;
+    std::string str1;
+    std::string str2 = str1;
+
+    str1.assign ( arg );
+    sr1 = arg;
+    BOOST_CHECK ( sr1  == sr1);	    // compare string_ref and string_ref
+    BOOST_CHECK ( sr1  == str1);	// compare string and string_ref
+    BOOST_CHECK ( str1 == sr1 );	// compare string_ref and string
+    BOOST_CHECK ( sr1  == arg );	// compare string_ref and pointer
+    BOOST_CHECK ( arg  == sr1 );	// compare pointer and string_ref
+
+    if ( sr1.size () > 0 ) {
+        (*str1.rbegin())++;
+        BOOST_CHECK ( sr1  != str1 );
+        BOOST_CHECK ( str1 != sr1 );
+        BOOST_CHECK ( sr1 < str1 );
+        BOOST_CHECK ( sr1 <= str1 );
+        BOOST_CHECK ( str1 > sr1 );
+        BOOST_CHECK ( str1 >= sr1 );
+
+        (*str1.rbegin()) -= 2;
+        BOOST_CHECK ( sr1  != str1 );
+        BOOST_CHECK ( str1 != sr1 );
+        BOOST_CHECK ( sr1 > str1 );
+        BOOST_CHECK ( sr1 >= str1 );
+        BOOST_CHECK ( str1 < sr1 );
+        BOOST_CHECK ( str1 <= sr1 );
+        }
+    }
+
 const char *test_strings [] = {
     "",
     "0",
@@ -239,18 +300,19 @@ const char *test_strings [] = {
     "abc\0asdfadsfasf",
     NULL
     };
-    
-int test_main( int , char* [] ) {
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
     const char **p = &test_strings[0];
-    
+
     while ( *p != NULL ) {
         starts_with ( *p );
         ends_with ( *p );
         reverse ( *p );
         find ( *p );
+        to_string ( *p );
+        compare ( *p );
 
         p++;
         }
-
-    return 0;
-    }
+}

test/string_ref_test_io.cpp

@@ -0,0 +1,183 @@
+/*
+ *             Copyright Andrey Semashev 2013.
+ * 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)
+ */
+/*!
+ * \file   string_ref_test_io.cpp
+ * \author Andrey Semashev
+ * \date   26.05.2013
+ *
+ * \brief  This header contains tests for stream operations of \c basic_string_ref.
+ */
+
+#define BOOST_TEST_MODULE string_ref_test_io
+
+#include <boost/utility/string_ref.hpp>
+
+#include <iomanip>
+#include <sstream>
+#include <algorithm>
+#include <iterator>
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/test/unit_test.hpp>
+
+typedef boost::mpl::vector<
+    char
+#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_STD_WSTREAMBUF) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    , wchar_t
+#endif
+/* Current implementations seem to be missing codecvt facets to convert chars to char16_t and char32_t even though the types are available.
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    , char16_t
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    , char32_t
+#endif
+*/
+>::type char_types;
+
+static const char* test_strings[] =
+{
+    "begin",
+    "abcd",
+    "end"
+};
+
+//! The context with test data for particular character type
+template< typename CharT >
+struct context
+{
+    typedef CharT char_type;
+    typedef std::basic_string< char_type > string_type;
+    typedef std::basic_ostringstream< char_type > ostream_type;
+
+    string_type begin, abcd, end;
+
+    context()
+    {
+        boost::string_ref str = test_strings[0];
+        std::copy(str.begin(), str.end(), std::back_inserter(begin));
+
+        str = test_strings[1];
+        std::copy(str.begin(), str.end(), std::back_inserter(abcd));
+
+        str = test_strings[2];
+        std::copy(str.begin(), str.end(), std::back_inserter(end));
+    }
+};
+
+// Test regular output
+BOOST_AUTO_TEST_CASE_TEMPLATE(string_ref_output, CharT, char_types)
+{
+    typedef CharT char_type;
+    typedef std::basic_string< char_type > string_type;
+    typedef std::basic_ostringstream< char_type > ostream_type;
+    typedef boost::basic_string_ref< char_type > string_ref_type;
+
+    context< char_type > ctx;
+
+    ostream_type strm;
+    strm << string_ref_type(ctx.abcd);
+    BOOST_CHECK(strm.str() == ctx.abcd);
+}
+
+// Test support for padding
+BOOST_AUTO_TEST_CASE_TEMPLATE(padding, CharT, char_types)
+{
+    typedef CharT char_type;
+    typedef std::basic_string< char_type > string_type;
+    typedef std::basic_ostringstream< char_type > ostream_type;
+    typedef boost::basic_string_ref< char_type > string_ref_type;
+
+    context< char_type > ctx;
+
+    // Test for padding
+    {
+        ostream_type strm_ref;
+        strm_ref << ctx.begin << std::setw(8) << string_ref_type(ctx.abcd) << ctx.end;
+
+        ostream_type strm_correct;
+        strm_correct << ctx.begin << std::setw(8) << ctx.abcd << ctx.end;
+
+        BOOST_CHECK(strm_ref.str() == strm_correct.str());
+    }
+
+    // Test for long padding
+    {
+        ostream_type strm_ref;
+        strm_ref << ctx.begin << std::setw(100) << string_ref_type(ctx.abcd) << ctx.end;
+
+        ostream_type strm_correct;
+        strm_correct << ctx.begin << std::setw(100) << ctx.abcd << ctx.end;
+
+        BOOST_CHECK(strm_ref.str() == strm_correct.str());
+    }
+
+    // Test that short width does not truncate the string
+    {
+        ostream_type strm_ref;
+        strm_ref << ctx.begin << std::setw(1) << string_ref_type(ctx.abcd) << ctx.end;
+
+        ostream_type strm_correct;
+        strm_correct << ctx.begin << std::setw(1) << ctx.abcd << ctx.end;
+
+        BOOST_CHECK(strm_ref.str() == strm_correct.str());
+    }
+}
+
+// Test support for padding fill
+BOOST_AUTO_TEST_CASE_TEMPLATE(padding_fill, CharT, char_types)
+{
+    typedef CharT char_type;
+    typedef std::basic_string< char_type > string_type;
+    typedef std::basic_ostringstream< char_type > ostream_type;
+    typedef boost::basic_string_ref< char_type > string_ref_type;
+
+    context< char_type > ctx;
+
+    ostream_type strm_ref;
+    strm_ref << ctx.begin << std::setfill(static_cast< char_type >('x')) << std::setw(8) << string_ref_type(ctx.abcd) << ctx.end;
+
+    ostream_type strm_correct;
+    strm_correct << ctx.begin << std::setfill(static_cast< char_type >('x')) << std::setw(8) << ctx.abcd << ctx.end;
+
+    BOOST_CHECK(strm_ref.str() == strm_correct.str());
+}
+
+// Test support for alignment
+BOOST_AUTO_TEST_CASE_TEMPLATE(alignment, CharT, char_types)
+{
+    typedef CharT char_type;
+    typedef std::basic_string< char_type > string_type;
+    typedef std::basic_ostringstream< char_type > ostream_type;
+    typedef boost::basic_string_ref< char_type > string_ref_type;
+
+    context< char_type > ctx;
+
+    // Left alignment
+    {
+        ostream_type strm_ref;
+        strm_ref << ctx.begin << std::left << std::setw(8) << string_ref_type(ctx.abcd) << ctx.end;
+
+        ostream_type strm_correct;
+        strm_correct << ctx.begin << std::left << std::setw(8) << ctx.abcd << ctx.end;
+
+        BOOST_CHECK(strm_ref.str() == strm_correct.str());
+    }
+
+    // Right alignment
+    {
+        ostream_type strm_ref;
+        strm_ref << ctx.begin << std::right << std::setw(8) << string_ref_type(ctx.abcd) << ctx.end;
+
+        ostream_type strm_correct;
+        strm_correct << ctx.begin << std::right << std::setw(8) << ctx.abcd << ctx.end;
+
+        BOOST_CHECK(strm_ref.str() == strm_correct.str());
+    }
+}

utility.htm

@@ -84,8 +84,10 @@ const std::list&lt;T&gt;::iterator next = boost::next(prev, 2);</pre>
 			will prevent the otherwise implicitly-generated functions (which don't have the 
 			proper semantics) from becoming a trap for other programmers.</p>
 		<p>The traditional way to deal with these is to declare a private copy constructor 
-			and copy assignment, and then document why this is done.&nbsp; But deriving 
-			from <b>noncopyable</b> is simpler and clearer, and doesn't require additional 
+        and copy assignment, and then document why this is done.&nbsp; A new alternative  
+        was introduced in C++2011, declaring a copy constructor and a copy assignment  
+        operator, but marking both as <code>delete</code>d.&nbsp; Deriving
+        from <b>noncopyable</b> is simpler and clearer, and doesn't require additional 
 			documentation.</p>
 		<p>The program <a href="noncopyable_test.cpp">noncopyable_test.cpp</a> can be used 
 			to verify class <b>noncopyable</b> works as expected. It has have been run 
@@ -106,7 +108,9 @@ class ResourceLadenFileSystem : boost::noncopyable {
 			about the effect on compiler optimization of adding (even trivial inline) 
 			destructor declarations. He says &quot;Probably this concern is misplaced, 
 			because noncopyable will be used mostly for classes which own resources and 
-			thus have non-trivial destruction semantics.&quot;</p>
+        thus have non-trivial destruction semantics.&quot;&nbsp; With C++2011, using an  
+        optimized and trivial constructor and similar destructor can be enforced by  
+        declaring both and marking them <code>default</code>.</p> 
 		<h2><a name="addressof">Function template addressof()</a></h2>
 		<p>Function <strong>addressof()</strong> returns the address of an object.</p>
 		<blockquote>
@@ -255,6 +259,46 @@ typedef boost::result_of&lt;
                 represent the return type of
                 <code>operator()</code> given a call expression.</p>
 
+                <p>Additionally, <code>boost::result_of</code>
+                provides a third mode of operation, which some users
+                may find convenient. When
+                <code>BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK</code>
+                is defined, <code>boost::result_of</code> behaves as
+                follows. If the function object has a member
+                type <code>result_type</code> or member
+                template <code>result&lt;&gt;</code>, then
+                <code>boost::result_of</code> will use the TR1
+                protocol. Otherwise,
+                <code>boost::result_of</code> will
+                use <code>decltype</code>. Using TR1 with
+                a <code>declytpe</code> fallback may workaround
+                certain problems at the cost of portability. For
+                example:
+                <ul>
+                    <li>Deficient compiler: If your code
+                    requires <code>boost::result_of</code> to work
+                    with incomplete return types but your
+                    compiler's <code>decltype</code> implementation
+                    does not support incomplete return types, then you
+                    can use the TR1 protocol as a workaround. Support
+                    for incomplete return types was added late in the
+                    C++11 standardization process
+                    (see <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3276.pdf">N3276</a>)
+                    and is not implemented by some compilers.</li>
+
+                    <li>Deficient legacy code: If your existing TR1
+                    function object advertises a different type than
+                    the actual result type deduced
+                    by <code>decltype</code>, then using TR1 with a
+                    <code>decltype</code> fallback will allow you to
+                    work with both your existing TR1 function objects
+                    and new C++11 function object. This situation
+                    could occur if your legacy function objects
+                    misused the TR1 protocol. See the documentation on
+                    known <a href="#result_of_tr1_diff">differences</a>
+                    between <code>boost::result_of</code> and TR1.</li>
+                </ul>
+
                 <a name="BOOST_NO_RESULT_OF"></a>
                 <p>This implementation of <code>result_of</code>
                 requires class template partial specialization, the

value_init.htm

@@ -295,7 +295,7 @@ so for those compilers that need to have such a workaround, based on the
 <br>    operator T&amp;() { return x ; }
 <br>    T const &amp;data() const { return x ; }
 <br>    T&amp; data() { return x ; }
-<br>    void swap( value_initialized&lt;T&gt;&amp; );
+<br>    void swap( value_initialized&amp; );
 <br>
 <br>  private :
 <br>    <i>unspecified</i> x ;
@@ -313,6 +313,12 @@ so for those compilers that need to have such a workaround, based on the
 <br>  return x.data() ;
 <br>}
 <br>
+<br>template&lt;class T&gt;
+<br>void swap ( value_initialized&lt;T&gt;&amp; lhs, value_initialized&lt;T&gt;&amp; rhs )
+<br>{
+<br>  lhs.swap(rhs) ;
+<br>}
+<br>
 <br>} // namespace boost
 <br></pre>
                     
@@ -385,7 +391,7 @@ the wrapped object is always performed with the <code>get()</code> idiom:</p>
 <br>    operator T&amp;();
 <br>    T const &amp;data() const;
 <br>    T&amp; data();
-<br>    void swap( value_initialized&lt;T&gt;&amp; );
+<br>    void swap( initialized&amp; );
 <br>
 <br>  private :
 <br>    <i>unspecified</i> x ;
@@ -397,6 +403,9 @@ the wrapped object is always performed with the <code>get()</code> idiom:</p>
 <br>template&lt;class T&gt;
 <br>T&amp; get ( initialized&lt;T&gt;&amp; x );
 <br>
+<br>template&lt;class T&gt;
+<br>void swap ( initialized&lt;T&gt;&amp; lhs, initialized&lt;T&gt;&amp; rhs );
+<br>
 <br>} // namespace boost
 <br></pre>
 

value_init_test.cpp

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