Branch to work on filename handling without disturbing trunk.

[SVN r68345]
Refs #4987 . Added forward declaration of namespace-scope swap for boost::optional, this should fix GCC compilation errors. Also swap implementation now uses Boost.Utility.Swap to make use of the workarounds for some broken compilers. If it breaks for your compiler, let me know in the mentioned ticket.
2025-07-12 20:06:36 +02:00 · 2011-01-21 09:17:08 +00:00 · 2010-12-17 21:12:56 +00:00 · 2010-12-12 11:35:19 +00:00 · 2010-12-08 18:32:36 +00:00 · 2010-12-08 17:53:29 +00:00
26 changed files with 508 additions and 481 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,22 +0,0 @@
-#----------------------------------------------------------------------------
-# This file was automatically generated from the original CMakeLists.txt file
-# Add a variable to hold the headers for the library
-set (lib_headers
-    optional.hpp
-    optional
-)
-
-# Add a library target to the build system
-boost_library_project(
-  optional
-  #  SRCDIRS 
-  TESTDIRS  test
-  HEADERS ${lib_headers}
-  DOCDIRS doc
-  #  DESCRIPTION 
-  MODULARIZED 
-  #  AUTHORS 
-  #  MAINTAINERS 
-)
-
-
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@ -1,2 +0,0 @@
-boost_add_documentation(optional.qbk)
-
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -24,7 +24,7 @@ boostbook standalone
        optional
    :
        <xsl:param>boost.root=../../../..
-        <xsl:param>boost.libraries=../../../libraries.htm
+        <xsl:param>html.stylesheet=boostbook.css
        <xsl:param>toc.max.depth=2
        <xsl:param>toc.section.depth=2
        <xsl:param>chunk.section.depth=1
--- a/doc/html/boost_optional/a_note_about_optional_bool_.html
+++ b/doc/html/boost_optional/a_note_about_optional_bool_.html
@ -3,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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">
@ -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" lang="en">
+<div class="section" title="A note about optional&lt;bool&gt;">
 <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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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">
@ -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" lang="en">
+<div class="section" title="Acknowledgments">
 <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="id704954"></a>
+<a name="id583998"></a>
      <a class="link" href="acknowledgments.html#boost_optional.acknowledgments.pre_formal_review">Pre-formal
      review</a>
    </h4>
-<div class="itemizedlist"><ul type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
        Peter Dimov suggested the name 'optional', and was the first to point out
        the need for aligned storage.
      </li>
-<li>
+<li class="listitem">
        Douglas Gregor developed 'type_with_alignment', and later Eric Friedman coded
        'aligned_storage', which are the core of the optional class implementation.
      </li>
-<li>
+<li class="listitem">
        Andrei Alexandrescu and Brian Parker also worked with aligned storage techniques
        and their work influenced the current implementation.
      </li>
-<li>
+<li class="listitem">
        Gennadiy Rozental made extensive and important comments which shaped the
        design.
      </li>
-<li>
+<li class="listitem">
        Vesa Karvonen and Douglas Gregor made quite useful comparisons between optional,
        variant and any; and made other relevant comments.
      </li>
-<li>
+<li class="listitem">
        Douglas Gregor and Peter Dimov commented on comparisons and evaluation in
        boolean contexts.
      </li>
-<li>
+<li class="listitem">
        Eric Friedman helped understand the issues involved with aligned storage,
        move/copy operations and exception safety.
      </li>
-<li>
+<li class="listitem">
        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="id705000"></a>
+<a name="id584068"></a>
      <a class="link" href="acknowledgments.html#boost_optional.acknowledgments.post_formal_review">Post-formal
      review</a>
    </h4>
-<div class="itemizedlist"><ul type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
        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>
+<li class="listitem">
        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>
+<li class="listitem">
        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>
+<li class="listitem">
        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>
+<li class="listitem">
        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>
+<li class="listitem">
        Other comments were posted by Vincent Finn, Anthony Williams, Ed Brey, Rob
        Stewart, and others.
      </li>
-<li>
+<li class="listitem">
        Joel de Guzman made the case for the support of references and helped with
        the proper semantics.
      </li>
-<li>
+<li class="listitem">
        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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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">
@ -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" lang="en">
+<div class="section" title="Dependencies and Portability">
 <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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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">
@ -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" lang="en">
+<div class="section" title="Detailed Semantics">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
        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>
+<li class="listitem">
        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>
+<li class="listitem">
        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"><table border="0" summary="Note">
+<div class="note" title="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="id677650"></a>
+<a name="id560085"></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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Effect:</strong></span> Default-Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
        Notes: T's default constructor <span class="underline">is not</span>
        called.
      </li>
