Create branch to keep WIP patch for modular build.

[SVN r85883]
Corrected comment.
2013-09-25 08:12:19 +00:00 · 2013-09-09 18:43:27 +00:00 · 2013-09-08 18:45:41 +00:00 · 2013-09-05 18:25:41 +00:00 · 2013-09-05 08:28:24 +00:00 · 2013-09-01 16:31:16 +00:00
27 changed files with 1112 additions and 219 deletions
--- a/base_from_member.html
+++ b/base_from_member.html
@@ -129,6 +129,8 @@ particular member type does not need to concern itself with the integer.</p>
 <h2><a name="synopsis">Synopsis</a></h2>

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

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

    template&lt; typename T1 &gt;
@@ -154,6 +161,7 @@ protected:
     typename T10 &gt;
    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7,
     T8 x8, T9 x9, T10 x10 );
+#endif
 };
 </pre></blockquote>

@@ -166,13 +174,29 @@ value of zero if it is omitted.  The class template has a protected
 data member called <var>member</var> that the derived class can use
 for later base classes (or itself).</p>

-<p>There is a default constructor and several constructor member
-templates.  These constructor templates can take as many arguments
-(currently up to ten) as possible and pass them to a constructor of
-the data member.  Since C++ does not allow any way to explicitly state
+<p>If the appropriate features of C++2011 are present, there will be a single
+constructor template.  It implements &quot;perfect forwarding&quot; to the best
+constructor call of <code>member</code> (if any).  The constructor template is
+marked both <code>constexpr</code> and <code>explicit</code>.  The former will
+be ignored if the corresponding inner constructor call (of <code>member</code>)
+does not have the marker.  The latter binds the other way; always taking
+effect, even when the inner constructor call does not have the marker.  The
+constructor template propagates the <code>noexcept</code> status of the inner
+constructor call.  (The constructor template has a trailing parameter with a
+default value that disables the template when its signature is too close to the
+signatures of the automatically-defined non-template copy- and/or
+move-constructors of <code>base_from_member</code>.)</p>
+
+<p>On earlier-standard compilers, there is a default constructor and several
+constructor member templates.  These constructor templates can take as many
+arguments (currently up to ten) as possible and pass them to a constructor of
+the data member.</p>
+
+<p>Since C++ does not allow any way to explicitly state
 the template parameters of a templated constructor, make sure that
 the arguments are already close as possible to the actual type used in
-the data member's desired constructor.</p>
+the data member's desired constructor.  Explicit conversions may be
+necessary.</p>

 <p>The <var>BOOST_BASE_FROM_MEMBER_MAX_ARITY</var> macro constant specifies
 the maximum argument length for the constructor templates.  The constant
@@ -180,7 +204,7 @@ may be overridden if more (or less) argument configurations are needed.  The
 constant may be read for code that is expandable like the class template and
 needs to maintain the same maximum size.  (Example code would be a class that
 uses this class template as a base class for a member with a flexible set of
-constructors.)</p>
+constructors.)  This constant is ignored when C++2011 features are present.</p>

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

@@ -323,11 +347,14 @@ constructor argument for <code>pbase0_type</code> is converted from
 argument for <code>pbase2_type</code> is converted from <code>int</code>
 to <code>double</code>.  The second constructor argument for
 <code>pbase3_type</code> is a special case of necessary conversion; all
-forms of the null-pointer literal in C++ also look like compile-time
-integral expressions, so C++ always interprets such code as an integer
-when it has overloads that can take either an integer or a pointer.  The
-last conversion is necessary for the compiler to call a constructor form
-with the exact pointer type used in <code>switcher</code>'s constructor.</p>
+forms of the null-pointer literal in C++ (except <code>nullptr</code> from
+C++2011) also look like compile-time integral expressions, so C++ always
+interprets such code as an integer when it has overloads that can take either
+an integer or a pointer.  The last conversion is necessary for the compiler to
+call a constructor form with the exact pointer type used in
+<code>switcher</code>'s constructor.  (If C++2011's <code>nullptr</code> is
+used, it still needs a conversion if multiple pointer types can be accepted in
+a constructor call but <code>std::nullptr_t</code> cannot.)</p>

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

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

 <hr>

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

