Create branches/filesystem-v3 for v2 removal

[SVN r77385]

doc/Jamfile.v2

@@ -43,7 +43,7 @@ using quickbook ;
 path-constant boost-images : ../../../doc/src/images ;
 
 xml declval : declval.qbk ;
-boostbook standalone_declval
+boostbook standalone
     :
         declval
     :
@@ -59,42 +59,10 @@ 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 ;
-boostbook standalone_string_ref
-    :
-        string_ref
-    :
-        # File name of HTML output:
-        <xsl:param>root.filename=string_ref
-        # 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
-     ;
 
-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/declval.qbk

@@ -1,6 +1,7 @@
 [/
  / Copyright (c) 2008 Howard Hinnant
- / Copyright (c) 2009-20012 Vicente J. Botet Escriba
+ / Copyright (c) 2008 Beman Dawes
+ / Copyright (c) 2009-20010 Vicente J. Botet Escriba
  /
  / Distributed under the Boost Software License, Version 1.0. (See accompanying
  / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -9,9 +10,11 @@
 [article Declval
     [quickbook 1.5]
     [authors [Hinnant, Howard]]
+    [authors [Dawes, Beman]]
     [authors [Botet Escriba, Vicente J.]]
     [copyright 2008 Howard Hinnant]
-    [copyright 2009-2012 Vicente J. Botet Escriba]
+    [copyright 2008 Beman Dawes]
+    [copyright 2009-2010 Vicente J. Botet Escriba]
     [license
         Distributed under the Boost Software License, Version 1.0.
         (See accompanying file LICENSE_1_0.txt or copy at
@@ -74,7 +77,7 @@ This extremely light-weight function is expected to be part of the daily tool-bo
     namespace boost {
 
         template <typename T>
-        typename add_rvalue_reference<T>::type declval() noexcept; // as unevaluated operand
+        typename add_rvalue_reference<T>::type declval(); //noexcept; // as unevaluated operand
 
     }  // namespace boost
 
@@ -97,19 +100,5 @@ Declares a function template convert which only participates in overloading if t
 
 [endsect]
 
-[/===============]
-[section History]
-[/===============]
-
-[heading boost 1.50]
-
-Fixes:
-
-* [@http://svn.boost.org/trac/boost/ticket/6570 #6570] Adding noexcept to boost::declval.
- 	
-
-[endsect]
-
-
 
 

doc/explicit_operator_bool.qbk

@@ -1,68 +0,0 @@
-[/
- / 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/declval.html

@@ -3,7 +3,7 @@
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Declval</title>
 <link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="declval.html" title="Declval">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -27,13 +27,17 @@
 <span class="firstname">Howard</span> <span class="surname">Hinnant</span>
 </h3></div>
 <div class="author"><h3 class="author">
+<span class="firstname">Beman</span> <span class="surname">Dawes</span>
+</h3></div>
+<div class="author"><h3 class="author">
 <span class="firstname">Vicente J.</span> <span class="surname">Botet Escriba</span>
 </h3></div>
 </div></div>
 <div><p class="copyright">Copyright &#169; 2008 Howard Hinnant</p></div>
-<div><p class="copyright">Copyright &#169; 2009 -2012 Vicente J. Botet Escriba</p></div>
+<div><p class="copyright">Copyright &#169; 2008 Beman Dawes</p></div>
+<div><p class="copyright">Copyright &#169; 2009, 2010 Vicente J. Botet Escriba</p></div>
 <div><div class="legalnotice">
-<a name="idp13456288"></a><p>
+<a name="id3354293"></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>
@@ -46,10 +50,9 @@
 <dl>
 <dt><span class="section"><a href="declval.html#declval.overview">Overview</a></span></dt>
 <dt><span class="section"><a href="declval.html#declval.reference">Reference </a></span></dt>
-<dt><span class="section"><a href="declval.html#declval.history">History</a></span></dt>
 </dl>
 </div>
-<div class="section declval_overview">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="declval.overview"></a><a class="link" href="declval.html#declval.overview" title="Overview">Overview</a>
 </h2></div></div></div>
@@ -109,7 +112,7 @@
       is expected to be part of the daily tool-box of the C++0x programmer.
     </p>
 </div>
-<div class="section declval_reference">
+<div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="declval.reference"></a><a class="link" href="declval.html#declval.reference" title="Reference">Reference </a>
 </h2></div></div></div>
@@ -119,7 +122,7 @@
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
 
     <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
-    <span class="keyword">typename</span> <span class="identifier">add_rvalue_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">declval</span><span class="special">()</span> <span class="identifier">noexcept</span><span class="special">;</span> <span class="comment">// as unevaluated operand
+    <span class="keyword">typename</span> <span class="identifier">add_rvalue_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">declval</span><span class="special">();</span> <span class="comment">//noexcept; // as unevaluated operand
 </span>
 <span class="special">}</span>  <span class="comment">// namespace boost
 </span></pre>
@@ -149,25 +152,9 @@
       if the type From can be explicitly converted to type To.
     </p>
 </div>
-<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="idp13559952"></a>
-      <a class="link" href="declval.html#declval.history.boost_1_50">boost 1.50</a>
-    </h4>
-<p>
-      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>
-          Adding noexcept to boost::declval.
-        </li></ul></div>
-</div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: March 25, 2012 at 18:26:23 GMT</small></p></td>
+<td align="left"><p><small>Last revised: April 06, 2011 at 20:06:10 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

doc/html/string_ref.html

@@ -1,280 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>String_Ref</title>
-<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="string_ref.html" title="String_Ref">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
-<td align="center"><a href="../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav"></div>
-<div class="article">
-<div class="titlepage">
-<div>
-<div><h2 class="title">
-<a name="string_ref"></a>String_Ref</h2></div>
-<div><div class="authorgroup"><div class="author"><h3 class="author">
-<span class="firstname">Marshall</span> <span class="surname">Clow</span>
-</h3></div></div></div>
-<div><p class="copyright">Copyright &#169; 2012 Marshall Clow</p></div>
-<div><div class="legalnotice">
-<a name="string_ref.legal"></a><p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></div>
-</div>
-<hr>
-</div>
-<div class="toc">
-<p><b>Table of Contents</b></p>
-<dl>
-<dt><span class="section"><a href="string_ref.html#string_ref.overview">Overview</a></span></dt>
-<dt><span class="section"><a href="string_ref.html#string_ref.examples">Examples</a></span></dt>
-<dt><span class="section"><a href="string_ref.html#string_ref.reference">Reference </a></span></dt>
-<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="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>
-<p>
-      Boost.StringRef is an implementation of Jeffrey Yaskin's <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html" target="_top">N3442:
-      string_ref: a non-owning reference to a string</a>.
-    </p>
-<p>
-      When you are parsing/processing strings from some external source, frequently
-      you want to pass a piece of text to a procedure for specialized processing.
-      The canonical way to do this is as a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>,
-      but that has certain drawbacks:
-    </p>
-<p>
-      1) If you are processing a buffer of text (say a HTTP response or the contents
-      of a file), then you have to create the string from the text you want to pass,
-      which involves memory allocation and copying of data.
-    </p>
-<p>
-      2) if a routine receives a constant <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>
-      and wants to pass a portion of that string to another routine, then it must
-      create a new string of that substring.
-    </p>
-<p>
-      3) A routine receives a constant <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>
-      and wants to return a portion of the string, then it must create a new string
-      to return.
-    </p>
-<p>
-      <code class="computeroutput"><span class="identifier">string_ref</span></code> is designed to solve
-      these efficiency problems. A <code class="computeroutput"><span class="identifier">string_ref</span></code>
-      is a read-only reference to a contiguous sequence of characters, and provides
-      much of the functionality of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>.
-      A <code class="computeroutput"><span class="identifier">string_ref</span></code> is cheap to create,
-      copy and pass by value, because it does not actually own the storage that it
-      points to.
-    </p>
-<p>
-      A <code class="computeroutput"><span class="identifier">string_ref</span></code> is implemented
-      as a small struct that contains a pointer to the start of the character data
-      and a count. A <code class="computeroutput"><span class="identifier">string_ref</span></code> is
-      cheap to create and cheap to copy.
-    </p>
-<p>
-      <code class="computeroutput"><span class="identifier">string_ref</span></code> acts as a container;
-      it includes all the methods that you would expect in a container, including
-      iteration support, <code class="computeroutput"><span class="keyword">operator</span> <span class="special">[]</span></code>,
-      <code class="computeroutput"><span class="identifier">at</span></code> and <code class="computeroutput"><span class="identifier">size</span></code>.
-      It can be used with any of the iterator-based algorithms in the STL - as long
-      as you don't need to change the underlying data (<code class="computeroutput"><span class="identifier">sort</span></code>
-      and <code class="computeroutput"><span class="identifier">remove</span></code>, for example, will
-      not work)
-    </p>
-<p>
-      Besides generic container functionality, <code class="computeroutput"><span class="identifier">string_ref</span></code>
-      provides a subset of the interface of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>.
-      This makes it easy to replace parameters of type <code class="computeroutput"><span class="keyword">const</span>
-      <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">&amp;</span></code>
-      with <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">string_ref</span></code>. Like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>,
-      <code class="computeroutput"><span class="identifier">string_ref</span></code> has a static member
-      variable named <code class="computeroutput"><span class="identifier">npos</span></code> to denote
-      the result of failed searches, and to mean "the end".
-    </p>
-<p>
-      Because a <code class="computeroutput"><span class="identifier">string_ref</span></code> does not
-      own the data that it "points to", it introduces lifetime issues into
-      code that uses it. The programmer must ensure that the data that a <code class="computeroutput"><span class="identifier">string_ref</span></code> refers to exists as long as the
-      <code class="computeroutput"><span class="identifier">string_ref</span></code> does.
-    </p>
-</div>
-<div class="section string_ref_examples">
-<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>
-<p>
-      Integrating <code class="computeroutput"><span class="identifier">string_ref</span></code> into
-      your code is fairly simple. Wherever you pass a <code class="computeroutput"><span class="keyword">const</span>
-      <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">&amp;</span></code>
-      or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code> as a parameter, that's a candidate
-      for passing a <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">string_ref</span></code>.
-    </p>
-<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">extract_part</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">&amp;</span><span class="identifier">bar</span> <span class="special">)</span> <span class="special">{</span>
-    <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>
-</pre>
-<p>
-      Let's figure out what happens in this (contrived) example.
-    </p>
-<p>
-      First, a temporary string is created from the string literal <code class="computeroutput"><span class="string">"ABCDEFG"</span></code>, and it is passed (by reference)
-      to the routine <code class="computeroutput"><span class="identifier">extract_part</span></code>.
-      Then a second string is created in the call <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">::</span><span class="identifier">substr</span></code>
-      and returned to <code class="computeroutput"><span class="identifier">extract_part</span></code>
-      (this copy may be elided by RVO). Then <code class="computeroutput"><span class="identifier">extract_part</span></code>
-      returns that string back to the caller (again this copy may be elided). The
-      first temporary string is deallocated, and <code class="computeroutput"><span class="identifier">front</span></code>
-      is called on the second string, and then it is deallocated as well.
-    </p>
-<p>
-      Two <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>s are created, and two copy operations.
-      That's (potentially) four memory allocations and deallocations, and the associated
-      copying of data.
-    </p>
-<p>
-      Now let's look at the same code with <code class="computeroutput"><span class="identifier">string_ref</span></code>:
-    </p>
-<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">string_ref</span> <span class="identifier">extract_part</span> <span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">string_ref</span> <span class="identifier">bar</span> <span class="special">)</span> <span class="special">{</span>
-    <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>
-</pre>
-<p>
-      No memory allocations. No copying of character data. No changes to the code
-      other than the types. There are two <code class="computeroutput"><span class="identifier">string_ref</span></code>s
-      created, and two <code class="computeroutput"><span class="identifier">string_ref</span></code>s
-      copied, but those are cheap operations.
-    </p>
-</div>
-<div class="section string_ref_reference">
-<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> .
-    </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>
-    </p>
-<p>
-      Construction and copying:
-    </p>
-<pre class="programlisting"><span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">basic_string_ref</span> <span class="special">();</span>    <span class="comment">// Constructs an empty string_ref</span>
-<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">basic_string_ref</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">str</span><span class="special">);</span> <span class="comment">// Constructs from a NULL-terminated string</span>
-<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">basic_string_ref</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">str</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">len</span><span class="special">);</span> <span class="comment">// Constructs from a pointer, length pair</span>
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
-<span class="identifier">basic_string_ref</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">str</span><span class="special">);</span> <span class="comment">// Constructs from a std::string</span>
-<span class="identifier">basic_string_ref</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">basic_string_ref</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">);</span>
-<span class="identifier">basic_string_ref</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">basic_string_ref</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">);</span>
-</pre>
-<p>
-      <code class="computeroutput"><span class="identifier">string_ref</span></code> does not define
-      a move constructor nor a move-assignment operator because copying a <code class="computeroutput"><span class="identifier">string_ref</span></code> is just a cheap as moving one.
-    </p>
-<p>
-      Basic container-like functions:
-    </p>
-<pre class="programlisting"><span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">()</span>     <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">length</span><span class="special">()</span>   <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">bool</span> <span class="identifier">empty</span><span class="special">()</span>         <span class="keyword">const</span> <span class="special">;</span>
-
-<span class="comment">// All iterators are const_iterators</span>
-<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">const_iterator</span>  <span class="identifier">begin</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">const_iterator</span> <span class="identifier">cbegin</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">const_iterator</span>    <span class="identifier">end</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">const_iterator</span>   <span class="identifier">cend</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">const_reverse_iterator</span>         <span class="identifier">rbegin</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">const_reverse_iterator</span>        <span class="identifier">crbegin</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">const_reverse_iterator</span>           <span class="identifier">rend</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">const_reverse_iterator</span>          <span class="identifier">crend</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span>
-</pre>
-<p>
-      Access to the individual elements (all of which are const):
-    </p>
-<pre class="programlisting"><span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">const</span> <span class="identifier">charT</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">[](</span><span class="identifier">size_type</span> <span class="identifier">pos</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="keyword">const</span> <span class="identifier">charT</span><span class="special">&amp;</span> <span class="identifier">at</span><span class="special">(</span><span class="identifier">size_t</span> <span class="identifier">pos</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">const</span> <span class="identifier">charT</span><span class="special">&amp;</span> <span class="identifier">front</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">const</span> <span class="identifier">charT</span><span class="special">&amp;</span> <span class="identifier">back</span><span class="special">()</span>  <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">data</span><span class="special">()</span>  <span class="keyword">const</span> <span class="special">;</span>
-</pre>
-<p>
-      Modifying the <code class="computeroutput"><span class="identifier">string_ref</span></code> (but
-      not the underlying data):
-    </p>
-<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">clear</span><span class="special">();</span>
-<span class="keyword">void</span> <span class="identifier">remove_prefix</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
-<span class="keyword">void</span> <span class="identifier">remove_suffix</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
-</pre>
-<p>
-      Searching:
-    </p>
-<pre class="programlisting"><span class="identifier">size_type</span> <span class="identifier">find</span><span class="special">(</span><span class="identifier">basic_string_ref</span> <span class="identifier">s</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">size_type</span> <span class="identifier">find</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">size_type</span> <span class="identifier">rfind</span><span class="special">(</span><span class="identifier">basic_string_ref</span> <span class="identifier">s</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">size_type</span> <span class="identifier">rfind</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">size_type</span> <span class="identifier">find_first_of</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">size_type</span> <span class="identifier">find_last_of</span> <span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-
-<span class="identifier">size_type</span> <span class="identifier">find_first_of</span><span class="special">(</span><span class="identifier">basic_string_ref</span> <span class="identifier">s</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">size_type</span> <span class="identifier">find_last_of</span><span class="special">(</span><span class="identifier">basic_string_ref</span> <span class="identifier">s</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">size_type</span> <span class="identifier">find_first_not_of</span><span class="special">(</span><span class="identifier">basic_string_ref</span> <span class="identifier">s</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">size_type</span> <span class="identifier">find_first_not_of</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">size_type</span> <span class="identifier">find_last_not_of</span><span class="special">(</span><span class="identifier">basic_string_ref</span> <span class="identifier">s</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="identifier">size_type</span> <span class="identifier">find_last_not_of</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-</pre>
-<p>
-      String-like operations:
-    </p>
-<pre class="programlisting"><span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">basic_string_ref</span> <span class="identifier">substr</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">pos</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">=</span><span class="identifier">npos</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span> <span class="comment">// Creates a new string_ref</span>
-<span class="keyword">bool</span> <span class="identifier">starts_with</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<span class="keyword">bool</span> <span class="identifier">starts_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>
-<span class="keyword">bool</span> <span class="identifier">ends_with</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
-<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="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>
-<h4>
-<a name="string_ref.history.h0"></a>
-      <span><a name="string_ref.history.boost_1_53"></a></span><a class="link" href="string_ref.html#string_ref.history.boost_1_53">boost
-      1.53</a>
-    </h4>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
-          Introduced
-        </li></ul></div>
-</div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: January 14, 2013 at 16:24:14 GMT</small></p></td>
-<td align="right"><div class="copyright-footer"></div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav"></div>
-</body>
-</html>

doc/string_ref.qbk

@@ -1,167 +0,0 @@
-[/
- / Copyright (c) 2012 Marshall Clow
- /
- / 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 String_Ref
-    [quickbook 1.5]
-    [authors [Clow, Marshall]]
-    [copyright 2012 Marshall Clow]
-    [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.StringRef is an implementation of Jeffrey Yaskin's [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html N3442:
-string_ref: a non-owning reference to a string]. 
-
-When you are parsing/processing strings from some external source, frequently you want to pass a piece of text to a procedure for specialized processing. The canonical way to do this is as a `std::string`, but that has certain drawbacks:
-
-1) If you are processing a buffer of text (say a HTTP response or the contents of a file), then you have to create the string from the text you want to pass, which involves memory allocation and copying of data.
-
-2) if a routine receives a constant `std::string` and wants to pass a portion of that string to another routine, then it must create a new string of that substring.
-
-3) A routine receives a constant `std::string` and wants to return a portion of the string, then it must create a new string to return.
-
-`string_ref` is designed to solve these efficiency problems. A `string_ref` is a read-only reference to a contiguous sequence of characters, and provides much of the functionality of `std::string`. A `string_ref` is cheap to create, copy and pass by value, because it does not actually own the storage that it points to. 
-
-A `string_ref` is implemented as a small struct that contains a pointer to the start of the character data and a count. A `string_ref` is cheap to create and cheap to copy.
-
-`string_ref` acts as a container; it includes all the methods that you would expect in a container, including iteration support, `operator []`, `at` and `size`. It can be used with any of the iterator-based algorithms in the STL - as long as you don't need to change the underlying data (`sort` and `remove`, for example, will not work)
-
-Besides generic container functionality, `string_ref` provides a subset of the interface of `std::string`. This makes it easy to replace parameters of type `const std::string &` with `boost::string_ref`. Like `std::string`, `string_ref` has a static member variable named `npos` to denote the result of failed searches, and to mean "the end".
-
-Because a `string_ref` does not own the data that it "points to", it introduces lifetime issues into code that uses it. The programmer must ensure that the data that a `string_ref` refers to exists as long as the `string_ref` does.
-
-[endsect]
-
-
-[/===============]
-[section Examples]
-[/===============]
-
-Integrating `string_ref` into your code is fairly simple. Wherever you pass a `const std::string &` or `std::string` as a parameter, that's a candidate for passing a `boost::string_ref`.
-
-    std::string extract_part ( const std::string &bar ) {
-        return bar.substr ( 2, 3 );
-        }
-        
-    if ( extract_part ( "ABCDEFG" ).front() == 'C' ) { /* do something */ }
-    
-Let's figure out what happens in this (contrived) example.
-
-First, a temporary string is created from the string literal `"ABCDEFG"`, and it is passed (by reference) to the routine `extract_part`. Then a second string is created in the call `std::string::substr` and returned to `extract_part` (this copy may be elided by RVO). Then `extract_part` returns that string back to the caller (again this copy may be elided). The first temporary string is deallocated, and `front` is called on the second string, and then it is deallocated as well.
-
-Two `std::string`s are created, and two copy operations. That's (potentially) four memory allocations and deallocations, and the associated copying of data.
-
-Now let's look at the same code with `string_ref`:
-
-    boost::string_ref extract_part ( boost::string_ref bar ) {
-        return bar.substr ( 2, 3 );
-        }
-        
-    if ( extract_part ( "ABCDEFG" ).front() == "C" ) { /* do something */ }
-
-No memory allocations. No copying of character data. No changes to the code other than the types. There are two `string_ref`s created, and two `string_ref`s copied, but those are cheap operations.
-
-[endsect]
-
-
-[/=================]
-[section:reference Reference ]
-[/=================]
-
-The header file "string_ref.hpp" defines a template `boost::basic_string_ref`, and four specializations - for `char` / `wchar_t` / `char16_t` / `char32_t` .
-
-`#include <boost/utility/string_ref.hpp>`
-
-Construction and copying:
-
-    BOOST_CONSTEXPR basic_string_ref ();    // Constructs an empty string_ref
-    BOOST_CONSTEXPR basic_string_ref(const charT* str); // Constructs from a NULL-terminated string
-    BOOST_CONSTEXPR basic_string_ref(const charT* str, size_type len); // Constructs from a pointer, length pair
-    template<typename Allocator>
-    basic_string_ref(const std::basic_string<charT, traits, Allocator>& str); // Constructs from a std::string
-    basic_string_ref (const basic_string_ref &rhs);
-    basic_string_ref& operator=(const basic_string_ref &rhs);
-
-`string_ref` does not define a move constructor nor a move-assignment operator because copying a `string_ref` is just a cheap as moving one.
-
-Basic container-like functions:
-
-    BOOST_CONSTEXPR size_type size()     const ;
-    BOOST_CONSTEXPR size_type length()   const ;
-    BOOST_CONSTEXPR size_type max_size() const ;
-    BOOST_CONSTEXPR bool empty()         const ;
-    
-    // All iterators are const_iterators
-    BOOST_CONSTEXPR const_iterator  begin() const ;
-    BOOST_CONSTEXPR const_iterator cbegin() const ;
-    BOOST_CONSTEXPR const_iterator    end() const ;
-    BOOST_CONSTEXPR const_iterator   cend() const ;
-    const_reverse_iterator         rbegin() const ;
-    const_reverse_iterator        crbegin() const ;
-    const_reverse_iterator           rend() const ;
-    const_reverse_iterator          crend() const ;
-
-Access to the individual elements (all of which are const):
-
-    BOOST_CONSTEXPR const charT& operator[](size_type pos) const ;
-    const charT& at(size_t pos) const ;
-    BOOST_CONSTEXPR const charT& front() const ;
-    BOOST_CONSTEXPR const charT& back()  const ;
-    BOOST_CONSTEXPR const charT* data()  const ;
-
-Modifying the `string_ref` (but not the underlying data):
-
-    void clear();
-    void remove_prefix(size_type n);
-    void remove_suffix(size_type n);
-
-Searching:
-
-    size_type find(basic_string_ref s) const ;
-    size_type find(charT c) const ;
-    size_type rfind(basic_string_ref s) const ;
-    size_type rfind(charT c) const ;
-    size_type find_first_of(charT c) const ;
-    size_type find_last_of (charT c) const ;
-        
-    size_type find_first_of(basic_string_ref s) const ;
-    size_type find_last_of(basic_string_ref s) const ;
-    size_type find_first_not_of(basic_string_ref s) const ;
-    size_type find_first_not_of(charT c) const ;
-    size_type find_last_not_of(basic_string_ref s) const ;
-    size_type find_last_not_of(charT c) const ;
-
-String-like operations:
-
-    BOOST_CONSTEXPR basic_string_ref substr(size_type pos, size_type n=npos) const ; // Creates a new string_ref
-    bool starts_with(charT c) const ;
-    bool starts_with(basic_string_ref x) const ;
-    bool ends_with(charT c) const ;
-    bool ends_with(basic_string_ref x) const ;
-
-[endsect]
-
-[/===============]
-[section History]
-[/===============]
-
-[heading boost 1.53]
-* Introduced
-    
-
-[endsect]
-
-
-
-

identity_type/doc/Jamfile.v2

@@ -15,7 +15,7 @@ doxygen reference : ../../../../boost/utility/identity_type.hpp
         <doxygen:param>WARN_IF_UNDOCUMENTED=NO
         <doxygen:param>HIDE_UNDOC_MEMBERS=YES
         <doxygen:param>HIDE_UNDOC_CLASSES=YES
-        <doxygen:param>ALIASES=" Params=\"<b>Parameters:</b> <table border="0">\" Param{2}=\"<tr><td><b><tt>\\1</tt></b></td><td>\\2</td></tr>\" EndParams=\"</table>\" Returns=\"<b>Returns:</b>\" Note=\"<b>Note:</b>\" Warning=\"<b>Warning:</b>\" See=\"<b>See:</b>\" RefSect{2}=\"\\xmlonly<link linkend='boost_utility_identitytype.\\1'>\\2</link>\\endxmlonly\" RefClass{1}=\"\\xmlonly<computeroutput><classname alt='\\1'>\\1</classname></computeroutput>\\endxmlonly\" RefFunc{1}=\"\\xmlonly<computeroutput><functionname alt='\\1'>\\1</functionname></computeroutput>\\endxmlonly\" RefMacro{1}=\"\\xmlonly<computeroutput><macroname alt='\\1'>\\1</macroname></computeroutput>\\endxmlonly\" "
+        <doxygen:param>ALIASES=" Params=\"<b>Parameters:</b> <table border="0">\" Param{2}=\"<tr><td><b><tt>\\1</tt></b></td><td>\\2</td></tr>\" EndParams=\"</table>\" Returns=\"<b>Returns:</b>\" Note=\"<b>Note:</b>\" Warning=\"<b>Warning:</b>\" See=\"<b>See:</b>\" RefSect{1}=\"\\xmlonly<link linkend='boost_utility_identitytype.\\1'>\\1</link>\\endxmlonly\" RefSectId{2}=\"\\xmlonly<link linkend='boost_utility_identitytype.\\1'>\\2</link>\\endxmlonly\" RefClass{1}=\"\\xmlonly<computeroutput><classname alt='\\1'>\\1</classname></computeroutput>\\endxmlonly\" RefFunc{1}=\"\\xmlonly<computeroutput><functionname alt='\\1'>\\1</functionname></computeroutput>\\endxmlonly\" RefMacro{1}=\"\\xmlonly<computeroutput><macroname alt='\\1'>\\1</macroname></computeroutput>\\endxmlonly\" "
     ;
 
 # This target must be called "index" so to generate "index.html" file.
@@ -29,16 +29,3 @@ boostbook doc : index
         <xsl:param>boost.root=../../../../..
     ;
 
-#
-# This is very imperfect - it results in both html and pdf docs being built,
-# for some reason I can't get the "onehtml" format specified above to play nice
-# with the usual incantations for mixed pdf/html builds. JM 06/2012.
-#
-boostbook pdf_doc : index
-    :
-       <format>pdf
-       <format>html:<build>no
-    ;
-
-install pdf_doc_install : pdf_doc : <location>. <name>identity_type.pdf <install-type>PDF ;
-explicit pdf_doc_install ;

identity_type/doc/html/index.html

@@ -4,8 +4,8 @@
         file LICENSE_1_0.txt or a copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p></div></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#boost_utility_identitytype.motivation">Motivation</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.solution">Solution</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.templates">Templates</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.abstract_types">Abstract Types</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.annex__usage">Annex: Usage</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.annex__implementation">Annex:
     Implementation</a></span></dt><dt><span class="section"><a href="#reference">Reference</a></span></dt></dl></div><p>
-    This library allows to wrap types within round parenthesis so they can always
+    This library allows to wrap type expressions within round parenthesis so they
-    be passed as macro parameters.
+    can be passed to macros even when they contain commas.
   </p><div class="section boost_utility_identitytype_motivation" title="Motivation"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.motivation"></a><a class="link" href="#boost_utility_identitytype.motivation" title="Motivation">Motivation</a></h2></div></div></div><p>
       Consider the following macro which declares a variable named <code class="computeroutput"><span class="identifier">var</span></code><code class="literal"><span class="emphasis"><em>n</em></span></code>
       with the specified <code class="literal"><span class="emphasis"><em>type</em></span></code> (see also
@@ -36,23 +36,21 @@
           <code class="computeroutput"><span class="number">2</span></code>
         </li></ol></div><p>
       Note that, differently from the compiler, the preprocessor only recognizes
-      round parenthesis <code class="computeroutput"><span class="special">()</span></code>. Angular
+      round parameters <code class="computeroutput"><span class="special">()</span></code>. Angular
-      <code class="computeroutput"><span class="special">&lt;&gt;</span></code> and squared <code class="computeroutput"><span class="special">[]</span></code> parenthesis are not recognized by the preprocessor
+      <code class="computeroutput"><span class="special">&lt;&gt;</span></code> or squared <code class="computeroutput"><span class="special">[]</span></code> parenthesis are not used by the preprocessor
-      when parsing macro parameters.
+      when parsing the macro parameters.
     </p></div><div class="section boost_utility_identitytype_solution" title="Solution"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.solution"></a><a class="link" href="#boost_utility_identitytype.solution" title="Solution">Solution</a></h2></div></div></div><p>
       In some cases, it might be possible to workaround this issue by avoiding to
-      pass the type expression to the macro all together. For example, in the case
+      pass the type expression to the macro all together. For example, in some cases
-      above a <code class="computeroutput"><span class="keyword">typedef</span></code> could have been
+      a <code class="computeroutput"><span class="keyword">typedef</span></code> can be used to specify
-      used to specify the type expression with the commas outside the macro (see
+      the type expression with the commas outside the macro (see also <a href="../../test/var.cpp" target="_top"><code class="literal">var.cpp</code></a>):
-      also <a href="../../test/var.cpp" target="_top"><code class="literal">var.cpp</code></a>):
     </p><p>
 </p><pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;</span> <span class="identifier">map_type</span><span class="special">;</span>
 <span class="identifier">VAR</span><span class="special">(</span><span class="identifier">map_type</span><span class="special">,</span> <span class="number">3</span><span class="special">);</span> <span class="comment">// OK.</span>
 </pre><p>
     </p><p>
-      When this is neither possible nor desired (e.g., see the function template
+      When this is not possible or desired (e.g., see the function template <code class="computeroutput"><span class="identifier">f</span></code> in the section below), the library header
-      <code class="computeroutput"><span class="identifier">f</span></code> in the section below), this
+      <code class="computeroutput"><a class="link" href="#header.boost.utility.identity_type_hpp" title="Header &lt;boost/utility/identity_type.hpp&gt;">boost/utility/identity_type.hpp</a></code>
-      library header <code class="computeroutput"><a class="link" href="#header.boost.utility.identity_type_hpp" title="Header &lt;boost/utility/identity_type.hpp&gt;">boost/utility/identity_type.hpp</a></code>
       defines a macro <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
       which can be used to workaround the issue while keeping the type expression
       as one of the macro parameters (see also <a href="../../test/var.cpp" target="_top"><code class="literal">var.cpp</code></a>).
@@ -62,21 +60,15 @@
 <span class="identifier">VAR</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;)),</span> <span class="number">4</span><span class="special">);</span> <span class="comment">// OK.</span>
 </pre><p>
     </p><p>
-      The <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code> macro
+      This macro expands to an expression that evaluates (at compile-time) to the
-      expands to an expression that evaluates (at compile-time) to the specified
+      specified type. The specified type is never split into multiple macro parameters
-      type. The specified type is never split into multiple macro parameters because
+      because it is always wrapped by a set of extra round parenthesis <code class="computeroutput"><span class="special">()</span></code>. In fact, a total of two sets of round parenthesis
-      it is always wrapped by a set of extra round parenthesis <code class="computeroutput"><span class="special">()</span></code>.
+      must be used: The parenthesis to invoke the macro <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">(...)</span></code> plus the inner parenthesis to wrap the
-      In fact, a total of two sets of round parenthesis must be used: The parenthesis
-      to invoke the macro <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">(...)</span></code> plus the inner parenthesis to wrap the
       type passed to the macro <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((...))</span></code>.
     </p><p>
       This macro works on any <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/standards" target="_top">C++03</a>
-      compiler (and it does not use <a href="http://en.wikipedia.org/wiki/Variadic_macro" target="_top">variadic
+      compiler (because it does not use <a href="http://en.wikipedia.org/wiki/Variadic_macro" target="_top">variadic
-      macros</a>). <sup>[<a name="boost_utility_identitytype.solution.f0" href="#ftn.boost_utility_identitytype.solution.f0" class="footnote">1</a>]</sup> The authors originally developed and tested this library using
+      macros</a>). <sup>[<a name="boost_utility_identitytype.solution.f0" href="#ftn.boost_utility_identitytype.solution.f0" class="footnote">1</a>]</sup>
-      GNU Compiler Collection (GCC) C++ 4.5.3 (with and without C++11 features enabled
-      <code class="computeroutput"><span class="special">-</span><span class="identifier">std</span><span class="special">=</span><span class="identifier">c</span><span class="special">++</span><span class="number">0</span><span class="identifier">x</span></code>) on Cygwin
-      and Miscrosoft Visual C++ (MSVC) 8.0 on Windows 7. See the library <a href="http://www.boost.org/development/tests/release/developer/utility-identity_type.html" target="_top">regressions
-      test results</a> for more information on supported compilers and platforms.
     </p></div><div class="section boost_utility_identitytype_templates" title="Templates"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.templates"></a><a class="link" href="#boost_utility_identitytype.templates" title="Templates">Templates</a></h2></div></div></div><p>
       This macro must be prefixed by <code class="computeroutput"><span class="keyword">typename</span></code>
       when used within templates. For example, let's program a macro that declares
@@ -102,12 +94,11 @@
 </pre><p>
     </p><p>
       However, note that the template parameter <code class="computeroutput"><span class="keyword">char</span></code>
-      must be manually specified when invoking the function as in <code class="computeroutput"><span class="identifier">f</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;(</span><span class="identifier">a</span><span class="special">)</span></code>. In fact,
+      must be manually specified when invoking the function <code class="computeroutput"><span class="identifier">f</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;(</span><span class="identifier">a</span><span class="special">)</span></code>. In fact,
       when the <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
       macro is used to wrap a function template parameter, the template parameter
       can no longer be automatically deduced by the compiler form the function call
-      as <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> would
+      as in <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>. <sup>[<a name="boost_utility_identitytype.templates.f0" href="#ftn.boost_utility_identitytype.templates.f0" class="footnote">2</a>]</sup> (This limitation does not apply to class templates because class
-      have done. <sup>[<a name="boost_utility_identitytype.templates.f0" href="#ftn.boost_utility_identitytype.templates.f0" class="footnote">2</a>]</sup> (This limitation does not apply to class templates because class
       template parameters must always be explicitly specified.) In other words, without
       using the <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
       macro, C++ would normally be able to automatically deduce the function template
@@ -127,14 +118,15 @@
     </p></div><div class="section boost_utility_identitytype_abstract_types" title="Abstract Types"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.abstract_types"></a><a class="link" href="#boost_utility_identitytype.abstract_types" title="Abstract Types">Abstract Types</a></h2></div></div></div><p>
       On some compilers (e.g., GCC), using this macro on abstract types (i.e., classes
       with one or more pure virtual functions) generates a compiler error. This can
-      be avoided by manipulating the type adding and removing a reference to it.
+      be worked around by manipulating the type adding and removing a reference to
+      it.
     </p><p>
       Let's program a macro that performs a static assertion on a <a href="http://en.wikipedia.org/wiki/Template_metaprogramming" target="_top">Template
       Meta-Programming</a> (TMP) meta-function (similarly to Boost.MPL <a href="http://www.boost.org/doc/libs/1_36_0/libs/mpl/doc/refmanual/assert.html" target="_top"><code class="computeroutput"><span class="identifier">BOOST_MPL_ASSERT</span></code></a>). The <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code> macro can be used
       to pass a meta-function with multiple template parameters to the assert macro
       (so to handle the commas separating the template parameters). In this case,
       if the meta-function is an abstract type, it needs to be manipulated adding
-      and removing a reference to it (see also <a href="../../test/abstract.cpp" target="_top"><code class="literal">abstract.cpp</code></a>):
+      and removing a reference to it (see also <a href="../../test/tmp_assert.cpp" target="_top"><code class="literal">tmp_assert.cpp</code></a>):
     </p><p>
 </p><pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">TMP_ASSERT</span><span class="special">(</span><span class="identifier">metafunction</span><span class="special">)</span> <span class="special">\</span>
     <span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">(</span><span class="identifier">metafunction</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span>
@@ -158,36 +150,31 @@
     </p></div><div class="section boost_utility_identitytype_annex__usage" title="Annex: Usage"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.annex__usage"></a><a class="link" href="#boost_utility_identitytype.annex__usage" title="Annex: Usage">Annex: Usage</a></h2></div></div></div><p>
       The <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code> macro
       can be used either when calling a user-defined macro (as shown by the examples
-      so far), or internally when implementing a user-defined macro (as shown below).
+      so far), or internally in the definition of a user-defined macro (as shown
-      When <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code> is
+      below). When <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
-      used in the implementation of the user-defined macro, the caller of the user
+      is used in the user macro definition, the call of the user macro will only
-      macro will have to specify the extra parenthesis (see also <a href="../../test/paren.cpp" target="_top"><code class="literal">paren.cpp</code></a>):
+      have to specify the extra parenthesis (see also <a href="../../test/tmp_assert.cpp" target="_top"><code class="literal">tmp_assert.cpp</code></a>):
     </p><p>
 </p><pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">TMP_ASSERT_PAREN</span><span class="special">(</span><span class="identifier">parenthesized_metafunction</span><span class="special">)</span> <span class="special">\</span>
     <span class="comment">/* use `BOOST_IDENTITY_TYPE` in macro definition instead of invocation */</span> <span class="special">\</span>
     <span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">(</span><span class="identifier">parenthesized_metafunction</span><span class="special">)::</span><span class="identifier">value</span><span class="special">)</span>
 
-<span class="preprocessor">#define</span> <span class="identifier">TMP_ASSERT</span><span class="special">(</span><span class="identifier">metafunction</span><span class="special">)</span> <span class="special">\</span>
-    <span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">(</span><span class="identifier">metafunction</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span>
-
 <span class="comment">// Specify only extra parenthesis `((...))`.</span>
 <span class="identifier">TMP_ASSERT_PAREN</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&gt;));</span>
-
 <span class="comment">// Specify both the extra parenthesis `((...))` and `BOOST_IDENTITY_TYPE` macro.</span>
 <span class="identifier">TMP_ASSERT</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&gt;)));</span>
 </pre><p>
     </p><p>