-<li>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Effect:</strong></span> Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>
        uninitialized.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Effect:</strong></span> Directly-Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Effect:</strong></span> Directly-Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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 type="disc"><li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
        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 type="disc"><li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
        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="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="error">'</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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Effect:</strong></span> Copy-Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Effect:</strong></span> Copy-Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Effect:</strong></span> Copy-Constructs an <code class="computeroutput"><span class="identifier">optional</span></code>.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<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
        Factories</a>
 </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Effect:</strong></span> (Re)binds thee wrapped reference.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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.
      </li>
-<li>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Effect:</strong></span> (Re)binds thee wrapped reference.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
        for details on this behavior.
      </li>
-<li>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Effect:</strong></span> Assigns another convertible optional
        to an optional.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc"><li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
 <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 type="disc"><li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Requirements:</strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initialized
      </li>
-<li>
+<li class="listitem">
 <span class="bold"><strong>Returns:</strong></span> A reference to the contained value
      </li>
-<li>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Requirements: </strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initialized
      </li>
-<li>
+<li class="listitem">
 <span class="bold"><strong>Returns:</strong></span><span class="underline">The</span>
        reference contained.
      </li>
-<li>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Requirements: </strong></span><code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is initialized.
      </li>
-<li>
+<li class="listitem">
 <span class="bold"><strong>Returns:</strong></span> A pointer to the contained value.
      </li>
-<li>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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="id692371"></a>
+<a name="id572503"></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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
 </ul></div>
@ -1542,13 +1542,13 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
 </ul></div>
@ -1568,12 +1568,12 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
 </ul></div>
@ -1593,12 +1593,12 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Throws:</strong></span> Nothing.
      </li>
 </ul></div>
@ -1618,37 +1618,37 @@
 <p>
      </p>
 </blockquote></div>
-<div class="itemizedlist"><ul type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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">
@ -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" lang="en">
+<div class="section" title="Development">
 <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" lang="en">
+<div class="section" title="The models">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>deep-copy</strong></span> semantics: copies of the variant
          implies copies of the value.
        </li>
-<li>
+<li class="listitem">
 <span class="bold"><strong>deep-relational</strong></span> semantics: comparisons
          between variants matches both current types and values
        </li>
-<li>
+<li class="listitem">
          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>
+<li class="listitem">
          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>
+<li class="listitem">
          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>
+<li class="listitem">
          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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>deep-copy</strong></span> semantics: copies of the container
          implies copies of the value.
        </li>
-<li>
+<li class="listitem">
 <span class="bold"><strong>deep-relational</strong></span> semantics: comparisons
          between containers compare container size and if match, contained value
        </li>
-<li>
+<li class="listitem">
          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>
+<li class="listitem">
          If the container is empty, it is modeling an <span class="emphasis"><em>uninitialized</em></span>
          optional.
        </li>
-<li>
+<li class="listitem">
          Testing if the container is empty models testing if the optional is initialized
        </li>
-<li>
+<li class="listitem">
          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" lang="en">
+<div class="section" title="The semantics">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="bold"><strong>Default Construction:</strong></span> To introduce a formally
          uninitialized wrapped object.
        </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Deep Copy Construction:</strong></span> To obtain a new
          yet equivalent wrapped object.
        </li>
-<li>
+<li class="listitem">
 <span class="bold"><strong>Direct Value Assignment (upon initialized):</strong></span>
          To assign a value to the wrapped object.
        </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Assignment (upon initialized):</strong></span> To assign
          to the wrapped object the value of another wrapped object.
        </li>
-<li>
+<li class="listitem">
 <span class="bold"><strong>Assignment (upon uninitialized):</strong></span> To initialize
          the wrapped object with value of another wrapped object.
        </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <span class="bold"><strong>Value access:</strong></span> To unwrap the wrapped object.
        </li>
-<li>
+<li class="listitem">
 <span class="bold"><strong>Initialization state query:</strong></span> To determine
          if the object is formally initialized or not.
        </li>
-<li>
+<li class="listitem">
 <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>
+<li class="listitem">
 <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" lang="en">
+<div class="section" title="The Interface">
 <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="id672645"></a>
+<a name="id555569"></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="id672851"></a>
+<a name="id555831"></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"><table border="0" summary="Warning">
+<div class="warning" title="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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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">
@ -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" lang="en">
+<div class="section" title="Examples">
 <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" lang="en">
+<div class="section" title="Optional return values">
 <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" lang="en">
+<div class="section" title="Optional local variables">
 <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" lang="en">
+<div class="section" title="Optional data members">
 <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" lang="en">
+<div class="section" title="Bypassing expensive unnecessary default construction">
 <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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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;">
