Release 1.41.0

[SVN r57747]
rm cmake from the release branch before it goes out broken. Policy dictates that you never commit to release, you commit to trunk and merge to release.
2025-06-27 04:51:43 +02:00 · 2009-11-18 14:58:26 +00:00 · 2009-10-17 01:10:45 +00:00 · 2009-07-22 21:51:01 +00:00 · 2009-05-20 19:41:20 +00:00 · 2009-05-15 04:44:20 +00:00
18 changed files with 346 additions and 732 deletions
--- a/doc/html/boost_optional/a_note_about_optional_bool_.html
+++ b/doc/html/boost_optional/a_note_about_optional_bool_.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>A note about optional&lt;bool&gt;</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="in_place_factories.html" title="In-Place Factories">
 <link rel="next" href="exception_safety_guarantees.html" title="Exception Safety Guarantees">
@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="in_place_factories.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="exception_safety_guarantees.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-<div class="section" title="A note about optional&lt;bool&gt;">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.a_note_about_optional_bool_"></a><a class="link" href="a_note_about_optional_bool_.html" title="A note about optional&lt;bool&gt;">A note about
    optional&lt;bool&gt;</a>
--- a/doc/html/boost_optional/acknowledgments.html
+++ b/doc/html/boost_optional/acknowledgments.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Acknowledgments</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="dependencies_and_portability.html" title="Dependencies and Portability">
 </head>
@ -21,89 +21,89 @@
 <div class="spirit-nav">
 <a accesskey="p" href="dependencies_and_portability.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a>
 </div>
-<div class="section" title="Acknowledgments">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.acknowledgments"></a><a class="link" href="acknowledgments.html" title="Acknowledgments">Acknowledgments</a>
 </h2></div></div></div>
 <a name="boost_optional.acknowledgments.pre_formal_review"></a><h4>
-<a name="id583998"></a>
+<a name="id2865262"></a>
      <a class="link" href="acknowledgments.html#boost_optional.acknowledgments.pre_formal_review">Pre-formal
      review</a>
    </h4>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
        Peter Dimov suggested the name 'optional', and was the first to point out
        the need for aligned storage.
      </li>
-<li class="listitem">
+<li>
        Douglas Gregor developed 'type_with_alignment', and later Eric Friedman coded
        'aligned_storage', which are the core of the optional class implementation.
      </li>
-<li class="listitem">
+<li>
        Andrei Alexandrescu and Brian Parker also worked with aligned storage techniques
        and their work influenced the current implementation.
      </li>
-<li class="listitem">
+<li>
        Gennadiy Rozental made extensive and important comments which shaped the
        design.
      </li>
-<li class="listitem">
+<li>
        Vesa Karvonen and Douglas Gregor made quite useful comparisons between optional,
        variant and any; and made other relevant comments.
      </li>
-<li class="listitem">
+<li>
        Douglas Gregor and Peter Dimov commented on comparisons and evaluation in
        boolean contexts.
      </li>
-<li class="listitem">
+<li>
        Eric Friedman helped understand the issues involved with aligned storage,
        move/copy operations and exception safety.
      </li>
-<li class="listitem">
+<li>
        Many others have participated with useful comments: Aleksey Gurotov, Kevlin
        Henney, David Abrahams, and others I can't recall.
      </li>
 </ul></div>
 <a name="boost_optional.acknowledgments.post_formal_review"></a><h4>
-<a name="id584068"></a>
+<a name="id2865331"></a>
      <a class="link" href="acknowledgments.html#boost_optional.acknowledgments.post_formal_review">Post-formal
      review</a>
    </h4>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
        William Kempf carefully considered the originally proposed interface and
        suggested the new interface which is currently used. He also started and
        fueled the discussion about the analogy optional&lt;&gt;/smart pointer and
        about relational operators.
      </li>
-<li class="listitem">
+<li>
        Peter Dimov, Joel de Guzman, David Abrahams, Tanton Gibbs and Ian Hanson
        focused on the relational semantics of optional (originally undefined); concluding
        with the fact that the pointer-like interface doesn't make it a pointer so
        it shall have deep relational operators.
      </li>
-<li class="listitem">
+<li>
        Augustus Saunders also explored the different relational semantics between
        optional&lt;&gt; and a pointer and developed the OptionalPointee concept
        as an aid against potential conflicts on generic code.
      </li>
-<li class="listitem">
+<li>
        Joel de Guzman noticed that optional&lt;&gt; can be seen as an API on top
        of variant&lt;T,nil_t&gt;.
      </li>
-<li class="listitem">
+<li>
        Dave Gomboc explained the meaning and usage of the Haskell analog to optional&lt;&gt;:
        the Maybe type constructor (analogy originally pointed out by David Sankel).
      </li>
-<li class="listitem">
+<li>
        Other comments were posted by Vincent Finn, Anthony Williams, Ed Brey, Rob
        Stewart, and others.
      </li>
-<li class="listitem">
+<li>
        Joel de Guzman made the case for the support of references and helped with
        the proper semantics.
      </li>
-<li class="listitem">
+<li>
        Mat Marcus shown the virtues of a value-oriented interface, influencing the
        current design, and contributed the idea of "none".
      </li>
--- a/doc/html/boost_optional/dependencies_and_portability.html
+++ b/doc/html/boost_optional/dependencies_and_portability.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Dependencies and Portability</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="implementation_notes.html" title="Implementation Notes">
 <link rel="next" href="acknowledgments.html" title="Acknowledgments">
@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="implementation_notes.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgments.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-<div class="section" title="Dependencies and Portability">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.dependencies_and_portability"></a><a class="link" href="dependencies_and_portability.html" title="Dependencies and Portability">Dependencies
    and Portability</a>
--- a/doc/html/boost_optional/detailed_semantics.html
+++ b/doc/html/boost_optional/detailed_semantics.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Detailed Semantics</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="synopsis.html" title="Synopsis">
 <link rel="next" href="examples.html" title="Examples">
@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="synopsis.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-<div class="section" title="Detailed Semantics">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.detailed_semantics"></a><a class="link" href="detailed_semantics.html" title="Detailed Semantics">Detailed Semantics</a>
 </h2></div></div></div>
@ -31,24 +31,24 @@
      type, in the sequel, those entries whose semantic depends on <code class="computeroutput"><span class="identifier">T</span></code> being of reference type or not will be
      distinguished using the following convention:
    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
        If the entry reads: <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span></code><span class="emphasis"><em>(not
        a ref)</em></span><code class="computeroutput"><span class="special">&gt;</span></code>, the description
        corresponds only to the case where <code class="computeroutput"><span class="identifier">T</span></code>
        is not of reference type.
      </li>
-<li class="listitem">
+<li>
        If the entry reads: <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span></code>,
        the description corresponds only to the case where <code class="computeroutput"><span class="identifier">T</span></code>
        is of reference type.
      </li>
-<li class="listitem">
+<li>
        If the entry reads: <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>,
        the description is the same for both cases.
      </li>
 </ul></div>
-<div class="note" title="Note"><table border="0" summary="Note">
+<div class="note"><table border="0" summary="Note">
 <tr>
 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/html/images/note.png"></td>
 <th align="left">Note</th>
@ -64,7 +64,7 @@
      <span class="inlinemediaobject"><img src="../images/space.png" alt="space"></span>
    </p>
 <a name="boost_optional.detailed_semantics.optional_class_member_functions"></a><h4>
-<a name="id560085"></a>
+<a name="id2841077"></a>
      <a class="link" href="detailed_semantics.html#boost_optional.detailed_semantics.optional_class_member_functions">optional
      class member functions</a>
    </h4>
@ -82,21 +82,21 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> Default-Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions:</strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is <span class="underline">uninitialized</span>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
        Notes: T's default constructor <span class="underline">is not</span>
        called.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">def</span> <span class="special">;</span>
 <span class="identifier">assert</span> <span class="special">(</span> <span class="special">!</span><span class="identifier">def</span> <span class="special">)</span> <span class="special">;</span>
 </pre>
@ -116,23 +116,23 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>
        uninitialized.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions:</strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is <span class="underline">uninitialized</span>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span><code class="computeroutput"><span class="identifier">T</span></code>'s
        default constructor <span class="underline">is not</span> called.
        The expression <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">none</span></code> denotes an instance of <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">none_t</span></code> that can be used as the parameter.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">none</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">n</span><span class="special">(</span><span class="identifier">none</span><span class="special">)</span> <span class="special">;</span>
 <span class="identifier">assert</span> <span class="special">(</span> <span class="special">!</span><span class="identifier">n</span> <span class="special">)</span> <span class="special">;</span>
@ -153,31 +153,31 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> Directly-Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions:</strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is <span class="underline">initialized</span>
        and its value is a<span class="emphasis"><em>copy</em></span> of <code class="computeroutput"><span class="identifier">v</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Whatever <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span>
        <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code> throws.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes: </strong></span><code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span>
        <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code> is
        called.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Exception Safety:</strong></span> Exceptions can only be
        thrown during <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span> <span class="identifier">T</span>
        <span class="keyword">const</span><span class="special">&amp;</span>
        <span class="special">);</span></code> in that case, this constructor
        has no effect.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">T</span> <span class="identifier">v</span><span class="special">;</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">opt</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>
 <span class="identifier">assert</span> <span class="special">(</span> <span class="special">*</span><span class="identifier">opt</span> <span class="special">==</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span>
@ -196,19 +196,19 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> Directly-Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions:</strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is <span class="underline">initialized</span>
        and its value is an instance of an internal type wrapping the reference
        <code class="computeroutput"><span class="identifier">ref</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">T</span> <span class="identifier">v</span><span class="special">;</span>
 <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">vref</span> <span class="special">=</span> <span class="identifier">v</span> <span class="special">;</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span> <span class="identifier">opt</span><span class="special">(</span><span class="identifier">vref</span><span class="special">);</span>
@ -246,7 +246,7 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+<div class="itemizedlist"><ul type="disc"><li>
        If condition is true, same as:
      </li></ul></div>
 <div class="blockquote"><blockquote class="blockquote">
@ -269,14 +269,14 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+<div class="itemizedlist"><ul type="disc"><li>
        otherwise, same as:
      </li></ul></div>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
        </p>
 <p>
-          <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span> <span class="special">[</span><span class="error">'</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">a</span>
+          <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span> <span class="special">[</span>#<span class="special">(</span><span class="keyword">not</span> <span class="identifier">a</span>
          <span class="identifier">ref</span><span class="special">)]&gt;::</span><span class="identifier">optional</span><span class="special">()</span></code>
        </p>
 <p>
@ -308,32 +308,32 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> Copy-Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions:</strong></span> If rhs is initialized,
        <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
        is initialized and its value is a <span class="emphasis"><em>copy</em></span> of the value
        of <code class="computeroutput"><span class="identifier">rhs</span></code>; else <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is uninitialized.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Whatever <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span>
        <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code> throws.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> If rhs is initialized, <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code> is
        called.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Exception Safety:</strong></span> Exceptions can only be
        thrown during <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span> <span class="identifier">T</span>
        <span class="keyword">const</span><span class="special">&amp;</span>
        <span class="special">);</span></code> in that case, this constructor
        has no effect.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">uninit</span> <span class="special">;</span>
 <span class="identifier">assert</span> <span class="special">(!</span><span class="identifier">uninit</span><span class="special">);</span>