-      However, note that the caller will <span class="emphasis"><em>always</em></span> have to specify
+      However, note that the user will <span class="emphasis"><em>always</em></span> have to specify
       the extra parenthesis even when the macro parameters contain no comma:
     </p><p>
 </p><pre class="programlisting"><span class="identifier">TMP_ASSERT_PAREN</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;));</span> <span class="comment">// Always extra `((...))`.</span>
-
 <span class="identifier">TMP_ASSERT</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;);</span> <span class="comment">// No extra `((...))` and no macro.</span>
 </pre><p>
     </p><p>
       In some cases, using <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
-      in the implementation of the user-defined macro might provide the best syntax
+      within the user macro definition might provide the best syntax for the user.
-      for the caller. For example, this is the case for <code class="computeroutput"><span class="identifier">BOOST_MPL_ASSERT</span></code>
+      For example, this is the case for <code class="computeroutput"><span class="identifier">BOOST_MPL_ASSERT</span></code>
       because the majority of template meta-programming expressions contain unwrapped
       commas so it is less confusing for the user to always specify the extra parenthesis
       <code class="computeroutput"><span class="special">((...))</span></code> instead of using <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>:
@@ -210,9 +197,7 @@
       Instead requiring the user to specify <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
       only when needed allows for the more natural syntax <code class="computeroutput"><span class="identifier">BOOST_LOCAL_FUNCTION</span><span class="special">(</span><span class="keyword">int</span><span class="special">&amp;</span>
       <span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">)</span></code> in the common cases when the parameter types
-      contain no comma (while still allowing to specify parameter types with commas
+      contain no comma.
-      as special cases using <code class="computeroutput"><span class="identifier">BOOST_LOCAL_FUNCTION</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">&gt;))&amp;</span>
-      <span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">)</span></code>).
     </p></div><div class="section boost_utility_identitytype_annex__implementation" title="Annex: Implementation"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.annex__implementation"></a><a class="link" href="#boost_utility_identitytype.annex__implementation" title="Annex: Implementation">Annex:
     Implementation</a></h2></div></div></div><p>
       The implementation of this library macro is equivalent to the following: <sup>[<a name="boost_utility_identitytype.annex__implementation.f0" href="#ftn.boost_utility_identitytype.annex__implementation.f0" class="footnote">3</a>]</sup>
@@ -236,8 +221,8 @@
 
 <a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a>(parenthesized_type)</pre><div class="refentry" title="Macro BOOST_IDENTITY_TYPE"><a name="BOOST_IDENTITY_TYPE"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro BOOST_IDENTITY_TYPE</span></h2><p>BOOST_IDENTITY_TYPE — This macro allows to wrap the specified type expression within extra round parenthesis so the type can be passed as a single macro parameter even if it contains commas (not already wrapped within round parenthesis). </p></div><h2 class="refsynopsisdiv-title">Synopsis</h2><div class="refsynopsisdiv"><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.boost.utility.identity_type_hpp" title="Header &lt;boost/utility/identity_type.hpp&gt;">boost/utility/identity_type.hpp</a>&gt;
 
-</span>BOOST_IDENTITY_TYPE(parenthesized_type)</pre></div><div class="refsect1" title="Description"><a name="id554262"></a><h2>Description</h2><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table class="table"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">parenthesized_type</code></strong></span></td><td>The type expression to be passed as macro parameter wrapped by a single set of round parenthesis <code class="computeroutput">(...)</code>. This type expression can contain an arbitrary number of commas.  </td></tr></tbody></table></div><p>
+</span>BOOST_IDENTITY_TYPE(parenthesized_type)</pre></div><div class="refsect1" title="Description"><a name="id512092"></a><h2>Description</h2><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table class="table"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">parenthesized_type</code></strong></span></td><td>The type expression to be passed as macro parameter wrapped by a single set of round parenthesis <code class="computeroutput">(...)</code>. This type expression can contain an arbitrary number of commas.  </td></tr></tbody></table></div><p>
-</p><p>This macro works on any C++03 compiler (it does not use variadic macros).</p><p>This macro must be prefixed by <code class="computeroutput">typename</code> when used within templates. Note that the compiler will not be able to automatically determine function template parameters when they are wrapped with this macro (these parameters need to be explicitly specified when calling the function template).</p><p>On some compilers (like GCC), using this macro on abstract types requires to add and remove a reference to the specified type. </p></div></div></div></div><div class="footnotes"><br><hr width="100" align="left"><div class="footnote"><p><sup>[<a id="ftn.boost_utility_identitytype.solution.f0" href="#boost_utility_identitytype.solution.f0" class="para">1</a>] </sup>
+</p><p>This macro works on any C++03 compiler (it does not require variadic macros).</p><p>This macro must be prefixed by <code class="computeroutput">typename</code> when used within templates. However, the compiler will not be able to automatically determine function template parameters when they are wrapped with this macro (these parameters need to be explicitly specified when calling the function template).</p><p>On some compilers (like GCC), using this macro on an abstract types requires to add and remove a reference to the type. </p></div></div></div></div><div class="footnotes"><br><hr width="100" align="left"><div class="footnote"><p><sup>[<a id="ftn.boost_utility_identitytype.solution.f0" href="#boost_utility_identitytype.solution.f0" class="para">1</a>] </sup>
         Using variadic macros, it would be possible to require a single set of extra
         parenthesis <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>type</em></span></code><code class="computeroutput"><span class="special">)</span></code> instead of two <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span></code><code class="literal"><span class="emphasis"><em>type</em></span></code><code class="computeroutput"><span class="special">))</span></code> but variadic macros are not part of C++03
         (even if nowadays they are supported by most modern compilers and they are
@@ -247,6 +232,6 @@
         wraps the specified type within a meta-function.
       </p></div><div class="footnote"><p><sup>[<a id="ftn.boost_utility_identitytype.annex__implementation.f0" href="#boost_utility_identitytype.annex__implementation.f0" class="para">3</a>] </sup>
         There is absolutely no guarantee that the macro is actually implemented using
-        the code listed in this documentation. The listed code is for explanatory
+        the code listed in this documentation. This code is for explanatory purposes
-        purposes only.
+        only.
       </p></div></div></div></body></html>

identity_type/doc/identity_type.qbk

@@ -19,13 +19,12 @@
     [category Utilities]
 ]
 