@ -22,7 +22,7 @@
 <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" lang="en">
+<div class="section" title="Exception Safety Guarantees">
 <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>
@ -31,21 +31,21 @@
      Because of the current implementation (see <a class="link" href="implementation_notes.html" title="Implementation Notes">Implementation
      Notes</a>), all of the assignment methods:
    </p>
-<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>
+<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>
        <span class="keyword">const</span><span class="special">&amp;</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="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>
+<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>
        <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">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 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>
        <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">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 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>
        <span class="keyword">const</span><span class="special">&amp;</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> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</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>
 </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 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>
+<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>
 </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="id704586"></a>
+<a name="id583497"></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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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">
@ -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" lang="en">
+<div class="section" title="Implementation Notes">
 <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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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">
@ -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" lang="en">
+<div class="section" title="In-Place Factories">
 <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>
@ -127,12 +127,12 @@
 <p>
      The factories are divided in two groups:
    </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
 <span class="underline">TypedInPlaceFactories</span>: those which
        take the target type as a primary template parameter.
      </li>
-<li>
+<li class="listitem">
 <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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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">
@ -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" lang="en">
+<div class="section" title="Optional references">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
        Converting constructors
      </li>
-<li>
+<li class="listitem">
        Converting assignment
      </li>
-<li>
+<li class="listitem">
        InPlace construction
      </li>
-<li>
+<li class="listitem">
        InPlace assignment
      </li>
-<li>
+<li class="listitem">
        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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
        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>
+<li class="listitem">
        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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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">
@ -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" lang="en">
+<div class="section" title="Rebinding semantics for assignment of optional references">
 <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="id699431"></a>
+<a name="id579234"></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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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">
@ -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" lang="en">
+<div class="section" title="Synopsis">
 <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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" 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">
@ -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" lang="en">
+<div class="section" title="Type requirements">
 <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,7 +3,7 @@
 <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.74.0">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="index.html" title="Chapter<65>1.<2E>Boost.Optional">
 <link rel="next" href="boost_optional/development.html" title="Development">
 </head>
@ -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" lang="en">
+<div class="chapter" title="Chapter<EFBFBD>1.<2E>Boost.Optional">
 <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">
-<a name="id663349"></a><p>
+<div><div class="legalnotice" title="Legal Notice">
+<a name="id553943"></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" lang="en">
+<div class="section" title="Motivation">
 <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 type="disc">