@ -360,11 +360,11 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> Copy-Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions:</strong></span> If <code class="computeroutput"><span class="identifier">rhs</span></code>
        is initialized, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
        is initialized and its value is another reference to the same object referenced
@ -372,16 +372,16 @@
        else <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
        is uninitialized.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> If <code class="computeroutput"><span class="identifier">rhs</span></code>
        is initialized, both <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
        and <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code>
        will reefer to the same object (they alias).
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span> <span class="identifier">uninit</span> <span class="special">;</span>
 <span class="identifier">assert</span> <span class="special">(!</span><span class="identifier">uninit</span><span class="special">);</span>

@ -417,11 +417,11 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> Copy-Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions:</strong></span> If <code class="computeroutput"><span class="identifier">rhs</span></code>
        is initialized, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
        is initialized and its value is a <span class="emphasis"><em>copy</em></span> of the value
@ -429,25 +429,25 @@
        else <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
        is uninitialized.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Whatever <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span>
        <span class="identifier">U</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code> throws.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes: </strong></span><code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span>
        <span class="identifier">U</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code> is
        called if <code class="computeroutput"><span class="identifier">rhs</span></code> is initialized,
        which requires a valid conversion from <code class="computeroutput"><span class="identifier">U</span></code>
        to <code class="computeroutput"><span class="identifier">T</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Exception Safety:</strong></span> Exceptions can only be
        thrown during <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span> <span class="identifier">U</span>
        <span class="keyword">const</span><span class="special">&amp;</span>
        <span class="special">);</span></code> in that case, this constructor
        has no effect.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">x</span><span class="special">(</span><span class="number">123.4</span><span class="special">);</span>
 <span class="identifier">assert</span> <span class="special">(</span> <span class="special">*</span><span class="identifier">x</span> <span class="special">==</span> <span class="number">123.4</span> <span class="special">)</span> <span class="special">;</span>

@ -483,31 +483,31 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>
        with a value of <code class="computeroutput"><span class="identifier">T</span></code> obtained
        from the factory.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions: </strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is <span class="underline">initialized</span>
        and its value is <span class="emphasis"><em>directly given</em></span> from the factory <code class="computeroutput"><span class="identifier">f</span></code> (i.e., the value <span class="underline">is
        not copied</span>).
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Whatever the <code class="computeroutput"><span class="identifier">T</span></code>
        constructor called by the factory throws.
      </li>
-<li class="listitem">
-<span class="bold"><strong>Notes:</strong></span> See <a class="link" href="in_place_factories.html" title="In-Place Factories">In-Place
+<li>
+<span class="bold"><strong>Notes:</strong></span> See <a class="link" href="../index.html#optional_in_place_factories">In-Place
        Factories</a>
 </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Exception Safety:</strong></span> Exceptions can only be
        thrown during the call to the <code class="computeroutput"><span class="identifier">T</span></code>
        constructor used by the factory; in that case, this constructor has no effect.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">C</span> <span class="special">{</span> <span class="identifier">C</span> <span class="special">(</span> <span class="keyword">char</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">)</span> <span class="special">;</span> <span class="special">}</span> <span class="special">;</span>

 <span class="identifier">C</span> <span class="identifier">v</span><span class="special">(</span><span class="char">'A'</span><span class="special">,</span><span class="number">123.4</span><span class="special">,</span><span class="string">"hello"</span><span class="special">);</span>
@ -538,25 +538,25 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> Assigns the value <code class="computeroutput"><span class="identifier">rhs</span></code> to an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions: </strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initialized and its value is a <span class="emphasis"><em>copy</em></span>
        of <code class="computeroutput"><span class="identifier">rhs</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Whatever <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code> or
        <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span><span class="identifier">T</span>
        <span class="keyword">const</span><span class="special">&amp;)</span></code>
        throws.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> was initialized, <code class="computeroutput"><span class="identifier">T</span></code>'s
        assignment operator is used, otherwise, its copy-constructor is used.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Exception Safety:</strong></span> In the event of an exception,
        the initialization state of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is unchanged and its value unspecified
        as far as <code class="computeroutput"><span class="identifier">optional</span></code> is concerned
@ -565,7 +565,7 @@
        is initially uninitialized and <code class="computeroutput"><span class="identifier">T</span></code>'s
        <span class="emphasis"><em>copy constructor</em></span> fails, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is left properly uninitialized.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">T</span> <span class="identifier">x</span><span class="special">;</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">def</span> <span class="special">;</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">opt</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span> <span class="special">;</span>
@ -594,20 +594,20 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> (Re)binds thee wrapped reference.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions: </strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initialized and it references the
        same object referenced by <code class="computeroutput"><span class="identifier">rhs</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> was initialized, is is <span class="emphasis"><em>rebound</em></span>
-        to the new object. See <a class="link" href="rebinding_semantics_for_assignment_of_optional_references.html" title="Rebinding semantics for assignment of optional references">here</a>
-        for details on this behavior.
+        to the new object. See <a class="link" href="../index.html#optional_refassign">here</a> for
+        details on this behavior.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="keyword">int</span> <span class="identifier">a</span> <span class="special">=</span> <span class="number">1</span> <span class="special">;</span>
 <span class="keyword">int</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span> <span class="special">;</span>
 <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">ra</span> <span class="special">=</span> <span class="identifier">a</span> <span class="special">;</span>
@ -645,29 +645,29 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> Assigns another <code class="computeroutput"><span class="identifier">optional</span></code>
        to an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions:</strong></span> If <code class="computeroutput"><span class="identifier">rhs</span></code>
        is initialized, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
        is initialized and its value is a <span class="emphasis"><em>copy</em></span> of the value
        of <code class="computeroutput"><span class="identifier">rhs</span></code>; else <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is uninitialized.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Whatever <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="keyword">operator</span><span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span></code> or <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span>
        <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code> throws.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> If both <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> and <code class="computeroutput"><span class="identifier">rhs</span></code>
        are initially initialized, <code class="computeroutput"><span class="identifier">T</span></code>'s
        <span class="emphasis"><em>assignment operator</em></span> is used. If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initially initialized but <code class="computeroutput"><span class="identifier">rhs</span></code> is uninitialized, <code class="computeroutput"><span class="identifier">T</span></code>'s
        [destructor] is called. If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initially uninitialized but <code class="computeroutput"><span class="identifier">rhs</span></code> is initialized, <code class="computeroutput"><span class="identifier">T</span></code>'s
        <span class="emphasis"><em>copy constructor</em></span> is called.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Exception Safety:</strong></span> In the event of an exception,
        the initialization state of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is unchanged and its value unspecified
        as far as optional is concerned (it is up to <code class="computeroutput"><span class="identifier">T</span></code>'s
@ -676,7 +676,7 @@
        is initially uninitialized and <code class="computeroutput"><span class="identifier">T</span></code>'s
        <span class="emphasis"><em>copy constructor</em></span> fails, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is left properly uninitialized.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">T</span> <span class="identifier">v</span><span class="special">;</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">opt</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">def</span> <span class="special">;</span>
@ -700,20 +700,20 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> (Re)binds thee wrapped reference.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions:</strong></span> If <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code> is initialized, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initialized and it references the
        same object referenced by <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code>; otherwise, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is uninitialized (and references no object).
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> was initialized and so is *rhs, this
-        is is <span class="emphasis"><em>rebound</em></span> to the new object. See <a class="link" href="rebinding_semantics_for_assignment_of_optional_references.html" title="Rebinding semantics for assignment of optional references">here</a>
+        is is <span class="emphasis"><em>rebound</em></span> to the new object. See <a class="link" href="../index.html#optional_refassign">here</a>
        for details on this behavior.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="keyword">int</span> <span class="identifier">a</span> <span class="special">=</span> <span class="number">1</span> <span class="special">;</span>
 <span class="keyword">int</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span> <span class="special">;</span>
 <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">ra</span> <span class="special">=</span> <span class="identifier">a</span> <span class="special">;</span>
@ -750,25 +750,25 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> Assigns another convertible optional
        to an optional.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions:</strong></span> If <code class="computeroutput"><span class="identifier">rhs</span></code>
        is initialized, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
        is initialized and its value is a <span class="emphasis"><em>copy</em></span> of the value
        of <code class="computeroutput"><span class="identifier">rhs</span></code><span class="emphasis"><em>converted</em></span>
        to type <code class="computeroutput"><span class="identifier">T</span></code>; else <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is uninitialized.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Whatever <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span> <span class="identifier">U</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code> or
        <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span> <span class="identifier">U</span>
        <span class="keyword">const</span><span class="special">&amp;</span>
        <span class="special">)</span></code> throws.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> If both <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> and rhs are initially initialized, <code class="computeroutput"><span class="identifier">T</span></code>'s <span class="emphasis"><em>assignment operator</em></span>
        (from <code class="computeroutput"><span class="identifier">U</span></code>) is used. If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initially
        initialized but <code class="computeroutput"><span class="identifier">rhs</span></code> is uninitialized,