-This library allows to wrap types within round parenthesis so they can always be passed as macro parameters.
+This library allows to wrap type expressions within round parenthesis so they can be passed to macros even when they contain commas.
 
 [import ../test/var_error.cpp]
 [import ../test/var.cpp]
 [import ../test/template.cpp]
-[import ../test/abstract.cpp]
+[import ../test/tmp_assert.cpp]
-[import ../test/paren.cpp]
 
 [section Motivation]
 
@@ -47,32 +46,30 @@ The preprocessor interprets that unwrapped comma as a separation between macro p
 # `char>`
 # `2`
 
-Note that, differently from the compiler, the preprocessor only recognizes round parenthesis `()`.
+Note that, differently from the compiler, the preprocessor only recognizes round parameters `()`.
-Angular `<>` and squared `[]` parenthesis are not recognized by the preprocessor when parsing macro parameters.
+Angular `<>` or squared `[]` parenthesis are not used by the preprocessor when parsing the macro parameters.
 
 [endsect]
 
 [section Solution]
 
 In some cases, it might be possible to workaround this issue by avoiding to pass the type expression to the macro all together.
-For example, in the case above a `typedef` could have been used to specify the type expression with the commas outside the macro (see also [@../../test/var.cpp =var.cpp=]):
+For example, in some cases a `typedef` can be used to specify the type expression with the commas outside the macro (see also [@../../test/var.cpp =var.cpp=]):
 
 [var_typedef]
 