-<li>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
        (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>
+<li class="listitem">
        (B) <code class="computeroutput"><span class="keyword">char</span> <span class="identifier">get_async_input</span><span class="special">();</span></code>
 </li>
-<li>
+<li class="listitem">
        (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>
@ -166,7 +166,7 @@
  </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: February 09, 2009 at 11:55:08 GMT</small></p></td>
+<td align="left"><p><small>Last revised: November 20, 2009 at 10:24:28 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
--- a/include/boost/detail/none_t.hpp
+++ b/include/boost/detail/none_t.hpp
@ -4,7 +4,7 @@
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// See http://www.boost.org/lib/optional for documentation.
+// See http://www.boost.org/libs/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
--- a/include/boost/none.hpp
+++ b/include/boost/none.hpp
@ -20,7 +20,7 @@

 namespace boost {

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

 } // namespace boost

--- a/include/boost/optional/optional.hpp
+++ b/include/boost/optional/optional.hpp
@ -4,37 +4,39 @@
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// See http://www.boost.org/lib/optional for documentation.
+// See http://www.boost.org/libs/optional for documentation.
 //
 // 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

-#include<new>
-#include<algorithm>
+#include <new>
+#include <algorithm>

-#include "boost/config.hpp"
-#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"
-#include "boost/mpl/if.hpp"
-#include "boost/mpl/bool.hpp"
-#include "boost/mpl/not.hpp"
-#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/config.hpp>
+#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>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/detail/reference_content.hpp>
+#include <boost/none.hpp>
+#include <boost/utility/swap.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/utility/compare_pointees.hpp>
+#include <boost/utility/in_place_factory.hpp>

-#include "boost/optional/optional_fwd.hpp"
+#include <boost/optional/optional_fwd.hpp>

 #if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
 // VC6.0 has the following bug:
@ -81,6 +83,15 @@
 #define BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
 #endif

+#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) > 302 \
+    && !defined(__INTEL_COMPILER)
+// GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with
+// regard to violation of the strict aliasing rules. The optional< T > storage type is marked
+// with this attribute in order to let the compiler know that it will alias objects of type T
+// and silence compilation warnings.
+#define BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS
+#endif
+
 // Daniel Wallin discovered that bind/apply.hpp badly interacts with the apply<>
 // member template of a factory as used in the optional<> implementation.
 // He proposed this simple fix which is to move the call to apply<> outside
@ -88,7 +99,7 @@
 namespace boost_optional_detail
 {
  template <class T, class Factory>
-  void construct(Factory const& factory, void* address)
+  inline void construct(Factory const& factory, void* address)
  {
    factory.BOOST_NESTED_TEMPLATE apply<T>(address);
  }
@ -100,6 +111,9 @@ namespace boost {
 class in_place_factory_base ;
 class typed_in_place_factory_base ;

+// This forward is needed to refer to namespace scope swap from the member swap
+template<class T> void swap ( optional<T>& x, optional<T>& y );
+
 namespace optional_detail {

 // This local class is used instead of that in "aligned_storage.hpp"
@ -110,7 +124,12 @@ template <class T>
 class aligned_storage
 {
    // Borland ICEs if unnamed unions are used for this!
-    union dummy_u
+    union
+    // This works around GCC warnings about breaking strict aliasing rules when casting storage address to T*
+#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
+    __attribute__((may_alias))
+#endif
+    dummy_u
    {
        char data[ sizeof(T) ];
        BOOST_DEDUCED_TYPENAME type_with_alignment<
@ -119,8 +138,13 @@ class aligned_storage

  public:

-    void const* address() const { return &dummy_.data[0]; }
-    void      * address()       { return &dummy_.data[0]; }
+#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
+    void const* address() const { return &dummy_; }
+    void      * address()       { return &dummy_; }
+#else
+    void const* address() const { return dummy_.data; }
+    void      * address()       { return dummy_.data; }
+#endif
 } ;

 template<class T>
@ -154,7 +178,7 @@ class optional_base : public optional_tag
    typedef
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
    BOOST_DEDUCED_TYPENAME
-#endif 
+#endif
    ::boost::detail::make_reference_content<T>::type internal_type ;

    typedef aligned_storage<internal_type> storage_type ;
@ -173,8 +197,10 @@ 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 ;
@ -203,7 +229,7 @@ class optional_base : public optional_tag
    {
      construct(val);
    }
-    
+
    // Creates an optional<T> initialized with 'val' IFF cond is true, otherwise creates an uninitialzed optional<T>.
    // Can throw if T::T(T const&) does
    optional_base ( bool cond, argument_type val )
@ -424,8 +450,22 @@ class optional_base : public optional_tag
  private :

    // internal_type can be either T or reference_content<T>
+#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
+    // This workaround is supposed to silence GCC warnings about broken strict aliasing rules
+    internal_type const* get_object() const
+    {
+        union { void const* ap_pvoid; internal_type const* as_ptype; } caster = { m_storage.address() };
+        return caster.as_ptype;
+    }
+    internal_type *      get_object()
+    {
+        union { void* ap_pvoid; internal_type* as_ptype; } caster = { m_storage.address() };
+        return caster.as_ptype;
+    }
+#else
    internal_type const* get_object() const { return static_cast<internal_type const*>(m_storage.address()); }
    internal_type *      get_object()       { return static_cast<internal_type *>     (m_storage.address()); }
+#endif

    // reference_content<T> lacks an implicit conversion to T&, so the following is needed to obtain a proper reference.
    reference_const_type dereference( internal_type const* p, is_not_reference_tag ) const { return *p ; }
@ -516,7 +556,7 @@ class optional : public optional_detail::optional_base<T>
    // Depending on the above some T ctor is called.
    // Can throw is the resolved T ctor throws.
    template<class Expr>
-    explicit optional ( Expr const& expr ) : base(expr,&expr) {}
+    explicit optional ( Expr const& expr ) : base(expr,boost::addressof(expr)) {}
 #endif

    // Creates a deep copy of another optional<T>
@ -530,9 +570,9 @@ class optional : public optional_detail::optional_base<T>
    // Assigns from an expression. See corresponding constructor.
    // Basic Guarantee: If the resolved T ctor throws, this is left UNINITIALIZED
    template<class Expr>
-    optional& operator= ( Expr expr )
+    optional& operator= ( Expr const& expr )
      {
-        this->assign_expr(expr,&expr);
+        this->assign_expr(expr,boost::addressof(expr));
        return *this ;
      }
 #endif
@ -579,7 +619,7 @@ class optional : public optional_detail::optional_base<T>
    void swap( optional & arg )
      {
        // allow for Koenig lookup
-        using boost::swap ;
+        using boost::swap;
        swap(*this, arg);
      }

@ -593,7 +633,7 @@ class optional : public optional_detail::optional_base<T>
    // Returns a copy of the value if this is initialized, 'v' otherwise
    reference_const_type get_value_or ( reference_const_type v ) const { return this->is_initialized() ? get() : v ; }
    reference_type       get_value_or ( reference_type       v )       { return this->is_initialized() ? get() : v ; }
-    
+
    // Returns a pointer to the value if this is initialized, otherwise,
    // the behaviour is UNDEFINED
    // No-throw
@ -610,22 +650,22 @@ class optional : public optional_detail::optional_base<T>
    // No-throw
    operator unspecified_bool_type() const { return this->safe_bool() ; }

-       // This is provided for those compilers which don't like the conversion to bool
-       // on some contexts.
-       bool operator!() const { return !this->is_initialized() ; }
+    // This is provided for those compilers which don't like the conversion to bool
+    // on some contexts.
+    bool operator!() const { return !this->is_initialized() ; }
 } ;

 // Returns optional<T>(v)
-template<class T> 
-inline 
+template<class T>
+inline
 optional<T> make_optional ( T const& v  )
 {
  return optional<T>(v);
 }

 // Returns optional<T>(cond,v)
-template<class T> 
-inline 
+template<class T>
+inline
 optional<T> make_optional ( bool cond, T const& v )
 {
  return optional<T>(cond,v);
@ -878,79 +918,63 @@ inline
 bool operator >= ( none_t x, optional<T> const& y )
 { return !( x < y ) ; }

-//
-// The following swap implementation follows the GCC workaround as found in
-//  "boost/detail/compressed_pair.hpp"
-//
 namespace optional_detail {

-// GCC < 3.2 gets the using declaration at namespace scope (FLC, DWA)
-#if BOOST_WORKAROUND(__GNUC__, < 3)                             \
-    || BOOST_WORKAROUND(__GNUC__, == 3) && __GNUC_MINOR__ <= 2
-   using std::swap;
-#define BOOST_OPTIONAL_STD_SWAP_INTRODUCED_AT_NS_SCOPE
-#endif
+template<bool use_default_constructor> struct swap_selector;

-  template<bool use_default_constructor> struct swap_selector;
-
-  template<>
-  struct swap_selector<true>
-  {
+template<>
+struct swap_selector<true>
+{
    template<class T>
    static void optional_swap ( optional<T>& x, optional<T>& y )
    {
-     bool hasX = x;
-     bool hasY = y;
+        const bool hasX = !!x;
+        const bool hasY = !!y;

-     if ( !hasX && !hasY )
-       return;
+        if ( !hasX && !hasY )
+            return;

-     if( !hasX )
-         x = boost::in_place();
-     else if ( !hasY )
-         y = boost::in_place();
+        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)
-#ifndef BOOST_OPTIONAL_STD_SWAP_INTRODUCED_AT_NS_SCOPE
-     // allow for Koenig lookup
-     using std::swap ;
-#endif
-     swap(*x,*y);
+        // Boost.Utility.Swap will take care of ADL and workarounds for broken compilers
+        boost::swap(x.get(),y.get());

-     if( !hasX )
-         y = boost::none ;
-     else if( !hasY )
-         x = boost::none ;
+        if( !hasX )
+            y = boost::none ;
+        else if( !hasY )
+            x = boost::none ;
    }
-  };
+};

-  template<>
-  struct swap_selector<false>
-  {
+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);
-      }
+        const bool hasX = !!x;
+        const bool hasY = !!y;
+
+        if ( !hasX && hasY )
+        {
+            x = y.get();
+            y = boost::none ;
+        }
+        else if ( hasX && !hasY )
+        {
+            y = x.get();
+            x = boost::none ;
+        }
+        else if ( hasX && hasY )
+        {
+            // Boost.Utility.Swap will take care of ADL and workarounds for broken compilers
+            boost::swap(x.get(),y.get());
+        }
    }
-  };
+};

 } // namespace optional_detail

@ -959,10 +983,9 @@ struct optional_swap_should_use_default_constructor : has_nothrow_default_constr

 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::swap_selector<optional_swap_should_use_default_constructor<T>::value>::optional_swap(x, y);
 }

 } // namespace boost

 #endif