-<p>Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and distribution
+<p>Copyright 2001, 2003, 2004, 2012 Daryle Walker.  Use, modification, and distribution
 are subject to the Boost Software License, Version 1.0.  (See accompanying
 file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
 href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
--- a/call_traits_test.cpp
+++ b/call_traits_test.cpp
@@ -210,8 +210,10 @@ int main()
   comparible_UDT u;
   c1(u);
   call_traits_checker<int> c2;
+   call_traits_checker<enum_UDT> c2b;
   int i = 2;
   c2(i);
+   c2b(one);
   int* pi = &i;
   int a[2] = {1,2};
 #if defined(BOOST_MSVC6_MEMBER_TEMPLATES) && !defined(__ICL)
@@ -292,7 +294,11 @@ int main()
   BOOST_CHECK_TYPE(incomplete_type&, boost::call_traits<incomplete_type>::reference);
   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference);
   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::param_type);
-
+   // test enum:
+   BOOST_CHECK_TYPE(enum_UDT, boost::call_traits<enum_UDT>::value_type);
+   BOOST_CHECK_TYPE(enum_UDT&, boost::call_traits<enum_UDT>::reference);
+   BOOST_CHECK_TYPE(const enum_UDT&, boost::call_traits<enum_UDT>::const_reference);
+   BOOST_CHECK_TYPE(const enum_UDT, boost::call_traits<enum_UDT>::param_type);
   return 0;
 }

--- a/doc/Jamfile.v2
+++ b/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
     ;
--- a/doc/explicit_operator_bool.qbk
+++ b/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]
+
+
+
+
--- a/doc/html/declval.html
+++ b/doc/html/declval.html
@@ -33,7 +33,7 @@
 <div><p class="copyright">Copyright &#169; 2008 Howard Hinnant</p></div>
 <div><p class="copyright">Copyright &#169; 2009 -2012 Vicente J. Botet Escriba</p></div>
 <div><div class="legalnotice">
-<a name="idp13449552"></a><p>
+<a name="idp13456288"></a><p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
@@ -49,7 +49,7 @@
 <dt><span class="section"><a href="declval.html#declval.history">History</a></span></dt>
 </dl>
 </div>
-<div class="section">
+<div class="section declval_overview">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="declval.overview"></a><a class="link" href="declval.html#declval.overview" title="Overview">Overview</a>
 </h2></div></div></div>
@@ -109,7 +109,7 @@
      is expected to be part of the daily tool-box of the C++0x programmer.
    </p>
 </div>
-<div class="section">
+<div class="section declval_reference">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="declval.reference"></a><a class="link" href="declval.html#declval.reference" title="Reference">Reference </a>
 </h2></div></div></div>
@@ -149,16 +149,16 @@
      if the type From can be explicitly converted to type To.
    </p>
 </div>
-<div class="section">
+<div class="section declval_history">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="declval.history"></a><a class="link" href="declval.html#declval.history" title="History">History</a>
 </h2></div></div></div>
 <a name="declval.history.boost_1_50"></a><h4>
-<a name="idp13553216"></a>
+<a name="idp13559952"></a>
      <a class="link" href="declval.html#declval.history.boost_1_50">boost 1.50</a>
    </h4>
 <p>
-      Fixes:
+      New Features:
    </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          <a href="http://svn.boost.org/trac/boost/ticket/6570" target="_top">#6570</a>