@ -778,7 +778,7 @@
        <span class="emphasis"><em>converting constructor</em></span> (from <code class="computeroutput"><span class="identifier">U</span></code>)
        is called.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Exception Safety:</strong></span> In the event of an exception,
        the initialization state of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is unchanged and its value unspecified
        as far as optional is concerned (it is up to <code class="computeroutput"><span class="identifier">T</span></code>'s
@ -787,7 +787,7 @@
        is initially uninitialized and <code class="computeroutput"><span class="identifier">T</span></code>'s
        converting constructor fails, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is left properly uninitialized.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">T</span> <span class="identifier">v</span><span class="special">;</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">opt0</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="identifier">opt1</span><span class="special">;</span>
@ -812,7 +812,7 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+<div class="itemizedlist"><ul type="disc"><li>
 <span class="bold"><strong>Deprecated:</strong></span> same as <code class="computeroutput"><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">T</span>
        <span class="keyword">const</span><span class="special">&amp;</span>
        <span class="identifier">v</span><span class="special">)</span> <span class="special">;</span></code>
@ -831,7 +831,7 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+<div class="itemizedlist"><ul type="disc"><li>
 <span class="bold"><strong>Deprecated:</strong></span> Same as <code class="computeroutput"><span class="keyword">operator</span><span class="special">=(</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">none_t</span> <span class="special">);</span></code>
 </li></ul></div>
 <p>
@ -902,21 +902,21 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Requirements:</strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initialized
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Returns:</strong></span> A reference to the contained value
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> The requirement is asserted via
        <code class="computeroutput"><span class="identifier">BOOST_ASSERT</span><span class="special">()</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">T</span> <span class="identifier">v</span> <span class="special">;</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">opt</span> <span class="special">(</span> <span class="identifier">v</span> <span class="special">);</span>
 <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">u</span> <span class="special">=</span> <span class="special">*</span><span class="identifier">opt</span><span class="special">;</span>
@ -982,15 +982,15 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns:</strong></span> A reference to the contained value,
        if any, or <code class="computeroutput"><span class="keyword">default</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">T</span> <span class="identifier">v</span><span class="special">,</span> <span class="identifier">z</span> <span class="special">;</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">def</span><span class="special">;</span>
 <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">=</span> <span class="identifier">def</span><span class="special">.</span><span class="identifier">get_value_or</span><span class="special">(</span><span class="identifier">z</span><span class="special">);</span>
@ -1068,22 +1068,22 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Requirements: </strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initialized
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Returns:</strong></span><span class="underline">The</span>
        reference contained.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> The requirement is asserted via
        <code class="computeroutput"><span class="identifier">BOOST_ASSERT</span><span class="special">()</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">T</span> <span class="identifier">v</span> <span class="special">;</span>
 <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">vref</span> <span class="special">=</span> <span class="identifier">v</span> <span class="special">;</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span> <span class="identifier">opt</span> <span class="special">(</span> <span class="identifier">vref</span> <span class="special">);</span>
@ -1143,20 +1143,20 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns:</strong></span> If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initialized, a pointer to the contained
        value; else <code class="computeroutput"><span class="number">0</span></code> (<span class="emphasis"><em>null</em></span>).
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> The contained value is permanently
        stored within <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>,
        so you should not hold nor delete this pointer
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">T</span> <span class="identifier">v</span><span class="special">;</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">opt</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span> <span class="identifier">copt</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>
@ -1194,21 +1194,21 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Requirements: </strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initialized.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Returns:</strong></span> A pointer to the contained value.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> The requirement is asserted via
        <code class="computeroutput"><span class="identifier">BOOST_ASSERT</span><span class="special">()</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span> <span class="special">{</span> <span class="keyword">int</span> <span class="identifier">mdata</span> <span class="special">;</span> <span class="special">}</span> <span class="special">;</span>
 <span class="identifier">X</span> <span class="identifier">x</span> <span class="special">;</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;</span> <span class="identifier">opt</span> <span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
@ -1230,15 +1230,15 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns:</strong></span> An unspecified value which if used
        on a boolean context is equivalent to (<code class="computeroutput"><span class="identifier">get</span><span class="special">()</span> <span class="special">!=</span> <span class="number">0</span></code>)
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">def</span> <span class="special">;</span>
 <span class="identifier">assert</span> <span class="special">(</span> <span class="identifier">def</span> <span class="special">==</span> <span class="number">0</span> <span class="special">);</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">opt</span> <span class="special">(</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span>
@ -1261,20 +1261,20 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns:</strong></span> If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is uninitialized, <code class="computeroutput"><span class="keyword">true</span></code>;
        else <code class="computeroutput"><span class="keyword">false</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> This operator is provided for those
        compilers which can't use the <span class="emphasis"><em>unspecified-bool-type operator</em></span>
        in certain boolean contexts.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">opt</span> <span class="special">;</span>
 <span class="identifier">assert</span> <span class="special">(</span> <span class="special">!</span><span class="identifier">opt</span> <span class="special">);</span>
 <span class="special">*</span><span class="identifier">opt</span> <span class="special">=</span> <span class="identifier">some_T</span> <span class="special">;</span>
@ -1298,16 +1298,16 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns: </strong></span><code class="computeroutput"><span class="keyword">true</span></code>
        if the <code class="computeroutput"><span class="identifier">optional</span></code> is initialized,
        <code class="computeroutput"><span class="keyword">false</span></code> otherwise.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">def</span> <span class="special">;</span>
 <span class="identifier">assert</span> <span class="special">(</span> <span class="special">!</span><span class="identifier">def</span><span class="special">.</span><span class="identifier">is_initialized</span><span class="special">()</span> <span class="special">);</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">opt</span> <span class="special">(</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span>
@ -1319,7 +1319,7 @@
      <span class="inlinemediaobject"><img src="../images/space.png" alt="space"></span>
    </p>
 <a name="boost_optional.detailed_semantics.free_functions"></a><h4>
-<a name="id572503"></a>
+<a name="id2853708"></a>
      <a class="link" href="detailed_semantics.html#boost_optional.detailed_semantics.free_functions">Free functions</a>
    </h4>
 <p>
@ -1336,13 +1336,13 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns: </strong></span><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">v</span><span class="special">)</span></code> for
        the <span class="emphasis"><em>deduced</em></span> type <code class="computeroutput"><span class="identifier">T</span></code>
        of <code class="computeroutput"><span class="identifier">v</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">foo</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span>

 <span class="identifier">foo</span> <span class="special">(</span> <span class="identifier">make_optional</span><span class="special">(</span><span class="number">1</span><span class="special">+</span><span class="number">1</span><span class="special">)</span> <span class="special">)</span> <span class="special">;</span> <span class="comment">// Creates an optional&lt;int&gt;
@ -1364,13 +1364,13 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns: </strong></span><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">condition</span><span class="special">,</span><span class="identifier">v</span><span class="special">)</span></code> for
        the <span class="emphasis"><em>deduced</em></span> type <code class="computeroutput"><span class="identifier">T</span></code>
        of <code class="computeroutput"><span class="identifier">v</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">calculate_foo</span><span class="special">()</span>
 <span class="special">{</span>
  <span class="keyword">double</span> <span class="identifier">val</span> <span class="special">=</span> <span class="identifier">compute_foo</span><span class="special">();</span>
@ -1398,17 +1398,17 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns:</strong></span> If both <code class="computeroutput"><span class="identifier">x</span></code>
        and <code class="computeroutput"><span class="identifier">y</span></code> are initialized, <code class="computeroutput"><span class="special">(*</span><span class="identifier">x</span> <span class="special">==</span>
        <span class="special">*</span><span class="identifier">y</span><span class="special">)</span></code>. If only <code class="computeroutput"><span class="identifier">x</span></code>
        or <code class="computeroutput"><span class="identifier">y</span></code> is initialized, <code class="computeroutput"><span class="keyword">false</span></code>. If both are uninitialized, <code class="computeroutput"><span class="keyword">true</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> Pointers have shallow relational
        operators while <code class="computeroutput"><span class="identifier">optional</span></code>
        has deep relational operators. Do not use <code class="computeroutput"><span class="keyword">operator</span>
@ -1417,7 +1417,7 @@
        or a pointer; use <a href="../../../../utility/OptionalPointee.html#equal" target="_top"><code class="computeroutput"><span class="identifier">equal_pointees</span><span class="special">()</span></code></a>
        instead
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">T</span> <span class="identifier">x</span><span class="special">(</span><span class="number">12</span><span class="special">);</span>
 <span class="identifier">T</span> <span class="identifier">y</span><span class="special">(</span><span class="number">12</span><span class="special">);</span>
 <span class="identifier">T</span> <span class="identifier">z</span><span class="special">(</span><span class="number">21</span><span class="special">);</span>
@ -1459,17 +1459,17 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns:</strong></span> If <code class="computeroutput"><span class="identifier">y</span></code>
        is not initialized, <code class="computeroutput"><span class="keyword">false</span></code>. If
        <code class="computeroutput"><span class="identifier">y</span></code> is initialized and <code class="computeroutput"><span class="identifier">x</span></code> is not initialized, <code class="computeroutput"><span class="keyword">true</span></code>.
        If both <code class="computeroutput"><span class="identifier">x</span></code> and <code class="computeroutput"><span class="identifier">y</span></code> are initialized, <code class="computeroutput"><span class="special">(*</span><span class="identifier">x</span> <span class="special">&lt;</span> <span class="special">*</span><span class="identifier">y</span><span class="special">)</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> Pointers have shallow relational
        operators while <code class="computeroutput"><span class="identifier">optional</span></code>
        has deep relational operators. Do not use <code class="computeroutput"><span class="keyword">operator</span>
@ -1478,7 +1478,7 @@
        or a pointer; use <a href="../../../../utility/OptionalPointee.html#less" target="_top"><code class="computeroutput"><span class="identifier">less_pointees</span><span class="special">()</span></code></a>
        instead.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">T</span> <span class="identifier">x</span><span class="special">(</span><span class="number">12</span><span class="special">);</span>
 <span class="identifier">T</span> <span class="identifier">y</span><span class="special">(</span><span class="number">34</span><span class="special">);</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">def</span> <span class="special">;</span>
@ -1516,13 +1516,13 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns: </strong></span><code class="computeroutput"><span class="special">!(</span>
        <span class="identifier">x</span> <span class="special">==</span>
        <span class="identifier">y</span> <span class="special">);</span></code>
 </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
 </ul></div>
@ -1542,13 +1542,13 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns: </strong></span><code class="computeroutput"><span class="special">(</span>
        <span class="identifier">y</span> <span class="special">&lt;</span>
        <span class="identifier">x</span> <span class="special">);</span></code>
 </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
 </ul></div>
@ -1568,12 +1568,12 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns: </strong></span><code class="computeroutput"><span class="special">!(</span>
        <span class="identifier">y</span><span class="special">&lt;</span><span class="identifier">x</span> <span class="special">);</span></code>
 </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
 </ul></div>
@ -1593,12 +1593,12 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Returns: </strong></span><code class="computeroutput"><span class="special">!(</span>
        <span class="identifier">x</span><span class="special">&lt;</span><span class="identifier">y</span> <span class="special">);</span></code>
 </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
 </ul></div>
@ -1618,37 +1618,37 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Effect:</strong></span> If both <code class="computeroutput"><span class="identifier">x</span></code>
        and <code class="computeroutput"><span class="identifier">y</span></code> are initialized, calls
        <code class="computeroutput"><span class="identifier">swap</span><span class="special">(*</span><span class="identifier">x</span><span class="special">,*</span><span class="identifier">y</span><span class="special">)</span></code> using <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span></code>.
        If only one is initialized, say <code class="computeroutput"><span class="identifier">x</span></code>,
        calls: <code class="computeroutput"><span class="identifier">y</span><span class="special">.</span><span class="identifier">reset</span><span class="special">(*</span><span class="identifier">x</span><span class="special">);</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">reset</span><span class="special">();</span></code> If none is initialized, does nothing.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Postconditions:</strong></span> The states of <code class="computeroutput"><span class="identifier">x</span></code> and <code class="computeroutput"><span class="identifier">y</span></code>
        interchanged.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Throws:</strong></span> If both are initialized, whatever
        <code class="computeroutput"><span class="identifier">swap</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;,</span><span class="identifier">T</span><span class="special">&amp;)</span></code>
        throws. If only one is initialized, whatever <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span> <span class="special">(</span>
        <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code> throws.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Notes:</strong></span> If both are initialized, <code class="computeroutput"><span class="identifier">swap</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;,</span><span class="identifier">T</span><span class="special">&amp;)</span></code> is used unqualified but with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span></code>
        introduced in scope. If only one is initialized, <code class="computeroutput"><span class="identifier">T</span><span class="special">::~</span><span class="identifier">T</span><span class="special">()</span></code>
        and <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span> <span class="identifier">T</span>
        <span class="keyword">const</span><span class="special">&amp;</span>
        <span class="special">)</span></code> is called.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Exception Safety:</strong></span> If both are initialized,
        this operation has the exception safety guarantees of <code class="computeroutput"><span class="identifier">swap</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;,</span><span class="identifier">T</span><span class="special">&amp;)</span></code>.
        If only one is initialized, it has the same basic guarantee as <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">reset</span><span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code>.
      </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Example:</strong></span><pre class="programlisting"><span class="identifier">T</span> <span class="identifier">x</span><span class="special">(</span><span class="number">12</span><span class="special">);</span>
 <span class="identifier">T</span> <span class="identifier">y</span><span class="special">(</span><span class="number">21</span><span class="special">);</span>
 <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">def0</span> <span class="special">;</span>