-When this is neither possible nor desired (e.g., see the function template `f` in the section below), this library header [headerref boost/utility/identity_type.hpp] defines a macro [macroref BOOST_IDENTITY_TYPE] which can be used to workaround the issue while keeping the type expression as one of the macro parameters (see also [@../../test/var.cpp =var.cpp=]).
+When this is not possible or desired (e.g., see the function template `f` in the section below), the library header [headerref boost/utility/identity_type.hpp] defines a macro [macroref BOOST_IDENTITY_TYPE] which can be used to workaround the issue while keeping the type expression as one of the macro parameters (see also [@../../test/var.cpp =var.cpp=]).
 
 [var_ok]
 
-The [macroref BOOST_IDENTITY_TYPE] macro expands to an expression that evaluates (at compile-time) to the specified type.
+This macro expands to an expression that evaluates (at compile-time) to the specified type.
 The specified type is never split into multiple macro parameters because it is always wrapped by a set of extra round parenthesis `()`.
 In fact, a total of two sets of round parenthesis must be used: The parenthesis to invoke the macro `BOOST_IDENTITY_TYPE(...)` plus the inner parenthesis to wrap the type passed to the macro `BOOST_IDENTITY_TYPE((...))`.
 
-This macro works on any [@http://www.open-std.org/JTC1/SC22/WG21/docs/standards C++03] compiler (and it does not use [@http://en.wikipedia.org/wiki/Variadic_macro variadic macros]).
+This macro works on any [@http://www.open-std.org/JTC1/SC22/WG21/docs/standards C++03] compiler (because it does not use [@http://en.wikipedia.org/wiki/Variadic_macro variadic macros]).
 [footnote
 Using variadic macros, it would be possible to require a single set of extra parenthesis `BOOST_IDENTITY_TYPE(`[^['type]]`)` instead of two `BOOST_IDENTITY_TYPE((`[^['type]]`))` but variadic macros are not part of C++03 (even if nowadays they are supported by most modern compilers and they are also part of C++11).
 ]
-The authors originally developed and tested this library using GNU Compiler Collection (GCC) C++ 4.5.3 (with and without C++11 features enabled `-std=c++0x`) on Cygwin and Miscrosoft Visual C++ (MSVC) 8.0 on Windows 7.
-See the library [@http://www.boost.org/development/tests/release/developer/utility-identity_type.html regressions test results] for more information on supported compilers and platforms.
 
 [endsect]
 
@@ -84,8 +81,8 @@ For example, let's program a macro that declares a function parameter named `arg
 [template_f_decl]
 [template_f_call]
 
-However, note that the template parameter `char` must be manually specified when invoking the function as in `f<char>(a)`.
+However, note that the template parameter `char` must be manually specified when invoking the function `f<char>(a)`.
-In fact, when the [macroref BOOST_IDENTITY_TYPE] macro is used to wrap a function template parameter, the template parameter can no longer be automatically deduced by the compiler form the function call as `f(a)` would have done.
+In fact, when the [macroref BOOST_IDENTITY_TYPE] macro is used to wrap a function template parameter, the template parameter can no longer be automatically deduced by the compiler form the function call as in `f(a)`.
 [footnote
 This is because the implementation of [macroref BOOST_IDENTITY_TYPE] wraps the specified type within a meta-function.
 ]
@@ -100,28 +97,28 @@ In other words, without using the [macroref BOOST_IDENTITY_TYPE] macro, C++ woul
 [section Abstract Types]
 
 On some compilers (e.g., GCC), using this macro on abstract types (i.e., classes with one or more pure virtual functions) generates a compiler error.
-This can be avoided by manipulating the type adding and removing a reference to it.
+This can be worked around by manipulating the type adding and removing a reference to it.
 
 Let's program a macro that performs a static assertion on a [@http://en.wikipedia.org/wiki/Template_metaprogramming Template Meta-Programming] (TMP) meta-function (similarly to Boost.MPL [@http://www.boost.org/doc/libs/1_36_0/libs/mpl/doc/refmanual/assert.html `BOOST_MPL_ASSERT`]).
 The [macroref BOOST_IDENTITY_TYPE] macro can be used to pass a meta-function with multiple template parameters to the assert macro (so to handle the commas separating the template parameters).
-In this case, if the meta-function is an abstract type, it needs to be manipulated adding and removing a reference to it (see also [@../../test/abstract.cpp =abstract.cpp=]):
+In this case, if the meta-function is an abstract type, it needs to be manipulated adding and removing a reference to it (see also [@../../test/tmp_assert.cpp =tmp_assert.cpp=]):
 
-[abstract]
+[tmp_assert_abstract]
 
 [endsect]
 
 [section Annex: Usage]
 
-The [macroref BOOST_IDENTITY_TYPE] macro can be used either when calling a user-defined macro (as shown by the examples so far), or internally when implementing a user-defined macro (as shown below).
+The [macroref BOOST_IDENTITY_TYPE] macro can be used either when calling a user-defined macro (as shown by the examples so far), or internally in the definition of a user-defined macro (as shown below).
-When [macroref BOOST_IDENTITY_TYPE] is used in the implementation of the user-defined macro, the caller of the user macro will have to specify the extra parenthesis (see also [@../../test/paren.cpp =paren.cpp=]):
+When [macroref BOOST_IDENTITY_TYPE] is used in the user macro definition, the call of the user macro will only have to specify the extra parenthesis (see also [@../../test/tmp_assert.cpp =tmp_assert.cpp=]):
 
-[paren]
+[tmp_assert_alternative]
 
-However, note that the caller will /always/ have to specify the extra parenthesis even when the macro parameters contain no comma:
+However, note that the user will /always/ have to specify the extra parenthesis even when the macro parameters contain no comma:
 
-[paren_always]
+[tmp_assert_alternative_always]
 
-In some cases, using [macroref BOOST_IDENTITY_TYPE] in the implementation of the user-defined macro might provide the best syntax for the caller.
+In some cases, using [macroref BOOST_IDENTITY_TYPE] within the user macro definition might provide the best syntax for the user.
 For example, this is the case for `BOOST_MPL_ASSERT` because the majority of template meta-programming expressions contain unwrapped commas so it is less confusing for the user to always specify the extra parenthesis `((...))` instead of using [macroref BOOST_IDENTITY_TYPE]:
 
     BOOST_MPL_ASSERT(( // Natural syntax.
@@ -138,7 +135,7 @@ For example, this is the case for [@http://www.boost.org/libs/local_function `BO
         return x + y;
     } BOOST_LOCAL_FUNCTION_NAME(add)
 
-Instead requiring the user to specify [macroref BOOST_IDENTITY_TYPE] only when needed allows for the more natural syntax `BOOST_LOCAL_FUNCTION(int& x, int& y)` in the common cases when the parameter types contain no comma (while still allowing to specify parameter types with commas as special cases using `BOOST_LOCAL_FUNCTION(BOOST_IDENTITY_TYPE((std::map<int, char>))& x, int& y)`).
+Instead requiring the user to specify [macroref BOOST_IDENTITY_TYPE] only when needed allows for the more natural syntax `BOOST_LOCAL_FUNCTION(int& x, int& y)` in the common cases when the parameter types contain no comma.
 
 [endsect]
 
@@ -147,7 +144,7 @@ Instead requiring the user to specify [macroref BOOST_IDENTITY_TYPE] only when n
 The implementation of this library macro is equivalent to the following:
 [footnote
 There is absolutely no guarantee that the macro is actually implemented using the code listed in this documentation.
-The listed code is for explanatory purposes only.
+This code is for explanatory purposes only.
 ]
 
     #include <boost/type_traits/function_traits.hpp>

identity_type/test/Jamfile.v2

@@ -10,7 +10,5 @@ import testing ;
 compile-fail var_error.cpp ;
 run var.cpp ;
 run template.cpp ;
-run abstract.cpp ;
+run tmp_assert.cpp ;
-run noncopyable.cpp ;
-run paren.cpp ;
 

identity_type/test/abstract.cpp

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

identity_type/test/noncopyable.cpp

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

identity_type/test/tmp_assert.cpp

@@ -8,26 +8,44 @@
 #include <boost/utility/identity_type.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 #include <map>
 
-//[paren
+//[tmp_assert_abstract
+#define TMP_ASSERT(metafunction) \
+    BOOST_STATIC_ASSERT(metafunction::value)
+
+template<typename T, bool b>
+struct abstract {
+    static const bool value = b;
+    virtual void f(T const& x) = 0;     // Pure virtual function.
+};
+
+TMP_ASSERT(
+    boost::remove_reference<            // Add and remove
+        BOOST_IDENTITY_TYPE((           // reference for
+            boost::add_reference<       // abstract type.
+                abstract<int, true>
+            >::type
+        ))
+    >::type
+);
+//]
+
+//[tmp_assert_alternative
 #define TMP_ASSERT_PAREN(parenthesized_metafunction) \
     /* use `BOOST_IDENTITY_TYPE` in macro definition instead of invocation */ \
     BOOST_STATIC_ASSERT(BOOST_IDENTITY_TYPE(parenthesized_metafunction)::value)
 
-#define TMP_ASSERT(metafunction) \
-    BOOST_STATIC_ASSERT(metafunction::value)
-
 // Specify only extra parenthesis `((...))`.
 TMP_ASSERT_PAREN((boost::is_const<std::map<int, char> const>));
-
 // Specify both the extra parenthesis `((...))` and `BOOST_IDENTITY_TYPE` macro.
 TMP_ASSERT(BOOST_IDENTITY_TYPE((boost::is_const<std::map<int, char> const>)));
 //]
 
-//[paren_always
+//[tmp_assert_alternative_always
 TMP_ASSERT_PAREN((boost::is_const<int const>)); // Always extra `((...))`.
-
 TMP_ASSERT(boost::is_const<int const>); // No extra `((...))` and no macro.
 //]
 

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,7 +34,6 @@
 
 #elif defined(BOOST_ENABLE_ASSERT_HANDLER)
 
-#include <boost/config.hpp>
 #include <boost/current_function.hpp>
 
 namespace boost
@@ -43,7 +42,7 @@ namespace boost
                         char const * function, char const * file, long line); // user defined
 } // namespace boost
 
-#define BOOST_ASSERT(expr) (BOOST_LIKELY(!!(expr)) \
+#define BOOST_ASSERT(expr) ((expr) \
   ? ((void)0) \
   : ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
 
@@ -64,7 +63,6 @@ namespace boost
 
 #elif defined(BOOST_ENABLE_ASSERT_HANDLER)
 
-  #include <boost/config.hpp>
   #include <boost/current_function.hpp>
 
   namespace boost
@@ -73,7 +71,7 @@ namespace boost
                               char const * function, char const * file, long line); // user defined
   } // namespace boost
 
-  #define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr)) \
+  #define BOOST_ASSERT_MSG(expr, msg) ((expr) \
     ? ((void)0) \
     : ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
 
@@ -82,7 +80,6 @@ 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
@@ -97,28 +94,26 @@ namespace boost
       { 
         namespace detail
         {
-          // Note: The template is needed to make the function non-inline and avoid linking errors
+          inline void assertion_failed_msg(char const * expr, char const * msg, char const * function,
-          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
+			#ifdef UNDER_CE
 				// The Windows CE CRT library does not have abort() so use exit(-1) instead.
 				std::exit(-1);
-#else
+			#else
 				std::abort();
-#endif
+			#endif
           }
         } // detail
       } // assertion
     } // detail
   #endif
 