@@ -167,7 +167,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: May 28, 2012 at 18:59:06 GMT</small></p></td>
+<td align="left"><p><small>Last revised: March 25, 2012 at 18:26:23 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
--- a/include/boost/assert.hpp
+++ b/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,31 +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
+#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__))
--- a/include/boost/exception.hpp
+++ b/include/boost/exception.hpp
@@ -1,11 +0,0 @@
-//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
-
-//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)
-
-#ifndef UUID_1D94A7C6054E11DB9804B622A1EF5492
-#define UUID_1D94A7C6054E11DB9804B622A1EF5492
-
-#error The header <boost/exception.hpp> has been deprecated. Please #include <boost/exception/all.hpp> instead.
-
-#endif
--- a/include/boost/utility/base_from_member.hpp
+++ b/include/boost/utility/base_from_member.hpp
@@ -1,6 +1,6 @@
 //  boost utility/base_from_member.hpp header file  --------------------------//

-//  Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and
+//  Copyright 2001, 2003, 2004, 2012 Daryle Walker.  Use, modification, and
 //  distribution are subject to the Boost Software License, Version 1.0.  (See
 //  accompanying file LICENSE_1_0.txt or a copy at
 //  <http://www.boost.org/LICENSE_1_0.txt>.)
@@ -10,10 +10,15 @@
 #ifndef BOOST_UTILITY_BASE_FROM_MEMBER_HPP
 #define BOOST_UTILITY_BASE_FROM_MEMBER_HPP

+#include <boost/config.hpp>
 #include <boost/preprocessor/arithmetic/inc.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/utility/enable_if.hpp>


 //  Base-from-member arity configuration macro  ------------------------------//
@@ -53,6 +58,59 @@
 namespace boost
 {

+namespace detail
+{
+
+//  Type-unmarking class template  -------------------------------------------//
+
+// Type-trait to get the raw type, i.e. the type without top-level reference nor
+// cv-qualification, from a type expression.  Mainly for function arguments, any
+// reference part is stripped first.
+
+// Contributed by Daryle Walker
+
+template < typename T >
+struct remove_cv_ref
+{
+    typedef typename ::boost::remove_cv<typename
+     ::boost::remove_reference<T>::type>::type  type;
+
+};  // boost::detail::remove_cv_ref
+
+//  Unmarked-type comparison class template  ---------------------------------//
+
+// Type-trait to check if two type expressions have the same raw type.
+
+// Contributed by Daryle Walker, based on a work-around by Luc Danton
+
+template < typename T, typename U >
+struct is_related
+    : public ::boost::is_same<
+     typename ::boost::detail::remove_cv_ref<T>::type,
+     typename ::boost::detail::remove_cv_ref<U>::type >
+{};
+
+//  Enable-if-on-unidentical-unmarked-type class template  -------------------//
+
+// Enable-if on the first two type expressions NOT having the same raw type.
+
+// Contributed by Daryle Walker, based on a work-around by Luc Danton
+
+#ifndef BOOST_NO_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

--- a/include/boost/utility/declval.hpp
+++ b/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
--- a/include/boost/utility/detail/result_of_iterate.hpp
+++ b/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)>
--- a/include/boost/utility/empty_deleter.hpp
+++ b/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_
--- a/include/boost/utility/explicit_operator_bool.hpp
+++ b/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_
--- a/include/boost/utility/result_of.hpp
+++ b/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,8 +73,12 @@ 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
--- a/include/boost/utility/string_ref.hpp
+++ b/include/boost/utility/string_ref.hpp
@@ -17,11 +17,15 @@

 #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 {

@@ -36,18 +40,6 @@ namespace boost {
            };
        }

-    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,7 +53,7 @@ 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
@@ -119,7 +111,7 @@ namespace boost {

        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];
            }