-
--- a/include/boost/optional/optional_fwd.hpp
+++ b/include/boost/optional/optional_fwd.hpp
@ -4,7 +4,7 @@
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// See http://www.boost.org/lib/optional for documentation.
+// See http://www.boost.org/libs/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
--- a/include/boost/optional/optional_io.hpp
+++ b/include/boost/optional/optional_io.hpp
@ -4,7 +4,7 @@
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// See http://www.boost.org/lib/optional for documentation.
+// See http://www.boost.org/libs/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
@ -13,19 +13,20 @@
 #define BOOST_OPTIONAL_OPTIONAL_IO_FLC_19NOV2002_HPP

 #if defined __GNUC__
-#  if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) 
+#  if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97)
 #    define BOOST_OPTIONAL_NO_TEMPLATED_STREAMS
 #  endif
 #endif // __GNUC__

 #if defined BOOST_OPTIONAL_NO_TEMPLATED_STREAMS
 #  include <iostream>
-#else 
+#else
 #  include <istream>
 #  include <ostream>
-#endif  
-
+#endif

+#include <boost/none.hpp>
+#include <boost/assert.hpp>
 #include "boost/optional/optional.hpp"
 #include "boost/utility/value_init.hpp"

@ -62,17 +63,30 @@ std::basic_istream<CharType, CharTrait>&
 operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v)
 #endif
 {
-  if ( in.good() )
+  if (in.good())
  {
    int d = in.get();
-    if ( d == ' ' )
+    if (d == ' ')
    {
-      T x ;
+      T x;
      in >> x;
-      v = x ;
+      v = x;
    }
    else
-      v = optional<T>() ;
+    {
+      if (d == '-')
+      {
+        d = in.get();
+
+        if (d == '-')
+        {
+          v = none;
+          return in;
+        }
+      }
+
+      in.setstate( std::ios::failbit );
+    }
  }

  return in;
--- a/module.cmake
+++ b/module.cmake
@ -1 +0,0 @@
-boost_module(optional DEPENDS utility)
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@ -1,16 +0,0 @@
-boost_additional_test_dependencies(optional BOOST_DEPENDS test tuple)
-
-
-boost_test_run(optional_test)
-boost_test_run(optional_test_tie)
-boost_test_run(optional_test_ref)
-boost_test_run(optional_test_inplace)
-boost_test_run(optional_test_io)
-boost_test_compile_fail(optional_test_fail1)
-boost_test_compile_fail(optional_test_fail3a)
-boost_test_compile_fail(optional_test_fail3b)
-boost_test_compile_fail(optional_test_ref_fail1)
-boost_test_compile_fail(optional_test_ref_fail3)
-boost_test_compile_fail(optional_test_ref_fail4)
-boost_test_compile_fail(optional_test_inplace_fail)
-boost_test_compile_fail(optional_test_inplace_fail2)
--- a/test/optional_test.cpp
+++ b/test/optional_test.cpp
@ -158,27 +158,27 @@ void test_basics( T const* )
  ob.reset();
  check_is_pending_dtor( ARG(T) ) ;
  check_uninitialized(ob);
-  
+
 }

 template<class T>
 void test_conditional_ctor_and_get_valur_or ( T const* )
 {
  TRACE( std::endl << BOOST_CURRENT_FUNCTION  );
-  
+
  T a(321);
-  
+
  T z(123);
-  
+
  optional<T> const cdef0(false,a);
-  
+
  optional<T> def0(false,a);
  optional<T> def1 = boost::make_optional(false,a); //  T is not within boost so ADL won't find make_optional unqualified
  check_uninitialized(def0);
  check_uninitialized(def1);

  optional<T> const co0(true,a);
-  
+
  optional<T> o0(true,a);
  optional<T> o1 = boost::make_optional(true,a); //  T is not within boost so ADL won't find make_optional unqualified

@ -186,65 +186,65 @@ void test_conditional_ctor_and_get_valur_or ( T const* )
  check_initialized(o1);
  check_value(o0,a,z);
  check_value(o1,a,z);
-  
+
  T b = def0.get_value_or(z);
  BOOST_CHECK( b == z ) ;
-  
+
  b = get_optional_value_or(def0,z);
  BOOST_CHECK( b == z ) ;
-  
+
  b = o0.get_value_or(z);
  BOOST_CHECK( b == a ) ;

  b = get_optional_value_or(o0,z);
  BOOST_CHECK( b == a ) ;
-  
-  
+
+
  T const& crz = z ;
  T&        rz = z ;
-  
+
  T const& crzz = def0.get_value_or(crz);
  BOOST_CHECK( crzz == crz ) ;
-  
+
  T& rzz = def0.get_value_or(rz);
  BOOST_CHECK( rzz == rz ) ;
-  
+
  T const& crzzz = get_optional_value_or(cdef0,crz);
  BOOST_CHECK( crzzz == crz ) ;
-  
+
  T& rzzz = get_optional_value_or(def0,rz);
  BOOST_CHECK( rzzz == rz ) ;
-  
+
  T const& crb = o0.get_value_or(crz);
  BOOST_CHECK( crb == a ) ;
-  
+
  T& rb = o0.get_value_or(rz);
  BOOST_CHECK( rb == b ) ;
-  
+
  T const& crbb = get_optional_value_or(co0,crz);
  BOOST_CHECK( crbb == b ) ;
-  
+
  T const& crbbb = get_optional_value_or(o0,crz);
  BOOST_CHECK( crbbb == b ) ;
-  
+
  T& rbb = get_optional_value_or(o0,rz);
  BOOST_CHECK( rbb == b ) ;
-  
+
  T& ra = a ;
-  
+
  optional<T&> defref(false,ra);
  BOOST_CHECK(!defref);
-  
+
  optional<T&> ref(true,ra);
  BOOST_CHECK(!!ref);
-  
+
  a = T(432);
-  
+
  BOOST_CHECK( *ref == a ) ;
-  
+
  T& r1 = defref.get_value_or(z);
  BOOST_CHECK( r1 == z ) ;
-  
+
  T& r2 = ref.get_value_or(z);
  BOOST_CHECK( r2 == a ) ;
 }