-  #define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr)) \
+  #define BOOST_ASSERT_MSG(expr, msg) ((expr) \
     ? ((void)0) \
     : ::boost::assertion::detail::assertion_failed_msg(#expr, msg, \
           BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))

include/boost/exception.hpp

@@ -0,0 +1,11 @@
+//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

include/boost/noncopyable.hpp

@@ -9,8 +9,6 @@
 #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
@@ -23,21 +21,11 @@ namespace noncopyable_  // protection from unintended ADL
   class noncopyable
   {
    protected:
-#ifndef BOOST_NO_DEFAULTED_FUNCTIONS
-    BOOST_CONSTEXPR noncopyable() = default;
-    ~noncopyable() = default;
-#else
       noncopyable() {}
       ~noncopyable() {}
-#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& );
-      noncopyable& operator=( const noncopyable& );
+      const noncopyable& operator=( const noncopyable& );
-#endif
   };
 }
 

include/boost/utility.hpp

@@ -13,7 +13,6 @@
 #include <boost/utility/base_from_member.hpp>
 #include <boost/utility/binary.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <boost/utility/identity_type.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/next_prior.hpp>
 #include <boost/noncopyable.hpp>

include/boost/utility/addressof.hpp

@@ -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 ) ) ) || defined( __SUNPRO_CC )
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) )
 
     return boost::detail::addressof_impl<T>::f( v, 0 );
 

include/boost/utility/base_from_member.hpp

@@ -96,7 +96,7 @@ struct is_related
 
 // Contributed by Daryle Walker, based on a work-around by Luc Danton
 
-#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#ifndef BOOST_NO_VARIADIC_TEMPLATES
 template<typename ...T>
 struct enable_if_unrelated
     : public ::boost::enable_if_c<true>
@@ -126,10 +126,9 @@ class base_from_member
 protected:
     MemberType  member;
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
+    !defined(BOOST_NO_VARIADIC_TEMPLATES) && \
-    !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && \
+    !defined(BOOST_NO_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 )

include/boost/utility/declval.hpp

@@ -1,12 +1,12 @@
-//  declval.hpp  -------------------------------------------------------------//
+//  common_type.hpp  ---------------------------------------------------------//
 
 //  Copyright 2010 Vicente J. Botet Escriba
 
 //  Distributed under the Boost Software License, Version 1.0.
 //  See http://www.boost.org/LICENSE_1_0.txt
 
-#ifndef BOOST_UTILITY_DECLVAL_HPP
+#ifndef BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP
-#define BOOST_UTILITY_DECLVAL_HPP
+#define BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP
 
 #include <boost/config.hpp>
 
@@ -17,28 +17,28 @@
 //----------------------------------------------------------------------------//
 //                                                                            //
 //                           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 {
 
     template <typename T>
-    typename add_rvalue_reference<T>::type declval() BOOST_NOEXCEPT; // as unevaluated operand
+    typename add_rvalue_reference<T>::type declval(); //noexcept; // as unevaluated operand
 
 }  // namespace boost
 
-#endif  // BOOST_UTILITY_DECLVAL_HPP
+#endif  // BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP

include/boost/utility/detail/result_of_iterate.hpp

@@ -5,11 +5,6 @@
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
-//  Copyright Daniel Walker, Eric Niebler, Michel Morin 2008-2012.
-//  Use, modification and distribution is subject to the Boost Software
-//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or
-//  copy at http://www.boost.org/LICENSE_1_0.txt)
-
 // For more information, see http://www.boost.org/libs/utility
 #if !defined(BOOST_PP_IS_ITERATING)
 # error Boost result_of - do not include this file!
@@ -23,7 +18,8 @@
 #endif
 
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of<F(BOOST_RESULT_OF_ARGS)>
     : mpl::if_<
           mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
@@ -37,28 +33,14 @@ struct tr1_result_of<F(BOOST_RESULT_OF_ARGS)>
             (boost::detail::has_result_type<F>::value)> >::type { };
 #endif
 
-#ifdef BOOST_RESULT_OF_USE_DECLTYPE
+#if !defined(BOOST_NO_DECLTYPE) && defined(BOOST_RESULT_OF_USE_DECLTYPE)
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename 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
+// 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)>
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
-struct result_of<F(BOOST_RESULT_OF_ARGS)>
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-    : mpl::if_<mpl::or_<detail::has_result_type<F>, detail::has_result<F> >,
+struct result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
-               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>
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
         , detail::tr1_result_of_impl<
             typename remove_cv<F>::type, 
             typename remove_cv<F>::type(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
@@ -69,98 +51,31 @@ struct cpp0x_result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
       >::type
 {};
 
-#ifdef BOOST_NO_SFINAE_EXPR
+namespace detail {
 
-template<typename F>
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
-struct BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION());
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-
+struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
-template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename T)>
-struct BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<R(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), T))> {
-    R operator()(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), T)) const;
-    typedef result_of_private_type const &(*pfn_t)(...);
-    operator pfn_t() const volatile;
-};
-
-template<typename F>
-struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION());
-
-template<typename F>
-struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<F *>
-  : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
-{};
-
-template<typename F>
-struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<F &>
-  : BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
-{};
-
-template<typename F>
-struct BOOST_PP_CAT(result_of_select_call_wrapper_type_, BOOST_PP_ITERATION())
-  : mpl::eval_if<
-        is_class<typename remove_reference<F>::type>,
-        result_of_wrap_callable_class<F>,
-        mpl::identity<BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<typename remove_cv<F>::type> >
-    >
-{};
-
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename T)>
-struct BOOST_PP_CAT(result_of_is_callable_, BOOST_PP_ITERATION()) {
-    typedef typename BOOST_PP_CAT(result_of_select_call_wrapper_type_, BOOST_PP_ITERATION())<F>::type wrapper_t;
-    static const bool value = (
-        sizeof(result_of_no_type) == sizeof(detail::result_of_is_private_type(
-            (boost::declval<wrapper_t>()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)), result_of_weird_type())
-        ))
-    );
-    typedef mpl::bool_<value> type;
-};
-
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), true>
-    : lazy_enable_if<
-          BOOST_PP_CAT(result_of_is_callable_, BOOST_PP_ITERATION())<F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), T)>
-        , cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false>
-      >
-{};
-
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false>
 {
   typedef decltype(
     boost::declval<F>()(
-      BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
+      BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), declval<T, >() BOOST_PP_INTERCEPT)
     )
   ) type;
 };
 
-#else // BOOST_NO_SFINAE_EXPR
-
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)),
-                            typename result_of_always_void<decltype(
-                                boost::declval<F>()(
-                                    BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
-                                )
-                            )>::type> {
-  typedef decltype(
-    boost::declval<F>()(
-      BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
-    )
-  ) type;
-};
-
-#endif // BOOST_NO_SFINAE_EXPR
-
 } // namespace detail 
 
-#else // defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
+#else // defined(BOOST_NO_DECLTYPE)
 
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct result_of<F(BOOST_RESULT_OF_ARGS)>
     : tr1_result_of<F(BOOST_RESULT_OF_ARGS)> { };
 #endif
 
-#endif // defined(BOOST_RESULT_OF_USE_DECLTYPE)
+#endif // defined(BOOST_NO_DECLTYPE)
 
 #undef BOOST_RESULT_OF_ARGS
 
@@ -168,20 +83,23 @@ struct result_of<F(BOOST_RESULT_OF_ARGS)>
 
 namespace detail {
 
-template<typename R,  typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
 {
   typedef R type;
 };
 
-template<typename R,  typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (&)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
 {
   typedef R type;
 };
 
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (T0::*)
                      (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T)),
                  FArgs, false>
@@ -189,7 +107,8 @@ struct tr1_result_of_impl<R (T0::*)
   typedef R type;
 };
 
-template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (T0::*)
                      (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                      const,
@@ -198,7 +117,8 @@ struct tr1_result_of_impl<R (T0::*)
   typedef R type;
 };
 
-template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (T0::*)
                      (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                      volatile,
@@ -207,7 +127,8 @@ struct tr1_result_of_impl<R (T0::*)
   typedef R type;
 };
 