@@ -144,18 +136,12 @@ namespace boost {


        // 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 {
@@ -260,173 +246,207 @@ namespace boost {
 //  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>
-    bool operator==(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+    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>
-    bool operator==(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+    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, const charT * 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>
-    bool operator==(const charT * x, basic_string_ref<charT, traits> y) {
+    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>
-    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 true;
        return x.compare(y) != 0;
        }

    template<typename charT, typename traits, typename Allocator>
-    bool operator!=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+    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>
-    bool operator!=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+    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, const charT * 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>
-    bool operator!=(const charT * x, basic_string_ref<charT, traits> y) {
+    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>
-    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) {
        return x.compare(y) < 0;
        }

    template<typename charT, typename traits, typename Allocator>
-    bool operator<(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+    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>
-    bool operator<(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+    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, const charT * 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>
-    bool operator<(const charT * x, basic_string_ref<charT, traits> y) {
+    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>
-    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) {
        return x.compare(y) > 0;
        }

    template<typename charT, typename traits, typename Allocator>
-    bool operator>(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+    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>
-    bool operator>(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+    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, const charT * 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>
-    bool operator>(const charT * x, basic_string_ref<charT, traits> y) {
+    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>
-    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) {
        return x.compare(y) <= 0;
        }

    template<typename charT, typename traits, typename Allocator>
-    bool operator<=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+    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>
-    bool operator<=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+    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, const charT * 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>
-    bool operator<=(const charT * x, basic_string_ref<charT, traits> y) {
+    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>
-    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) {
        return x.compare(y) >= 0;
        }

    template<typename charT, typename traits, typename Allocator>
-    bool operator>=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
+    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>
-    bool operator>=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
+    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, const charT * 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>
-    bool operator>=(const charT * x, basic_string_ref<charT, traits> y) {
+    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;
        }

@@ -436,67 +456,67 @@ namespace boost {
    //  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
--- a/include/boost/utility/string_ref_fwd.hpp
+++ b/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
--- a/index.html
+++ b/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>
-
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -38,6 +38,7 @@ test-suite utility
        [ run ../shared_iterator_test.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 ]
@@ -47,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 ]
    ;

--- a/test/explicit_operator_bool.cpp
+++ b/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;
+}
--- a/test/explicit_operator_bool_compile_fail_conv_int.cpp
+++ b/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;
+}
--- a/test/explicit_operator_bool_compile_fail_conv_pvoid.cpp
+++ b/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;
+}
--- a/test/explicit_operator_bool_compile_fail_delete.cpp
+++ b/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;
+}
--- a/test/explicit_operator_bool_compile_fail_shift.cpp
+++ b/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;
+}
--- a/test/result_of_test.cpp
+++ b/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;
 }
--- a/test/string_ref_test_io.cpp
+++ b/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());
+    }
+}
--- a/utility.htm
+++ b/utility.htm
@@ -259,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
--- a/value_init.htm
+++ b/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>

--- a/value_init_test.cpp
+++ b/value_init_test.cpp
@@ -22,7 +22,7 @@
 #pragma hdrstop
 #endif

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

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

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

  check_initialized_value(y);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