@ -718,7 +718,7 @@ void test_relops( T const* )
  optional<T> opt0(v0);
  optional<T> opt1(v1);
  optional<T> opt2(v2);
-  
+
  // Check identity
  BOOST_CHECK ( def0 == def0 ) ;
  BOOST_CHECK ( opt0 == opt0 ) ;
@ -756,7 +756,7 @@ void test_relops( T const* )
  BOOST_CHECK ( opt1 >  opt0 ) ;
  BOOST_CHECK ( opt1 <= opt2 ) ;
  BOOST_CHECK ( opt1 >= opt0 ) ;
-  
+
  // Compare against a value directly
  BOOST_CHECK ( opt0 == v0 ) ;
  BOOST_CHECK ( opt0 != v1 ) ;
@ -799,7 +799,7 @@ void test_none( T const* )
  BOOST_CHECK ( def0    == none ) ;
  BOOST_CHECK ( non_def != none ) ;
  BOOST_CHECK ( !def1           ) ;
-  BOOST_CHECK ( !(non_def <  none) ) ; 
+  BOOST_CHECK ( !(non_def <  none) ) ;
  BOOST_CHECK (   non_def >  none  ) ;
  BOOST_CHECK ( !(non_def <= none) ) ;
  BOOST_CHECK (   non_def >= none  ) ;