--- a/doc/html/boost_optional/development.html
+++ b/doc/html/boost_optional/development.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Development</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="next" href="synopsis.html" title="Synopsis">
@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="../index.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="synopsis.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-<div class="section" title="Development">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.development"></a><a class="link" href="development.html" title="Development">Development</a>
 </h2></div></div></div>
@ -31,7 +31,7 @@
 <dt><span class="section"><a href="development.html#boost_optional.development.the_semantics">The semantics</a></span></dt>
 <dt><span class="section"><a href="development.html#boost_optional.development.the_interface">The Interface</a></span></dt>
 </dl></div>
-<div class="section" title="The models">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_optional.development.the_models"></a><a class="link" href="development.html#boost_optional.development.the_models" title="The models">The models</a>
 </h3></div></div></div>
@ -110,28 +110,28 @@
 <p>
        Discriminated-union:
      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>deep-copy</strong></span> semantics: copies of the variant
          implies copies of the value.
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>deep-relational</strong></span> semantics: comparisons
          between variants matches both current types and values
        </li>
-<li class="listitem">
+<li>
          If the variant's current type is <code class="computeroutput"><span class="identifier">T</span></code>,
          it is modeling an <span class="emphasis"><em>initialized</em></span> optional.
        </li>
-<li class="listitem">
+<li>
          If the variant's current type is not <code class="computeroutput"><span class="identifier">T</span></code>,
          it is modeling an <span class="emphasis"><em>uninitialized</em></span> optional.
        </li>
-<li class="listitem">
+<li>
          Testing if the variant's current type is <code class="computeroutput"><span class="identifier">T</span></code>
          models testing if the optional is initialized
        </li>
-<li class="listitem">
+<li>
          Trying to extract a <code class="computeroutput"><span class="identifier">T</span></code> from
          a variant when its current type is not <code class="computeroutput"><span class="identifier">T</span></code>,
          models the undefined behavior of trying to access the value of an uninitialized
@ -141,34 +141,34 @@
 <p>
        Single-element container:
      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>deep-copy</strong></span> semantics: copies of the container
          implies copies of the value.
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>deep-relational</strong></span> semantics: comparisons
          between containers compare container size and if match, contained value
        </li>
-<li class="listitem">
+<li>
          If the container is not empty (contains an object of type <code class="computeroutput"><span class="identifier">T</span></code>), it is modeling an <span class="emphasis"><em>initialized</em></span>
          optional.
        </li>
-<li class="listitem">
+<li>
          If the container is empty, it is modeling an <span class="emphasis"><em>uninitialized</em></span>
          optional.
        </li>
-<li class="listitem">
+<li>
          Testing if the container is empty models testing if the optional is initialized
        </li>
-<li class="listitem">
+<li>
          Trying to extract a <code class="computeroutput"><span class="identifier">T</span></code> from
          an empty container models the undefined behavior of trying to access the
          value of an uninitialized optional
        </li>
 </ul></div>
 </div>
-<div class="section" title="The semantics">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_optional.development.the_semantics"></a><a class="link" href="development.html#boost_optional.development.the_semantics" title="The semantics">The semantics</a>
 </h3></div></div></div>
@ -193,55 +193,55 @@
        We can draw from the purpose of <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
        the required basic semantics:
      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="bold"><strong>Default Construction:</strong></span> To introduce a formally
          uninitialized wrapped object.
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Direct Value Construction via copy:</strong></span> To
          introduce a formally initialized wrapped object whose value is obtained
          as a copy of some object.
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Deep Copy Construction:</strong></span> To obtain a new
          yet equivalent wrapped object.
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Direct Value Assignment (upon initialized):</strong></span>
          To assign a value to the wrapped object.
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Direct Value Assignment (upon uninitialized):</strong></span>
          To initialize the wrapped object with a value obtained as a copy of some
          object.
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Assignment (upon initialized):</strong></span> To assign
          to the wrapped object the value of another wrapped object.
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Assignment (upon uninitialized):</strong></span> To initialize
          the wrapped object with value of another wrapped object.
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Deep Relational Operations (when supported by the
          type T):</strong></span> To compare wrapped object values taking into account
          the presence of uninitialized states.
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Value access:</strong></span> To unwrap the wrapped object.
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Initialization state query:</strong></span> To determine
          if the object is formally initialized or not.
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>Swap:</strong></span> To exchange wrapped objects. (with
          whatever exception safety guarantees are provided by <code class="computeroutput"><span class="identifier">T</span></code>'s
          swap).
        </li>
-<li class="listitem">
+<li>
 <span class="bold"><strong>De-initialization:</strong></span> To release the wrapped
          object (if any) and leave the wrapper in the uninitialized state.
        </li>
@ -252,7 +252,7 @@
        via a pointer to the wrapped object or null.
      </p>
 </div>
-<div class="section" title="The Interface">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_optional.development.the_interface"></a><a class="link" href="development.html#boost_optional.development.the_interface" title="The Interface">The Interface</a>
 </h3></div></div></div>
@ -292,7 +292,7 @@
        itself which are supported by a special interface.
      </p>
 <a name="boost_optional.development.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_untitialized_optional_objects__the_operators___and___gt_"></a><h5>
-<a name="id555569"></a>
+<a name="id2836653"></a>
        <a class="link" href="development.html#boost_optional.development.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_untitialized_optional_objects__the_operators___and___gt_">Lexically-hinted
        Value Access in the presence of possibly untitialized optional objects: The
        operators * and -&gt;</a>
@ -357,7 +357,7 @@
        incarnated by pointers.
      </p>
 <a name="boost_optional.development.the_interface.optional_lt_t_gt__as_a_model_of_optionalpointee"></a><h5>
-<a name="id555831"></a>
+<a name="id2836963"></a>
        <a class="link" href="development.html#boost_optional.development.the_interface.optional_lt_t_gt__as_a_model_of_optionalpointee">Optional&lt;T&gt;
        as a model of OptionalPointee</a>
      </h5>
@ -367,7 +367,7 @@
        about the possibly uninitialized state appealing to the familiar pointer
        semantics w.r.t. to null pointers.
      </p>
-<div class="warning" title="Warning"><table border="0" summary="Warning">
+<div class="warning"><table border="0" summary="Warning">
 <tr>
 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../../doc/html/images/warning.png"></td>
 <th align="left">Warning</th>
--- a/doc/html/boost_optional/examples.html
+++ b/doc/html/boost_optional/examples.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Examples</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="detailed_semantics.html" title="Detailed Semantics">
 <link rel="next" href="optional_references.html" title="Optional references">
@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="detailed_semantics.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="optional_references.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-<div class="section" title="Examples">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.examples"></a><a class="link" href="examples.html" title="Examples">Examples</a>
 </h2></div></div></div>
@ -36,7 +36,7 @@
 <dt><span class="section"><a href="examples.html#boost_optional.examples.bypassing_expensive_unnecessary_default_construction">Bypassing
      expensive unnecessary default construction</a></span></dt>
 </dl></div>
-<div class="section" title="Optional return values">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_optional.examples.optional_return_values"></a><a class="link" href="examples.html#boost_optional.examples.optional_return_values" title="Optional return values">Optional
      return values</a>