-template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (T0::*)
                      (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                      const volatile,

include/boost/utility/empty_deleter.hpp

@@ -1,43 +0,0 @@
-/*
- *          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

@@ -1,128 +0,0 @@
-/*
- *          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/identity_type.hpp

@@ -28,15 +28,14 @@ This type expression can contain an arbitrary number of commas.
 }
 @EndParams
 
-This macro works on any C++03 compiler (it does not use variadic macros).
+This macro works on any C++03 compiler (it does not require variadic macros).
 
 This macro must be prefixed by <c>typename</c> when used within templates.
-Note that the compiler will not be able to automatically determine function
+However, the compiler will not be able to automatically determine function template parameters when they are wrapped with this macro (these parameters need to
-template parameters when they are wrapped with this macro (these parameters
+be explicitly specified when calling the function template).
-need to be explicitly specified when calling the function template).
 
-On some compilers (like GCC), using this macro on abstract types requires to
+On some compilers (like GCC), using this macro on an abstract types requires to
-add and remove a reference to the specified type.
+add and remove a reference to the type.
 */
 #define BOOST_IDENTITY_TYPE(parenthesized_type) \
     /* must NOT prefix this with `::` to work with parenthesized syntax */ \

include/boost/utility/result_of.hpp

@@ -10,59 +10,26 @@
 #define BOOST_RESULT_OF_HPP
 
 #include <boost/config.hpp>
-#include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/iteration/iterate.hpp> 
+#include <boost/preprocessor/punctuation/comma_if.hpp> 
 #include <boost/preprocessor/repetition/enum_params.hpp> 
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp> 
 #include <boost/preprocessor/repetition/enum_shifted_params.hpp> 
 #include <boost/preprocessor/facilities/intercept.hpp> 
 #include <boost/detail/workaround.hpp>
 #include <boost/mpl/has_xxx.hpp>
 #include <boost/mpl/if.hpp>
-#include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/bool.hpp>
-#include <boost/mpl/identity.hpp>
 #include <boost/mpl/or.hpp>
-#include <boost/type_traits/is_class.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/type_traits/is_member_function_pointer.hpp>
 #include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_reference.hpp>
 #include <boost/utility/declval.hpp>
-#include <boost/utility/enable_if.hpp>
 
 #ifndef BOOST_RESULT_OF_NUM_ARGS
 #  define BOOST_RESULT_OF_NUM_ARGS 16
 #endif
 
-// Use the decltype-based version of result_of by default if the compiler
-// supports N3276 <http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf>.
-// The user can force the choice by defining 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_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
-
 namespace boost {
 
 template<typename F> struct result_of;
@@ -73,79 +40,8 @@ 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_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 {
-  friend result_of_private_type operator,(result_of_private_type, result_of_weird_type);
-};
-
-typedef char result_of_yes_type;      // sizeof(result_of_yes_type) == 1
-typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type)  == 2
-
-template<typename T>
-result_of_no_type result_of_is_private_type(T const &);
-result_of_yes_type result_of_is_private_type(result_of_private_type);
-
-template<typename C>
-struct result_of_callable_class : C {
-    result_of_callable_class();
-    typedef result_of_private_type const &(*pfn_t)(...);
-    operator pfn_t() const volatile;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class {
-  typedef result_of_callable_class<C> type;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class<C const> {
-  typedef result_of_callable_class<C> const type;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class<C volatile> {
-  typedef result_of_callable_class<C> volatile type;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class<C const volatile> {
-  typedef result_of_callable_class<C> const volatile type;
-};
-
-template<typename C>
-struct result_of_wrap_callable_class<C &> {
-  typedef typename result_of_wrap_callable_class<C>::type &type;
-};
-
-template<typename F, bool TestCallability = true> struct cpp0x_result_of_impl;
-
-#else // BOOST_NO_SFINAE_EXPR
-
-template<typename T>
-struct result_of_always_void
-{
-  typedef void type;
-};
-
-template<typename F, typename Enable = void> struct cpp0x_result_of_impl {};
-
-#endif // BOOST_NO_SFINAE_EXPR
 
 template<typename F>
 struct result_of_void_impl

include/boost/utility/string_ref.hpp

@@ -1,536 +0,0 @@
-/*
-   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_HPP
-#define BOOST_STRING_REF_HPP
-
-#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 <iterator>
-#include <string>
-#include <iosfwd>
-
-namespace boost {
-
-    namespace detail {
-    //  A helper functor because sometimes we don't have lambdas
-        template <typename charT, typename traits>
-        class string_ref_traits_eq {
-        public:
-            string_ref_traits_eq ( charT ch ) : ch_(ch) {}
-            bool operator () ( charT val ) const { return traits::eq ( ch_, val ); }
-            charT ch_;
-            };
-        }
-
-    template<typename charT, typename traits>
-    class basic_string_ref {
-    public:
-        // types
-        typedef charT value_type;
-        typedef const charT* pointer;
-        typedef const charT& reference;
-        typedef const charT& const_reference;
-        typedef pointer const_iterator; // impl-defined
-        typedef const_iterator iterator;
-        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-        typedef const_reverse_iterator reverse_iterator;
-        typedef std::size_t size_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) {}
-
-        BOOST_CONSTEXPR basic_string_ref (const basic_string_ref &rhs)
-            : ptr_(rhs.ptr_), len_(rhs.len_) {}
-
-        basic_string_ref& operator=(const basic_string_ref &rhs) {
-            ptr_ = rhs.ptr_;
-            len_ = rhs.len_;
-            return *this;
-            }
-
-        basic_string_ref(const charT* str)
-            : ptr_(str), len_(traits::length(str)) {}
-
-        template<typename Allocator>
-        basic_string_ref(const std::basic_string<charT, traits, Allocator>& str)
-            : ptr_(str.data()), len_(str.length()) {}
-
-        BOOST_CONSTEXPR basic_string_ref(const charT* str, size_type len)
-            : ptr_(str), len_(len) {}
-
-#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-        template<typename Allocator>
-        explicit operator std::basic_string<charT, traits, Allocator>() const {
-            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_; }
-        BOOST_CONSTEXPR const_iterator     end() const { return ptr_ + len_; }
-        BOOST_CONSTEXPR const_iterator    cend() const { return ptr_ + len_; }
-                const_reverse_iterator  rbegin() const { return const_reverse_iterator (end()); }
-                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_ )
-                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) {
-            if ( n > len_ )
-                n = len_;
-            ptr_ += n;
-            len_ -= n;
-            }
-
-        void remove_suffix(size_type n) {
-            if ( n > len_ )
-                n = len_;
-            len_ -= n;
-            }
-
-
-        // basic_string_ref string operations
-        basic_string_ref substr(size_type pos, size_type n=npos) const {
-            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 );
-            }
-
-        int compare(basic_string_ref x) const {
-            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 (),
-                                                s.cbegin (), s.cend (), traits::eq );
-            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 (),
-                                    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 (),
-                                                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 (),
-                                    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 );
-            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
-                ( 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 );
-            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 );
-            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 ))
-                    return reverse_distance ( this->crbegin (), iter );
-            return npos;
-            }
-
-    private:
-        template <typename r_iter>
-        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;
-            }
-
-
-
-        const charT *ptr_;
-        std::size_t len_;
-        };
-
-
-//  Comparison operators
-//  Equality
-    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 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>
-    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>
-    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>
-    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>
-    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>
-    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>
-    inline std::basic_ostream<charT, traits>&
-    operator<<(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
-        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.
-    //
-    inline int stoi (string_ref str, size_t* idx=0, int base=10) {
-        return std::stoi ( std::string(str), idx, base );
-        }
-
-    inline long stol (string_ref str, size_t* idx=0, int base=10) {
-        return std::stol ( std::string(str), idx, base );
-        }
-
-    inline unsigned long stoul (string_ref str, size_t* idx=0, int base=10) {
-        return std::stoul ( std::string(str), idx, base );
-        }
-
-    inline long long stoll (string_ref str, size_t* idx=0, int base=10) {
-        return std::stoll ( std::string(str), idx, base );
-        }
-
-    inline unsigned long long stoull (string_ref str, size_t* idx=0, int base=10) {
-        return std::stoull ( std::string(str), idx, base );
-        }
-
-    inline float stof (string_ref str, size_t* idx=0) {
-        return std::stof ( std::string(str), idx );
-        }
-
-    inline double stod (string_ref str, size_t* idx=0) {
-        return std::stod ( std::string(str), idx );
-        }
-
-    inline long double stold (string_ref str, size_t* idx=0)  {
-        return std::stold ( std::string(str), idx );
-        }
-
-    inline int  stoi (wstring_ref str, size_t* idx=0, int base=10) {
-        return std::stoi ( std::wstring(str), idx, base );
-        }
-
-    inline long stol (wstring_ref str, size_t* idx=0, int base=10) {
-        return std::stol ( std::wstring(str), idx, base );
-        }
-
-    inline unsigned long stoul (wstring_ref str, size_t* idx=0, int base=10) {
-        return std::stoul ( std::wstring(str), idx, base );
-        }
-
-    inline long long stoll (wstring_ref str, size_t* idx=0, int base=10) {
-        return std::stoll ( std::wstring(str), idx, base );
-        }
-
-    inline unsigned long long stoull (wstring_ref str, size_t* idx=0, int base=10) {
-        return std::stoull ( std::wstring(str), idx, base );
-        }
-
-    inline float  stof (wstring_ref str, size_t* idx=0) {
-        return std::stof ( std::wstring(str), idx );
-        }
-
-    inline double stod (wstring_ref str, size_t* idx=0) {
-        return std::stod ( std::wstring(str), idx );
-        }
-
-    inline long double stold (wstring_ref str, size_t* idx=0) {
-        return std::stold ( std::wstring(str), idx );
-        }
-#endif
-
-}
-
-#if 0
-namespace std {
-    // Hashing
-    template<> struct hash<boost::string_ref>;
-    template<> struct hash<boost::u16string_ref>;
-    template<> struct hash<boost::u32string_ref>;
-    template<> struct hash<boost::wstring_ref>;
-}
-#endif
-
-#endif

include/boost/utility/string_ref_fwd.hpp

@@ -1,37 +0,0 @@
-/*
-   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

@@ -34,9 +34,7 @@
 				<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>

test/Jamfile.v2

@@ -8,11 +8,6 @@
 # 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
     :
@@ -36,9 +31,6 @@ 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 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 ]
@@ -48,10 +40,5 @@ 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

@@ -1,54 +0,0 @@
-/*
- *          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

@@ -1,40 +0,0 @@
-/*
- *          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

@@ -1,40 +0,0 @@
-/*
- *          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

@@ -1,40 +0,0 @@
-/*
- *          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

@@ -1,40 +0,0 @@
-/*
- *          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,13 +5,7 @@
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
-// Examples:
+#define BOOST_RESULT_OF_USE_DECLTYPE
-//   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
 #include <boost/utility/result_of.hpp>
@@ -68,9 +62,6 @@ struct int_result_type_and_float_result_of_and_char_return_template
   char operator()(char);
 };
 
-template<typename T>
-struct cv_overload_check {};
-
 struct result_of_member_function_template
 {
   template<typename F> struct result;
@@ -78,13 +69,13 @@ struct result_of_member_function_template
   template<typename This, typename That> struct result<This(That)> { typedef That type; };
   template<class T> typename result<result_of_member_function_template(T)>::type operator()(T);
 
-  template<typename This, typename That> struct result<const This(That)> { typedef cv_overload_check<const That> type; };
+  template<typename This, typename That> struct result<const This(That)> { typedef const That type; };
   template<class T> typename result<const result_of_member_function_template(T)>::type operator()(T) const;
 
-  template<typename This, typename That> struct result<volatile This(That)> { typedef cv_overload_check<volatile That> type; };
+  template<typename This, typename That> struct result<volatile This(That)> { typedef volatile That type; };
   template<class T> typename result<volatile result_of_member_function_template(T)>::type operator()(T) volatile;
 
-  template<typename This, typename That> struct result<const volatile This(That)> { typedef cv_overload_check<const volatile That> type; };
+  template<typename This, typename That> struct result<const volatile This(That)> { typedef const volatile That type; };
   template<class T> typename result<const volatile result_of_member_function_template(T)>::type operator()(T) const volatile;
 
   template<typename This, typename That> struct result<This(That &, That)> { typedef That & type; };
@@ -100,17 +91,14 @@ struct result_of_member_function_template
   template<class T> typename result<result_of_member_function_template(T const volatile &, T)>::type operator()(T const volatile &, T);
 };
 
-struct no_result_type_or_result
+struct no_result_type_or_result_of
 {
-  short operator()(double);
+  int operator()(double);
-  cv_overload_check<const short> operator()(double) const;
+  short operator()(double) const;
-  cv_overload_check<volatile short> operator()(double) volatile;
+  unsigned int operator()();
-  cv_overload_check<const volatile short> operator()(double) const volatile;
+  unsigned short operator()() volatile;
-  int operator()();
+  const unsigned short operator()() const volatile;
-  cv_overload_check<const int> operator()() const;
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
-  cv_overload_check<volatile int> operator()() volatile;
-  cv_overload_check<const volatile int> operator()() const volatile;
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
   short operator()(int&&);
   int operator()(int&);
   long operator()(int const&);
@@ -118,44 +106,20 @@ struct no_result_type_or_result
 };
 
 template<typename T>
-struct no_result_type_or_result_template
+struct no_result_type_or_result_of_template
 {
-  short operator()(double);
+  int operator()(double);
-  cv_overload_check<const short> operator()(double) const;
+  short operator()(double) const;
-  cv_overload_check<volatile short> operator()(double) volatile;
+  unsigned int operator()();
-  cv_overload_check<const volatile short> operator()(double) const volatile;
+  unsigned short operator()() volatile;
-  int operator()();
+  const unsigned short operator()() const volatile;
-  cv_overload_check<const int> operator()() const;
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
-  cv_overload_check<volatile int> operator()() volatile;
-  cv_overload_check<const volatile int> operator()() const volatile;
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
   short operator()(int&&);
   int operator()(int&);
   long operator()(int const&);
 #endif
 };
 
-// sfinae_tests are derived from example code from Joel de Guzman,
-// which demonstrated the interaction between result_of and SFINAE.
-template <typename F, typename Arg>
-typename boost::result_of<F(Arg const&)>::type
-sfinae_test(F f, Arg const& arg)
-{
-    return f(arg);
-}
-
-template <typename F, typename Arg>
-typename boost::result_of<F(Arg&)>::type
-sfinae_test(F f, Arg& arg)
-{
-    return f(arg);
-}
-
-int sfinae_test_f(int& i)
-{
-    return i;
-}
-
 struct X {};
 
 int main()
@@ -166,10 +130,6 @@ int main()
   typedef int (&func_ref)(float, double);
   typedef int (*func_ptr_0)();
   typedef int (&func_ref_0)();
-  typedef void (*func_ptr_void)(float, double);
-  typedef void (&func_ref_void)(float, double);
-  typedef void (*func_ptr_void_0)();
-  typedef void (&func_ref_void_0)();
   typedef int (X::*mem_func_ptr)(float);
   typedef int (X::*mem_func_ptr_c)(float) const;
   typedef int (X::*mem_func_ptr_v)(float) volatile;
@@ -196,8 +156,8 @@ 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
-  // of nullary function objects unless they exposed a result_type.
+  // nullary function objects unless they exposed a result_type.
-#if defined(BOOST_RESULT_OF_USE_DECLTYPE)
+#if !defined(BOOST_NO_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));
   BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(void)>::type, int>::value));
@@ -209,11 +169,14 @@ int main()
   BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of_template<void>(void)>::type, void>::value));
 #endif
 
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, int>::value));
+
   // Prior to decltype, result_of ignored a nested result<> if
   // result_type was defined. After decltype, result_of deduces the
   // actual return type of the function object, ignoring both
   // result<> and result_type.
-#if defined(BOOST_RESULT_OF_USE_DECLTYPE)
+#if !defined(BOOST_NO_DECLTYPE)
   BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, char>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, char>::value));
 #else
@@ -221,52 +184,41 @@ int main()
   BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, int>::value));
 #endif
 
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, int>::value));
-
   BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(char, float)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<func_ref(char, float)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<func_ptr_0()>::type, int>::value)); 
   BOOST_STATIC_ASSERT((is_same<result_of<func_ref_0()>::type, int>::value)); 
-  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr_void(char, float)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<func_ref_void(char, float)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr_void_0()>::type, void>::value)); 
-  BOOST_STATIC_ASSERT((is_same<result_of<func_ref_void_0()>::type, void>::value)); 
   BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr(X,char)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_c(X,char)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_v(X,char)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_cv(X,char)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_0(X)>::type, int>::value)); 
+  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(void)>::type, int>::value));
 
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr(char, float)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref(char, float)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr_0()>::type, int>::value)); 
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref_0()>::type, int>::value)); 
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr_void(char, float)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref_void(char, float)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr_void_0()>::type, void>::value)); 
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref_void_0()>::type, void>::value)); 
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr(X,char)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_c(X,char)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_v(X,char)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_cv(X,char)>::type, int>::value));
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_0(X)>::type, int>::value)); 
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr(void)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref(void)>::type, int>::value));
 
   BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(double)>::type, double>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const result_of_member_function_template(double)>::type, cv_overload_check<const double> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const result_of_member_function_template(double)>::type, const double>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<volatile result_of_member_function_template(double)>::type, cv_overload_check<volatile double> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile result_of_member_function_template(double)>::type, volatile double>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const volatile result_of_member_function_template(double)>::type, cv_overload_check<const volatile double> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const volatile result_of_member_function_template(double)>::type, const volatile double>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int &, int)>::type, int &>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int const &, int)>::type, int const &>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int volatile &, int)>::type, int volatile &>::value));
   BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int const volatile &, int)>::type, int const volatile &>::value));
 
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(double)>::type, double>::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<const result_of_member_function_template(double)>::type, cv_overload_check<const double> >::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<const result_of_member_function_template(double)>::type, const double>::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<volatile result_of_member_function_template(double)>::type, cv_overload_check<volatile double> >::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<volatile result_of_member_function_template(double)>::type, volatile double>::value));
-  BOOST_STATIC_ASSERT((is_same<tr1_result_of<const volatile result_of_member_function_template(double)>::type, cv_overload_check<const volatile double> >::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<const volatile result_of_member_function_template(double)>::type, const volatile double>::value));
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int &, int)>::type, int &>::value));
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int const &, int)>::type, int const &>::value));
   BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int volatile &, int)>::type, int volatile &>::value));
@@ -279,38 +231,26 @@ 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) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
+#if !defined(BOOST_NO_DECLTYPE)
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(double)>::type, short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(double)>::type, int>::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<no_result_type_or_result_of(void)>::type, unsigned int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result(double)>::type, cv_overload_check<volatile short> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_of(double)>::type, short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result(double)>::type, cv_overload_check<const volatile short> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_of(void)>::type, unsigned short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(void)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_of(void)>::type, const unsigned short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result(void)>::type, cv_overload_check<const int> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(double)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result(void)>::type, cv_overload_check<volatile int> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(void)>::type, unsigned int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result(void)>::type, cv_overload_check<const volatile int> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_of_template<void>(double)>::type, short>::value));
-
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_of_template<void>(void)>::type, unsigned short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(double)>::type, short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_of_template<void>(void)>::type, const unsigned short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_template<void>(double)>::type, cv_overload_check<const short> >::value));
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
-  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_template<void>(double)>::type, cv_overload_check<volatile short> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(int&&)>::type, short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_template<void>(double)>::type, cv_overload_check<const volatile short> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(int&)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(void)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(int const&)>::type, long>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_template<void>(void)>::type, cv_overload_check<const int> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(int&&)>::type, short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_template<void>(void)>::type, cv_overload_check<volatile int> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(int&)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_template<void>(void)>::type, cv_overload_check<const volatile int> >::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(int const&)>::type, long>::value));
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(int&&)>::type, short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(int&)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(int const&)>::type, long>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(int&&)>::type, short>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(int&)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(int const&)>::type, long>::value));
 #endif
 #endif
 
-#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) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
-
   return 0;
 }

test/string_ref_test1.cpp

@@ -1,109 +0,0 @@
-/*
-   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
-*/
-
-#include <iostream>
-#include <algorithm>
-#include <string>
-
-#include <boost/utility/string_ref.hpp>
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-
-typedef boost::string_ref string_ref;
-
-//  Should be equal
-void interop ( const std::string &str, string_ref ref ) {
-//  BOOST_CHECK ( str == ref );
-    BOOST_CHECK ( str.size () == ref.size ());
-    BOOST_CHECK ( std::equal ( str.begin (),  str.end (),  ref.begin ()));
-    BOOST_CHECK ( std::equal ( str.rbegin (), str.rend (), ref.rbegin ()));
-    }
-
-void null_tests ( const char *p ) {
-//  All zero-length string-refs should be equal
-    string_ref sr1; // NULL, 0
-    string_ref sr2 ( NULL, 0 );
-    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 );
-    }
-
-//  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 ));
-    }
-
-//  make sure that removing prefixes and suffixes work just like strings
-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;
-      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;
-      while ( ref.size () >= i ) {
-          interop ( work, ref );
-          work.erase ( work.size () - i, i );
-          ref.remove_suffix (i);
-          }
-      }
-    }
-
-const char *test_strings [] = {
-    "",
-    "1",
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
-    "0123456789",
-    NULL
-    };
-
-BOOST_AUTO_TEST_CASE( test_main )
-{
-    const char **p = &test_strings[0];
-
-    while ( *p != NULL ) {
-        interop ( *p, *p );
-        test_substr ( *p );
-        test_remove ( *p );
-        null_tests ( *p );
-
-        p++;
-        }
-}

test/string_ref_test2.cpp

@@ -1,318 +0,0 @@
-/*
-   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
-*/
-
-#include <iostream>
-#include <cstring>    // for std::strchr
-
-#include <boost/utility/string_ref.hpp>
-
-#define BOOST_TEST_MAIN
-#include <boost/test/unit_test.hpp>
-
-typedef boost::string_ref string_ref;
-
-void ends_with ( const char *arg ) {
-    const size_t sz = strlen ( arg );
-    string_ref sr ( arg );
-    string_ref sr2 ( arg );
-    const char *p = arg;
-
-    while ( *p ) {
-        BOOST_CHECK ( sr.ends_with ( p ));
-        ++p;
-        }
-
-    while ( !sr2.empty ()) {
-        BOOST_CHECK ( sr.ends_with ( sr2 ));
-        sr2.remove_prefix (1);
-        }
-
-    sr2 = arg;
-    while ( !sr2.empty ()) {
-        BOOST_CHECK ( sr.ends_with ( sr2 ));
-        sr2.remove_prefix (1);
-        }
-
-    char ch = sz == 0 ? '\0' : arg [ sz - 1 ];
-    sr2 = arg;
-    if ( sz > 0 )
-      BOOST_CHECK ( sr2.ends_with ( ch ));
-    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 );
-    string_ref sr2 ( arg );
-    const char *p = arg + std::strlen ( arg ) - 1;
-    while ( p >= arg ) {
-        std::string foo ( arg, p + 1 );
-        BOOST_CHECK ( sr.starts_with ( foo ));
-        --p;
-        }
-
-    while ( !sr2.empty ()) {
-        BOOST_CHECK ( sr.starts_with ( sr2 ));
-        sr2.remove_suffix (1);
-        }
-
-    char ch = *arg;
-    sr2 = arg;
-  if ( sz > 0 )
-    BOOST_CHECK ( sr2.starts_with ( ch ));
-    BOOST_CHECK ( !sr2.starts_with ( ++ch ));
-    BOOST_CHECK ( sr2.starts_with ( string_ref ()));
-    }
-
-void reverse ( const char *arg ) {
-//  Round trip
-    string_ref sr1 ( arg );
-    std::string string1 ( sr1.rbegin (), sr1.rend ());
-    string_ref sr2 ( string1 );
-    std::string string2 ( sr2.rbegin (), sr2.rend ());
-
-    BOOST_CHECK ( std::equal ( sr2.rbegin (), sr2.rend (), arg ));
-    BOOST_CHECK ( string2 == arg );
-    BOOST_CHECK ( std::equal ( sr1.begin (), sr1.end (), string2.begin ()));
-    }
-
-//	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 );
-    }
-
-void find ( const char *arg ) {
-    string_ref sr1;
-    string_ref sr2;
-    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;
-      }
-
-//  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;
-      }
-
-//	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;
-//  for all possible chars, see if we find them in the right place.
-//  Note that strchr will/might do the _wrong_ thing if we search for NULL
-    for ( int ch = 1; ch < 256; ++ch ) {
-        string_ref::size_type pos = sr1.find(ch);
-        const char *strp = std::strchr ( arg, ch );
-        BOOST_CHECK (( strp == NULL ) == ( pos == string_ref::npos ));
-        if ( strp != NULL )
-            BOOST_CHECK ( ptr_diff ( strp, arg ) == pos );
-    }
-
-    sr1 = arg;
-    p = arg;
-//  for all possible chars, see if we find them in the right place.
-//  Note that strchr will/might do the _wrong_ thing if we search for NULL
-    for ( int ch = 1; ch < 256; ++ch ) {
-        string_ref::size_type pos = sr1.rfind(ch);
-        const char *strp = std::strrchr ( arg, ch );
-        BOOST_CHECK (( strp == NULL ) == ( pos == string_ref::npos ));
-        if ( strp != NULL )
-            BOOST_CHECK ( ptr_diff ( strp, arg ) == pos );
-    }
-
-
-//  Find everything at the start
-    p = arg;
-    sr1 = arg;
-    while ( !sr1.empty ()) {
-        string_ref::size_type pos = sr1.find(*p);
-        BOOST_CHECK ( pos == 0 );
-        sr1.remove_prefix (1);
-        ++p;
-        }
-
-//  Find everything at the end
-    sr1  = arg;
-    p    = arg + strlen ( arg ) - 1;
-    while ( !sr1.empty ()) {
-        string_ref::size_type pos = sr1.rfind(*p);
-        BOOST_CHECK ( pos == sr1.size () - 1 );
-        sr1.remove_suffix (1);
-        --p;
-        }
-
-//  Find everything at the start
-    sr1  = arg;
-    p    = arg;
-    while ( !sr1.empty ()) {
-        string_ref::size_type pos = sr1.find_first_of(*p);
-        BOOST_CHECK ( pos == 0 );
-        sr1.remove_prefix (1);
-        ++p;
-        }
-
-
-//  Find everything at the end
-    sr1  = arg;
-    p    = arg + strlen ( arg ) - 1;
-    while ( !sr1.empty ()) {
-        string_ref::size_type pos = sr1.find_last_of(*p);
-        BOOST_CHECK ( pos == sr1.size () - 1 );
-        sr1.remove_suffix (1);
-        --p;
-        }
-
-//  Basic sanity checking for "find_first_of / find_first_not_of"
-    sr1 = arg;
-    sr2 = arg;
-    while ( !sr1.empty() ) {
-        BOOST_CHECK ( sr1.find_first_of ( sr2 )     == 0 );
-        BOOST_CHECK ( sr1.find_first_not_of ( sr2 ) == string_ref::npos );
-        sr1.remove_prefix ( 1 );
-        }
-
-    p = arg;
-    sr1 = arg;
-    while ( *p ) {
-        string_ref::size_type pos1 = sr1.find_first_of(*p);
-        string_ref::size_type pos2 = sr1.find_first_not_of(*p);
-        BOOST_CHECK ( pos1 != string_ref::npos && pos1 < sr1.size () && pos1 <= ptr_diff ( p, arg ));
-        if ( pos2 != string_ref::npos ) {
-            for ( size_t i = 0 ; i < pos2; ++i )
-                BOOST_CHECK ( sr1[i] == *p );
-            BOOST_CHECK ( sr1 [ pos2 ] != *p );
-            }
-
-        BOOST_CHECK ( pos2 != pos1 );
-        ++p;
-        }
-
-//  Basic sanity checking for "find_last_of / find_last_not_of"
-    sr1 = arg;
-    sr2 = arg;
-    while ( !sr1.empty() ) {
-        BOOST_CHECK ( sr1.find_last_of ( sr2 )     == ( sr1.size () - 1 ));
-        BOOST_CHECK ( sr1.find_last_not_of ( sr2 ) == string_ref::npos );
-        sr1.remove_suffix ( 1 );
-        }
-
-    p = arg;
-    sr1 = arg;
-    while ( *p ) {
-        string_ref::size_type pos1 = sr1.find_last_of(*p);
-        string_ref::size_type pos2 = sr1.find_last_not_of(*p);
-        BOOST_CHECK ( pos1 != string_ref::npos && pos1 < sr1.size () && pos1 >= ptr_diff ( p, arg ));
-        BOOST_CHECK ( pos2 == string_ref::npos || pos1 < sr1.size ());
-        if ( pos2 != string_ref::npos ) {
-            for ( size_t i = sr1.size () -1 ; i > pos2; --i )
-                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",
-    "abc",
-    "AAA",  // all the same
-    "adsfadadiaef;alkdg;aljt;j agl;sjrl;tjs;lga;lretj;srg[w349u5209dsfadfasdfasdfadsf",
-    "abc\0asdfadsfasf",
-    NULL
-    };
-
-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++;
-        }
-}