@ -819,11 +819,11 @@ void test_arrow( T const* )

  optional<T>        oa(a) ;
  optional<T> const coa(a) ;
-  
+
  BOOST_CHECK ( coa->V() == 1234 ) ;
-  
+
  oa->V() = 4321 ;
-  
+
  BOOST_CHECK (     a.V() = 1234 ) ;
  BOOST_CHECK ( (*oa).V() = 4321 ) ;
 }
@ -1086,7 +1086,7 @@ namespace optional_swap_test
       x = boost::in_place('\0');
    else if ( !hasY )
       y = boost::in_place('\0');
-    
+
    optional_swap_test::swap(*x,*y);

     if( !hasX )
@ -1118,7 +1118,7 @@ template <class T> struct optional_swap_should_use_default_constructor<
 //
 // Specialization of boost::swap:
 //
-template <> 
+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);
@ -1133,25 +1133,25 @@ namespace std {
 // Specializations of std::swap:
 //

-template <> 
+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 <> 
+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 <> 
+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 <> 
+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);
@ -1204,7 +1204,7 @@ bool test_swap_function( T const* )

 //
 // Tests whether the optional<T>::swap member function works properly.
-// Assumes that T has one data member, of type char. 
+// Assumes that T has one data member, of type char.
 // Returns true iff the test is passed.
 //
 template <class T>
@ -1263,6 +1263,33 @@ void test_swap_tweaking()
  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::template_whose_default_ctor_should_be_used<char>) ) );
 }