@ -57,7 +57,7 @@
 <span class="special">}</span>
 </pre>
 </div>
-<div class="section" title="Optional local variables">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_optional.examples.optional_local_variables"></a><a class="link" href="examples.html#boost_optional.examples.optional_local_variables" title="Optional local variables">Optional
      local variables</a>
@ -78,7 +78,7 @@
 <span class="keyword">else</span> <span class="identifier">print</span><span class="special">(</span><span class="string">"employer's name not found!"</span><span class="special">);</span>
 </pre>
 </div>
-<div class="section" title="Optional data members">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_optional.examples.optional_data_members"></a><a class="link" href="examples.html#boost_optional.examples.optional_data_members" title="Optional data members">Optional
      data members</a>
@ -116,7 +116,7 @@
 <span class="special">};</span>
 </pre>
 </div>
-<div class="section" title="Bypassing expensive unnecessary default construction">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h3 class="title">
 <a name="boost_optional.examples.bypassing_expensive_unnecessary_default_construction"></a><a class="link" href="examples.html#boost_optional.examples.bypassing_expensive_unnecessary_default_construction" title="Bypassing expensive unnecessary default construction">Bypassing
      expensive unnecessary default construction</a>
--- a/doc/html/boost_optional/exception_safety_guarantees.html
+++ b/doc/html/boost_optional/exception_safety_guarantees.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Exception Safety Guarantees</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="a_note_about_optional_bool_.html" title="A note about optional&lt;bool&gt;">
 <link rel="next" href="type_requirements.html" title="Type requirements">
@ -22,30 +22,30 @@
 <div class="spirit-nav">
 <a accesskey="p" href="a_note_about_optional_bool_.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="type_requirements.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-<div class="section" title="Exception Safety Guarantees">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.exception_safety_guarantees"></a><a class="link" href="exception_safety_guarantees.html" title="Exception Safety Guarantees">Exception Safety
    Guarantees</a>
 </h2></div></div></div>
 <p>
-      Because of the current implementation (see <a class="link" href="implementation_notes.html" title="Implementation Notes">Implementation
+      Because of the current implementation (see <a class="link" href="../index.html#optional_implementation_notes">Implementation
      Notes</a>), all of the assignment methods:
    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem"><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span>
+<div class="itemizedlist"><ul type="disc">
+<li><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span>
        <span class="keyword">const</span><span class="special">&amp;</span>
        <span class="special">)</span></code></li>
-<li class="listitem"><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code></li>
-<li class="listitem"><code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span>
+<li><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code></li>
+<li><code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span>
        <span class="keyword">const</span><span class="special">&amp;</span>
        <span class="special">)</span></code></li>
-<li class="listitem"><code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">InPlaceFactory</span>
+<li><code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">InPlaceFactory</span>
        <span class="keyword">const</span><span class="special">&amp;</span>
        <span class="special">)</span></code></li>
-<li class="listitem"><code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">TypedInPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory</span>
+<li><code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">TypedInPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory</span>
        <span class="keyword">const</span><span class="special">&amp;</span>
        <span class="special">)</span> </code></li>
-<li class="listitem"><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;:::</span><span class="identifier">reset</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span></code></li>
+<li><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;:::</span><span class="identifier">reset</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span></code></li>
 </ul></div>
 <p>
      Can only <span class="emphasis"><em>guarantee</em></span> the <span class="underline">basic
@ -56,9 +56,9 @@
 <p>
      On the other hand, the <span class="emphasis"><em>uninitializing</em></span> methods:
    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem"><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">none_t</span> <span class="special">)</span></code></li>
-<li class="listitem"><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">reset</span><span class="special">()</span></code></li>
+<div class="itemizedlist"><ul type="disc">
+<li><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">none_t</span> <span class="special">)</span></code></li>
+<li><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">reset</span><span class="special">()</span></code></li>
 </ul></div>
 <p>
      Provide the no-throw guarantee (assuming a no-throw <code class="computeroutput"><span class="identifier">T</span><span class="special">::~</span><span class="identifier">T</span><span class="special">()</span></code>)
@ -112,7 +112,7 @@
 <span class="special">}</span>
 </pre>
 <a name="boost_optional.exception_safety_guarantees.swap"></a><h4>
-<a name="id583497"></a>
+<a name="id2864737"></a>
      <a class="link" href="exception_safety_guarantees.html#boost_optional.exception_safety_guarantees.swap">Swap</a>
    </h4>
 <p>
--- a/doc/html/boost_optional/implementation_notes.html
+++ b/doc/html/boost_optional/implementation_notes.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Implementation Notes</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="type_requirements.html" title="Type requirements">
 <link rel="next" href="dependencies_and_portability.html" title="Dependencies and Portability">
@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="type_requirements.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="dependencies_and_portability.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-<div class="section" title="Implementation Notes">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.implementation_notes"></a><a class="link" href="implementation_notes.html" title="Implementation Notes">Implementation Notes</a>
 </h2></div></div></div>
--- a/doc/html/boost_optional/in_place_factories.html
+++ b/doc/html/boost_optional/in_place_factories.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>In-Place Factories</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="rebinding_semantics_for_assignment_of_optional_references.html" title="Rebinding semantics for assignment of optional references">
 <link rel="next" href="a_note_about_optional_bool_.html" title="A note about optional&lt;bool&gt;">
@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="rebinding_semantics_for_assignment_of_optional_references.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="a_note_about_optional_bool_.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-<div class="section" title="In-Place Factories">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.in_place_factories"></a><a class="link" href="in_place_factories.html" title="In-Place Factories">In-Place Factories</a>
 </h2></div></div></div>
@ -121,18 +121,18 @@
 <span class="special">{</span>
    <span class="comment">// Wrapped object constructed in-place via a TypedInPlaceFactory.
 </span>    <span class="comment">// No temporary created.
-</span>    <span class="identifier">W</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory2</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">,</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;(</span><span class="number">123</span><span class="special">,</span><span class="string">"hello"</span><span class="special">))</span> <span class="special">;</span>
+</span>    <span class="identifier">W</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory2</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">,</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span><span class="identifier">rt</span><span class="special">(</span><span class="number">123</span><span class="special">,</span><span class="string">"hello"</span><span class="special">))</span> <span class="special">;</span>
 <span class="special">}</span>
 </pre>
 <p>
      The factories are divided in two groups:
    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
 <span class="underline">TypedInPlaceFactories</span>: those which
        take the target type as a primary template parameter.
      </li>
-<li class="listitem">
+<li>
 <span class="underline">InPlaceFactories</span>: those with a template
        <code class="computeroutput"><span class="identifier">construct</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code> member
        function taking the target type.
--- a/doc/html/boost_optional/optional_references.html
+++ b/doc/html/boost_optional/optional_references.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Optional references</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="examples.html" title="Examples">
 <link rel="next" href="rebinding_semantics_for_assignment_of_optional_references.html" title="Rebinding semantics for assignment of optional references">
@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="examples.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="rebinding_semantics_for_assignment_of_optional_references.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-<div class="section" title="Optional references">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.optional_references"></a><a class="link" href="optional_references.html" title="Optional references">Optional references</a>
 </h2></div></div></div>
@ -35,20 +35,20 @@
      However, since references are not real objects some restrictions apply and
      some operations are not available in this case:
    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
        Converting constructors
      </li>
-<li class="listitem">
+<li>
        Converting assignment
      </li>
-<li class="listitem">
+<li>
        InPlace construction
      </li>
-<li class="listitem">
+<li>
        InPlace assignment
      </li>
-<li class="listitem">
+<li>
        Value-access via pointer
      </li>
 </ul></div>
@ -57,13 +57,13 @@
      treats it wrapped pseudo-object much as a real value, a true real reference
      is stored so aliasing will ocurr:
    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
        Copies of <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span></code>
        will copy the references but all these references will nonetheless reefer
        to the same object.
      </li>
-<li class="listitem">
+<li>
        Value-access will actually provide access to the referenced object rather
        than the reference itself.
      </li>
--- a/doc/html/boost_optional/rebinding_semantics_for_assignment_of_optional_references.html
+++ b/doc/html/boost_optional/rebinding_semantics_for_assignment_of_optional_references.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Rebinding semantics for assignment of optional references</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="optional_references.html" title="Optional references">
 <link rel="next" href="in_place_factories.html" title="In-Place Factories">
@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="optional_references.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="in_place_factories.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-<div class="section" title="Rebinding semantics for assignment of optional references">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.rebinding_semantics_for_assignment_of_optional_references"></a><a class="link" href="rebinding_semantics_for_assignment_of_optional_references.html" title="Rebinding semantics for assignment of optional references">Rebinding
    semantics for assignment of optional references</a>
@ -70,7 +70,7 @@
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">b</span><span class="special">==</span><span class="number">3</span><span class="special">);</span> 
 </pre>
 <a name="boost_optional.rebinding_semantics_for_assignment_of_optional_references.rationale"></a><h4>
-<a name="id579234"></a>
+<a name="id2860344"></a>
      <a class="link" href="rebinding_semantics_for_assignment_of_optional_references.html#boost_optional.rebinding_semantics_for_assignment_of_optional_references.rationale">Rationale</a>
    </h4>
 <p>
--- a/doc/html/boost_optional/synopsis.html
+++ b/doc/html/boost_optional/synopsis.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Synopsis</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="development.html" title="Development">
 <link rel="next" href="detailed_semantics.html" title="Detailed Semantics">
@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="development.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="detailed_semantics.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-<div class="section" title="Synopsis">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.synopsis"></a><a class="link" href="synopsis.html" title="Synopsis">Synopsis</a>
 </h2></div></div></div>
--- a/doc/html/boost_optional/type_requirements.html
+++ b/doc/html/boost_optional/type_requirements.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Type requirements</title>
 <link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="up" href="../index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="prev" href="exception_safety_guarantees.html" title="Exception Safety Guarantees">
 <link rel="next" href="implementation_notes.html" title="Implementation Notes">
@ -22,7 +22,7 @@
 <div class="spirit-nav">
 <a accesskey="p" href="exception_safety_guarantees.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="implementation_notes.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-<div class="section" title="Type requirements">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="boost_optional.type_requirements"></a><a class="link" href="type_requirements.html" title="Type requirements">Type requirements</a>
 </h2></div></div></div>