-unsigned int expected_failures = 0;
-
-
Author	SHA1	Message	Date
Vladimir Prus	dbb99bf7df	Create branch to keep WIP patch for modular build. [SVN r85883]	2013-09-25 08:12:19 +00:00
Andrey Semashev	0f5ae0e73c	Corrected comment. [SVN r85624]	2013-09-09 18:43:27 +00:00
Andrey Semashev	497198c624	Made indents similar. [SVN r85611]	2013-09-08 18:45:41 +00:00
Andrey Semashev	9df000eece	Extracted empty_deleter to Boost.Utility. [SVN r85577]	2013-09-05 18:25:41 +00:00
Andrey Semashev	8e4054467e	Attempt to work around explicit_operator_bool_compile_fail_conv_pvoid test failure for VACPP. [SVN r85570]	2013-09-05 08:28:24 +00:00
Andrey Semashev	7ae5e14681	Extracted BOOST_EXPLICIT_OPERATOR_BOOL macro from Boost.Log. [SVN r85543]	2013-09-01 16:31:16 +00:00
Robert Kawulak	eca8d9f1ef	[utility] Fixes to value_init docs. [SVN r85335]	2013-08-13 21:39:57 +00:00
Daniel Walker	15021632dc	added new result_of mode that uses TR1 with a decltype fallback as suggested by Nathan Crookston; fixes #7753 [SVN r84949]	2013-07-03 22:14:27 +00:00
Andrey Semashev	9baf33dd16	Optimized BOOST_ASSERT_MSG so that it is more lightweight and doesn't prevent enclosing functions from inlining. Also added branching hints for the checked conditions. [SVN r84682]	2013-06-07 20:21:24 +00:00
Andrey Semashev	6bb1ce9b7b	Avoid using ios_base and streamsize, which are not defined in iosfwd. [SVN r84636]	2013-06-04 18:41:39 +00:00
Andrey Semashev	9092b9277b	Added a test for long padding. [SVN r84613]	2013-06-02 20:00:04 +00:00
Andrey Semashev	d09b37d3ef	More modifications according to the review. [SVN r84611]	2013-06-02 19:16:50 +00:00
Andrey Semashev	f3bb2a493c	Modifications according to the review. [SVN r84609]	2013-06-02 18:15:53 +00:00
Andrey Semashev	71b501a0b0	Removed constexpr from substr() as it doesn't work with BOOST_THROW_EXCEPTION. Added a test for streaming. [SVN r84518]	2013-05-26 19:23:52 +00:00
Andrey Semashev	547c562464	Minor change (no need to create a sentry, it will be created by the stream methods). [SVN r84513]	2013-05-26 15:52:16 +00:00
Andrey Semashev	91aab126e1	1. Extracted forward declarations to a separate header so that it can be included by other libraries (Boost.Log, for instance). 2. Added a default value for char traits template parameter. 3. Added missing headers and removed unused ones. 4. Added inline specifiers to operators. 5. Fixed operator<< behaving incorrectly when particular width is requested (std::setw, etc.). 6. Replaced all throw statements with BOOST_THROW_EXCEPTION. [SVN r84511]	2013-05-26 15:36:25 +00:00
Vicente J. Botet Escriba	1057ff4d9e	Utility/noncopyable: Make use of =delete #6578 . [SVN r83833]	2013-04-10 17:16:02 +00:00
Marshall Clow	9cb31aee6e	Fix bug in test; thanks to AddressSanitizer for the heads-up [SVN r83493]	2013-03-18 20:46:53 +00:00
Vicente J. Botet Escriba	2e4007413e	Assert: rollback [82428]. [SVN r83431]	2013-03-14 22:27:04 +00:00
Vicente J. Botet Escriba	98bb9e6300	Utility: address_of take care of #7079 . [SVN r83429]	2013-03-14 17:48:06 +00:00
Vicente J. Botet Escriba	1cdb78c30a	Assert: take care of #7028 . [SVN r83428]	2013-03-14 17:46:52 +00:00
Eric Niebler	e0e16be802	fix breakage of string_ref logical ops, detabify, remove trailing whitespace [SVN r83147]	2013-02-25 06:30:00 +00:00
Eric Niebler	9284a64936	disable annoying msvc warning, refs #7663 [SVN r82960]	2013-02-17 23:56:10 +00:00
Marshall Clow	6e2c1b6b53	Added to_string and better comparisons to Boost.StringRef [SVN r82902]	2013-02-15 16:12:30 +00:00
Marshall Clow	e4d622019f	Fixed bug in string_ref::find; Refs #8067 [SVN r82901]	2013-02-15 16:07:06 +00:00
Marshall Clow	05af0deaed	Update Boost.StringRef tests to use newer Boost.Test features [SVN r82825]	2013-02-11 21:49:56 +00:00
Marshall Clow	00d151828c	Fixed typo; Refs #8002 [SVN r82771]	2013-02-07 14:14:53 +00:00
Marshall Clow	f0c62e9e00	Fix typo in docs; Refs #7974 [SVN r82729]	2013-02-04 14:14:42 +00:00
Marshall Clow	71205b6e84	Updated the string_ref docs with a reference section; committed the generated HTML [SVN r82489]	2013-01-14 16:25:56 +00:00
Marshall Clow	98d793152c	Move string_ref to Boost.Utility; first crack at docs [SVN r81972]	2012-12-15 16:38:07 +00:00
Marshall Clow	dc8ffe92b8	Removed use of deprecated macros [SVN r81801]	2012-12-08 18:37:29 +00:00
Marshall Clow	c55d5ca7de	Removed usage of deprecated macros in Boost.Utility; specifically result_of [SVN r81574]	2012-11-26 20:32:24 +00:00
Michel Morin	943af35553	Tweak comments (removing a non-ascii character, updating references to the C++11 standard, etc.) and rename the include guard macro. [SVN r81112]	2012-10-30 16:51:16 +00:00
Eric Niebler	3cca2755cf	add missing close tag [SVN r80834]	2012-10-03 23:08:44 +00:00
Eric Niebler	93f6e3473b	friendlier wrt overloaded comma [SVN r80732]	2012-09-28 08:47:35 +00:00
Eric Niebler	4a08e3d0bf	remove workaround for gcc-4.4, boost.config is correct now [SVN r80712]	2012-09-26 18:47:08 +00:00
Eric Niebler	3d650b7f92	nicer work-around for gcc warnings [SVN r80656]	2012-09-23 02:08:32 +00:00
Daniel Walker	0568a114a8	supress warnings in result_of_iterate.hpp on gcc 4 and up. [SVN r80655]	2012-09-23 01:44:39 +00:00
Eric Niebler	7148d6c95e	gcc-4.4 doesn't have robust enough support for sfinae-for-expressions [SVN r80654]	2012-09-23 01:11:00 +00:00
Eric Niebler	1cfe3145b4	sfinae-friendly result_of implementation for compilers that don't have extended sfinae for expressions [SVN r80636]	2012-09-22 19:15:37 +00:00
Eric Niebler	57d65d6a94	untab-ify [SVN r80608]	2012-09-20 17:06:34 +00:00
Daniel Walker	ac9f617f7f	SFINAE enabled result_of fixes [7343] [SVN r80605]	2012-09-19 23:10:08 +00:00
Daniel Walker	b6a55f878c	reverting [78195] in result_of_iterate.hpp to allow users to force result_of to use decltype [SVN r80550]	2012-09-17 00:04:55 +00:00
Daniel Walker	a4e332c4c0	updated docs to include guidelines, changes and various suggestions from Andrey Semashev, JeffLee Hellrung and others [SVN r80535]	2012-09-16 00:39:41 +00:00
Daniel Walker	e9bbb50eb4	reverting [80445] which is still under discussion on the mailing list [SVN r80452]	2012-09-08 15:32:35 +00:00
Andrey Semashev	e8440e8855	Added result_of usage guideline. [SVN r80445]	2012-09-08 13:54:41 +00:00
Daniel Walker	ff0cb36416	Fixes [6754]. Minor edits to documentation. [SVN r80352]	2012-09-01 20:00:33 +00:00
Emil Dotchevski	37c5395e7a	Ticket #7094 , thanks 1czajnik [SVN r79398]	2012-07-10 03:43:13 +00:00
Daniel James	3558d61c51	Make the new pdf install rules explicit, and fix intrusive's. [SVN r78877]	2012-06-11 01:33:10 +00:00
John Maddock	a201cbe646	Changes required to build PDF versions of docs. [SVN r78845]	2012-06-07 12:32:56 +00:00
Vicente J. Botet Escriba	8036d4370f	Utility/declval: update history. [SVN r78729]	2012-05-28 18:44:24 +00:00
Lorenzo Caminiti	5fe00c4322	Added identity_type.hpp to utility.hpp. Added static to Addable data members because they are references. Marked a couple of regression tests for release compilers. [SVN r78653]	2012-05-26 20:39:22 +00:00
Lorenzo Caminiti	eb613e1b16	Resolved all LocalFunctions to-dos. Still trying to pin-point a VACPP internal error. [SVN r78371]	2012-05-07 18:54:38 +00:00
John Maddock	923caf4410	Fix for GCC-4.3.x. [SVN r78268]	2012-04-30 14:07:24 +00:00
Lorenzo Caminiti	36bc0a72ac	Updated docs. [SVN r78234]	2012-04-28 02:35:08 +00:00
Eric Niebler	d5cacff7c6	only use decltype when Boost.Config says it's ok [SVN r78195]	2012-04-25 17:41:51 +00:00
Lorenzo Caminiti	b9411f807f	Added Lorenzo Caminiti to maintainers.txt and libraries.htm. [SVN r77945]	2012-04-13 01:02:02 +00:00
Eric Niebler	4111de6f68	result_of uses decltype on compilers that implement N3276 [SVN r77905]	2012-04-11 00:28:33 +00:00
Eric Niebler	df9315101e	whoops [SVN r77904]	2012-04-11 00:13:10 +00:00
Eric Niebler	2637dfcc59	result_of uses decltype on compilers that implement N3276 [SVN r77903]	2012-04-11 00:05:56 +00:00
Lorenzo Caminiti	a7e8d28621	Updated IdentityType docs. [SVN r77902]	2012-04-10 21:53:28 +00:00
Daniel Walker	acf8b66a4f	Applied patch from Michel Morin to fix #6755 . Updated copyright to recognize contributors from the past several years. [SVN r77702]	2012-04-01 20:38:36 +00:00
Vicente J. Botet Escriba	c11e08b6b7	Utility: Rollback unwanted commit while adding noexcept to boost::declval [SVN r77562]	2012-03-26 17:07:17 +00:00
Vicente J. Botet Escriba	2cfe775694	Utility: Fix for Adding noexcept to boost::declval [SVN r77552]	2012-03-25 23:17:39 +00:00
Vicente J. Botet Escriba	799b066e7d	Utility: Added doc for Adding noexcept to boost::declval [SVN r77543]	2012-03-25 18:28:24 +00:00
Vicente J. Botet Escriba	9fa5d63525	Utility: Apply patch for 6570: Adding noexcept to boost::declval [SVN r77539]	2012-03-25 15:58:40 +00:00
Lorenzo Caminiti	2a6cd0c9c4	Split Utility/IdentityType and Functional/OverloadedFunction tests into smaller tests. Updated docs for ScopeExit, LocalFunction, Utility/IdentityType, and Functional/OverloadedFunction. [SVN r77484]	2012-03-22 20:54:20 +00:00
Lorenzo Caminiti	5825b6c329	Fixed test indentation and updated docs. [SVN r77080]	2012-02-20 20:17:07 +00:00
Lorenzo Caminiti	54c78121c2	Updated ScopeExit "world" tests making person a struct instead of a class. Added a code comment to Utility/IdentityType tmp_assert test. [SVN r77071]	2012-02-18 19:29:35 +00:00
Lorenzo Caminiti	2891cb52d6	Added Boost.Utility/IdentityType and Boost.Functional/OverloadedFunction to status/Jamfile.v2 list of regression tests. Updated Boost.ScopeExit documentation. [SVN r77059]	2012-02-17 21:02:00 +00:00
Daryle Walker	0db9276e8c	Fixed (hopefully) conflict between boost::base_from_member's C++11 constructor template and the automatically defined non-template copy- and/or move-constructors. [SVN r77046]	2012-02-17 01:55:33 +00:00
Lorenzo Caminiti	d6cb9a9176	Fixed a bug in BOOST_LOCAL_FUNCTION_DETAIL_PP_VOID_LIST: a typo VOId -> VOID. Fixed a bug in scope_exit.hpp: An extra trailing \ in a macro definition (compiled only when BOOST_NO_VARIADIC_MACROS is defined). Renamed LocalFunction and ScopeExit tests and examples from _err to _error. Updated LocalFunction docs. [SVN r77042]	2012-02-16 18:24:34 +00:00