+// Test for support for classes with overridden operator&
+class CustomAddressOfClass
+{
+    int n;
+
+public:
+    CustomAddressOfClass() : n(0) {}
+    CustomAddressOfClass(CustomAddressOfClass const& that) : n(that.n) {}
+    explicit CustomAddressOfClass(int m) : n(m) {}
+    int* operator& () { return &n; }
+    bool operator== (CustomAddressOfClass const& that) const { return n == that.n; }
+};
+
+void test_custom_addressof_operator()
+{
+    boost::optional< CustomAddressOfClass > o1(CustomAddressOfClass(10));
+    BOOST_CHECK(!!o1);
+    BOOST_CHECK(o1.get() == CustomAddressOfClass(10));
+
+    o1 = CustomAddressOfClass(20);
+    BOOST_CHECK(!!o1);
+    BOOST_CHECK(o1.get() == CustomAddressOfClass(20));
+
+    o1 = boost::none;
+    BOOST_CHECK(!o1);
+}
+
 int test_main( int, char* [] )
 {
  try
@ -1273,6 +1300,7 @@ int test_main( int, char* [] )
    test_conversions1();
    test_conversions2();
    test_swap_tweaking();
+    test_custom_addressof_operator();
  }
  catch ( ... )
  {
--- a/test/optional_test_io.cpp
+++ b/test/optional_test_io.cpp
@ -55,10 +55,14 @@ void test2( Opt o, Opt buff )
 {
  stringstream s ;

-  s << o ;
-  s >> buff ;
+  const int markv = 123 ;
+  int mark = 0 ;
+  
+  s << o << " " << markv ;
+  s >> buff >> mark ;

  BOOST_ASSERT( buff == o ) ;
+  BOOST_ASSERT( mark == markv ) ;
 }


@ -77,7 +81,6 @@ int test_main( int, char* [] )
  {
    test(1,2);
    test(string("hello"),string("buffer"));
-    test(string(""),string("buffer"));
  }
  catch ( ... )
  {
Author	SHA1	Message	Date
Daniel James	7734d69cb9	Branch to work on filename handling without disturbing trunk. [SVN r68345]	2011-01-21 09:17:08 +00:00
Andrey Semashev	e9989b260e	Refs #4987 . Added forward declaration of namespace-scope swap for boost::optional, this should fix GCC compilation errors. Also swap implementation now uses Boost.Utility.Swap to make use of the workarounds for some broken compilers. If it breaks for your compiler, let me know in the mentioned ticket. [SVN r67288]	2010-12-17 21:12:56 +00:00
Andrey Semashev	646488e0e2	operator>> behavior changed slightly so that the stream is not accessed when unrecognized character sequence is detected. [SVN r67184]	2010-12-12 11:35:19 +00:00
Andrey Semashev	64d8062621	The may_alias workaround is also disabled for GCC prior to 3.2. Also added description for this workaround. [SVN r67112]	2010-12-08 18:32:36 +00:00
Ralf W. Grosse-Kunstleve	d39627c5b6	boost/optional/optional.hpp: avoid gcc 3.2 warnings [SVN r67109]	2010-12-08 17:53:29 +00:00
Andrey Semashev	f88c8ae423	Refs #3395 . Optional construction and assignment now works correctly for types with overridden operator&. Also silenced some GCC warnings about broken strict aliasing rules. [SVN r67020]	2010-12-05 14:43:18 +00:00
Sebastian Redl	ab01dfff7e	Fully qualify ios flags. Fixes compilation of PropertyTree, bug 4459. [SVN r64342]	2010-07-25 22:21:45 +00:00
Fernando Cacciola	8608ad1497	Fixed behaviour in case of invalid input [SVN r64208]	2010-07-20 19:21:44 +00:00
Fernando Cacciola	c93e5a88c7	Fixed extraction operator for empty optionals [SVN r64206]	2010-07-20 18:20:40 +00:00
Fernando Cacciola	425d141cbf	Test for fixed extraction operator for empty optinals [SVN r64205]	2010-07-20 18:20:01 +00:00
Daniel James	57c07c7a57	Fix doc build for 2 libraries which use own css. I changed the default to use doc/src/boostbook.css. So add an explicit location to libraries which use their own stylesheet. [SVN r64170]	2010-07-19 20:17:58 +00:00
Daniel James	97e314f03a	Fix some header links. [SVN r64006]	2010-07-14 08:15:33 +00:00
Daniel James	bccd75c72f	Update various libraries' documentation build. Mostly to use the images and css files under doc/src instead of doc/html, usually be deleting the settings in order to use the defaults. Also add 'boost.root' to some builds in order to fix links which rely on it. [SVN r63146]	2010-06-20 18:00:48 +00:00
Douglas Gregor	16f0a0aaaf	Expose the "types" typedef of boost::optional_detail::operator_base as public, rather than protected, since Spirit pokes at this typedef. [SVN r61832]	2010-05-06 21:44:18 +00:00
Daniel James	a63dbe0f14	Rebuild optional docs. [SVN r57812]	2009-11-20 10:26:23 +00:00
Troy D. Straszheim	066dd6f345	rm cmake from trunk. I'm not entirely sure this is necessary to satisfy the inspect script, but I'm not taking any chances, and it is easy to put back [SVN r56942]	2009-10-17 02:07:38 +00:00
Troy D. Straszheim	4e628ed4a6	Copyrights on CMakeLists.txt to keep them from clogging up the inspect reports. This is essentially the same commit as r55095 on the release branch. [SVN r55159]	2009-07-26 00:49:56 +00:00
Gennadiy Rozental	8682f2bbaa	avoid C style casts [SVN r53671]	2009-06-06 09:42:41 +00:00