test/string_ref_test_io.cpp

@@ -1,183 +0,0 @@
-/*
- *             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,9 +84,7 @@ 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; A new alternative  
+			and copy assignment, and then document why this is done.&nbsp; But deriving 
-        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 
@@ -108,9 +106,7 @@ 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;&nbsp; With C++2011, using an  
+			thus have non-trivial destruction semantics.&quot;</p>
-        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>
@@ -147,7 +143,7 @@ void f() {
                 <h2><a name="result_of">Class template
                 result_of</a></h2> <p>The class template
                 <code>result_of</code> helps determine the type of a
-                call expression. For example, given an lvalue <code>f</code> of
+                call expression. Given an lvalue <code>f</code> of
                 type <code>F</code> and lvalues <code>t1</code>,
                 <code>t2</code>, ..., <code>t<em>N</em></code> of
                 types <code>T1</code>, <code>T2</code>, ...,
@@ -165,18 +161,16 @@ void f() {
                 resides in the header <code>&lt;<a
                 href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>&gt;</code>.</p>
 
-                <p>If your compiler's support for <code>decltype</code> is
+                <p>If your compiler supports <code>decltype</code>,
-                adequate, <code>result_of</code> automatically uses it to
+                then you can enable automatic result type deduction by
-                deduce the type of the call expression, in which case
+                defining the macro <code>BOOST_RESULT_OF_USE_DECLTYPE</code>,
-                <code>result_of&lt;F(T1, T2, ...,
+                as in the following example.</p>
-                T<em>N</em>)&gt;::type</code> names the type
-                <code>decltype(boost::declval&lt;F&gt;()(boost::declval&lt;T1&gt;(),
-                boost::declval&lt;T2&gt;(), ...,
-                boost::declval&lt;T<em>N</em>&gt;()))</code>, as in the
-                following example.</p>
 
                 <blockquote>
-                <pre>struct functor {
+                <pre>#define BOOST_RESULT_OF_USE_DECLTYPE
+#include &lt;boost/utility/result_of.hpp&gt;
+
+struct functor {
     template&lt;class T&gt;
     T operator()(T x)
     {
@@ -186,29 +180,21 @@ void f() {
 
 typedef boost::result_of&lt;
     functor(int)
-&gt;::type type; // type is int</pre>
+&gt;::type type;</pre>
                 </blockquote>
 
-                <p>You can test whether <code>result_of</code> is using
+                <p>If <code>decltype</code> is not enabled,
-                <code>decltype</code> by checking if the macro
-                <code>BOOST_RESULT_OF_USE_DECLTYPE</code> is defined after
-                including <code>result_of.hpp</code>. You can also force
-                <code>result_of</code> to use <code>decltype</code> by
-                defining <code>BOOST_RESULT_OF_USE_DECLTYPE</code> prior
-                to including <code>result_of.hpp</code>.</p>
-
-                <p>If <code>decltype</code> is not used,
                 then automatic result type deduction of function
                 objects is not possible. Instead, <code>result_of</code>
                 uses the following protocol to allow the programmer to
                 specify a type. When <code>F</code> is a class type with a
                 member type <code>result_type</code>,
                 <code>result_of&lt;F(T1, T2, ...,
-                T<em>N</em>)&gt;::type</code> is
+                T<em>N</em>)&gt;</code> is
                 <code>F::result_type</code>. When <code>F</code> does
                 not contain <code>result_type</code>,
                 <code>result_of&lt;F(T1, T2, ...,
-                T<em>N</em>)&gt;::type</code> is <code>F::result&lt;F(T1,
+                T<em>N</em>)&gt;</code> is <code>F::result&lt;F(T1,
                 T2, ..., T<em>N</em>)&gt;::type</code> when
                 <code><em>N</em> &gt; 0</code> or <code>void</code>
                 when <code><em>N</em> = 0</code>. Note that it is the
@@ -235,69 +221,22 @@ typedef boost::result_of&lt;
 
 typedef boost::result_of&lt;
     functor(int)
-&gt;::type type; // type is int</pre>
+&gt;::type type;</pre>
                 </blockquote>
 
-                <p>Since <code>decltype</code> is a new language
+                <p>In a future
-                feature recently standardized in C++11,
+                release, <code>BOOST_RESULT_OF_USE_DECLTYPE</code>
-                if you are writing a function object
+                may be enabled by default on compilers that
-                to be used with <code>result_of</code>, for
+                support <code>decltype</code>, so if you use the above
-                maximum portability, you might consider following
+                protocol please take care to ensure that
-                the above protocol even if your compiler has
+                the <code>result_type</code>
-                proper <code>decltype</code> support. If you wish to continue to
+                and <code>result&lt;&gt;</code> members accurately
+                represent the result type. If you wish to continue to
                 use the protocol on compilers that
-                support <code>decltype</code>, there are two options:
+                support <code>decltype</code>,
-                You can use <code>boost::tr1_result_of</code>, which is also
+                use <code>boost::tr1_result_of</code>, which is also
-                defined in <code>&lt;<a href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>&gt;</code>.
+                defined
-                Alternatively, you can define the macro
+                in <code>&lt;<a href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>&gt;</code>.</p>
-                <code>BOOST_RESULT_OF_USE_TR1</code>, which causes
-                <code>result_of</code> to use the protocol described
-                above instead of <code>decltype</code>. If you choose to
-                follow the protocol, take care to ensure that the
-                <code>result_type</code> and
-                <code>result&lt;&gt;</code> members accurately
-                represent the return type of
-                <code>operator()</code> 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>
@@ -314,322 +253,7 @@ typedef boost::result_of&lt;
                 <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf">N1836</a>,
                 or, for motivation and design rationale,
                 the <code>result_of</code> <a href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1454.html">proposal</a>.</p>
-
+                Contributed by Doug Gregor.</p>
-                <a name="result_of_guidelines">
-                <h3>Usage guidelines for boost::result_of</h3>
-                </a>
-
-                <p>The following are general suggestions about when
-                and how to use <code>boost::result_of</code>.</p>
-
-                <ol>
-                <li> If you are targeting C++11 and are not concerned
-                about portability to non-compliant compilers or
-                previous versions of the standard, then use
-                <code>std::result_of</code>. If <code>std::result_of</code>
-                meets your needs, then there's no reason to stop using
-                it.</li>
-
-                <li> If you are targeting C++11 but may port your code
-                to legacy compilers at some time in the future, then
-                use <code>boost::result_of</code> with
-                <code>decltype</code>. When <code>decltype</code> is
-                used <code>boost::result_of</code>
-                and <code>std::result_of</code> are usually
-                interchangeable. See the documentation on
-                known <a href="#result_of_cxx11_diff">differences</a>
-                between boost::result_of and C++11 result_of.</li>
-
-                <li> If compiler portability is required,
-                use <code>boost::result_of</code> with the TR1 protocol.</li>
-                </ol>
-
-                <p>Regardless of how you
-                configure <code>boost::result_of</code>, it is
-                important to bear in mind that the return type of a
-                function may change depending on its arguments, and
-                additionally, the return type of a member function may
-                change depending on the cv-qualification of the
-                object. <code>boost::result_of</code> must be passed
-                the appropriately cv-qualified types in order to
-                deduce the corresponding return type. For example:
-
-                <blockquote>
-                <pre>struct functor {
-    int& operator()(int);
-    int const& operator()(int) const;
-
-    float& operator()(float&);
-    float const& operator()(float const&);
-};
-
-typedef boost::result_of&lt;
-    functor(int)
-&gt;::type type1; // type1 is int &
-
-typedef boost::result_of&lt;
-    const functor(int)
-&gt;::type type2; // type2 is int const &
-
-typedef boost::result_of&lt;
-    functor(float&)
-&gt;::type type3; // type3 is float &
-
-typedef boost::result_of&lt;
-    functor(float const&)
-&gt;::type type4; // type4 is float const &</pre>
-                </blockquote>
-
-                <a name="result_of_tr1_protocol_guidelines">
-                <h3>Usage guidelines for the TR1 result_of protocol</h3>
-                </a>
-
-                <p>On compliant C++11
-                compilers, <code>boost::result_of</code> can
-                use <code>decltype</code> to deduce the type of any
-                call expression, including calls to function
-                objects. However, on pre-C++11 compilers or on
-                compilers without adequate decltype support,
-                additional scaffolding is needed from function
-                objects as described above. The following are
-                suggestions about how to use the TR1 protocol.</p>
-
-                <ul>
-                    <li>When the return type does not depend on the
-                    argument types or the cv-qualification of the
-                    function object, simply
-                    define <code>result_type</code>. There is no need
-                    to use the <code>result</code> template unless the
-                    return type varies.</li>
-
-                    <li>Use the protocol specified type when defining
-                    function prototypes. This can help ensure the
-                    actual return type does not get out of sync with
-                    the protocol specification. For example:
-
-                   <blockquote>
-                   <pre>struct functor {
-    typedef int result_type;
-    result_type operator()(int);
-};</pre>
-                   </blockquote> </li>
-
-                   <li>Always specify the <code>result</code>
-                   specialization near the corresponding
-                   <code>operator()</code> overload. This can make it
-                   easier to keep the specializations in sync with the
-                   overloads. For example:
-
-                   <blockquote>
-                   <pre>struct functor {
-    template&lt;class&gt; struct result;
-
-    template&lt;class F&gt;
-    struct result&lt;F(int)&gt; {
-        typedef int& type;
-    };
-    result&lt;functor(int)&gt;::type operator()(int);
-
-    template&lt;class F&gt;
-    struct result&lt;const F(int)&gt; {
-        typedef int const& type;
-    };
-    result&lt;const functor(int)&gt;::type operator()(int) const;
-};</pre>
-                   </blockquote> </li>
-
-                   <li>Use type transformations to simplify
-                   the <code>result</code> template specialization. For
-                   example, the following uses
-                   <a href="../type_traits/doc/html/index.html">Boost.TypeTraits</a>
-                   to specialize the <code>result</code> template for
-                   a single <code>operator()</code> that can be called on
-                   both a const and non-const function object with
-                   either an lvalue or rvalue argument.
-
-                   <blockquote>
-                   <pre>struct functor {
-    template&lt;class&gt; struct result;
-
-    template&lt;class F, class T&gt;
-    struct result&lt;F(T)&gt; 
-        : boost::remove_cv&lt;
-              typename boost::remove_reference&lt;T&gt;::type
-          &gt;
-    {};
-
-    template&lt;class T&gt;
-    T operator()(T const&amp; x) const;
-};</pre>
-                   </blockquote></li>
-                </ul>
-
-                <a name="result_of_tr1_diff">
-                <h3>Known differences between boost::result_of and TR1 result_of</h3>
-                </a>
-
-                When using <code>decltype</code>, <code>boost::result_of</code>
-                ignores the TR1 protocol and instead deduces the
-                return type of function objects directly
-                via <code>decltype</code>. In most situations, users
-                will not notice a difference, so long as they use the
-                protocol correctly. The following are situations in
-                which the type deduced
-                by <code>boost::result_of</code> is known to differ depending on
-                whether <code>decltype</code> or the TR1 protocol is
-                used.
-
-                <ul>
-                <li> TR1 protocol misusage
-
-                     <p>When using the TR1
-                     protocol, <code>boost::result_of</code> cannot
-                     detect whether the actual type of a call to a
-                     function object is the same as the type specified
-                     by the protocol, which allows for the possibility
-                     of inadvertent mismatches between the specified
-                     type and the actual type. When
-                     using <code>decltype</code>, these subtle bugs
-                     may result in compilation errors. For example:</p>
-
-                     <blockquote>
-                     <pre>struct functor {
-   typedef short result_type;
-   int operator()(short);
-};
-
-#ifdef BOOST_RESULT_OF_USE_DECLTYPE
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;boost::result_of&lt;functor(short)&gt;::type, int&gt;::value
-)); 
-
-#else
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;boost::result_of&lt;functor(short)&gt;::type, short&gt;::value
-));
-
-#endif</pre>
-                   </blockquote>
-
-                  <p>Note that the user can
-                  force <code>boost::result_of</code> to use the TR1
-                  protocol even on platforms that
-                  support <code>decltype</code> by
-                  defining <code>BOOST_RESULT_OF_USE_TR1</code>.</p></li>
-
-                  <li> Nullary function objects
-
-                       <p>When using the TR1 protocol, <code>boost::result_of</code>
-                       cannot always deduce the type of calls to
-                       nullary function objects, in which case the
-                       type defaults to void. When using <code>decltype</code>,
-                       <code>boost::result_of</code> always gives the actual type of the
-                       call expression. For example:</p>
-
-                       <blockquote>
-                       <pre>struct functor {
-   template&lt;class&gt; struct result {
-       typedef int type;
-   };
-   int operator()();
-};
-
-#ifdef BOOST_RESULT_OF_USE_DECLTYPE
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;boost::result_of&lt;functor()&gt;::type, int&gt;::value
-));
-
-#else
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;boost::result_of&lt;functor()&gt;::type, void&gt;::value
-));
-
-#endif</pre>
-                       </blockquote>
-
-                       <p>Note that there are some workarounds for the
-                       nullary function problem. So long as the return
-                       type does not vary,
-                       <code>result_type</code> can always be used to
-                       specify the return type regardless of arity. If the
-                       return type does vary, then the user can
-                       specialize <code>boost::result_of</code> itself for
-                       nullary calls.</p></li>
-
-                  <li> Non-class prvalues and cv-qualification
-
-                       <p>When using the TR1
-                       protocol, <code>boost::result_of</code> will
-                       report the cv-qualified type specified
-                       by <code>result_type</code> or
-                       the <code>result</code> template regardless of
-                       the actual cv-qualification of the call
-                       expression. When using
-                       <code>decltype</code>, <code>boost::result_of</code>
-                       will report the actual type of the call expression,
-                       which is not cv-qualified when the expression is a
-                       non-class prvalue. For example:</p>
-
-                       <blockquote>
-                       <pre>struct functor {
-   template&lt;class&gt; struct result;
-   template&lt;class F, class T&gt; struct result&lt;F(const T)&gt; {
-       typedef const T type;
-   };
-
-   const short operator()(const short);
-   int const & operator()(int const &);
-};
-
-// Non-prvalue call expressions work the same with or without decltype.
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;
-       boost::result_of&lt;functor(int const &)&gt;::type,
-       int const &
-::value
-));
-
-// Non-class prvalue call expressions are not actually cv-qualified,
-// but only the decltype-based result_of reports this accurately.
-
-#ifdef BOOST_RESULT_OF_USE_DECLTYPE
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;
-       boost::result_of&lt;functor(const short)&gt;::type,
-       short
-::value
-));
-
-#else
-
-BOOST_STATIC_ASSERT((
-   boost::is_same&lt;
-       boost::result_of&lt;functor(const short)&gt;::type,
-       const short
-::value
-));
-
-#endif</pre>
-                       </blockquote></li>
-                </ul>
-
-                <a name="result_of_cxx11_diff">
-                <h3>Known differences between boost::result_of and C++11 result_of</h3>
-                </a>
-
-                <p>When using <code>decltype</code>, <code>boost::result_of</code>
-                implements most of the C++11 result_of
-                specification. One known exception is that
-                <code>boost::result_of</code> does not implement the
-                requirements regarding pointers to member data.</p>
-
-                <p>Created by Doug Gregor. Contributions from Daniel Walker, Eric Niebler, Michel Morin and others</p>
 
 		<h2>Class templates for the Base-from-Member Idiom</h2>
 		<p>See <a href="base_from_member.html">separate documentation</a>.</p>

value_init.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&amp; );
+<br>    void swap( value_initialized&lt;T&gt;&amp; );
 <br>
 <br>  private :
 <br>    <i>unspecified</i> x ;
@@ -313,12 +313,6 @@ 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>
                     
@@ -391,7 +385,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( initialized&amp; );
+<br>    void swap( value_initialized&lt;T&gt;&amp; );
 <br>
 <br>  private :
 <br>    <i>unspecified</i> x ;
@@ -403,9 +397,6 @@ 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>