--- a/doc/html/index.html
+++ b/doc/html/index.html
@ -3,8 +3,8 @@
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <title>Chapter<EFBFBD>1.<2E>Boost.Optional</title>
 <link rel="stylesheet" href="boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="index.html" title="Chapter<65>1.<2E>Boost.Optional">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="next" href="boost_optional/development.html" title="Development">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@ -18,7 +18,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav"><a accesskey="n" href="boost_optional/development.html"><img src="../../../../doc/html/images/next.png" alt="Next"></a></div>
-<div class="chapter" title="Chapter<EFBFBD>1.<2E>Boost.Optional">
+<div class="chapter" lang="en">
 <div class="titlepage"><div>
 <div><h2 class="title">
 <a name="optional"></a>Chapter<EFBFBD>1.<2E>Boost.Optional</h2></div>
@ -26,8 +26,8 @@
 <span class="firstname">Fernando Luis</span> <span class="surname">Cacciola Carballal</span>
 </h3></div></div>
 <div><p class="copyright">Copyright <20> 2003 -2007 Fernando Luis Cacciola Carballal</p></div>
-<div><div class="legalnotice" title="Legal Notice">
-<a name="id553943"></a><p>
+<div><div class="legalnotice">
+<a name="id2826039"></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>
@ -71,7 +71,7 @@
 <dt><span class="section"><a href="boost_optional/acknowledgments.html">Acknowledgments</a></span></dt>
 </dl>
 </div>
-<div class="section" title="Motivation">
+<div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="optional.motivation"></a><a class="link" href="index.html#optional.motivation" title="Motivation">Motivation</a>
 </h2></div></div></div>
@ -79,15 +79,15 @@
      Consider these functions which should return a value but which might not have
      a value to return:
    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
+<div class="itemizedlist"><ul type="disc">
+<li>
        (A) <code class="computeroutput"><span class="keyword">double</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">n</span>
        <span class="special">);</span></code>
 </li>
-<li class="listitem">
+<li>
        (B) <code class="computeroutput"><span class="keyword">char</span> <span class="identifier">get_async_input</span><span class="special">();</span></code>
 </li>
-<li class="listitem">
+<li>
        (C) <code class="computeroutput"><span class="identifier">point</span> <span class="identifier">polygon</span><span class="special">::</span><span class="identifier">get_any_point_effectively_inside</span><span class="special">();</span></code>
 </li>
 </ul></div>
@ -164,9 +164,15 @@
 </div>
 <p>
  </p>
+<a name="optional_refassign"></a><p>
+  </p>
+<a name="optional_in_place_factories"></a><p>
+  </p>
+<a name="optional_implementation_notes"></a><p>
+  </p>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: November 20, 2009 at 10:24:28 GMT</small></p></td>
+<td align="left"><p><small>Last revised: October 10, 2008 at 20:53:37 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
--- a/include/boost/none.hpp
+++ b/include/boost/none.hpp
@ -20,7 +20,7 @@

 namespace boost {

-none_t const none = (static_cast<none_t>(0)) ;
+none_t const none = ((none_t)0) ;

 } // namespace boost

--- a/include/boost/optional/optional.hpp
+++ b/include/boost/optional/optional.hpp
@ -1,4 +1,4 @@
-// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@ -9,9 +9,6 @@
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
-// Revisions:
-// 27 Apr 2008 (improved swap) Fernando Cacciola, Niels Dekker, Thorsten Ottosen
-// 
 #ifndef BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP
 #define BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP

@ -22,7 +19,6 @@
 #include "boost/assert.hpp"
 #include "boost/type.hpp"
 #include "boost/type_traits/alignment_of.hpp"
-#include "boost/type_traits/has_nothrow_constructor.hpp"
 #include "boost/type_traits/type_with_alignment.hpp"
 #include "boost/type_traits/remove_reference.hpp"
 #include "boost/type_traits/is_reference.hpp"
@ -32,7 +28,6 @@
 #include "boost/detail/reference_content.hpp"
 #include "boost/none.hpp"
 #include "boost/utility/compare_pointees.hpp"
-#include "boost/utility/in_place_factory.hpp"

 #include "boost/optional/optional_fwd.hpp"

@ -173,10 +168,8 @@ class optional_base : public optional_tag

    typedef BOOST_DEDUCED_TYPENAME is_reference<T>::type is_reference_predicate ;

-  public:
    typedef BOOST_DEDUCED_TYPENAME mpl::if_<is_reference_predicate,types_when_ref,types_when_not_ref>::type types ;

-  protected:
    typedef bool (this_type::*unspecified_bool_type)() const;

    typedef BOOST_DEDUCED_TYPENAME types::reference_type       reference_type ;
@ -523,7 +516,7 @@ class optional : public optional_detail::optional_base<T>

    // Creates a deep copy of another optional<T>
    // Can throw if T::T(T const&) does
-    optional ( optional const& rhs ) : base( static_cast<base const&>(rhs) ) {}
+    optional ( optional const& rhs ) : base(rhs) {}

   // No-throw (assuming T::~T() doesn't)
    ~optional() {}
@ -557,7 +550,7 @@ class optional : public optional_detail::optional_base<T>
    //  (NOTE: On BCB, this operator is not actually called and left is left UNMODIFIED in case of a throw)
    optional& operator= ( optional const& rhs )
      {
-        this->assign( static_cast<base const&>(rhs) ) ;
+        this->assign( rhs ) ;
        return *this ;
      }

@ -578,14 +571,6 @@ class optional : public optional_detail::optional_base<T>
        return *this ;
      }

-    void swap( optional & arg )
-      {
-        // allow for Koenig lookup
-        using boost::swap ;
-        swap(*this, arg);
-      }
-
-
    // Returns a reference to the value if this is initialized, otherwise,
    // the behaviour is UNDEFINED
    // No-throw
@ -893,77 +878,44 @@ namespace optional_detail {
 #define BOOST_OPTIONAL_STD_SWAP_INTRODUCED_AT_NS_SCOPE
 #endif

-  template<bool use_default_constructor> struct swap_selector;
-
-  template<>
-  struct swap_selector<true>
+// optional's swap:
+// If both are initialized, calls swap(T&, T&). If this swap throws, both will remain initialized but their values are now unspecified.
+// If only one is initialized, calls U.reset(*I), THEN I.reset().
+// If U.reset(*I) throws, both are left UNCHANGED (U is kept uinitialized and I is never reset)
+// If both are uninitialized, do nothing (no-throw)
+template<class T>
+inline
+void optional_swap ( optional<T>& x, optional<T>& y )
+{
+  if ( !x && !!y )
  {
-    template<class T>
-    static void optional_swap ( optional<T>& x, optional<T>& y )
-    {
-     bool hasX = x;
-     bool hasY = y;
-
-     if ( !hasX && !hasY )
-       return;
-
-     if( !hasX )
-         x = boost::in_place();
-     else if ( !hasY )
-         y = boost::in_place();
-
-   // GCC > 3.2 and all other compilers have the using declaration at function scope (FLC)
+    x.reset(*y);
+    y.reset();
+  }
+  else if ( !!x && !y )
+  {
+    y.reset(*x);
+    x.reset();
+  }
+  else if ( !!x && !!y )
+  {
+// GCC > 3.2 and all other compilers have the using declaration at function scope (FLC)
 #ifndef BOOST_OPTIONAL_STD_SWAP_INTRODUCED_AT_NS_SCOPE
-     // allow for Koenig lookup
-     using std::swap ;
+    // allow for Koenig lookup
+    using std::swap ;
 #endif
-     swap(*x,*y);
-
-     if( !hasX )
-         y = boost::none ;
-     else if( !hasY )
-         x = boost::none ;
-    }
-  };
-
-  template<>
-  struct swap_selector<false>
-  {
-    template<class T>
-    static void optional_swap ( optional<T>& x, optional<T>& y )
-    {
-      if ( !x && !!y )
-      {
-        x = *y;
-        y = boost::none ;
-      }
-      else if ( !!x && !y )
-      {
-        y = *x ;
-        x = boost::none ;
-      }
-      else if ( !!x && !!y )
-      {
-    // GCC > 3.2 and all other compilers have the using declaration at function scope (FLC)
-    #ifndef BOOST_OPTIONAL_STD_SWAP_INTRODUCED_AT_NS_SCOPE
-        // allow for Koenig lookup
-        using std::swap ;
-    #endif
-        swap(*x,*y);
-      }
-    }
-  };
+    swap(*x,*y);
+  }
+}

 } // namespace optional_detail

-template<class T>
-struct optional_swap_should_use_default_constructor : has_nothrow_default_constructor<T> {} ;
-
 template<class T> inline void swap ( optional<T>& x, optional<T>& y )
 {
-  optional_detail::swap_selector<optional_swap_should_use_default_constructor<T>::value>::optional_swap(x, y);
+  optional_detail::optional_swap(x,y);
 }

+
 } // namespace boost

 #endif
--- a/include/boost/optional/optional_fwd.hpp
+++ b/include/boost/optional/optional_fwd.hpp
@ -1,4 +1,4 @@
-// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@ -9,9 +9,6 @@
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
-// Revisions:
-// 10 May 2008 (added swap related forward declaration) Niels Dekker
-// 
 #ifndef BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP
 #define BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP

@ -19,10 +16,6 @@ namespace boost {

 template<class T> class optional ;

-template<class T> void swap ( optional<T>& , optional<T>& ) ;
-
-template<class T> struct optional_swap_should_use_default_constructor ;
-
 } // namespace boost

 #endif
--- a/test/optional_test.cpp
+++ b/test/optional_test.cpp
@ -1,4 +1,4 @@
-// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@ -9,9 +9,6 @@
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
-// Revisions:
-// 12 May 2008 (added more swap tests)
-//
 #include<iostream>
 #include<stdexcept>
 #include<string>
@ -19,8 +16,6 @@
 #define BOOST_ENABLE_ASSERT_HANDLER

 #include "boost/bind/apply.hpp" // Included just to test proper interaction with boost::apply<> as reported by Daniel Wallin
-#include "boost/mpl/bool.hpp"
-#include "boost/mpl/bool_fwd.hpp"  // For mpl::true_ and mpl::false_

 #include "boost/optional/optional.hpp"

@ -932,337 +927,6 @@ void test_conversions2()
  BOOST_CHECK(*get(&opt1) == static_cast<double>(f));
 }

-
-namespace optional_swap_test
-{
-  class default_ctor_exception : public std::exception {} ;
-  class copy_ctor_exception : public std::exception {} ;
-  class assignment_exception : public std::exception {} ;
-
-  //
-  // Base class for swap test classes.  Its assignment should not be called, when swapping
-  // optional<T> objects.  (The default std::swap would do so.)
-  //
-  class base_class_with_forbidden_assignment
-  {
-  public:
-    base_class_with_forbidden_assignment & operator=(const base_class_with_forbidden_assignment &)
-    {
-      BOOST_CHECK(!"The assignment should not be used while swapping!");
-      throw assignment_exception();
-    }
-
-    virtual ~base_class_with_forbidden_assignment() {}
-  };
-
-  //
-  // Class without default constructor
-  //
-  class class_without_default_ctor : public base_class_with_forbidden_assignment
-  {
-  public:
-    char data;
-    explicit class_without_default_ctor(char arg) : data(arg) {}
-  };
-
-  //
-  // Class whose default constructor should not be used by optional::swap!
-  //
-  class class_whose_default_ctor_should_not_be_used : public base_class_with_forbidden_assignment
-  {
-  public:
-    char data;
-    explicit class_whose_default_ctor_should_not_be_used(char arg) : data(arg) {}
-
-    class_whose_default_ctor_should_not_be_used()
-    {
-      BOOST_CHECK(!"This default constructor should not be used while swapping!");
-      throw default_ctor_exception();
-    }
-  };
-
-  //
-  // Class whose default constructor should be used by optional::swap.
-  // Its copy constructor should be avoided!
-  //
-  class class_whose_default_ctor_should_be_used : public base_class_with_forbidden_assignment
-  {
-  public:
-    char data;
-    explicit class_whose_default_ctor_should_be_used(char arg) : data(arg) { }
-
-    class_whose_default_ctor_should_be_used() : data('\0') { }
-
-    class_whose_default_ctor_should_be_used(const class_whose_default_ctor_should_be_used &)
-    {
-      BOOST_CHECK(!"This copy constructor should not be used while swapping!");
-      throw copy_ctor_exception();
-    }
-  };
-
-  //
-  // Class template whose default constructor should be used by optional::swap.
-  // Its copy constructor should be avoided!
-  //
-  template <class T>
-  class template_whose_default_ctor_should_be_used : public base_class_with_forbidden_assignment
-  {
-  public:
-    T data;
-    explicit template_whose_default_ctor_should_be_used(T arg) : data(arg) { }
-
-    template_whose_default_ctor_should_be_used() : data('\0') { }
-
-    template_whose_default_ctor_should_be_used(const template_whose_default_ctor_should_be_used &)
-    {
-      BOOST_CHECK(!"This copy constructor should not be used while swapping!");
-      throw copy_ctor_exception();
-    }
-  };
-
-  //
-  // Class whose explicit constructor should be used by optional::swap.
-  // Its other constructors should be avoided!
-  //
-  class class_whose_explicit_ctor_should_be_used : public base_class_with_forbidden_assignment
-  {
-  public:
-    char data;
-    explicit class_whose_explicit_ctor_should_be_used(char arg) : data(arg) { }
-
-    class_whose_explicit_ctor_should_be_used()
-    {
-      BOOST_CHECK(!"This default constructor should not be used while swapping!");
-      throw default_ctor_exception();
-    }
-
-    class_whose_explicit_ctor_should_be_used(const class_whose_explicit_ctor_should_be_used &)
-    {
-      BOOST_CHECK(!"This copy constructor should not be used while swapping!");
-      throw copy_ctor_exception();
-    }
-  };
-
-  void swap(class_whose_default_ctor_should_not_be_used & lhs, class_whose_default_ctor_should_not_be_used & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  void swap(class_whose_default_ctor_should_be_used & lhs, class_whose_default_ctor_should_be_used & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  void swap(class_without_default_ctor & lhs, class_without_default_ctor & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  void swap(class_whose_explicit_ctor_should_be_used & lhs, class_whose_explicit_ctor_should_be_used & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  template <class T>
-  void swap(template_whose_default_ctor_should_be_used<T> & lhs, template_whose_default_ctor_should_be_used<T> & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  //
-  // optional<T>::swap should be customized when neither the copy constructor
-  // nor the default constructor of T are supposed to be used when swapping, e.g.,
-  // for the following type T = class_whose_explicit_ctor_should_be_used.
-  //
-  void swap(boost::optional<class_whose_explicit_ctor_should_be_used> & x, boost::optional<class_whose_explicit_ctor_should_be_used> & y)
-  {
-    bool hasX = x;
-    bool hasY = y;
-
-    if ( !hasX && !hasY )
-     return;
-
-    if( !hasX )
-       x = boost::in_place('\0');
-    else if ( !hasY )
-       y = boost::in_place('\0');
-    
-    optional_swap_test::swap(*x,*y);
-
-     if( !hasX )
-         y = boost::none ;
-     else if( !hasY )
-         x = boost::none ;
-  }
-
-
-} // End of namespace optional_swap_test.
-
-
-namespace boost {
-
-//
-// Compile time tweaking on whether or not swap should use the default constructor:
-//
-
-template <> struct optional_swap_should_use_default_constructor<
-  optional_swap_test::class_whose_default_ctor_should_be_used> : mpl::true_ {} ;
-
-template <> struct optional_swap_should_use_default_constructor<
-  optional_swap_test::class_whose_default_ctor_should_not_be_used> : mpl::false_ {} ;
-
-template <class T> struct optional_swap_should_use_default_constructor<
-  optional_swap_test::template_whose_default_ctor_should_be_used<T> > : mpl::true_ {} ;
-
-
-//
-// Specialization of boost::swap:
-//
-template <> 
-void swap(optional<optional_swap_test::class_whose_explicit_ctor_should_be_used> & x, optional<optional_swap_test::class_whose_explicit_ctor_should_be_used> & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-} // namespace boost
-
-
-namespace std {
-
-//
-// Specializations of std::swap:
-//
-
-template <> 
-void swap(optional_swap_test::class_whose_default_ctor_should_be_used & x, optional_swap_test::class_whose_default_ctor_should_be_used & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-template <> 
-void swap(optional_swap_test::class_whose_default_ctor_should_not_be_used & x, optional_swap_test::class_whose_default_ctor_should_not_be_used & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-template <> 
-void swap(optional_swap_test::class_without_default_ctor & x, optional_swap_test::class_without_default_ctor & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-template <> 
-void swap(optional_swap_test::class_whose_explicit_ctor_should_be_used & x, optional_swap_test::class_whose_explicit_ctor_should_be_used & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-} // namespace std
-
-
-//
-// Tests whether the swap function works properly for optional<T>.
-// Assumes that T has one data member, of type char.
-// Returns true iff the test is passed.
-//
-template <class T>
-bool test_swap_function( T const* )
-{
-  const boost::unit_test::counter_t counter_before_test = boost::minimal_test::errors_counter();
-  try
-  {
-    optional<T> obj1;
-    optional<T> obj2('a');
-
-    // Self-swap should not have any effect.
-    swap(obj1, obj1);
-    swap(obj2, obj2);
-    BOOST_CHECK(!obj1);
-    BOOST_CHECK(!!obj2 && obj2->data == 'a');
-
-    // Call non-member swap.
-    swap(obj1, obj2);
-
-    // Test if obj1 and obj2 are really swapped.
-    BOOST_CHECK(!!obj1 && obj1->data == 'a');
-    BOOST_CHECK(!obj2);
-
-    // Call non-member swap one more time.
-    swap(obj1, obj2);
-
-    // Test if obj1 and obj2 are swapped back.
-    BOOST_CHECK(!obj1);
-    BOOST_CHECK(!!obj2 && obj2->data == 'a');
-  }
-  catch(const std::exception &)
-  {
-    // The swap function should not throw, for our test cases.
-    return false ;
-  }
-  return boost::minimal_test::errors_counter() == counter_before_test ;
-}
-
-//
-// Tests whether the optional<T>::swap member function works properly.
-// Assumes that T has one data member, of type char. 
-// Returns true iff the test is passed.
-//
-template <class T>
-bool test_swap_member_function( T const* )
-{
-  const boost::unit_test::counter_t counter_before_test = boost::minimal_test::errors_counter();
-  try
-  {
-    optional<T> obj1;
-    optional<T> obj2('a');
-
-    // Self-swap should not have any effect.
-    obj1.swap(obj1);
-    obj2.swap(obj2);
-    BOOST_CHECK(!obj1);
-    BOOST_CHECK(!!obj2 && obj2->data == 'a');
-
-    // Call member swap.
-    obj1.swap(obj2);
-
-    // Test if obj1 and obj2 are really swapped.
-    BOOST_CHECK(!!obj1 && obj1->data == 'a');
-    BOOST_CHECK(!obj2);
-
-    // Call member swap one more time.
-    obj1.swap(obj2);
-
-    // Test if obj1 and obj2 are swapped back.
-    BOOST_CHECK(!obj1);
-    BOOST_CHECK(!!obj2 && obj2->data == 'a');
-  }
-  catch(const std::exception &)
-  {
-    // The optional<T>::swap member function should not throw, for our test cases.
-    return false ;
-  }
-  return boost::minimal_test::errors_counter() == counter_before_test ;
-}
-
-
-//
-// Tests compile time tweaking of swap, by means of
-// optional_swap_should_use_default_constructor.
-//
-void test_swap_tweaking()
-{
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::class_without_default_ctor) ) );
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::class_whose_default_ctor_should_be_used) ) );
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::class_whose_default_ctor_should_not_be_used) ) );
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::class_whose_explicit_ctor_should_be_used) ) );
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::template_whose_default_ctor_should_be_used<char>) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::class_without_default_ctor) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::class_whose_default_ctor_should_be_used) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::class_whose_default_ctor_should_not_be_used) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::class_whose_explicit_ctor_should_be_used) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::template_whose_default_ctor_should_be_used<char>) ) );
-}
-
 int test_main( int, char* [] )
 {
  try
@ -1272,7 +936,6 @@ int test_main( int, char* [] )
    test_no_implicit_conversions();
    test_conversions1();
    test_conversions2();
-    test_swap_tweaking();
  }
  catch ( ... )
  {
Author	SHA1	Message	Date
Beman Dawes	b00cf30372	Release 1.41.0 [SVN r57747]	2009-11-18 14:58:26 +00:00
Troy D. Straszheim	04c1b67629	rm cmake from the release branch before it goes out broken. Policy dictates that you never commit to release, you commit to trunk and merge to release. [SVN r56941]	2009-10-17 01:10:45 +00:00
Troy D. Straszheim	a81ac6e5aa	Add basic copyright/license to keep cmake out of the inspection report [SVN r55095]	2009-07-22 21:51:01 +00:00
Jeremiah Willcock	fac0a7d65d	Fixed almost all tab and min/max issues found by inspect tool [SVN r53142]	2009-05-20 19:41:20 +00:00
Douglas Gregor	30419ed5e0	Add support for "known failures", which match the build name via a regular expression and are attached to test cases as a "known-failure" label. [SVN r53014]	2009-05-15 04:44:20 +00:00
John Maddock	41a677bdaf	Merge PDF build changes from Trunk. [SVN r51417]	2009-02-23 18:39:32 +00:00
Daniel James	313d15c56c	Merge several documentation fixes. Plus a small inspect fix. Merged revisions 50798-50799,50837-50839,50847-50848 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r50798 \| danieljames \| 2009-01-26 23:14:53 +0000 (Mon, 26 Jan 2009) \| 5 lines Make checking for duplicated names case insensitive. This avoids generating filenames with names that only differ by case as they cause problems on case insensitive file systems. ........ r50799 \| danieljames \| 2009-01-26 23:29:52 +0000 (Mon, 26 Jan 2009) \| 1 line Label the line ending inspect errors. ........ r50837 \| danieljames \| 2009-01-28 09:14:21 +0000 (Wed, 28 Jan 2009) \| 1 line Add scope exit to the root html file. ........ r50838 \| danieljames \| 2009-01-28 09:14:45 +0000 (Wed, 28 Jan 2009) \| 1 line Fix a link in the typeof forwarding html file. ........ r50839 \| danieljames \| 2009-01-28 09:14:56 +0000 (Wed, 28 Jan 2009) \| 1 line Fix an incorrectly escaped right arrow. ........ r50847 \| danieljames \| 2009-01-28 15:17:34 +0000 (Wed, 28 Jan 2009) \| 2 lines Fix some documentation issues with scope_exit. ........ r50848 \| danieljames \| 2009-01-28 15:32:46 +0000 (Wed, 28 Jan 2009) \| 1 line Generate the scope_exit documentation. ........ [SVN r50849]	2009-01-28 15:53:42 +00:00
Troy D. Straszheim	6b8df2a27d	merge of cmake build files from trunk per beman [SVN r50756]	2009-01-24 18:57:20 +00:00
Daniel James	e68e68276c	Rebuild the numeric/conversion and optional documentation. Which should fix a few links. [SVN r49259]	2008-10-10 21:35:16 +00:00
Daniel James	101bb76c18	Add minor documentation fixes to the release branch. (I left out the changes to the hash library). Merged via svnmerge from https://svn.boost.org/svn/boost/trunk ................ r44807 \| danieljames \| 2008-04-27 08:39:49 +0100 (Sun, 27 Apr 2008) \| 78 lines Merge in documentation fixes. Apart from the change to optional's documenation Jamfile, which I included by mistake. I wrote about this at: http://lists.boost.org/Archives/boost/2008/04/136405.php Merged revisions 44585-44806 via svnmerge from https://svn.boost.org/svn/boost/branches/doc ........ r44585 \| danieljames \| 2008-04-19 16:25:27 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix broken link to vacpp in bjam docs. ........ r44586 \| danieljames \| 2008-04-19 16:27:36 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix broken link to bcpp in bjam docs. ........ r44587 \| danieljames \| 2008-04-19 16:33:58 +0100 (Sat, 19 Apr 2008) \| 2 lines DateTime documentation - Fix a link to the serialization library. ........ r44588 \| danieljames \| 2008-04-19 16:35:36 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix some links in interprocess & intrusive. ........ r44589 \| danieljames \| 2008-04-19 16:37:39 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix some links in the python docs. ........ r44590 \| danieljames \| 2008-04-19 16:38:29 +0100 (Sat, 19 Apr 2008) \| 2 lines Work around a quickbook bug which is affecting the python docs. ........ r44591 \| danieljames \| 2008-04-19 16:39:34 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix a broken link in the numeric conversion docs. ........ r44592 \| danieljames \| 2008-04-19 16:40:45 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix some links in the optional docs. ........ r44593 \| danieljames \| 2008-04-19 16:42:09 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix link to the hash documentation from bimap. ........ r44599 \| danieljames \| 2008-04-19 18:07:33 +0100 (Sat, 19 Apr 2008) \| 2 lines Fix a typo in the format library. ........ r44600 \| danieljames \| 2008-04-19 19:20:59 +0100 (Sat, 19 Apr 2008) \| 1 line Initialise svnmerge. ........ r44641 \| danieljames \| 2008-04-20 18:59:47 +0100 (Sun, 20 Apr 2008) \| 2 lines Fix the lincense url in shared container iterator documentation. ........ r44642 \| danieljames \| 2008-04-20 19:00:00 +0100 (Sun, 20 Apr 2008) \| 2 lines Fix image link in the mpi documentation. ........ r44643 \| danieljames \| 2008-04-20 19:00:11 +0100 (Sun, 20 Apr 2008) \| 2 lines Fix a typo in the spirit docs. ........ r44644 \| danieljames \| 2008-04-20 19:00:23 +0100 (Sun, 20 Apr 2008) \| 2 lines Escape the slash so that quickbook doesn't think it the start of an italic section, and mess up the link. Refs #1844 ........ r44647 \| danieljames \| 2008-04-20 19:39:47 +0100 (Sun, 20 Apr 2008) \| 2 lines Fix another typo in spirit docs. ........ ................ r45232 \| danieljames \| 2008-05-08 22:50:19 +0100 (Thu, 08 May 2008) \| 1 line Fix some invalid xml by replacing ampersands with character entities. ................ r45576 \| danieljames \| 2008-05-20 16:39:25 +0100 (Tue, 20 May 2008) \| 20 lines Merge some small documentation fixes from the doc branch, and mark some previously merged changes as merged. Merged revisions 44811,45129,45142,45154,45281-45282,45365 via svnmerge from https://svn.boost.org/svn/boost/branches/doc ........ r45129 \| danieljames \| 2008-05-05 12:36:50 +0100 (Mon, 05 May 2008) \| 2 lines Update navbar links in boostbook. ........ r45282 \| danieljames \| 2008-05-11 14:15:31 +0100 (Sun, 11 May 2008) \| 2 lines Group functions in the hash header - requires Frank's free-function-group fix. (not included in release branch). ........ r45365 \| danieljames \| 2008-05-14 21:39:00 +0100 (Wed, 14 May 2008) \| 2 lines Add boost.root to standalone hash documentation. (not included in release branch). ........ ................ [SVN r45622]	2008-05-21 20:57:05 +00:00
Daniel James	5a1938ccf7	Rebuild a lot of documentation. [SVN r43650]	2008-03-16 11:38:32 +00:00
Matias Capeletto	4c11dcc703	optional docs new version [SVN r43257]	2008-02-14 19:35:00 +00:00
Beman Dawes	eb19cc2729	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41370]	2007-11-25 18:38:02 +00:00
Beman Dawes	5956702c32	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41369]	2007-11-25 18:07:19 +00:00
Beman Dawes	4ba562871e	Starting point for releases [SVN r39706]	2007-10-05 14:25:06 +00:00
nobody	3ff4258fbb	This commit was manufactured by cvs2svn to create tag 'Version_1_34_1'. [SVN r38286]	2007-07-24 19:28:14 +00:00
Stefan Seefeld	35040aab6a	Add missing newline at eof. [SVN r37425]	2007-04-12 19:43:30 +00:00
Fernando Cacciola	bfd5cc0a87	Updated single-header implementation [SVN r37420]	2007-04-12 14:25:21 +00:00
Fernando Cacciola	0fd45d73b1	Doc update to reflect latest additions [SVN r37368]	2007-04-05 18:55:22 +00:00
Fernando Cacciola	3bf8d0f1b4	Fixed incorrect BORLANDC macro [SVN r37314]	2007-03-28 21:26:19 +00:00
Fernando Cacciola	789cb2b24f	boost::none implementation fixed for bcc <= 5.6.4 [SVN r37301]	2007-03-27 16:02:57 +00:00
Fernando Cacciola	7287f2bf11	in_palce_factory.apply problem fixed [SVN r37157]	2007-03-07 20:17:23 +00:00
Fernando Cacciola	b6a1946a60	none_t/none reimplemented to avoid precompiled header issues (thanks to Joe Gottam) optional<T> now has direct relational operator optional<T>::operator-> fixed for reference types [SVN r37126]	2007-03-01 23:08:33 +00:00
Fernando Cacciola	9bbde2be14	Fixed operator->() for optional references. [SVN r37125]	2007-03-01 21:50:12 +00:00
Fernando Cacciola	f258713788	Fixed operator->() for optional references. [SVN r37124]	2007-03-01 21:39:25 +00:00
Beman Dawes	3dc3f46d66	Merged copyright and license addition [SVN r35907]	2006-11-07 19:27:00 +00:00
Rene Rivera	c23c21d9c2	Remove obsolete Boost.Build v1 files. [SVN r35880]	2006-11-06 17:10:46 +00:00
Dave Abrahams	5182283649	misused "precedence" changed to "precedent" [SVN r35831]	2006-11-04 02:13:53 +00:00
Gennaro Prota	4599ae0bfd	merge from head [removed unnamed namespace (see http://lists.boost.org/Archives/boost/2006/07/107873.php ); usual copyright/license/url fixes] [SVN r34647]	2006-07-20 23:23:09 +00:00
Dave Abrahams	9ccefc8349	workaround for Borland [SVN r34288]	2006-06-12 19:02:41 +00:00
Hartmut Kaiser	0961a6598a	Disambiguated certain constructs. [SVN r34226]	2006-06-08 01:39:40 +00:00
nobody	03248b5fd8	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r33417]	2006-03-21 02:26:31 +00:00