Branch for working on the documentation tools documentation.

[SVN r68640]
Remove BOOST_ENABLE_ASSERT_MSG_HANDLER; use BOOST_ENABLE_ASSERT_HANDLER in its stead
2011-02-04 21:18:24 +00:00 · 2011-01-24 20:15:36 +00:00 · 2011-01-24 15:37:13 +00:00 · 2011-01-22 22:18:48 +00:00 · 2011-01-15 08:11:51 +00:00 · 2011-01-14 02:35:58 +00:00
104 changed files with 7115 additions and 2157 deletions
--- a/Assignable.html
+++ b/Assignable.html
@ -1,116 +1,109 @@
-<HTML>
-<!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  -->
-<Head>
-<Title>Assignable</Title>
-</HEAD>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../boost.png" 
-     ALT="C++ Boost" width="277" height="86"> 
-<!--end header-->
-<BR Clear>
-<H1>Assignable</H1>
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

-<h3>Description</h3>
-A type is Assignable if it is possible to assign one object of the type
-to another object of that type.
+<html>
+<head>
+  <meta http-equiv="Content-Language" content="en-us">
+  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">

+  <title>Assignable</title>
+</head>

-<h3>Notation</h3>
-<Table>
-<TR>
-<TD VAlign=top>
-<tt>T</tt>
-</TD>
-<TD VAlign=top>
-is type that is a model of Assignable
-</TD>
-</TR>
+<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
+"#FF0000">
+  <img src="../../boost.png" alt="C++ Boost" width="277" height=
+  "86"><br clear="none">

-<TR>
-<TD VAlign=top>
-<tt>t</tt>
-</TD>
-<TD VAlign=top>
-is an object of type <tt>T</tt>
-</TD>
-</tr>
+  <h1>Assignable</h1>

-<TR>
-<TD VAlign=top>
-<tt>u</tt>
-</TD>
-<TD VAlign=top>
-is an object of type <tt>T</tt> or possibly <tt>const T</tt>
-</TD>
-</tr>
+  <h3>Description</h3>

-</table>
-<h3>Definitions</h3>
-<h3>Valid expressions</h3>
-<Table border>
-<TR>
-<TH>
-Name
-</TH>
-<TH>
-Expression
-</TH>
-<TH>
-Return type
-</TH>
-<TH>
-Semantics
-</TH>
-</TR>
-<TR>
-<TD VAlign=top>
-Assignment
-</TD>
-<TD VAlign=top>
-<tt>t = u</tt>
-</TD>
-<TD VAlign=top>
-<tt>T&amp;</tt>
-</TD>
-<TD VAlign=top>
-<tt>t</tt> is equivalent to <tt>u</tt>
-</TD>
-</TR>
+  <p>A type is Assignable if it is possible to assign one object of the type
+  to another object of that type.</p>

-</table>
+  <h3>Notation</h3>

+  <table summary="">
+    <tr>
+      <td valign="top"><tt>T</tt></td>

-</table>
-<h3>Models</h3>
+      <td valign="top">is type that is a model of Assignable</td>
+    </tr>

-<UL>
-<LI><tt>int</tt>
-<LI><tt>std::pair</tt>
-</UL>
+    <tr>
+      <td valign="top"><tt>t</tt></td>

-<h3>See also</h3>
-<a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</A>
-and 
-<A href="./CopyConstructible.html">CopyConstructible</A>
+      <td valign="top">is an object of type <tt>T</tt></td>
+    </tr>

-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.lsc.nd.edu/~jsiek>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
-</TD></TR></TABLE>
+    <tr>
+      <td valign="top"><tt>u</tt></td>

-</BODY>
-</HTML> 
+      <td valign="top">is an object of type <tt>T</tt> or possibly <tt>const
+      T</tt></td>
+    </tr>
+  </table>
+
+  <h3>Definitions</h3>
+
+  <h3>Valid expressions</h3>
+
+  <table border summary="">
+    <tr>
+      <th>Name</th>
+
+      <th>Expression</th>
+
+      <th>Return type</th>
+
+      <th>Semantics</th>
+    </tr>
+
+    <tr>
+      <td valign="top">Assignment</td>
+
+      <td valign="top"><tt>t = u</tt></td>
+
+      <td valign="top"><tt>T&amp;</tt></td>
+
+      <td valign="top"><tt>t</tt> is equivalent to <tt>u</tt></td>
+    </tr>
+  </table>
+
+  <h3>Models</h3>
+
+  <ul>
+    <li><tt>int</tt></li>
+
+    <li><tt>std::pair</tt></li>
+  </ul>
+
+  <h3>See also</h3>
+
+  <p><a href=
+  "http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>
+  and <a href="./CopyConstructible.html">CopyConstructible</a><br></p>
+  <hr>
+
+  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
+  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
+  height="31" width="88"></a></p>
+
+  <p>Revised 
+  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05 December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
+
+  <table summary="">
+    <tr valign="top">
+      <td nowrap><i>Copyright &copy; 2000</i></td>
+
+      <td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
+      Notre Dame (<a href=
+      "mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
+    </tr>
+  </table>
+
+  <p><i>Distributed under the Boost Software License, Version 1.0. (See
+  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
+  copy at <a href=
+  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
+</body>
+</html>
--- a/Collection.html
+++ b/Collection.html
--- a/CopyConstructible.html
+++ b/CopyConstructible.html
@ -1,178 +1,139 @@
-<HTML>
-<!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  -->
-<Head>
-<Title>Copy Constructible</Title>
-</HEAD>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../boost.png" 
-     ALT="C++ Boost" width="277" height="86"> 
-<!--end header-->
-<BR Clear>
-<H1>Copy Constructible</H1>
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

-<h3>Description</h3>
-A type is Copy Constructible if it is possible to copy objects of that
-type.
+<html>
+<head>
+  <meta http-equiv="Content-Language" content="en-us">
+  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">

-<h3>Notation</h3>
-<Table>
-<TR>
-<TD VAlign=top>
-<tt>T</tt>
-</TD>
-<TD VAlign=top>
-is type that is a model of Copy Constructible
-</TD>
-</TR>
+  <title>Copy Constructible</title>
+</head>

-<TR>
-<TD VAlign=top>
-<tt>t</tt>
-</TD>
-<TD VAlign=top>
-is an object of type <tt>T</tt>
-</TD>
-</tr>
+<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
+"#FF0000">
+  <img src="../../boost.png" alt="C++ Boost" width="277" height=
+  "86"><br clear="none">

-<TR>
-<TD VAlign=top>
-<tt>u</tt>
-</TD>
-<TD VAlign=top>
-is an object of type <tt>const T</tt>
-</TD>
-</tr>
+  <h1>Copy Constructible</h1>

-</table>
-<h3>Definitions</h3>
-<h3>Valid expressions</h3>
-<Table border>
-<TR>
-<TH>
-Name
-</TH>
-<TH>
-Expression
-</TH>
-<TH>
-Return type
-</TH>
-<TH>
-Semantics
-</TH>
-</TR>
-<TR>
-<TD VAlign=top>
-Copy constructor
-</TD>
-<TD VAlign=top>
-<tt>T(t)</tt>
-</TD>
-<TD VAlign=top>
-<tt>T</tt>
-</TD>
-<TD VAlign=top>
-<tt>t</tt> is equivalent to <tt>T(t)</tt>
-</TD>
-</TR>
+  <h3>Description</h3>

+  <p>A type is Copy Constructible if it is possible to copy objects of that
+  type.</p>

-<TR>
-<TD VAlign=top>
-Copy constructor
-</TD>
-<TD VAlign=top>
-<pre>
+  <h3>Notation</h3>
+
+  <table summary="">
+    <tr>
+      <td valign="top"><tt>T</tt></td>
+
+      <td valign="top">is type that is a model of Copy Constructible</td>
+    </tr>
+
+    <tr>
+      <td valign="top"><tt>t</tt></td>
+
+      <td valign="top">is an object of type <tt>T</tt></td>
+    </tr>
+
+    <tr>
+      <td valign="top"><tt>u</tt></td>
+
+      <td valign="top">is an object of type <tt>const T</tt></td>
+    </tr>
+  </table>
+
+  <h3>Definitions</h3>
+
+  <h3>Valid expressions</h3>
+
+  <table border summary="">
+    <tr>
+      <th>Name</th>
+
+      <th>Expression</th>
+
+      <th>Return type</th>
+
+      <th>Semantics</th>
+    </tr>
+
+    <tr>
+      <td valign="top">Copy constructor</td>
+
+      <td valign="top"><tt>T(t)</tt></td>
+
+      <td valign="top"><tt>T</tt></td>
+
+      <td valign="top"><tt>t</tt> is equivalent to <tt>T(t)</tt></td>
+    </tr>
+
+    <tr>
+      <td valign="top">Copy constructor</td>
+
+      <td valign="top">
+        <pre>
 T(u)
 </pre>
-</TD>
-<TD VAlign=top>
-<tt>T</tt>
-</TD>
-<TD VAlign=top>
-<tt>u</tt> is equivalent to <tt>T(u)</tt>
-</TD>
-</TR>
+      </td>

+      <td valign="top"><tt>T</tt></td>

-<TR>
-<TD VAlign=top>
-Destructor
-</TD>
-<TD VAlign=top>
-<pre>
+      <td valign="top"><tt>u</tt> is equivalent to <tt>T(u)</tt></td>
+    </tr>
+
+    <tr>
+      <td valign="top">Destructor</td>
+
+      <td valign="top">
+        <pre>
 t.~T()
 </pre>
-</TD>
-<TD VAlign=top>
-<tt>T</tt>
-</TD>
-<TD VAlign=top>
-&nbsp;
-</TD>
-</TR>
+      </td>

-<TR>
-<TD VAlign=top>
-Address Operator
-</TD>
-<TD VAlign=top>
-<pre>
+      <td valign="top"><tt>T</tt></td>
+
+      <td valign="top">&nbsp;</td>
+    </tr>
+
+    <tr>
+      <td valign="top">Address Operator</td>
+
+      <td valign="top">
+        <pre>
 &amp;t
 </pre>
-</TD>
-<TD VAlign=top>
-<tt>T*</tt>
-</TD>
-<TD VAlign=top>
-denotes the address of <tt>t</tt>
-</TD>
-</TR>
+      </td>

-<TR>
-<TD VAlign=top>
-Address Operator
-</TD>
-<TD VAlign=top>
-<pre>
+      <td valign="top"><tt>T*</tt></td>
+
+      <td valign="top">denotes the address of <tt>t</tt></td>
+    </tr>
+
+    <tr>
+      <td valign="top">Address Operator</td>
+
+      <td valign="top">
+        <pre>
 &amp;u
 </pre>
-</TD>
-<TD VAlign=top>
-<tt>T*</tt>
-</TD>
-<TD VAlign=top>
-denotes the address of <tt>u</tt>
-</TD>
-</TR>
+      </td>

+      <td valign="top"><tt>T*</tt></td>

+      <td valign="top">denotes the address of <tt>u</tt></td>
+    </tr>
+  </table>

-</table>
+  <h3>Models</h3>

+  <ul>
+    <li><tt>int</tt></li>

-</table>
-<h3>Models</h3>
+    <li><tt>std::pair</tt></li>
+  </ul>

-<UL>
-<LI><tt>int</tt>
-<LI><tt>std::pair</tt>
-</UL>
-
-<h3>Concept Checking Class</h3>
-
-<pre>
+  <h3>Concept Checking Class</h3>
+  <pre>
  template &lt;class T&gt;
  struct CopyConstructibleConcept
  {
@ -192,19 +153,33 @@ denotes the address of <tt>u</tt>
  };
 </pre>

-<h3>See also</h3>
-<A
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</A>
-and 
-<A hrefa="./Assignable.html">Assignable</A>
+  <h3>See also</h3>

-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.lsc.nd.edu/~jsiek>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
-</TD></TR></TABLE>
+  <p><a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default
+  Constructible</a> and <a href="./Assignable.html">Assignable</a><br></p>
+  <hr>

-</BODY>
-</HTML> 
+  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
+  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
+  height="31" width="88"></a></p>
+
+  <p>Revised 
+  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
+  December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
+
+  <table summary="">
+    <tr valign="top">
+      <td nowrap><i>Copyright &copy; 2000</i></td>
+
+      <td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
+      Notre Dame (<a href=
+      "mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
+    </tr>
+  </table>
+
+  <p><i>Distributed under the Boost Software License, Version 1.0. (See
+  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
+  copy at <a href=
+  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
+</body>
+</html>
--- a/LessThanComparable.html
+++ b/LessThanComparable.html
@ -1,212 +1,210 @@
-<HTML>
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html>
 <!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+  == Copyright (c) 1996-1999
+  == Silicon Graphics Computer Systems, Inc.
+  ==
+  == Permission to use, copy, modify, distribute and sell this software
+  == and its documentation for any purpose is hereby granted without fee,
+  == provided that the above copyright notice appears in all copies and
+  == that both that copyright notice and this permission notice appear
+  == in supporting documentation.  Silicon Graphics makes no
+  == representations about the suitability of this software for any
+  == purpose.  It is provided "as is" without express or implied warranty.
+  ==
+  == Copyright (c) 1994
+  == Hewlett-Packard Company
+  ==
+  == Permission to use, copy, modify, distribute and sell this software
+  == and its documentation for any purpose is hereby granted without fee,
+  == provided that the above copyright notice appears in all copies and
+  == that both that copyright notice and this permission notice appear
+  == in supporting documentation.  Hewlett-Packard Company makes no
+  == representations about the suitability of this software for any
+  == purpose.  It is provided "as is" without express or implied warranty.
+  ==
  -->
-<!--
-  -- Copyright (c) 1996-1999
-  -- Silicon Graphics Computer Systems, Inc.
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  --
-  -- Copyright (c) 1994
-  -- Hewlett-Packard Company
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Hewlett-Packard Company makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  --
-  -->
-<Head>
-<Title>LessThanComparable</Title>
-</Head>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../boost.png" 
-     ALT="C++ Boost" width="277" height="86"> 
-<!--end header-->
-<BR Clear>
-<H1>LessThanComparable</H1>

-<h3>Description</h3>
-A type is LessThanComparable if it is ordered: it must
-be possible to compare two objects of that type using <tt>operator&lt;</tt>, and
-<tt>operator&lt;</tt> must be a strict weak ordering relation.
+<head>
+  <meta http-equiv="Content-Language" content="en-us">
+  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">

+  <title>LessThanComparable</title>
+</head>

-<h3>Refinement of</h3>
-<h3>Associated types</h3>
-<h3>Notation</h3>
-<Table>
-<TR>
-<TD VAlign=top>
-<tt>X</tt>
-</TD>
-<TD VAlign=top>
-A type that is a model of LessThanComparable
-</TD>
-</TR>
-<TR>
-<TD VAlign=top>
-<tt>x</tt>, <tt>y</tt>, <tt>z</tt>
-</TD>
-<TD VAlign=top>
-Object of type <tt>X</tt>
-</TD>
-</tr>
-</table>
-<h3>Definitions</h3>
-Consider the relation <tt>!(x &lt; y) &amp;&amp; !(y &lt; x)</tt>.  If this relation is
-transitive (that is, if <tt>!(x &lt; y) &amp;&amp; !(y &lt; x) &amp;&amp; !(y &lt; z) &amp;&amp; !(z &lt; y)</tt>
-implies <tt>!(x &lt; z) &amp;&amp; !(z &lt; x)</tt>), then it satisfies the mathematical
-definition of an equivalence relation.  In this case, <tt>operator&lt;</tt>
-is a <i>strict weak ordering</i>.
-<P>
-If <tt>operator&lt;</tt> is a strict weak ordering, and if each equivalence class
-has only a single element, then <tt>operator&lt;</tt> is a <i>total ordering</i>.
-<h3>Valid expressions</h3>
-<Table border>
-<TR>
-<TH>
-Name
-</TH>
-<TH>
-Expression
-</TH>
-<TH>
-Type requirements
-</TH>
-<TH>
-Return type
-</TH>
-</TR>
-<TR>
-<TD VAlign=top>
-Less
-</TD>
-<TD VAlign=top>
-<tt>x &lt; y</tt>
-</TD>
-<TD VAlign=top>
-&nbsp;
-</TD>
-<TD VAlign=top>
-Convertible to <tt>bool</tt>
-</TD>
-</TR>
-</table>
+<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
+"#FF0000">
+  <img src="../../boost.png" alt="C++ Boost" width="277" height=
+  "86"><br clear="none">

+  <h1>LessThanComparable</h1>

+  <h3>Description</h3>

-<h3>Expression semantics</h3>
-<Table border>
-<TR>
-<TH>
-Name
-</TH>
-<TH>
-Expression
-</TH>
-<TH>
-Precondition
-</TH>
-<TH>
-Semantics
-</TH>
-<TH>
-Postcondition
-</TH>
-</TR>
-<TR>
-<TD VAlign=top>
-Less
-</TD>
-<TD VAlign=top>
-<tt>x &lt; y</tt>
-</TD>
-<TD VAlign=top>
-<tt>x</tt> and <tt>y</tt> are in the domain of <tt>&lt;</tt>
-</TD>
-<TD VAlign=top>
-&nbsp;
-</TD>
-</table>
+  <p>A type is LessThanComparable if it is ordered: it must be possible to
+  compare two objects of that type using <tt>operator&lt;</tt>, and
+  <tt>operator&lt;</tt> must be a strict weak ordering relation.</p>

+  <h3>Refinement of</h3>

-<h3>Complexity guarantees</h3>
-<h3>Invariants</h3>
-<Table border>
-<TR>
-<TD VAlign=top>
-Irreflexivity
-</TD>
-<TD VAlign=top>
-<tt>x &lt; x</tt> must be false.
-</TD>
-</TR>
-<TR>
-<TD VAlign=top>
-Antisymmetry
-</TD>
-<TD VAlign=top>
-<tt>x &lt; y</tt> implies !(y &lt; x) <A href="#2">[2]</A>
-</TD>
-</TR>
-<TR>
-<TD VAlign=top>
-Transitivity
-</TD>
-<TD VAlign=top>
-<tt>x &lt; y</tt> and <tt>y &lt; z</tt> implies <tt>x &lt; z</tt> <A href="#3">[3]</A>
-</TD>
-</tr>
-</table>
-<h3>Models</h3>
-<UL>
-<LI>
-int
-</UL>
-<h3>Notes</h3>
-<P><A name="1">[1]</A>
-Only <tt>operator&lt;</tt> is fundamental; the other inequality operators
-are essentially syntactic sugar.
-<P><A name="2">[2]</A>
-Antisymmetry is a theorem, not an axiom: it follows from
-irreflexivity and transitivity.
-<P><A name="3">[3]</A>
-Because of irreflexivity and transitivity, <tt>operator&lt;</tt> always
-satisfies the definition of a <i>partial ordering</i>.  The definition of
-a <i>strict weak ordering</i> is stricter, and the definition of a
-<i>total ordering</i> is stricter still.
-<h3>See also</h3>
-<A href="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</A>, <A href="http://www.sgi.com/tech/stl/StrictWeakOrdering.html">StrictWeakOrdering</A>
+  <h3>Associated types</h3>

+  <h3>Notation</h3>

+  <table summary="">
+    <tr>
+      <td valign="top"><tt>X</tt></td>

-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.lsc.nd.edu/~jsiek>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
-</TD></TR></TABLE>
+      <td valign="top">A type that is a model of LessThanComparable</td>
+    </tr>

-</BODY>
-</HTML> 
+    <tr>
+      <td valign="top"><tt>x</tt>, <tt>y</tt>, <tt>z</tt></td>
+
+      <td valign="top">Object of type <tt>X</tt></td>
+    </tr>
+  </table>
+
+  <h3>Definitions</h3>
+
+  <p>Consider the relation <tt>!(x &lt; y) &amp;&amp; !(y &lt; x)</tt>. If
+  this relation is transitive (that is, if <tt>!(x &lt; y) &amp;&amp; !(y
+  &lt; x) &amp;&amp; !(y &lt; z) &amp;&amp; !(z &lt; y)</tt> implies <tt>!(x
+  &lt; z) &amp;&amp; !(z &lt; x)</tt>), then it satisfies the mathematical
+  definition of an equivalence relation. In this case, <tt>operator&lt;</tt>
+  is a <i>strict weak ordering</i>.</p>
+
+  <p>If <tt>operator&lt;</tt> is a strict weak ordering, and if each
+  equivalence class has only a single element, then <tt>operator&lt;</tt> is
+  a <i>total ordering</i>.</p>
+
+  <h3>Valid expressions</h3>
+
+  <table border summary="">
+    <tr>
+      <th>Name</th>
+
+      <th>Expression</th>
+
+      <th>Type requirements</th>
+
+      <th>Return type</th>
+    </tr>
+
+    <tr>
+      <td valign="top">Less</td>
+
+      <td valign="top"><tt>x &lt; y</tt></td>
+
+      <td valign="top">&nbsp;</td>
+
+      <td valign="top">Convertible to <tt>bool</tt></td>
+    </tr>
+  </table>
+
+  <h3>Expression semantics</h3>
+
+  <table border summary="">
+    <tr>
+      <th>Name</th>
+
+      <th>Expression</th>
+
+      <th>Precondition</th>
+
+      <th>Semantics</th>
+
+      <th>Postcondition</th>
+    </tr>
+
+    <tr>
+      <td valign="top">Less</td>
+
+      <td valign="top"><tt>x &lt; y</tt></td>
+
+      <td valign="top"><tt>x</tt> and <tt>y</tt> are in the domain of
+      <tt>&lt;</tt></td>
+
+      <td valign="top">&nbsp;</td>
+    </tr>
+  </table>
+
+  <h3>Complexity guarantees</h3>
+
+  <h3>Invariants</h3>
+
+  <table border summary="">
+    <tr>
+      <td valign="top">Irreflexivity</td>
+
+      <td valign="top"><tt>x &lt; x</tt> must be false.</td>
+    </tr>
+
+    <tr>
+      <td valign="top">Antisymmetry</td>
+
+      <td valign="top"><tt>x &lt; y</tt> implies !(y &lt; x) <a href=
+      "#n2">[2]</a></td>
+    </tr>
+
+    <tr>
+      <td valign="top">Transitivity</td>
+
+      <td valign="top"><tt>x &lt; y</tt> and <tt>y &lt; z</tt> implies <tt>x
+      &lt; z</tt> <a href="#n3">[3]</a></td>
+    </tr>
+  </table>
+
+  <h3>Models</h3>
+
+  <ul>
+    <li>int</li>
+  </ul>
+
+  <h3>Notes</h3>
+
+  <p><a name="n1" id="n1">[1]</a> Only <tt>operator&lt;</tt> is fundamental;
+  the other inequality operators are essentially syntactic sugar.</p>
+
+  <p><a name="n2" id="n2">[2]</a> Antisymmetry is a theorem, not an axiom: it
+  follows from irreflexivity and transitivity.</p>
+
+  <p><a name="n3" id="n3">[3]</a> Because of irreflexivity and transitivity,
+  <tt>operator&lt;</tt> always satisfies the definition of a <i>partial
+  ordering</i>. The definition of a <i>strict weak ordering</i> is stricter,
+  and the definition of a <i>total ordering</i> is stricter still.</p>
+
+  <h3>See also</h3>
+
+  <p><a href=
+  "http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a>,
+  <a href=
+  "http://www.sgi.com/tech/stl/StrictWeakOrdering.html">StrictWeakOrdering</a><br>
+  </p>
+  <hr>
+
+  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
+  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
+  height="31" width="88"></a></p>
+
+  <p>Revised 
+  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
+  December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
+
+  <table summary="">
+    <tr valign="top">
+      <td nowrap><i>Copyright &copy; 2000</i></td>
+
+      <td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
+      Notre Dame (<a href=
+      "mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
+    </tr>
+  </table>
+
+  <p><i>Distributed under the Boost Software License, Version 1.0. (See
+  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
+  copy at <a href=
+  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
+</body>
+</html>
--- a/MultiPassInputIterator.html
+++ b/MultiPassInputIterator.html
@ -1,92 +1,95 @@
-<HTML>
-<!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  -->
-<Head>
-<Title>MultiPassInputIterator</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-	ALINK="#ff0000"> 
-<IMG SRC="../../boost.png" 
-     ALT="C++ Boost" width="277" height="86"> 
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

-<BR Clear>
+<html>
+<head>
+  <meta http-equiv="Content-Language" content="en-us">
+  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">

-<H2>
-<A NAME="concept:MultiPassInputIterator"></A>
-Multi-Pass Input Iterator
-</H2>
+  <title>MultiPassInputIterator</title>
+</head>

-This concept is a refinement of <a
-href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
-adding the requirements that the iterator can be used to make multiple
-passes through a range, and that if <TT>it1 == it2</TT> and
-<TT>it1</TT> is dereferenceable then <TT>++it1 == ++it2</TT>. The
-Multi-Pass Input Iterator is very similar to the <a
-href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>. The
-only difference is that a <a
-href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>
-requires the <TT>reference</TT> type to be <TT>value_type&amp;</TT>, whereas
-MultiPassInputIterator is like <a
-href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
-in that the <TT>reference</TT> type merely has to be convertible to
-<TT>value_type</TT>.
+<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
+"#FF0000">
+  <img src="../../boost.png" alt="C++ Boost" width="277" height=
+  "86"><br clear="none">

+  <h2><a name="concept:MultiPassInputIterator" id=
+  "concept:MultiPassInputIterator"></a> Multi-Pass Input Iterator</h2>

-<h3>Design Notes</h3>
+  <p>This concept is a refinement of <a href=
+  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>, adding
+  the requirements that the iterator can be used to make multiple passes
+  through a range, and that if <tt>it1 == it2</tt> and <tt>it1</tt> is
+  dereferenceable then <tt>++it1 == ++it2</tt>. The Multi-Pass Input Iterator
+  is very similar to the <a href=
+  "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>.
+  The only difference is that a <a href=
+  "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>
+  requires the <tt>reference</tt> type to be <tt>value_type&amp;</tt>,
+  whereas MultiPassInputIterator is like <a href=
+  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> in that
+  the <tt>reference</tt> type merely has to be convertible to
+  <tt>value_type</tt>.</p>

-comments by Valentin Bonnard:
+  <h3>Design Notes</h3>

-<p> I think that introducing Multi-Pass Input Iterator isn't the right
-solution. Do you also want to define Multi-Pass Bidirectionnal Iterator
-and Multi-Pass Random Access Iterator ? I don't, definitly. It only
-confuses the issue. The problem lies into the existing hierarchy of
-iterators, which mixes movabillity, modifiabillity and lvalue-ness,
-and these are clearly independant.
+  <p>comments by Valentin Bonnard:</p>

-<p> The terms Forward, Bidirectionnal and Random Access are about
-movabillity and shouldn't be used to mean anything else.  In a
-completly orthogonal way, iterators can be immutable, mutable, or
-neither.  Lvalueness of iterators is also orthogonal with
-immutabillity.  With these clean concepts, your Multi-Pass Input Iterator
-is just called a Forward Iterator.
+  <p>I think that introducing Multi-Pass Input Iterator isn't the right
+  solution. Do you also want to define Multi-Pass Bidirectionnal Iterator and
+  Multi-Pass Random Access Iterator ? I don't, definitly. It only confuses
+  the issue. The problem lies into the existing hierarchy of iterators, which
+  mixes movabillity, modifiabillity and lvalue-ness, and these are clearly
+  independant.</p>

-<p>                
-Other translations are:<br>
-std::Forward Iterator -> ForwardIterator & Lvalue Iterator<br>
-std::Bidirectionnal Iterator -> Bidirectionnal Iterator & Lvalue Iterator<br>
-std::Random Access Iterator -> Random Access Iterator & Lvalue Iterator<br>
+  <p>The terms Forward, Bidirectionnal and Random Access are about
+  movabillity and shouldn't be used to mean anything else. In a completly
+  orthogonal way, iterators can be immutable, mutable, or neither. Lvalueness
+  of iterators is also orthogonal with immutabillity. With these clean
+  concepts, your Multi-Pass Input Iterator is just called a Forward
+  Iterator.</p>

-<p>
-Note that in practice the only operation not allowed on my 
-Forward Iterator which is allowed on std::Forward Iterator is 
-<tt>&*it</tt>. I think that <tt>&*</tt> is rarely needed in generic code.
+  <p>Other translations are:<br>
+  std::Forward Iterator -&gt; ForwardIterator &amp; Lvalue Iterator<br>
+  std::Bidirectionnal Iterator -&gt; Bidirectionnal Iterator &amp; Lvalue
+  Iterator<br>
+  std::Random Access Iterator -&gt; Random Access Iterator &amp; Lvalue
+  Iterator<br></p>

-<p>
-reply by Jeremy Siek:
+  <p>Note that in practice the only operation not allowed on my Forward
+  Iterator which is allowed on std::Forward Iterator is <tt>&amp;*it</tt>. I
+  think that <tt>&amp;*</tt> is rarely needed in generic code.</p>

-<p>
-The above analysis by Valentin is right on. Of course, there is
-the problem with backward compatibility. The current STL implementations
-are based on the old definition of Forward Iterator. The right course
-of action is to get Forward Iterator, etc. changed in the C++ standard.
-Once that is done we can drop Multi-Pass Input Iterator.
+  <p>reply by Jeremy Siek:</p>

+  <p>The above analysis by Valentin is right on. Of course, there is the
+  problem with backward compatibility. The current STL implementations are
+  based on the old definition of Forward Iterator. The right course of action
+  is to get Forward Iterator, etc. changed in the C++ standard. Once that is
+  done we can drop Multi-Pass Input Iterator.<br></p>
+  <hr>

-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<a HREF="../../people/jeremy_siek.htm">Jeremy Siek</a>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
-</TD></TR></TABLE>
+  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
+  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
+  height="31" width="88"></a></p>

-</BODY>
-</HTML> 
+  <p>Revised 
+  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
+  December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
+
+  <table summary="">
+    <tr valign="top">
+      <td nowrap><i>Copyright &copy; 2000</i></td>
+
+      <td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
+      Notre Dame (<a href=
+      "mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
+    </tr>
+  </table>
+
+  <p><i>Distributed under the Boost Software License, Version 1.0. (See
+  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
+  copy at <a href=
+  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
+</body>
+</html>
--- a/OptionalPointee.html
+++ b/OptionalPointee.html
@ -145,14 +145,20 @@ objects are is implemented in <a href="../../boost/utility/compare_pointees.hpp"
 so direct usage of relational operators with the implied aliasing of shallow semantics
 -as with pointers- should not be used with generic code written for this concept.</p>

+<h3>Acknowledgements</h3>
+<p>Based on the original concept developed by Augustus Saunders.
+
 <br>
+</p>
 <HR>
 <TABLE>
 <TR valign=top>
 <TD nowrap>Copyright &copy 2003</TD><TD>
-<A HREF="mailto:fernando_cacciola@hotmail.com">Fernando Cacciola</A>,
-based on the original concept developed by Augustus Saunders.
+<A HREF="mailto:fernando_cacciola@hotmail.com">Fernando Cacciola</A>
 </TD></TR></TABLE>

+<p>Distributed under the Boost Software License, Version 1.0. See
+<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
+
 </BODY>
 </HTML>
--- a/addressof_fn_test.cpp
+++ b/addressof_fn_test.cpp
@ -0,0 +1,76 @@
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable: 4786)  // identifier truncated in debug info
+#pragma warning(disable: 4710)  // function not inlined
+#pragma warning(disable: 4711)  // function selected for automatic inline expansion
+#pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+//  addressof_fn_test.cpp: addressof( f )
+//
+//  Copyright (c) 2008, 2009 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/utility/addressof.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+
+void f0()
+{
+}
+
+void f1(int)
+{
+}
+
+void f2(int, int)
+{
+}
+
+void f3(int, int, int)
+{
+}
+
+void f4(int, int, int, int)
+{
+}
+
+void f5(int, int, int, int, int)
+{
+}
+
+void f6(int, int, int, int, int, int)
+{
+}
+
+void f7(int, int, int, int, int, int, int)
+{
+}
+
+void f8(int, int, int, int, int, int, int, int)
+{
+}
+
+void f9(int, int, int, int, int, int, int, int, int)
+{
+}
+
+int main()
+{
+    BOOST_TEST( boost::addressof( f0 ) == &f0 );
+    BOOST_TEST( boost::addressof( f1 ) == &f1 );
+    BOOST_TEST( boost::addressof( f2 ) == &f2 );
+    BOOST_TEST( boost::addressof( f3 ) == &f3 );
+    BOOST_TEST( boost::addressof( f4 ) == &f4 );
+    BOOST_TEST( boost::addressof( f5 ) == &f5 );
+    BOOST_TEST( boost::addressof( f6 ) == &f6 );
+    BOOST_TEST( boost::addressof( f7 ) == &f7 );
+    BOOST_TEST( boost::addressof( f8 ) == &f8 );
+    BOOST_TEST( boost::addressof( f9 ) == &f9 );
+
+    return boost::report_errors();
+}
--- a/addressof_test2.cpp
+++ b/addressof_test2.cpp
@ -0,0 +1,95 @@
+// Copyright (C) 2002 Brad King (brad.king@kitware.com) 
+//                    Douglas Gregor (gregod@cs.rpi.edu)
+//
+// Copyright 2009 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+
+
+#include <boost/utility/addressof.hpp>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(push, 3)
+#endif
+
+#include <iostream>
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#pragma warning(pop)
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+
+template<class T> void scalar_test( T * = 0 )
+{
+    T* px = new T();
+
+    T& x = *px;
+    BOOST_TEST( boost::addressof(x) == px );
+
+    const T& cx = *px;
+    const T* pcx = boost::addressof(cx);
+    BOOST_TEST( pcx == px );
+
+    volatile T& vx = *px;
+    volatile T* pvx = boost::addressof(vx);
+    BOOST_TEST( pvx == px );
+
+    const volatile T& cvx = *px;
+    const volatile T* pcvx = boost::addressof(cvx);
+    BOOST_TEST( pcvx == px );
+
+    delete px;
+}
+
+template<class T> void array_test( T * = 0 )
+{
+    T nrg[3] = {1,2,3};
+    T (*pnrg)[3] = &nrg;
+    BOOST_TEST( boost::addressof(nrg) == pnrg );
+
+    T const cnrg[3] = {1,2,3};
+    T const (*pcnrg)[3] = &cnrg;
+    BOOST_TEST( boost::addressof(cnrg) == pcnrg );
+}
+
+class convertible {
+public:
+
+    convertible( int = 0 )
+    {
+    }
+
+    template<class U> operator U () const
+    {
+        return U();
+    }
+};
+
+class convertible2 {
+public:
+
+    convertible2( int = 0 )
+    {
+    }
+
+    operator convertible2* () const
+    {
+        return 0;
+    }
+};
+
+int main()
+{
+    scalar_test<convertible>();
+    scalar_test<convertible2>();
+
+    array_test<convertible>();
+    array_test<convertible2>();
+
+    return boost::report_errors();
+}
--- a/assert.html
+++ b/assert.html
@ -17,40 +17,99 @@
 				<td colspan="2" height="64">&nbsp;</td>
 			</tr>
 		</table>
+		<p>
+			<a href="#BOOST_ASSERT">BOOST_ASSERT</a><br>
+            <a href="#BOOST_ASSERT_MSG">BOOST_ASSERT_MSG</a><br>
+            <a href="#BOOST_VERIFY">BOOST_VERIFY</a></p>
+            
+<h2><a name="BOOST_ASSERT">BOOST_ASSERT</a></h2>
 		<p>
 			The header <STRONG>&lt;boost/assert.hpp&gt;</STRONG> defines the macro <b>BOOST_ASSERT</b>, 
 			which is similar to the standard <STRONG>assert</STRONG> macro defined in <STRONG>&lt;cassert&gt;</STRONG>. 
-			The macro is intended to be used in Boost libraries.
+			The macro is intended to be used in both Boost libraries and user 
+            code.
 		</p>
 		<P>By default, <tt>BOOST_ASSERT(expr)</tt> is equivalent to <tt>assert(expr)</tt>.</P>
-		<P>When the macro <STRONG>BOOST_DISABLE_ASSERTS</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+		<P>If the macro <STRONG>BOOST_DISABLE_ASSERTS</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			is included, <tt>BOOST_ASSERT(expr)</tt> is defined as <tt>((void)0)</tt>. This 
 			allows users to selectively disable <STRONG>BOOST_ASSERT</STRONG> without 
 			affecting the definition of the standard <STRONG>assert</STRONG>.</P>
-		<P>When the macro <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+		<P>If the macro <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			is included, <tt>BOOST_ASSERT(expr)</tt> evaluates <b>expr</b> and, if the 
 			result is false, evaluates the expression</P>
+		<blockquote>
 		<P><tt>::boost::assertion_failed(#expr, <a href="current_function.html">BOOST_CURRENT_FUNCTION</a>, 
 				__FILE__, __LINE__)</tt></P>
+		</blockquote>
 		<P><STRONG>assertion_failed</STRONG> is declared in <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			as</P>
-		<pre>
-namespace boost
+		<blockquote>
+		<pre>namespace boost
 {
-
-void assertion_failed(char const * expr, char const * function, char const * file, long line);
-
+  void assertion_failed(char const * expr, char const * function, char const * file, long line);
 }
 </pre>
+		</blockquote>
 		<p>but it is never defined. The user is expected to supply an appropriate 
 			definition.</p>
 		<P>As is the case with <STRONG>&lt;cassert&gt;</STRONG>, <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			can be included multiple times in a single translation unit. <STRONG>BOOST_ASSERT</STRONG>
 			will be redefined each time as specified above.</P>
+			
+<h2><a name="BOOST_ASSERT_MSG">BOOST_ASSERT_MSG</a></h2>
+		<p>
+			The header <STRONG>&lt;boost/assert.hpp&gt;</STRONG> defines the macro <b>BOOST_ASSERT_MSG</b>, 
+			which is similar to the standard <STRONG>assert</STRONG> macro defined in <STRONG>&lt;cassert&gt;</STRONG>, 
+            but with an additional macro parameter supplying an error message. The macro is intended to be used in both Boost libraries 
+            and user code.
+		</p>
+		<P> <tt>BOOST_ASSERT_MSG(expr, msg)</tt> is equivalent to <code>
+        ((void)0)</code> if <b>BOOST_DISABLE_ASSERTS</b> or <b>NDEBUG</b> are 
+        defined or <code>expr</code> evaluates to <code>true</code>. If those 
+        macros and <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> are not 
+        defined, and <code>expr</code> evaluates to <code>false</code>, an error 
+        message that includes <tt>#expr</tt>, <tt>msg</tt>, <tt> <a href="current_function.html">BOOST_CURRENT_FUNCTION</a></tt>, <tt>
+        __FILE__</tt>, and <tt>__LINE__</tt> is sent to output stream <b>
+        BOOST_ASSERT_MSG_OSTREAM</b> 
+        and <code>std::abort()</code> is called.</P>
+		<P> <b>BOOST_ASSERT_MSG_OSTREAM</b> defines the output stream. It defaults to <code>std::cerr</code>. 
+        Integrated development environments (IDE's) like Microsoft Visual Studio 
+        may produce easier to understand output if messages go to a different 
+        stream, such as <code>std::cout</code>. Users may define <b>BOOST_ASSERT_MSG_OSTREAM</b> before including <STRONG>&lt;boost/assert.hpp&gt;</STRONG> 
+        to specify a different output stream.&nbsp; </P>
+		<P>If the macro <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+			is included, instead of sending a error message to an output 
+        stream, this expression is evaluated</P>
+		<blockquote>
+		<P><tt>::boost::assertion_failed_msg(#expr, msg, <a href="current_function.html">BOOST_CURRENT_FUNCTION</a>, 
+				__FILE__, __LINE__)</tt></P>
+		</blockquote>
+		<P><STRONG>assertion_failed_msg</STRONG> is declared in <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+			as</P>
+		<blockquote>
+		<pre>namespace boost
+{
+  void assertion_failed_msg(char const * expr, char const * msg, char const * function, char const * file, long line);
+}
+</pre>
+		</blockquote>
+		<p>but it is never defined. The user is expected to supply an appropriate 
+			definition.</p>
+		<P>As is the case with <STRONG>&lt;cassert&gt;</STRONG>, <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
+			can be included multiple times in a single translation unit. <STRONG>BOOST_ASSERT_MSG</STRONG>
+			will be redefined each time as specified above.</P>
+			
+<h2><a name="BOOST_VERIFY">BOOST_VERIFY</a></h2>
+		<p><STRONG>&lt;boost/assert.hpp&gt;</STRONG> also defines the macro <STRONG>BOOST_VERIFY</STRONG>. 
+			It has exactly the same behavior as <STRONG>BOOST_ASSERT</STRONG>, except that 
+			the expression that is passed to <STRONG>BOOST_VERIFY</STRONG> is always 
+			evaluated. This is useful when the asserted expression has desirable side 
+			effects; it can also help suppress warnings about unused variables when the 
+			only use of the variable is inside an assertion.</p>
 		<p><br>
-			<small>Copyright <20> 2002 by Peter Dimov. Permission to copy, use, modify, sell and 
-				distribute this document is granted provided this copyright notice appears in 
-				all copies. This document is provided "as is" without express or implied 
-				warranty, and with no claim as to its suitability for any purpose.</small></p>
+			<small>Copyright <20> 2002, 2007 by Peter Dimov.&nbsp; Copyright <20> 2011 
+        by Beman Dawes. Distributed under the Boost Software 
+				License, Version 1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A>
+				or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
 	</body>
-</html>
+</html>
--- a/assert_test.cpp
+++ b/assert_test.cpp
@ -2,6 +2,7 @@
 //  assert_test.cpp - a test for boost/assert.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (2) Beman Dawes 2011
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@ -20,6 +21,11 @@ void test_default()
    BOOST_ASSERT(x);
    BOOST_ASSERT(x == 1);
    BOOST_ASSERT(&x);
+
+    BOOST_ASSERT_MSG(1, "msg");
+    BOOST_ASSERT_MSG(x, "msg");
+    BOOST_ASSERT_MSG(x == 1, "msg");
+    BOOST_ASSERT_MSG(&x, "msg");
 }

 #define BOOST_DISABLE_ASSERTS
@ -34,13 +40,23 @@ void test_disabled()
    BOOST_ASSERT(x == 1);
    BOOST_ASSERT(&x);

+    BOOST_ASSERT_MSG(1, "msg");
+    BOOST_ASSERT_MSG(x, "msg");
+    BOOST_ASSERT_MSG(x == 1, "msg");
+    BOOST_ASSERT_MSG(&x, "msg");
+
    BOOST_ASSERT(0);
    BOOST_ASSERT(!x);
    BOOST_ASSERT(x == 0);

+    BOOST_ASSERT_MSG(0, "msg");
+    BOOST_ASSERT_MSG(!x, "msg");
+    BOOST_ASSERT_MSG(x == 0, "msg");
+
    void * p = 0;

    BOOST_ASSERT(p);
+    BOOST_ASSERT_MSG(p, "msg");

    // supress warnings
    p = &x;
@ -55,6 +71,7 @@ void test_disabled()
 #include <cstdio>

 int handler_invoked = 0;
+int msg_handler_invoked = 0;

 void boost::assertion_failed(char const * expr, char const * function, char const * file, long line)
 {
@ -66,11 +83,24 @@ void boost::assertion_failed(char const * expr, char const * function, char cons
    ++handler_invoked;
 }

+void boost::assertion_failed_msg(char const * expr, char const * msg, char const * function,
+  char const * file, long line)
+{
+#if !defined(BOOST_NO_STDC_NAMESPACE)
+    using std::printf;
+#endif
+
+    printf("Expression: %s Message: %s\nFunction: %s\nFile: %s\nLine: %ld\n\n",
+      expr, msg, function, file, line);
+    ++msg_handler_invoked;
+}
+
 struct X
 {
    static void f()
    {
        BOOST_ASSERT(0);
+        BOOST_ASSERT_MSG(0, "msg f()");
    }
 };

@ -83,21 +113,35 @@ void test_handler()
    BOOST_ASSERT(x == 1);
    BOOST_ASSERT(&x);

+    BOOST_ASSERT_MSG(1, "msg2");
+    BOOST_ASSERT_MSG(x, "msg3");
+    BOOST_ASSERT_MSG(x == 1, "msg4");
+    BOOST_ASSERT_MSG(&x, "msg5");
+
    BOOST_ASSERT(0);
    BOOST_ASSERT(!x);
    BOOST_ASSERT(x == 0);

+    BOOST_ASSERT_MSG(0,"msg 0");
+    BOOST_ASSERT_MSG(!x, "msg !x");
+    BOOST_ASSERT_MSG(x == 0, "msg x == 0");
+
    void * p = 0;

    BOOST_ASSERT(p);
+    BOOST_ASSERT_MSG(p, "msg p");

    X::f();

    BOOST_ASSERT(handler_invoked == 5);
    BOOST_TEST(handler_invoked == 5);
+
+    BOOST_ASSERT_MSG(msg_handler_invoked == 5, "msg_handler_invoked count is wrong");
+    BOOST_TEST(msg_handler_invoked == 5);
 }

 #undef BOOST_ENABLE_ASSERT_HANDLER
+#undef BOOST_ENABLE_ASSERT_MSG_HANDLER

 int main()
 {
--- a/base_from_member.html
+++ b/base_from_member.html
@ -334,7 +334,7 @@ with the exact pointer type used in <code>switcher</code>'s constructor.</p>
 <h3><a name="contributors">Contributors</a></h3>

 <dl>
-	<dt><a href="../../people/ed_brey.htm">Ed Brey</a>
+	<dt><a href="http://www.boost.org/people/ed_brey.htm">Ed Brey</a>
 	<dd>Suggested some interface changes.

 	<dt><a href="http://www.moocat.org">R. Samuel Klatchko</a> (<a
@ -343,7 +343,7 @@ with the exact pointer type used in <code>switcher</code>'s constructor.</p>
 	<dd>Invented the idiom of how to use a class member for initializing
 		a base class.

-	<dt><a href="../../people/dietmar_kuehl.htm">Dietmar Kuehl</a>
+	<dt><a href="http://www.boost.org/people/dietmar_kuehl.htm">Dietmar Kuehl</a>
 	<dd>Popularized the base-from-member idiom in his
 		<a href="http://www.informatik.uni-konstanz.de/~kuehl/c++/iostream/">IOStream
 		example classes</a>.
@ -353,7 +353,7 @@ with the exact pointer type used in <code>switcher</code>'s constructor.</p>
 		can be controlled and automated with macros.  The implementation uses
 		the <a href="../preprocessor/index.html">Preprocessor library</a>.

-	<dt><a href="../../people/daryle_walker.html">Daryle Walker</a>
+	<dt><a href="http://www.boost.org/people/daryle_walker.html">Daryle Walker</a>
 	<dd>Started the library.  Contributed the test file <cite><a
 		href="base_from_member_test.cpp">base_from_member_test.cpp</a></cite>.
 </dl>
--- a/base_from_member_test.cpp
+++ b/base_from_member_test.cpp
@ -281,7 +281,7 @@ object_id_compare::operator ()
        }
        else
        {
-            return a.second->before( *b.second );
+            return a.second->before( *b.second ) != 0;
        }
    }
 }
--- a/binary_test.cpp
+++ b/binary_test.cpp
@ -0,0 +1,647 @@
+/*=============================================================================
+    Copyright (c) 2006, 2007 Matthew Calabrese
+
+    Use, modification and distribution is subject to the Boost Software
+    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/test/minimal.hpp>
+#include <boost/utility/binary.hpp>
+#include <algorithm>
+#include <cstddef>
+
+#ifdef BOOST_MSVC
+#pragma warning(disable:4996) // warning C4996: 'std::equal': Function call with parameters that may be unsafe - this call relies on the caller to check that the passed values are correct. To disable this warning, use -D_SCL_SECURE_NO_WARNINGS. See documentation on how to use Visual C++ 'Checked Iterators'
+#endif
+
+/*
+Note: This file tests every single valid bit-grouping on its own, and some
+      random combinations of bit-groupings.
+*/
+
+std::size_t const num_random_test_values = 32;
+
+// Note: These hex values should all correspond with the binary array below
+unsigned int const random_unsigned_ints_hex[num_random_test_values]
+  = { 0x0103u, 0x77ebu, 0x5f36u, 0x1f18u, 0xc530u, 0xa73au, 0xd6f8u, 0x0919u
+    , 0xfbb0u, 0x3e7cu, 0xd0e9u, 0x22c8u, 0x724eu, 0x14fau, 0xd98eu, 0x40b5
+    , 0xeba0u, 0xfe50u, 0x688au, 0x1b05u, 0x5f9cu, 0xe4fcu, 0xa7b8u, 0xd3acu
+    , 0x1dddu, 0xbf04u, 0x8352u, 0xe89cu, 0x7506u, 0xe767u, 0xf489u, 0xe167
+    };
+
+unsigned int const random_unsigned_ints_binary[num_random_test_values]
+  = { BOOST_BINARY( 0 00010000 0011 ), BOOST_BINARY( 0 11101 1111  101011 )
+    , BOOST_BINARY( 010111 1100110 1 1 0 ), BOOST_BINARY( 000 1 11110 00 11000 )
+    , BOOST_BINARY( 110 001010 0110 000 ), BOOST_BINARY( 1010 01110011 1010 )
+    , BOOST_BINARY( 11 010 1 101111 1000 ), BOOST_BINARY( 0000 100100 0110 01 )
+    , BOOST_BINARY( 1111 101110 11 0000 ), BOOST_BINARY( 00111110 01111100 )
+    , BOOST_BINARY( 11  010 000111 01001 ), BOOST_BINARY( 00100 010110   01000 )
+    , BOOST_BINARY( 01 11001001 001110 ), BOOST_BINARY( 0010 1001111 1010 )
+    , BOOST_BINARY( 1101 1 00110 0 01110 ), BOOST_BINARY( 100 000 01011010 1 )
+    , BOOST_BINARY( 11 1010 1110 1000 00 ), BOOST_BINARY( 11111 110010 10000 )
+    , BOOST_BINARY( 01101 00010 001010 ), BOOST_BINARY( 000 11011 000001 01 )
+    , BOOST_BINARY( 01 01111 1100111 00 ), BOOST_BINARY( 1 110010 0111111 00 )
+    , BOOST_BINARY( 101 0011 11 01110 00 ), BOOST_BINARY( 110100 1 110101 100 )
+    , BOOST_BINARY( 00 1110111 011 101 ), BOOST_BINARY( 1011 1111 00000 100 )
+    , BOOST_BINARY( 1000 00110 101 0010 ), BOOST_BINARY( 1110  10001 001110 0 )
+    , BOOST_BINARY( 011 1010100 000 110 ), BOOST_BINARY( 1110 0111 01100 111 )
+    , BOOST_BINARY( 11110 10010 001001 ), BOOST_BINARY( 11 1000010 1100 111 )
+    };
+
+unsigned int const unsigned_ints_1_bit[2] =
+{ BOOST_BINARY( 0 )
+, BOOST_BINARY( 1 )
+};
+
+unsigned int const unsigned_ints_2_bits[4] =
+{ BOOST_BINARY( 00 )
+, BOOST_BINARY( 01 )
+, BOOST_BINARY( 10 )
+, BOOST_BINARY( 11 )
+};
+
+unsigned int const unsigned_ints_3_bits[8] =
+{ BOOST_BINARY( 000 )
+, BOOST_BINARY( 001 )
+, BOOST_BINARY( 010 )
+, BOOST_BINARY( 011 )
+, BOOST_BINARY( 100 )
+, BOOST_BINARY( 101 )
+, BOOST_BINARY( 110 )
+, BOOST_BINARY( 111 )
+};
+
+unsigned int const unsigned_ints_4_bits[16] =
+{ BOOST_BINARY( 0000 )
+, BOOST_BINARY( 0001 )
+, BOOST_BINARY( 0010 )
+, BOOST_BINARY( 0011 )
+, BOOST_BINARY( 0100 )
+, BOOST_BINARY( 0101 )
+, BOOST_BINARY( 0110 )
+, BOOST_BINARY( 0111 )
+, BOOST_BINARY( 1000 )
+, BOOST_BINARY( 1001 )
+, BOOST_BINARY( 1010 )
+, BOOST_BINARY( 1011 )
+, BOOST_BINARY( 1100 )
+, BOOST_BINARY( 1101 )
+, BOOST_BINARY( 1110 )
+, BOOST_BINARY( 1111 )
+};
+
+unsigned int const unsigned_ints_5_bits[32] =
+{ BOOST_BINARY( 00000 )
+, BOOST_BINARY( 00001 )
+, BOOST_BINARY( 00010 )
+, BOOST_BINARY( 00011 )
+, BOOST_BINARY( 00100 )
+, BOOST_BINARY( 00101 )
+, BOOST_BINARY( 00110 )
+, BOOST_BINARY( 00111 )
+, BOOST_BINARY( 01000 )
+, BOOST_BINARY( 01001 )
+, BOOST_BINARY( 01010 )
+, BOOST_BINARY( 01011 )
+, BOOST_BINARY( 01100 )
+, BOOST_BINARY( 01101 )
+, BOOST_BINARY( 01110 )
+, BOOST_BINARY( 01111 )
+, BOOST_BINARY( 10000 )
+, BOOST_BINARY( 10001 )
+, BOOST_BINARY( 10010 )
+, BOOST_BINARY( 10011 )
+, BOOST_BINARY( 10100 )
+, BOOST_BINARY( 10101 )
+, BOOST_BINARY( 10110 )
+, BOOST_BINARY( 10111 )
+, BOOST_BINARY( 11000 )
+, BOOST_BINARY( 11001 )
+, BOOST_BINARY( 11010 )
+, BOOST_BINARY( 11011 )
+, BOOST_BINARY( 11100 )
+, BOOST_BINARY( 11101 )
+, BOOST_BINARY( 11110 )
+, BOOST_BINARY( 11111 )
+};
+
+unsigned int const unsigned_ints_6_bits[64] =
+{ BOOST_BINARY( 000000 )
+, BOOST_BINARY( 000001 )
+, BOOST_BINARY( 000010 )
+, BOOST_BINARY( 000011 )
+, BOOST_BINARY( 000100 )
+, BOOST_BINARY( 000101 )
+, BOOST_BINARY( 000110 )
+, BOOST_BINARY( 000111 )
+, BOOST_BINARY( 001000 )
+, BOOST_BINARY( 001001 )
+, BOOST_BINARY( 001010 )
+, BOOST_BINARY( 001011 )
+, BOOST_BINARY( 001100 )
+, BOOST_BINARY( 001101 )
+, BOOST_BINARY( 001110 )
+, BOOST_BINARY( 001111 )
+, BOOST_BINARY( 010000 )
+, BOOST_BINARY( 010001 )
+, BOOST_BINARY( 010010 )
+, BOOST_BINARY( 010011 )
+, BOOST_BINARY( 010100 )
+, BOOST_BINARY( 010101 )
+, BOOST_BINARY( 010110 )
+, BOOST_BINARY( 010111 )
+, BOOST_BINARY( 011000 )
+, BOOST_BINARY( 011001 )
+, BOOST_BINARY( 011010 )
+, BOOST_BINARY( 011011 )
+, BOOST_BINARY( 011100 )
+, BOOST_BINARY( 011101 )
+, BOOST_BINARY( 011110 )
+, BOOST_BINARY( 011111 )
+, BOOST_BINARY( 100000 )
+, BOOST_BINARY( 100001 )
+, BOOST_BINARY( 100010 )
+, BOOST_BINARY( 100011 )
+, BOOST_BINARY( 100100 )
+, BOOST_BINARY( 100101 )
+, BOOST_BINARY( 100110 )
+, BOOST_BINARY( 100111 )
+, BOOST_BINARY( 101000 )
+, BOOST_BINARY( 101001 )
+, BOOST_BINARY( 101010 )
+, BOOST_BINARY( 101011 )
+, BOOST_BINARY( 101100 )
+, BOOST_BINARY( 101101 )
+, BOOST_BINARY( 101110 )
+, BOOST_BINARY( 101111 )
+, BOOST_BINARY( 110000 )
+, BOOST_BINARY( 110001 )
+, BOOST_BINARY( 110010 )
+, BOOST_BINARY( 110011 )
+, BOOST_BINARY( 110100 )
+, BOOST_BINARY( 110101 )
+, BOOST_BINARY( 110110 )
+, BOOST_BINARY( 110111 )
+, BOOST_BINARY( 111000 )
+, BOOST_BINARY( 111001 )
+, BOOST_BINARY( 111010 )
+, BOOST_BINARY( 111011 )
+, BOOST_BINARY( 111100 )
+, BOOST_BINARY( 111101 )
+, BOOST_BINARY( 111110 )
+, BOOST_BINARY( 111111 )
+};
+
+unsigned int const unsigned_ints_7_bits[128] =
+{ BOOST_BINARY( 0000000 )
+, BOOST_BINARY( 0000001 )
+, BOOST_BINARY( 0000010 )
+, BOOST_BINARY( 0000011 )
+, BOOST_BINARY( 0000100 )
+, BOOST_BINARY( 0000101 )
+, BOOST_BINARY( 0000110 )
+, BOOST_BINARY( 0000111 )
+, BOOST_BINARY( 0001000 )
+, BOOST_BINARY( 0001001 )
+, BOOST_BINARY( 0001010 )
+, BOOST_BINARY( 0001011 )
+, BOOST_BINARY( 0001100 )
+, BOOST_BINARY( 0001101 )
+, BOOST_BINARY( 0001110 )
+, BOOST_BINARY( 0001111 )
+, BOOST_BINARY( 0010000 )
+, BOOST_BINARY( 0010001 )
+, BOOST_BINARY( 0010010 )
+, BOOST_BINARY( 0010011 )
+, BOOST_BINARY( 0010100 )
+, BOOST_BINARY( 0010101 )
+, BOOST_BINARY( 0010110 )
+, BOOST_BINARY( 0010111 )
+, BOOST_BINARY( 0011000 )
+, BOOST_BINARY( 0011001 )
+, BOOST_BINARY( 0011010 )
+, BOOST_BINARY( 0011011 )
+, BOOST_BINARY( 0011100 )
+, BOOST_BINARY( 0011101 )
+, BOOST_BINARY( 0011110 )
+, BOOST_BINARY( 0011111 )
+, BOOST_BINARY( 0100000 )
+, BOOST_BINARY( 0100001 )
+, BOOST_BINARY( 0100010 )
+, BOOST_BINARY( 0100011 )
+, BOOST_BINARY( 0100100 )
+, BOOST_BINARY( 0100101 )
+, BOOST_BINARY( 0100110 )
+, BOOST_BINARY( 0100111 )
+, BOOST_BINARY( 0101000 )
+, BOOST_BINARY( 0101001 )
+, BOOST_BINARY( 0101010 )
+, BOOST_BINARY( 0101011 )
+, BOOST_BINARY( 0101100 )
+, BOOST_BINARY( 0101101 )
+, BOOST_BINARY( 0101110 )
+, BOOST_BINARY( 0101111 )
+, BOOST_BINARY( 0110000 )
+, BOOST_BINARY( 0110001 )
+, BOOST_BINARY( 0110010 )
+, BOOST_BINARY( 0110011 )
+, BOOST_BINARY( 0110100 )
+, BOOST_BINARY( 0110101 )
+, BOOST_BINARY( 0110110 )
+, BOOST_BINARY( 0110111 )
+, BOOST_BINARY( 0111000 )
+, BOOST_BINARY( 0111001 )
+, BOOST_BINARY( 0111010 )
+, BOOST_BINARY( 0111011 )
+, BOOST_BINARY( 0111100 )
+, BOOST_BINARY( 0111101 )
+, BOOST_BINARY( 0111110 )
+, BOOST_BINARY( 0111111 )
+, BOOST_BINARY( 1000000 )
+, BOOST_BINARY( 1000001 )
+, BOOST_BINARY( 1000010 )
+, BOOST_BINARY( 1000011 )
+, BOOST_BINARY( 1000100 )
+, BOOST_BINARY( 1000101 )
+, BOOST_BINARY( 1000110 )
+, BOOST_BINARY( 1000111 )
+, BOOST_BINARY( 1001000 )
+, BOOST_BINARY( 1001001 )
+, BOOST_BINARY( 1001010 )
+, BOOST_BINARY( 1001011 )
+, BOOST_BINARY( 1001100 )
+, BOOST_BINARY( 1001101 )
+, BOOST_BINARY( 1001110 )
+, BOOST_BINARY( 1001111 )
+, BOOST_BINARY( 1010000 )
+, BOOST_BINARY( 1010001 )
+, BOOST_BINARY( 1010010 )
+, BOOST_BINARY( 1010011 )
+, BOOST_BINARY( 1010100 )
+, BOOST_BINARY( 1010101 )
+, BOOST_BINARY( 1010110 )
+, BOOST_BINARY( 1010111 )
+, BOOST_BINARY( 1011000 )
+, BOOST_BINARY( 1011001 )
+, BOOST_BINARY( 1011010 )
+, BOOST_BINARY( 1011011 )
+, BOOST_BINARY( 1011100 )
+, BOOST_BINARY( 1011101 )
+, BOOST_BINARY( 1011110 )
+, BOOST_BINARY( 1011111 )
+, BOOST_BINARY( 1100000 )
+, BOOST_BINARY( 1100001 )
+, BOOST_BINARY( 1100010 )
+, BOOST_BINARY( 1100011 )
+, BOOST_BINARY( 1100100 )
+, BOOST_BINARY( 1100101 )
+, BOOST_BINARY( 1100110 )
+, BOOST_BINARY( 1100111 )
+, BOOST_BINARY( 1101000 )
+, BOOST_BINARY( 1101001 )
+, BOOST_BINARY( 1101010 )
+, BOOST_BINARY( 1101011 )
+, BOOST_BINARY( 1101100 )
+, BOOST_BINARY( 1101101 )
+, BOOST_BINARY( 1101110 )
+, BOOST_BINARY( 1101111 )
+, BOOST_BINARY( 1110000 )
+, BOOST_BINARY( 1110001 )
+, BOOST_BINARY( 1110010 )
+, BOOST_BINARY( 1110011 )
+, BOOST_BINARY( 1110100 )
+, BOOST_BINARY( 1110101 )
+, BOOST_BINARY( 1110110 )
+, BOOST_BINARY( 1110111 )
+, BOOST_BINARY( 1111000 )
+, BOOST_BINARY( 1111001 )
+, BOOST_BINARY( 1111010 )
+, BOOST_BINARY( 1111011 )
+, BOOST_BINARY( 1111100 )
+, BOOST_BINARY( 1111101 )
+, BOOST_BINARY( 1111110 )
+, BOOST_BINARY( 1111111 )
+};
+unsigned int const unsigned_ints_8_bits[256] =
+{ BOOST_BINARY( 00000000 )
+, BOOST_BINARY( 00000001 )
+, BOOST_BINARY( 00000010 )
+, BOOST_BINARY( 00000011 )
+, BOOST_BINARY( 00000100 )
+, BOOST_BINARY( 00000101 )
+, BOOST_BINARY( 00000110 )
+, BOOST_BINARY( 00000111 )
+, BOOST_BINARY( 00001000 )
+, BOOST_BINARY( 00001001 )
+, BOOST_BINARY( 00001010 )
+, BOOST_BINARY( 00001011 )
+, BOOST_BINARY( 00001100 )
+, BOOST_BINARY( 00001101 )
+, BOOST_BINARY( 00001110 )
+, BOOST_BINARY( 00001111 )
+, BOOST_BINARY( 00010000 )
+, BOOST_BINARY( 00010001 )
+, BOOST_BINARY( 00010010 )
+, BOOST_BINARY( 00010011 )
+, BOOST_BINARY( 00010100 )
+, BOOST_BINARY( 00010101 )
+, BOOST_BINARY( 00010110 )
+, BOOST_BINARY( 00010111 )
+, BOOST_BINARY( 00011000 )
+, BOOST_BINARY( 00011001 )
+, BOOST_BINARY( 00011010 )
+, BOOST_BINARY( 00011011 )
+, BOOST_BINARY( 00011100 )
+, BOOST_BINARY( 00011101 )
+, BOOST_BINARY( 00011110 )
+, BOOST_BINARY( 00011111 )
+, BOOST_BINARY( 00100000 )
+, BOOST_BINARY( 00100001 )
+, BOOST_BINARY( 00100010 )
+, BOOST_BINARY( 00100011 )
+, BOOST_BINARY( 00100100 )
+, BOOST_BINARY( 00100101 )
+, BOOST_BINARY( 00100110 )
+, BOOST_BINARY( 00100111 )
+, BOOST_BINARY( 00101000 )
+, BOOST_BINARY( 00101001 )
+, BOOST_BINARY( 00101010 )
+, BOOST_BINARY( 00101011 )
+, BOOST_BINARY( 00101100 )
+, BOOST_BINARY( 00101101 )
+, BOOST_BINARY( 00101110 )
+, BOOST_BINARY( 00101111 )
+, BOOST_BINARY( 00110000 )
+, BOOST_BINARY( 00110001 )
+, BOOST_BINARY( 00110010 )
+, BOOST_BINARY( 00110011 )
+, BOOST_BINARY( 00110100 )
+, BOOST_BINARY( 00110101 )
+, BOOST_BINARY( 00110110 )
+, BOOST_BINARY( 00110111 )
+, BOOST_BINARY( 00111000 )
+, BOOST_BINARY( 00111001 )
+, BOOST_BINARY( 00111010 )
+, BOOST_BINARY( 00111011 )
+, BOOST_BINARY( 00111100 )
+, BOOST_BINARY( 00111101 )
+, BOOST_BINARY( 00111110 )
+, BOOST_BINARY( 00111111 )
+, BOOST_BINARY( 01000000 )
+, BOOST_BINARY( 01000001 )
+, BOOST_BINARY( 01000010 )
+, BOOST_BINARY( 01000011 )
+, BOOST_BINARY( 01000100 )
+, BOOST_BINARY( 01000101 )
+, BOOST_BINARY( 01000110 )
+, BOOST_BINARY( 01000111 )
+, BOOST_BINARY( 01001000 )
+, BOOST_BINARY( 01001001 )
+, BOOST_BINARY( 01001010 )
+, BOOST_BINARY( 01001011 )
+, BOOST_BINARY( 01001100 )
+, BOOST_BINARY( 01001101 )
+, BOOST_BINARY( 01001110 )
+, BOOST_BINARY( 01001111 )
+, BOOST_BINARY( 01010000 )
+, BOOST_BINARY( 01010001 )
+, BOOST_BINARY( 01010010 )
+, BOOST_BINARY( 01010011 )
+, BOOST_BINARY( 01010100 )
+, BOOST_BINARY( 01010101 )
+, BOOST_BINARY( 01010110 )
+, BOOST_BINARY( 01010111 )
+, BOOST_BINARY( 01011000 )
+, BOOST_BINARY( 01011001 )
+, BOOST_BINARY( 01011010 )
+, BOOST_BINARY( 01011011 )
+, BOOST_BINARY( 01011100 )
+, BOOST_BINARY( 01011101 )
+, BOOST_BINARY( 01011110 )
+, BOOST_BINARY( 01011111 )
+, BOOST_BINARY( 01100000 )
+, BOOST_BINARY( 01100001 )
+, BOOST_BINARY( 01100010 )
+, BOOST_BINARY( 01100011 )
+, BOOST_BINARY( 01100100 )
+, BOOST_BINARY( 01100101 )
+, BOOST_BINARY( 01100110 )
+, BOOST_BINARY( 01100111 )
+, BOOST_BINARY( 01101000 )
+, BOOST_BINARY( 01101001 )
+, BOOST_BINARY( 01101010 )
+, BOOST_BINARY( 01101011 )
+, BOOST_BINARY( 01101100 )
+, BOOST_BINARY( 01101101 )
+, BOOST_BINARY( 01101110 )
+, BOOST_BINARY( 01101111 )
+, BOOST_BINARY( 01110000 )
+, BOOST_BINARY( 01110001 )
+, BOOST_BINARY( 01110010 )
+, BOOST_BINARY( 01110011 )
+, BOOST_BINARY( 01110100 )
+, BOOST_BINARY( 01110101 )
+, BOOST_BINARY( 01110110 )
+, BOOST_BINARY( 01110111 )
+, BOOST_BINARY( 01111000 )
+, BOOST_BINARY( 01111001 )
+, BOOST_BINARY( 01111010 )
+, BOOST_BINARY( 01111011 )
+, BOOST_BINARY( 01111100 )
+, BOOST_BINARY( 01111101 )
+, BOOST_BINARY( 01111110 )
+, BOOST_BINARY( 01111111 )
+, BOOST_BINARY( 10000000 )
+, BOOST_BINARY( 10000001 )
+, BOOST_BINARY( 10000010 )
+, BOOST_BINARY( 10000011 )
+, BOOST_BINARY( 10000100 )
+, BOOST_BINARY( 10000101 )
+, BOOST_BINARY( 10000110 )
+, BOOST_BINARY( 10000111 )
+, BOOST_BINARY( 10001000 )
+, BOOST_BINARY( 10001001 )
+, BOOST_BINARY( 10001010 )
+, BOOST_BINARY( 10001011 )
+, BOOST_BINARY( 10001100 )
+, BOOST_BINARY( 10001101 )
+, BOOST_BINARY( 10001110 )
+, BOOST_BINARY( 10001111 )
+, BOOST_BINARY( 10010000 )
+, BOOST_BINARY( 10010001 )
+, BOOST_BINARY( 10010010 )
+, BOOST_BINARY( 10010011 )
+, BOOST_BINARY( 10010100 )
+, BOOST_BINARY( 10010101 )
+, BOOST_BINARY( 10010110 )
+, BOOST_BINARY( 10010111 )
+, BOOST_BINARY( 10011000 )
+, BOOST_BINARY( 10011001 )
+, BOOST_BINARY( 10011010 )
+, BOOST_BINARY( 10011011 )
+, BOOST_BINARY( 10011100 )
+, BOOST_BINARY( 10011101 )
+, BOOST_BINARY( 10011110 )
+, BOOST_BINARY( 10011111 )
+, BOOST_BINARY( 10100000 )
+, BOOST_BINARY( 10100001 )
+, BOOST_BINARY( 10100010 )
+, BOOST_BINARY( 10100011 )
+, BOOST_BINARY( 10100100 )
+, BOOST_BINARY( 10100101 )
+, BOOST_BINARY( 10100110 )
+, BOOST_BINARY( 10100111 )
+, BOOST_BINARY( 10101000 )
+, BOOST_BINARY( 10101001 )
+, BOOST_BINARY( 10101010 )
+, BOOST_BINARY( 10101011 )
+, BOOST_BINARY( 10101100 )
+, BOOST_BINARY( 10101101 )
+, BOOST_BINARY( 10101110 )
+, BOOST_BINARY( 10101111 )
+, BOOST_BINARY( 10110000 )
+, BOOST_BINARY( 10110001 )
+, BOOST_BINARY( 10110010 )
+, BOOST_BINARY( 10110011 )
+, BOOST_BINARY( 10110100 )
+, BOOST_BINARY( 10110101 )
+, BOOST_BINARY( 10110110 )
+, BOOST_BINARY( 10110111 )
+, BOOST_BINARY( 10111000 )
+, BOOST_BINARY( 10111001 )
+, BOOST_BINARY( 10111010 )
+, BOOST_BINARY( 10111011 )
+, BOOST_BINARY( 10111100 )
+, BOOST_BINARY( 10111101 )
+, BOOST_BINARY( 10111110 )
+, BOOST_BINARY( 10111111 )
+, BOOST_BINARY( 11000000 )
+, BOOST_BINARY( 11000001 )
+, BOOST_BINARY( 11000010 )
+, BOOST_BINARY( 11000011 )
+, BOOST_BINARY( 11000100 )
+, BOOST_BINARY( 11000101 )
+, BOOST_BINARY( 11000110 )
+, BOOST_BINARY( 11000111 )
+, BOOST_BINARY( 11001000 )
+, BOOST_BINARY( 11001001 )
+, BOOST_BINARY( 11001010 )
+, BOOST_BINARY( 11001011 )
+, BOOST_BINARY( 11001100 )
+, BOOST_BINARY( 11001101 )
+, BOOST_BINARY( 11001110 )
+, BOOST_BINARY( 11001111 )
+, BOOST_BINARY( 11010000 )
+, BOOST_BINARY( 11010001 )
+, BOOST_BINARY( 11010010 )
+, BOOST_BINARY( 11010011 )
+, BOOST_BINARY( 11010100 )
+, BOOST_BINARY( 11010101 )
+, BOOST_BINARY( 11010110 )
+, BOOST_BINARY( 11010111 )
+, BOOST_BINARY( 11011000 )
+, BOOST_BINARY( 11011001 )
+, BOOST_BINARY( 11011010 )
+, BOOST_BINARY( 11011011 )
+, BOOST_BINARY( 11011100 )
+, BOOST_BINARY( 11011101 )
+, BOOST_BINARY( 11011110 )
+, BOOST_BINARY( 11011111 )
+, BOOST_BINARY( 11100000 )
+, BOOST_BINARY( 11100001 )
+, BOOST_BINARY( 11100010 )
+, BOOST_BINARY( 11100011 )
+, BOOST_BINARY( 11100100 )
+, BOOST_BINARY( 11100101 )
+, BOOST_BINARY( 11100110 )
+, BOOST_BINARY( 11100111 )
+, BOOST_BINARY( 11101000 )
+, BOOST_BINARY( 11101001 )
+, BOOST_BINARY( 11101010 )
+, BOOST_BINARY( 11101011 )
+, BOOST_BINARY( 11101100 )
+, BOOST_BINARY( 11101101 )
+, BOOST_BINARY( 11101110 )
+, BOOST_BINARY( 11101111 )
+, BOOST_BINARY( 11110000 )
+, BOOST_BINARY( 11110001 )
+, BOOST_BINARY( 11110010 )
+, BOOST_BINARY( 11110011 )
+, BOOST_BINARY( 11110100 )
+, BOOST_BINARY( 11110101 )
+, BOOST_BINARY( 11110110 )
+, BOOST_BINARY( 11110111 )
+, BOOST_BINARY( 11111000 )
+, BOOST_BINARY( 11111001 )
+, BOOST_BINARY( 11111010 )
+, BOOST_BINARY( 11111011 )
+, BOOST_BINARY( 11111100 )
+, BOOST_BINARY( 11111101 )
+, BOOST_BINARY( 11111110 )
+, BOOST_BINARY( 11111111 )
+};
+
+struct left_is_not_one_less_than_right
+{
+  bool operator ()( unsigned int left, unsigned int right ) const
+  {
+    return right != left + 1;
+  }
+};
+
+template< std::size_t Size >
+bool is_ascending_from_0_array( unsigned int const (&array)[Size] )
+{
+  unsigned int const* const curr = array,
+                    * const end  = array + Size;
+
+  return    ( *curr == 0 )
+         && (    std::adjacent_find( curr, end
+                                   , left_is_not_one_less_than_right()
+                                   )
+              == end
+            );
+}
+
+std::size_t const unsigned_int_id = 1,
+                  unsigned_long_int_id = 2;
+
+typedef char (&unsigned_int_id_type)[unsigned_int_id];
+typedef char (&unsigned_long_int_id_type)[unsigned_long_int_id];
+
+// Note: Functions only used for type checking
+unsigned_int_id_type      binary_type_checker( unsigned int );
+unsigned_long_int_id_type binary_type_checker( unsigned long int );
+
+int test_main( int, char *[] )
+{
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_1_bit ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_2_bits ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_3_bits ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_4_bits ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_5_bits ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_6_bits ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_7_bits ) );
+  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_8_bits ) );
+
+  BOOST_CHECK( std::equal( &random_unsigned_ints_hex[0]
+                         , random_unsigned_ints_hex + num_random_test_values
+                         , &random_unsigned_ints_binary[0]
+                         )
+             );
+
+  BOOST_CHECK(    sizeof( binary_type_checker( BOOST_BINARY_U( 110100 1010 ) ) )
+               == unsigned_int_id
+             );
+
+  BOOST_CHECK(    sizeof( binary_type_checker( BOOST_BINARY_UL( 11110 ) ) )
+               == unsigned_long_int_id
+             );
+
+  BOOST_CHECK(    sizeof( binary_type_checker( BOOST_BINARY_LU( 10 0001 ) ) )
+               == unsigned_long_int_id
+             );
+
+  return 0;
+}
--- a/call_traits.htm
+++ b/call_traits.htm
@ -606,7 +606,7 @@ template &lt;bool opt&gt;
 struct filler
 {
   template &lt;typename I, typename T&gt;
-   static void do_fill(I first, I last, typename boost::call_traits&lt;T&gt;::param_type val);
+   static void do_fill(I first, I last, typename boost::call_traits&lt;T&gt;::param_type val)
   {
      while(first != last)
      {
@ -740,25 +740,16 @@ specialisation).</p>

 <p>Revised 01 September 2000</p>

-<p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify,
-sell and distribute this document is granted provided this
-copyright notice appears in all copies. This document is provided
-&quot;as is&quot; without express or implied warranty, and with
-no claim as to its suitability for any purpose.</p>
-
-<p>Based on contributions by Steve Cleary, Beman Dawes, Howard
-Hinnant and John Maddock.</p>
-
-<p>Maintained by <a href="mailto:john@johnmaddock.co.uk">John
-Maddock</a>, the latest version of this file can be found at <a
-href="http://www.boost.org/">www.boost.org</a>, and the boost
-discussion list at <a
-href="http://www.yahoogroups.com/list/boost">www.yahoogroups.com/list/boost</a>.</p>
-
-<p>.</p>
-
-<p>&nbsp;</p>
-
-<p>&nbsp;</p>
+   <p>
+      Copyright 2000 Steve Cleary, Beman Dawes, Howard
+      Hinnant and John Maddock. <br/>
+      Use, modification and distribution are subject to 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">
+         http://www.boost.org/LICENSE_1_0.txt
+      </a>).
+   </p>
 </body>
 </html>
+
--- a/call_traits_test.cpp
+++ b/call_traits_test.cpp
@ -12,7 +12,6 @@
 // 03 Oct 2000:
 //    Enabled extra tests for VC6.

-#include <cassert>
 #include <iostream>
 #include <iomanip>
 #include <algorithm>
@ -22,39 +21,9 @@
 #include <libs/type_traits/test/test.hpp>
 #include <libs/type_traits/test/check_type.hpp>

-//
-// define tests here
-unsigned failures = 0;
-unsigned test_count = 0;
-//
-// This must get defined within the test file.
-// All compilers have bugs, set this to the number of
-// regressions *expected* from a given compiler,
-// if there are no workarounds for the bugs, *and*
-// the regressions have been investigated.
-//
-extern unsigned int expected_failures;
-//
-// proc check_result()
-// Checks that there were no regressions:
-//
-int check_result(int argc, char** argv)
-{
-   std::cout << test_count << " tests completed, "
-      << failures << " failures found, "
-      << expected_failures << " failures expected from this compiler." << std::endl;
-   if((argc == 2) 
-      && (argv[1][0] == '-')
-      && (argv[1][1] == 'a')
-      && (argv[1][2] == 0))
-   {
-      std::cout << "Press any key to continue...";
-      std::cin.get();
-   }
-   return (failures == expected_failures)
-       ? 0
-       : (failures != 0) ? static_cast<int>(failures) : -1;
-}
+#ifdef BOOST_MSVC
+#pragma warning(disable:4181) // : warning C4181: qualifier applied to reference type; ignored
+#endif

 // a way prevent warnings for unused variables
 template<class T> inline void unused_variable(const T&) {}
@ -87,7 +56,8 @@ struct contained
   const_reference const_get()const { return v_; }
   // pass value:
   void call(param_type){}
-
+private:
+   contained& operator=(const contained&);
 };

 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@ -112,6 +82,8 @@ struct contained<T[N]>
   reference get() { return v_; }
   const_reference const_get()const { return v_; }
   void call(param_type){}
+private:
+   contained& operator=(const contained&);
 };
 #endif

@ -156,9 +128,9 @@ void call_traits_checker<T>::operator()(param_type p)
   T t(p);
   contained<T> c(t);
   cout << "checking contained<" << typeid(T).name() << ">..." << endl;
-   assert(t == c.value());
-   assert(t == c.get());
-   assert(t == c.const_get());
+   BOOST_CHECK(t == c.value());
+   BOOST_CHECK(t == c.get());
+   BOOST_CHECK(t == c.const_get());
 #ifndef __ICL
   //cout << "typeof contained<" << typeid(T).name() << ">::v_ is:           " << typeid(&contained<T>::v_).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::value() is:      " << typeid(&contained<T>::value).name() << endl;
@ -180,11 +152,11 @@ struct call_traits_checker<T[N]>
      cout << "checking contained<" << typeid(T[N]).name() << ">..." << endl;
      unsigned int i = 0;
      for(i = 0; i < N; ++i)
-         assert(t[i] == c.value()[i]);
+         BOOST_CHECK(t[i] == c.value()[i]);
      for(i = 0; i < N; ++i)
-         assert(t[i] == c.get()[i]);
+         BOOST_CHECK(t[i] == c.get()[i]);
      for(i = 0; i < N; ++i)
-         assert(t[i] == c.const_get()[i]);
+         BOOST_CHECK(t[i] == c.const_get()[i]);

      cout << "typeof contained<" << typeid(T[N]).name() << ">::v_ is:         " << typeid(&contained<T[N]>::v_).name() << endl;
      cout << "typeof contained<" << typeid(T[N]).name() << ">::value is:      " << typeid(&contained<T[N]>::value).name() << endl;
@ -202,7 +174,7 @@ template <class W, class U>
 void check_wrap(const W& w, const U& u)
 {
   cout << "checking " << typeid(W).name() << "..." << endl;
-   assert(w.value() == u);
+   BOOST_CHECK(w.value() == u);
 }

 //
@ -213,8 +185,8 @@ template <class T, class U, class V>
 void check_make_pair(T c, U u, V v)
 {
   cout << "checking std::pair<" << typeid(c.first).name() << ", " << typeid(c.second).name() << ">..." << endl;
-   assert(c.first == u);
-   assert(c.second == v);
+   BOOST_CHECK(c.first == u);
+   BOOST_CHECK(c.second == v);
   cout << endl;
 }

@ -232,7 +204,7 @@ struct comparible_UDT
   bool operator == (const comparible_UDT& v){ return v.i_ == i_; }
 };

-int main(int argc, char *argv[ ])
+int main()
 {
   call_traits_checker<comparible_UDT> c1;
   comparible_UDT u;
@ -290,8 +262,6 @@ int main(int argc, char *argv[ ])
   BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::param_type);
 #else
   std::cout << "Your compiler cannot instantiate call_traits<int&const>, skipping four tests (4 errors)" << std::endl;
-   failures += 4;
-   test_count += 4;
 #endif
   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::value_type);
   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::reference);
@ -313,13 +283,9 @@ int main(int argc, char *argv[ ])
   BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::param_type);
 #else
   std::cout << "You're compiler does not support partial template specialiation, skipping 8 tests (8 errors)" << std::endl;
-   failures += 12;
-   test_count += 12;
 #endif
 #else
   std::cout << "You're compiler does not support partial template specialiation, skipping 20 tests (20 errors)" << std::endl;
-   failures += 24;
-   test_count += 24;
 #endif
   // test with an incomplete type:
   BOOST_CHECK_TYPE(incomplete_type, boost::call_traits<incomplete_type>::value_type);
@ -327,12 +293,12 @@ int main(int argc, char *argv[ ])
   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference);
   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::param_type);

-   return check_result(argc, argv);
+   return 0;
 }

 //
 // define call_traits tests to check that the assertions in the docs do actually work
-// this is an instantiate only set of tests:
+// this is an compile-time only set of tests:
 //
 template <typename T, bool isarray = false>
 struct call_traits_test
@ -444,23 +410,3 @@ template struct call_traits_test<int[2], true>;
 #endif
 #endif

-#if defined(BOOST_MSVC) && _MSC_VER <= 1300
-unsigned int expected_failures = 12;
-#elif defined(__SUNPRO_CC)
-#if(__SUNPRO_CC <= 0x520)
-unsigned int expected_failures = 18;
-#elif(__SUNPRO_CC < 0x530)
-unsigned int expected_failures = 17;
-#else
-unsigned int expected_failures = 6;
-#endif
-#elif defined(__BORLANDC__)
-unsigned int expected_failures = 2;
-#elif (defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC__ == 3) && (__GNUC_MINOR__ < 1)))
-unsigned int expected_failures = 4;
-#elif defined(__HP_aCC)
-unsigned int expected_failures = 24;
-#else
-unsigned int expected_failures = 0;
-#endif
-
--- a/checked_delete.html
+++ b/checked_delete.html
@ -115,9 +115,8 @@ template&lt;class T&gt; struct checked_array_deleter
 		</p>
 		<p>
 			<br>
-			<small>Copyright <20> 2002 by Peter Dimov. Permission to copy, use, modify, sell and 
-				distribute this document is granted provided this copyright notice appears in 
-				all copies. This document is provided "as is" without express or implied 
-				warranty, and with no claim as to its suitability for any purpose.</small></p>
+			<small>Copyright <20> 2002 by Peter Dimov. Distributed under the Boost Software License, Version 
+				1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
+				copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
 	</body>
 </html>
--- a/compressed_pair.htm
+++ b/compressed_pair.htm
@ -3,7 +3,7 @@
      <title>Header </title>
      <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
      <meta name="Template" content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-      <meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
+      <meta name="GENERATOR" content="Microsoft FrontPage 5.0">
      <boostcompressed_pair.hpp>
   </head>
   <body bgcolor="#ffffff" text="#000000" link="#0000ff" vlink="#800080">
@ -59,17 +59,18 @@ public:
         empty type, then assigning to that member will produce memory corruption, 
         unless the empty type has a "do nothing" assignment operator defined. This is 
         due to a bug in the way VC6 generates implicit assignment operators.</p>
-      <hr>
-      <p>Revised 08 May 2001</p>
-      <p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify, sell and 
-         distribute this document is granted provided this copyright notice appears in 
-         all copies. This document is provided "as is" without express or implied 
-         warranty, and with no claim as to its suitability for any purpose.</p>
+      <h3>Acknowledgements</h3>
      <p>Based on contributions by Steve Cleary, Beman Dawes, Howard Hinnant and John 
         Maddock.</p>
      <p>Maintained by <a href="mailto:john@johnmaddock.co.uk">John Maddock</a>, the 
         latest version of this file can be found at <a href="http://www.boost.org">www.boost.org</a>, 
         and the boost discussion list at <a href="http://www.yahoogroups.com/list/boost">www.yahoogroups.com/list/boost</a>.</p>
-      <p>&nbsp;</p>
+      <hr>
+      <p>Revised
+      <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->07 November 2007<!--webbot bot="Timestamp" endspan i-checksum="40338" --></p>
+      <p><EFBFBD> Copyright Beman Dawes, 2000.</p>
+<p>Distributed under the Boost Software License, Version 1.0. See
+<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
+
   </body>
-</html>
+</html>
--- a/current_function.html
+++ b/current_function.html
@ -29,9 +29,8 @@
 			function. On such compilers, the string literal has an unspecified value.</p>
 		<p>
 			<br>
-			<small>Copyright <20> 2002 by Peter Dimov. Permission to copy, use, modify, sell and 
-				distribute this document is granted provided this copyright notice appears in 
-				all copies. This document is provided "as is" without express or implied 
-				warranty, and with no claim as to its suitability for any purpose.</small></p>
+			<small>Copyright <20> 2002 by Peter Dimov. Distributed under the Boost Software License, Version 
+				1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
+				copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
 	</body>
 </html>
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -0,0 +1,68 @@
+
+# Copyright John Maddock 2005. Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+project : requirements
+        # Path for links to Boost:
+        <xsl:param>boost.root=../../../..
+        
+        # Some general style settings:
+        <xsl:param>table.footnote.number.format=1
+        <xsl:param>footnote.number.format=1
+
+        # HTML options first:
+        # Use graphics not text for navigation:
+        <xsl:param>navig.graphics=1
+       # PDF Options:
+        # TOC Generation: this is needed for FOP-0.9 and later:
+        <xsl:param>fop1.extensions=0
+        <xsl:param>xep.extensions=1
+        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
+        <xsl:param>fop.extensions=0
+        # No indent on body text:
+        <xsl:param>body.start.indent=0pt
+        # Margin size:
+        <xsl:param>page.margin.inner=0.5in
+        # Margin size:
+        <xsl:param>page.margin.outer=0.5in
+        # Paper type = A4
+        <xsl:param>paper.type=A4
+        # Yes, we want graphics for admonishments:
+        <xsl:param>admon.graphics=1
+        # Set this one for PDF generation *only*:
+        # default pnd graphics are awful in PDF form,
+        # better use SVG's instead:
+        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
+        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/utility/doc/html
+;
+
+using quickbook ;
+
+path-constant boost-images : ../../../doc/src/images ;
+
+xml declval : declval.qbk ;
+boostbook standalone
+    :
+        declval
+    :
+        # File name of HTML output:
+        <xsl:param>root.filename=declval
+        # How far down we chunk nested sections, basically all of them:
+        <xsl:param>chunk.section.depth=0
+        # Don't put the first section on the same page as the TOC:
+        <xsl:param>chunk.first.sections=0
+        # How far down sections get TOC's
+        <xsl:param>toc.section.depth=1
+        # Max depth in each TOC:
+        <xsl:param>toc.max.depth=1
+        # How far down we go with TOC's
+        <xsl:param>generate.section.toc.level=1
+        
+     ;
+
+
+
+
+
--- a/doc/declval.qbk
+++ b/doc/declval.qbk
@ -0,0 +1,104 @@
+[/
+ / Copyright (c) 2008 Howard Hinnant
+ / Copyright (c) 2008 Beman Dawes
+ / Copyright (c) 2009-20010 Vicente J. Botet Escriba
+ /
+ / Distributed under the Boost Software License, Version 1.0. (See accompanying
+ / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ /]
+
+[article Declval
+    [quickbook 1.5]
+    [authors [Hinnant, Howard]]
+    [authors [Dawes, Beman]]
+    [authors [Botet Escriba, Vicente J.]]
+    [copyright 2008 Howard Hinnant]
+    [copyright 2008 Beman Dawes]
+    [copyright 2009-2010 Vicente J. Botet Escriba]
+    [license
+        Distributed under the Boost Software License, Version 1.0.
+        (See accompanying file LICENSE_1_0.txt or copy at
+        [@http://www.boost.org/LICENSE_1_0.txt])
+    ]
+]
+
+[/===============]
+[section Overview]
+[/===============]
+
+The motivation for `declval` was introduced in [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2958.html#Value N2958: 
+Moving Swap Forward]. Here follows a rewording of this chapter.
+
+With the provision of decltype, late-specified return types, and default template-arguments for function templates a 
+new generation of SFINAE patterns will emerge to at least partially compensate the lack of concepts on the C++0x timescale. 
+Using this technique, it is sometimes necessary to obtain an object of a known type in a non-using context, e.g. given the declaration 
+
+  template<class T>
+  T&& declval(); // not used
+  
+as part of the function template declaration 
+
+  template<class To, class From>
+  decltype(static_cast<To>(declval<From>())) convert(From&&);
+  
+or as part of a class template definition 
+
+  template<class> class result_of;
+
+  template<class Fn, class... ArgTypes>
+  struct result_of<Fn(ArgTypes...)> 
+  {
+    typedef decltype(declval<Fn>()(declval<ArgTypes>()...)) type;
+  };
+  
+The role of the function template declval() is a transformation of a type T into a value without using or evaluating this function. 
+The name is supposed to direct the reader's attention to the fact that the expression `declval<T>()` is an lvalue if and only if 
+T is an lvalue-reference, otherwise an rvalue. To extend the domain of this function we can do a bit better by changing its declaration to 
+
+  template<class T>
+  typename std::add_rvalue_reference<T>::type declval(); // not used
+  
+which ensures that we can also use cv void as template parameter. The careful reader might have noticed that `declval()` 
+already exists under the name create() as part of the definition of the semantics of the type trait is_convertible in the C==0x standard. 
+
+The provision of a new library component that allows the production of values in unevaluated expressions is considered as 
+important to realize constrained templates in C++0x where concepts are not available. 
+This extremely light-weight function is expected to be part of the daily tool-box of the C++0x programmer. 
+
+[endsect]
+
+
+[/=================]
+[section:reference Reference ]
+[/=================]
+
+`#include <boost/utility/declval.hpp>`
+
+    namespace boost {
+
+        template <typename T>
+        typename add_rvalue_reference<T>::type declval(); //noexcept; // as unevaluated operand
+
+    }  // namespace boost
+
+
+The library provides the function template declval to simplify the definition of expressions which occur as unevaluated operands.
+
+        template <typename T>
+        typename add_rvalue_reference<T>::type declval();
+
+[*Remarks:] If this function is used, the program is ill-formed.
+
+[*Remarks:] The template parameter T of declval may be an incomplete type.
+
+[*Example:]
+
+    template <class To, class From>
+    decltype(static_cast<To>(declval<From>())) convert(From&&);
+
+Declares a function template convert which only participats in overloading if the type From can be explicitly converted to type To. 
+
+[endsect]
+
+
+
--- a/doc/html/declval.html
+++ b/doc/html/declval.html
@ -0,0 +1,163 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Declval</title>
+<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
+<link rel="home" href="declval.html" title="Declval">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
+<td align="center"><a href="../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"></div>
+<div class="article" lang="en">
+<div class="titlepage">
+<div>
+<div><h2 class="title">
+<a name="declval"></a>Declval</h2></div>
+<div><div class="authorgroup">
+<div class="author"><h3 class="author">
+<span class="firstname">Howard</span> <span class="surname">Hinnant</span>
+</h3></div>
+<div class="author"><h3 class="author">
+<span class="firstname">Beman</span> <span class="surname">Dawes</span>
+</h3></div>
+<div class="author"><h3 class="author">
+<span class="firstname">Vicente J.</span> <span class="surname">Botet Escriba</span>
+</h3></div>
+</div></div>
+<div><p class="copyright">Copyright &#169; 2008 Howard Hinnant</p></div>
+<div><p class="copyright">Copyright &#169; 2008 Beman Dawes</p></div>
+<div><p class="copyright">Copyright &#169; 2009 -2010 Vicente J. Botet Escriba</p></div>
+<div><div class="legalnotice">
+<a name="id879409"></a><p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></div>
+</div>
+<hr>
+</div>
+<div class="toc">
+<p><b>Table of Contents</b></p>
+<dl>
+<dt><span class="section"><a href="declval.html#declval.overview">Overview</a></span></dt>
+<dt><span class="section"><a href="declval.html#declval.reference"> Reference </a></span></dt>
+</dl>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="declval.overview"></a><a class="link" href="declval.html#declval.overview" title="Overview">Overview</a>
+</h2></div></div></div>
+<p>
+      The motivation for <code class="computeroutput"><span class="identifier">declval</span></code>
+      was introduced in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2958.html#Value" target="_top">N2958:
+      Moving Swap Forward</a>. Here follows a rewording of this chapter.
+    </p>
+<p>
+      With the provision of decltype, late-specified return types, and default template-arguments
+      for function templates a new generation of SFINAE patterns will emerge to at
+      least partially compensate the lack of concepts on the C++0x timescale. Using
+      this technique, it is sometimes necessary to obtain an object of a known type
+      in a non-using context, e.g. given the declaration
+    </p>
+<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="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">declval</span><span class="special">();</span> <span class="comment">// not used
+</span></pre>
+<p>
+      as part of the function template declaration
+    </p>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">To</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">From</span><span class="special">&gt;</span>
+<span class="identifier">decltype</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">To</span><span class="special">&gt;(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">From</span><span class="special">&gt;()))</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">From</span><span class="special">&amp;&amp;);</span>
+</pre>
+<p>
+      or as part of a class template definition
+    </p>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">result_of</span><span class="special">;</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Fn</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">ArgTypes</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">result_of</span><span class="special">&lt;</span><span class="identifier">Fn</span><span class="special">(</span><span class="identifier">ArgTypes</span><span class="special">...)&gt;</span> 
+<span class="special">{</span>
+  <span class="keyword">typedef</span> <span class="identifier">decltype</span><span class="special">(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">Fn</span><span class="special">&gt;()(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">ArgTypes</span><span class="special">&gt;()...))</span> <span class="identifier">type</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<p>
+      The role of the function template declval() is a transformation of a type T
+      into a value without using or evaluating this function. The name is supposed
+      to direct the reader's attention to the fact that the expression <code class="computeroutput"><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span></code> is
+      an lvalue if and only if T is an lvalue-reference, otherwise an rvalue. To
+      extend the domain of this function we can do a bit better by changing its declaration
+      to
+    </p>
+<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">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">add_rvalue_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">declval</span><span class="special">();</span> <span class="comment">// not used
+</span></pre>
+<p>
+      which ensures that we can also use cv void as template parameter. The careful
+      reader might have noticed that <code class="computeroutput"><span class="identifier">declval</span><span class="special">()</span></code> already exists under the name create() as
+      part of the definition of the semantics of the type trait is_convertible in
+      the C==0x standard.
+    </p>
+<p>
+      The provision of a new library component that allows the production of values
+      in unevaluated expressions is considered as important to realize constrained
+      templates in C++0x where concepts are not available. This extremely light-weight
+      function is expected to be part of the daily tool-box of the C++0x programmer.
+    </p>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="declval.reference"></a><a class="link" href="declval.html#declval.reference" title="Reference"> Reference </a>
+</h2></div></div></div>
+<p>
+      <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">/</span><span class="identifier">declval</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+    </p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+
+    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
+    <span class="keyword">typename</span> <span class="identifier">add_rvalue_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">declval</span><span class="special">();</span> <span class="comment">//noexcept; // as unevaluated operand
+</span>
+<span class="special">}</span>  <span class="comment">// namespace boost
+</span></pre>
+<p>
+      The library provides the function template declval to simplify the definition
+      of expressions which occur as unevaluated operands.
+    </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<span class="keyword">typename</span> <span class="identifier">add_rvalue_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">declval</span><span class="special">();</span>
+</pre>
+<p>
+      <span class="bold"><strong>Remarks:</strong></span> If this function is used, the program
+      is ill-formed.
+    </p>
+<p>
+      <span class="bold"><strong>Remarks:</strong></span> The template parameter T of declval
+      may be an incomplete type.
+    </p>
+<p>
+      <span class="bold"><strong>Example:</strong></span>
+    </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">To</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">From</span><span class="special">&gt;</span>
+<span class="identifier">decltype</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">To</span><span class="special">&gt;(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">From</span><span class="special">&gt;()))</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">From</span><span class="special">&amp;&amp;);</span>
+</pre>
+<p>
+      Declares a function template convert which only participats in overloading
+      if the type From can be explicitly converted to type To.
+    </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"><p><small>Last revised: September 16, 2010 at 16:19:10 GMT</small></p></td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"></div>
+</body>
+</html>
--- a/enable_if.html
+++ b/enable_if.html
@ -366,17 +366,18 @@ David Vandevoorde and Nicolai&nbsp;M. Josuttis.
 <EM>C++ Templates: The Complete Guide</EM>.
 Addison-Wesley, 2002.</DL>

-
-
-
-
-<hr></hr>
-
-<B>Contributed by:</B> <BR>
-Jaakko J&auml;rvi, Jeremiah Willcock and Andrew Lumsdaine<BR>
+<hr/>
+   <p>Copyright Jaakko J&auml;rvi, Jeremiah Willcock and Andrew Lumsdaine<BR>
 <EM>{jajarvi|jewillco|lums}@osl.iu.edu</EM><BR>
 Indiana University<BR>
-Open Systems Lab
+Open Systems Lab<br/>
+Use, modification and distribution are subject to 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">
+   http://www.boost.org/LICENSE_1_0.txt
+</a>).
+</p>
 <!--HTMLFOOT-->
 <!--ENDHTML-->
 <!--FOOTER-->
--- a/enable_if/test/Jamfile
+++ b/enable_if/test/Jamfile
@ -1,33 +0,0 @@
-# Copyright David Abrahams 2003.
-# Distributed under the Boost Software License, Version 1.0. 
-# (See accompanying file LICENSE_1_0.txt or copy at 
-# http://www.boost.org/LICENSE_1_0.txt)
-
-# For more information, see http://www.boost.org/
-
-subproject libs/utility/enable_if/test ;
-
-# bring in rules for testing
-import testing ;
-
-# Make tests run by default.
-DEPENDS all : test ;
-
-{
-    local test_monitor = <lib>@boost/libs/test/build/boost_test_exec_monitor ;
-
-    # look in BOOST_ROOT for sources first, just in this Jamfile
-    local SEARCH_SOURCE = $(BOOST_ROOT) $(SEARCH_SOURCE) ;
-
-    test-suite utility/enable_if
-        :
-        [ run libs/utility/enable_if/test/constructors.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/dummy_arg_disambiguation.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/lazy.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/lazy_test.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/member_templates.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/namespace_disambiguation.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/no_disambiguation.cpp $(test_monitor) ]
-        [ run libs/utility/enable_if/test/partial_specializations.cpp $(test_monitor) ]
-    ;
-}
--- a/enable_if/test/constructors.cpp
+++ b/enable_if/test/constructors.cpp
@ -1,12 +1,12 @@
 // Boost enable_if library

-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.

 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)

--- a/enable_if/test/dummy_arg_disambiguation.cpp
+++ b/enable_if/test/dummy_arg_disambiguation.cpp
@ -1,12 +1,12 @@
 // Boost enable_if library

-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.

 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)

--- a/enable_if/test/lazy.cpp
+++ b/enable_if/test/lazy.cpp
@ -1,12 +1,12 @@
 // Boost enable_if library

-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.

 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)

--- a/enable_if/test/lazy_test.cpp
+++ b/enable_if/test/lazy_test.cpp
@ -1,12 +1,12 @@
 // Boost enable_if library

-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.

 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)

--- a/enable_if/test/member_templates.cpp
+++ b/enable_if/test/member_templates.cpp
@ -1,12 +1,12 @@
 // Boost enable_if library

-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.

 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)

--- a/enable_if/test/namespace_disambiguation.cpp
+++ b/enable_if/test/namespace_disambiguation.cpp
@ -1,12 +1,12 @@
 // Boost enable_if library

-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.

 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)

--- a/enable_if/test/no_disambiguation.cpp
+++ b/enable_if/test/no_disambiguation.cpp
@ -1,12 +1,12 @@
 // Boost enable_if library

-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.

 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)

--- a/enable_if/test/partial_specializations.cpp
+++ b/enable_if/test/partial_specializations.cpp
@ -1,12 +1,12 @@
 // Boost enable_if library

-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.

 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)

--- a/generator_iterator.htm
+++ b/generator_iterator.htm
@ -1,33 +1,37 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

 <html>
 <head>
-<title>Generator Iterator Adaptor Documentation</title>
+  <meta http-equiv="Content-Language" content="en-us">
+  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
+
+  <title>Generator Iterator Adaptor Documentation</title>
 </head>

 <body bgcolor="#FFFFFF" text="#000000">
-        
-<img src="../../boost.png" alt="boost.png (6897 bytes)" align="center" width="277" height="86"> 
+  <img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle"
+  width="277" height="86">

-<h1>Generator Iterator Adaptor</h1>
-Defined in header <a href="../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a> 
-<p>
-The generator iterator adaptor makes it easier to create custom input
-iterators from 0-ary functions and function objects.  The adaptor
-takes a
-<a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a>
-and creates a model of
-<a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.
-Each increment retrieves an item from the generator and makes it
-available to be retrieved by dereferencing.  The motivation for this
-iterator is that some concepts can be more naturally expressed as a
-generator, while most STL algorithms expect an iterator.  An example
-is the <a href="../random/index.html">Random Number</a> library.
+  <h1>Generator Iterator Adaptor</h1>

-<h2>Synopsis</h2>
+  <p>Defined in header <a href=
+  "../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a></p>

-<blockquote>
-<pre>
+  <p>The generator iterator adaptor makes it easier to create custom input
+  iterators from 0-ary functions and function objects. The adaptor takes a
+  <a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a> and
+  creates a model of <a href=
+  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>. Each
+  increment retrieves an item from the generator and makes it available to be
+  retrieved by dereferencing. The motivation for this iterator is that some
+  concepts can be more naturally expressed as a generator, while most STL
+  algorithms expect an iterator. An example is the <a href=
+  "../random/index.html">Random Number</a> library.</p>
+
+  <h2>Synopsis</h2>
+
+  <blockquote>
+    <pre>
 namespace boost {
  template &lt;class Generator&gt;
  class generator_iterator_policies;
@ -40,21 +44,19 @@ namespace boost {
  make_generator_iterator(Generator &amp; gen);
 }
 </pre>
-</blockquote>
+  </blockquote>
+  <hr>

-<hr>
+  <h2>The Generator Iterator Generator Class</h2>

-<h2>The Generator Iterator Generator Class</h2>
-
-The class generator_iterator_generator is a helper class whose purpose
-is to construct a generator iterator type. The template parameter for
-this class is the Generator function object type that is being
-wrapped.  The generator iterator adaptor only holds a reference (or
-pointer) to the function object, therefore the function object must
-outlive the generator iterator adaptor constructed from it.
-
-<pre>
-template &lt;class Generator>
+  <p>The class generator_iterator_generator is a helper class whose purpose
+  is to construct a generator iterator type. The template parameter for this
+  class is the Generator function object type that is being wrapped. The
+  generator iterator adaptor only holds a reference (or pointer) to the
+  function object, therefore the function object must outlive the generator
+  iterator adaptor constructed from it.</p>
+  <pre>
+template &lt;class Generator&gt;
 class generator_iterator_generator
 {
 public:
@ -62,65 +64,65 @@ public:
 }
 </pre>

+  <h3>Template Parameters</h3>

-<h3>Template Parameters</h3>
+  <table border summary="">
+    <tr>
+      <th>Parameter</th>

-<table border>
-<tr>
-<th>Parameter</th>
-<th>Description</th>
-</tr>
+      <th>Description</th>
+    </tr>

-<tr>
-<td><tt><a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt> 
-<td>The generator (0-ary function object) type being
-wrapped.  The return type of the function must be defined as
-<tt>Generator::result_type</tt>.  The function object must be a model
-of
-<a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a>.
-</td>
-</table>
+    <tr>
+      <td><tt><a href=
+      "http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt></td>

-<h3>Concept Model</h3>
-The generator iterator class is a model of
-<a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.
+      <td>The generator (0-ary function object) type being wrapped. The
+      return type of the function must be defined as
+      <tt>Generator::result_type</tt>. The function object must be a model of
+      <a href=
+      "http://www.sgi.com/tech/stl/Generator.html">Generator</a>.</td>
+    </tr>
+  </table>

-<h3>Members</h3>
-The generator iterator implements the member functions
-and operators required of the
-<a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
-concept.
+  <h3>Concept Model</h3>

-<br>
+  <p>The generator iterator class is a model of <a href=
+  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.</p>

-<hr>
-<h2><a name="make_generator_iterator">The Generator Iterator Object Generator</a></h2>
+  <h3>Members</h3>

-The <tt>make_generator_iterator()</tt> function provides a
-convenient way to create generator iterator objects. The function
-saves the user the trouble of explicitly writing out the iterator
-types.
+  <p>The generator iterator implements the member functions and operators
+  required of the <a href=
+  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
+  concept.<br></p>
+  <hr>

-<blockquote>
-<pre>
+  <h2><a name="make_generator_iterator" id="make_generator_iterator">The
+  Generator Iterator Object Generator</a></h2>
+
+  <p>The <tt>make_generator_iterator()</tt> function provides a convenient
+  way to create generator iterator objects. The function saves the user the
+  trouble of explicitly writing out the iterator types.</p>
+
+  <blockquote>
+    <pre>
 template &lt;class Generator&gt;
 typename generator_iterator_generator&lt;Generator&gt;::type
 make_generator_iterator(Generator &amp; gen);
 </pre>
-</blockquote>
+  </blockquote>
+  <hr>

-<hr>
+  <h3>Example</h3>

+  <p>The following program shows how <code>generator_iterator</code>
+  transforms a generator into an input iterator.</p>

-<h3>Example</h3>
-
-The following program shows how <code>generator_iterator</code>
-transforms a generator into an input iterator.
-
-<blockquote>
-<pre>
-#include &lt;iostream>
-#include &lt;boost/generator_iterator.hpp>
+  <blockquote>
+    <pre>
+#include &lt;iostream&gt;
+#include &lt;boost/generator_iterator.hpp&gt;

 class my_generator
 {
@ -140,11 +142,22 @@ int main()
    std::cout &lt;&lt; *it &lt;&lt; std::endl;
 }
 </pre>
-</blockquote>
+  </blockquote>
+  <hr>

-<hr>
+  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
+  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
+  height="31" width="88"></a></p>

-Written by Jens Maurer.
+  <p>Revised 
+  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05 December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>

+  <p><i>Copyright &copy; 2001 <a href=
+  "http://www.boost.org/people/jens_maurer.htm">Jens Maurer</a></i></p>
+
+  <p><i>Distributed under the Boost Software License, Version 1.0. (See
+  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
+  copy at <a href=
+  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
 </body>
 </html>
--- a/in_place_factories.html
+++ b/in_place_factories.html
@ -3,9 +3,8 @@
 <HTML>

 <HEAD>
-<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
-<LINK REL="stylesheet" TYPE="text/css" HREF="../../boost.css">
-<TITLE>Header </TITLE>
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=windows-1252">
+<TITLE>In_place_factory Documentation</TITLE>
 </HEAD>

 <BODY BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#800080">
@ -77,7 +76,7 @@ object is likely to be temporary and serve no purpose besides being the source</
 </pre>
 <p>A solution to this problem is to support direct construction of the contained
 object right in the container's storage.<br>
-In this shceme, the user supplies the arguments for the X constructor
+In this scheme, the user supplies the arguments for the X constructor
 directly to the container:</p>
 <pre>struct C
 {
@ -100,7 +99,7 @@ directly to the container:</p>
 <H2><A NAME="framework"></A>Framework</H2>
 <p>
 This library proposes a framework to allow some containers to directly contruct contained objects in-place without requiring
-the entire set of constructor overloads ftom the contained type. It also allows the container to remove the CopyConstuctible
+the entire set of constructor overloads from the contained type. It also allows the container to remove the CopyConstuctible
 requirement from the contained type since objects can be directly constructed in-place without need of a copy.<br>
 The only requirement on the container is that it must provide proper storage (that is, correctly aligned and sized).
 Naturally, the container will typically support uninitialized storage to avoid the in-place construction to override
@ -118,7 +117,7 @@ The following simplified example shows the basic idea. A complete example follow
 <pre>struct C
 {
   template&lt;class InPlaceFactory&gt;
-   C ( InPlaceFactory const& aFactoty )
+   C ( InPlaceFactory const& aFactory )
    :
    contained_ ( uninitialized_storage() )
   {
@ -138,7 +137,7 @@ The following simplified example shows the basic idea. A complete example follow

 void foo()
 {
-  C c( in_place(123,"hello" ) ;
+  C c( in_place(123,"hello") ) ;
 }
 </pre>

@ -294,4 +293,4 @@ the latest version of this file can be found at <A
 HREF="http://www.boost.org">www.boost.org</A>, and the boost
 <A HREF="http://www.boost.org/more/mailing_lists.htm#main">discussion lists</A></P>
 </BODY>
-</HTML>
+</HTML>
--- a/include/boost/assert.hpp
+++ b/include/boost/assert.hpp
@ -1,7 +1,11 @@
 //
 //  boost/assert.hpp - BOOST_ASSERT(expr)
+//                     BOOST_ASSERT_MSG(expr, msg)
+//                     BOOST_VERIFY(expr)
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2007 Peter Dimov
+//  Copyright (c) Beman Dawes 2011
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@ -12,6 +16,16 @@
 //  See http://www.boost.org/libs/utility/assert.html for documentation.
 //

+//
+// Stop inspect complaining about use of 'assert':
+//
+// boostinspect:naassert_macro
+//
+
+//--------------------------------------------------------------------------------------//
+//                                     BOOST_ASSERT                                     //
+//--------------------------------------------------------------------------------------//
+
 #undef BOOST_ASSERT

 #if defined(BOOST_DISABLE_ASSERTS)
@ -24,14 +38,94 @@

 namespace boost
 {
-
-void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
-
+  void assertion_failed(char const * expr,
+                        char const * function, char const * file, long line); // user defined
 } // namespace boost

-#define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+#define BOOST_ASSERT(expr) ((expr) \
+  ? ((void)0) \
+  : ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))

 #else
 # include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
 # define BOOST_ASSERT(expr) assert(expr)
 #endif
+
+//--------------------------------------------------------------------------------------//
+//                                   BOOST_ASSERT_MSG                                   //
+//--------------------------------------------------------------------------------------//
+
+# undef BOOST_ASSERT_MSG
+
+#if defined(BOOST_DISABLE_ASSERTS) || defined(NDEBUG)
+
+  #define BOOST_ASSERT_MSG(expr, msg) ((void)0)
+
+#elif defined(BOOST_ENABLE_ASSERT_HANDLER)
+
+  #include <boost/current_function.hpp>
+
+  namespace boost
+  {
+    void assertion_failed_msg(char const * expr, char const * msg,
+                              char const * function, char const * file, long line); // user defined
+  } // namespace boost
+
+  #define BOOST_ASSERT_MSG(expr, msg) ((expr) \
+    ? ((void)0) \
+    : ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+
+#else
+  #ifndef BOOST_ASSERT_HPP
+    #define BOOST_ASSERT_HPP
+    #include <cstdlib>
+    #include <iostream>
+    #include <boost/current_function.hpp>
+
+    //  IDE's like Visual Studio perform better if output goes to std::cout or
+    //  some other stream, so allow user to configure output stream:
+    #ifndef BOOST_ASSERT_MSG_OSTREAM
+    # define BOOST_ASSERT_MSG_OSTREAM std::cerr
+    #endif
+
+    namespace boost
+    { 
+      namespace assertion 
+      { 
+        namespace detail
+        {
+          inline void assertion_failed_msg(char const * expr, char const * msg, char const * function,
+            char const * file, long line)
+          {
+            BOOST_ASSERT_MSG_OSTREAM
+              << "***** Internal Program Error - assertion (" << expr << ") failed in "
+              << function << ":\n"
+              << file << '(' << line << "): " << msg << std::endl;
+            std::abort();
+          }
+        } // detail
+      } // assertion
+    } // detail
+  #endif
+
+  #define BOOST_ASSERT_MSG(expr, msg) ((expr) \
+    ? ((void)0) \
+    : ::boost::assertion::detail::assertion_failed_msg(#expr, msg, \
+          BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+#endif
+
+//--------------------------------------------------------------------------------------//
+//                                     BOOST_VERIFY                                     //
+//--------------------------------------------------------------------------------------//
+
+#undef BOOST_VERIFY
+
+#if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) )
+
+# define BOOST_VERIFY(expr) ((void)(expr))
+
+#else
+
+# define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
+
+#endif
--- a/include/boost/current_function.hpp
+++ b/include/boost/current_function.hpp
@ -32,6 +32,10 @@ inline void current_function_helper()

 # define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__

+#elif defined(__DMC__) && (__DMC__ >= 0x810)
+
+# define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
+
 #elif defined(__FUNCSIG__)

 # define BOOST_CURRENT_FUNCTION __FUNCSIG__
--- a/include/boost/detail/call_traits.hpp
+++ b/include/boost/detail/call_traits.hpp
@ -58,7 +58,7 @@ struct ct_imp<T, isp, true>
 template <typename T, bool b1>
 struct ct_imp<T, true, b1>
 {
-   typedef T const param_type;
+   typedef const T param_type;
 };

 }
@ -92,7 +92,7 @@ struct call_traits<T&>
   typedef T& param_type;  // hh removed const
 };

-#if BOOST_WORKAROUND( __BORLANDC__,  BOOST_TESTED_AT( 0x570 ) )
+#if BOOST_WORKAROUND( __BORLANDC__,  < 0x5A0 )
 // these are illegal specialisations; cv-qualifies applied to
 // references have no effect according to [8.3.2p1],
 // C++ Builder requires them though as it treats cv-qualified
@ -121,6 +121,15 @@ struct call_traits<T&const volatile>
   typedef const T& const_reference;
   typedef T& param_type;  // hh removed const
 };
+
+template <typename T>
+struct call_traits< T * >
+{
+   typedef T * value_type;
+   typedef T * & reference;
+   typedef T * const & const_reference;
+   typedef T * const param_type;  // hh removed const
+};
 #endif
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
 template <typename T, std::size_t N>
--- a/include/boost/detail/compressed_pair.hpp
+++ b/include/boost/detail/compressed_pair.hpp
@ -27,6 +27,10 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/call_traits.hpp>

+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable:4512)
+#endif 
 namespace boost
 {

@ -132,7 +136,7 @@ namespace details

   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 1>
-      : private ::boost::remove_cv<T1>::type
+      : protected ::boost::remove_cv<T1>::type
   {
   public:
      typedef T1                                                 first_type;
@ -174,7 +178,7 @@ namespace details

   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 2>
-      : private ::boost::remove_cv<T2>::type
+      : protected ::boost::remove_cv<T2>::type
   {
   public:
      typedef T1                                                 first_type;
@ -217,8 +221,8 @@ namespace details

   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 3>
-      : private ::boost::remove_cv<T1>::type,
-        private ::boost::remove_cv<T2>::type
+      : protected ::boost::remove_cv<T1>::type,
+        protected ::boost::remove_cv<T2>::type
   {
   public:
      typedef T1                                                 first_type;
@ -253,11 +257,14 @@ namespace details

   // JM
   // 4    T1 == T2, T1 and T2 both empty
-   //      Note does not actually store an instance of T2 at all -
-   //      but reuses T1 base class for both first() and second().
+   //      Originally this did not store an instance of T2 at all
+   //      but that led to problems beause it meant &x.first() == &x.second()
+   //      which is not true for any other kind of pair, so now we store an instance
+   //      of T2 just in case the user is relying on first() and second() returning
+   //      different objects (albeit both empty).
   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 4>
-      : private ::boost::remove_cv<T1>::type
+      : protected ::boost::remove_cv<T1>::type
   {
   public:
      typedef T1                                                 first_type;
@ -428,5 +435,9 @@ swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)

 } // boost

+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif 
+
 #endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP

--- a/include/boost/exception.hpp
+++ b/include/boost/exception.hpp
@ -0,0 +1,11 @@
+//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+
+//Distributed under the Boost Software License, Version 1.0. (See accompanying
+//file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef UUID_1D94A7C6054E11DB9804B622A1EF5492
+#define UUID_1D94A7C6054E11DB9804B622A1EF5492
+
+#error The header <boost/exception.hpp> has been deprecated. Please #include <boost/exception/all.hpp> instead.
+
+#endif
--- a/include/boost/operators.hpp
+++ b/include/boost/operators.hpp
@ -8,6 +8,13 @@
 //  See http://www.boost.org/libs/utility/operators.htm for documentation.

 //  Revision History
+//  16 Dec 10 Limit warning suppression for 4284 to older versions of VC++
+//            (Matthew Bradbury, fixes #4432)
+//  07 Aug 08 Added "euclidean" spelling. (Daniel Frey)
+//  03 Apr 08 Make sure "convertible to bool" is sufficient
+//            for T::operator<, etc. (Daniel Frey)
+//  24 May 07 Changed empty_base to depend on T, see
+//            http://svn.boost.org/trac/boost/ticket/979
 //  21 Oct 02 Modified implementation of operators to allow compilers with a
 //            correct named return value optimization (NRVO) to produce optimal
 //            code.  (Daniel Frey)
@ -83,22 +90,22 @@
 #   pragma set woff 1234
 #endif

-#if defined(BOOST_MSVC)
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1600)
 #   pragma warning( disable : 4284 ) // complaint about return type of 
 #endif                               // operator-> not begin a UDT

 namespace boost {
 namespace detail {

+template <typename T> class empty_base {
+
 // Helmut Zeisel, empty base class optimization bug with GCC 3.0.0
 #if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==0 && __GNU_PATCHLEVEL__==0
-class empty_base {
  bool dummy; 
-};
-#else
-class empty_base {};
 #endif

+};
+
 } // namespace detail
 } // namespace boost

@ -119,37 +126,37 @@ namespace boost
 //  Note that friend functions defined in a class are implicitly inline.
 //  See the C++ std, 11.4 [class.friend] paragraph 5

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct less_than_comparable2 : B
 {
-     friend bool operator<=(const T& x, const U& y) { return !(x > y); }
-     friend bool operator>=(const T& x, const U& y) { return !(x < y); }
+     friend bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
+     friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
     friend bool operator>(const U& x, const T& y)  { return y < x; }
     friend bool operator<(const U& x, const T& y)  { return y > x; }
-     friend bool operator<=(const U& x, const T& y) { return !(y < x); }
-     friend bool operator>=(const U& x, const T& y) { return !(y > x); }
+     friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
+     friend bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
 };

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct less_than_comparable1 : B
 {
     friend bool operator>(const T& x, const T& y)  { return y < x; }
-     friend bool operator<=(const T& x, const T& y) { return !(y < x); }
-     friend bool operator>=(const T& x, const T& y) { return !(x < y); }
+     friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
+     friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
 };

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct equality_comparable2 : B
 {
     friend bool operator==(const U& y, const T& x) { return x == y; }
-     friend bool operator!=(const U& y, const T& x) { return !(x == y); }
-     friend bool operator!=(const T& y, const U& x) { return !(y == x); }
+     friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
+     friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
 };

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct equality_comparable1 : B
 {
-     friend bool operator!=(const T& x, const T& y) { return !(x == y); }
+     friend bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
 };

 // A macro which produces "name_2left" from "name".
@ -165,7 +172,7 @@ struct equality_comparable1 : B
 // implementation available.

 #define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                         \
-template <class T, class U, class B = ::boost::detail::empty_base>            \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >        \
 struct NAME##2 : B                                                            \
 {                                                                             \
  friend T operator OP( const T& lhs, const U& rhs )                          \
@ -174,33 +181,33 @@ struct NAME##2 : B                                                            \
    { T nrv( rhs ); nrv OP##= lhs; return nrv; }                              \
 };                                                                            \
                                                                              \
-template <class T, class B = ::boost::detail::empty_base>                     \
+template <class T, class B = ::boost::detail::empty_base<T> >                 \
 struct NAME##1 : B                                                            \
 {                                                                             \
  friend T operator OP( const T& lhs, const T& rhs )                          \
    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
 };

-#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )           \
-template <class T, class U, class B = ::boost::detail::empty_base>  \
-struct NAME##2 : B                                                  \
-{                                                                   \
-  friend T operator OP( const T& lhs, const U& rhs )                \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
-};                                                                  \
-                                                                    \
-template <class T, class U, class B = ::boost::detail::empty_base>  \
-struct BOOST_OPERATOR2_LEFT(NAME) : B                               \
-{                                                                   \
-  friend T operator OP( const U& lhs, const T& rhs )                \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
-};                                                                  \
-                                                                    \
-template <class T, class B = ::boost::detail::empty_base>           \
-struct NAME##1 : B                                                  \
-{                                                                   \
-  friend T operator OP( const T& lhs, const T& rhs )                \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
+#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
+struct NAME##2 : B                                                      \
+{                                                                       \
+  friend T operator OP( const T& lhs, const U& rhs )                    \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
+};                                                                      \
+                                                                        \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
+struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
+{                                                                       \
+  friend T operator OP( const U& lhs, const T& rhs )                    \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
+};                                                                      \
+                                                                        \
+template <class T, class B = ::boost::detail::empty_base<T> >           \
+struct NAME##1 : B                                                      \
+{                                                                       \
+  friend T operator OP( const T& lhs, const T& rhs )                    \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
 };

 #else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
@ -210,35 +217,35 @@ struct NAME##1 : B                                                  \
 // BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
 // optimization opportunities to the compiler :)

-#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                         \
-template <class T, class U, class B = ::boost::detail::empty_base>            \
-struct NAME##2 : B                                                            \
-{                                                                             \
-  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; }       \
-  friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; }       \
-};                                                                            \
-                                                                              \
-template <class T, class B = ::boost::detail::empty_base>                     \
-struct NAME##1 : B                                                            \
-{                                                                             \
-  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
+#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                   \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
+struct NAME##2 : B                                                      \
+{                                                                       \
+  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
+  friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \
+};                                                                      \
+                                                                        \
+template <class T, class B = ::boost::detail::empty_base<T> >           \
+struct NAME##1 : B                                                      \
+{                                                                       \
+  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
 };

 #define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
-template <class T, class U, class B = ::boost::detail::empty_base>      \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
 struct NAME##2 : B                                                      \
 {                                                                       \
  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
 };                                                                      \
                                                                        \
-template <class T, class U, class B = ::boost::detail::empty_base>      \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
 struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
 {                                                                       \
  friend T operator OP( const U& lhs, const T& rhs )                    \
    { return T( lhs ) OP##= rhs; }                                      \
 };                                                                      \
                                                                        \
-template <class T, class B = ::boost::detail::empty_base>               \
+template <class T, class B = ::boost::detail::empty_base<T> >           \
 struct NAME##1 : B                                                      \
 {                                                                       \
  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
@ -261,7 +268,7 @@ BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )

 //  incrementable and decrementable contributed by Jeremy Siek

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct incrementable : B
 {
  friend T operator++(T& x, int)
@ -274,7 +281,7 @@ private: // The use of this typedef works around a Borland bug
  typedef T incrementable_type;
 };

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct decrementable : B
 {
  friend T operator--(T& x, int)
@ -289,7 +296,7 @@ private: // The use of this typedef works around a Borland bug

 //  Iterator operator classes (contributed by Jeremy Siek) ------------------//

-template <class T, class P, class B = ::boost::detail::empty_base>
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct dereferenceable : B
 {
  P operator->() const
@ -298,7 +305,7 @@ struct dereferenceable : B
  }
 };

-template <class T, class I, class R, class B = ::boost::detail::empty_base>
+template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
 struct indexable : B
 {
  R operator[](I n) const
@ -313,14 +320,14 @@ struct indexable : B
 #if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)

 #define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
-template <class T, class U, class B = ::boost::detail::empty_base>            \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >        \
 struct NAME##2 : B                                                            \
 {                                                                             \
  friend T operator OP( const T& lhs, const U& rhs )                          \
    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
 };                                                                            \
                                                                              \
-template <class T, class B = ::boost::detail::empty_base>                     \
+template <class T, class B = ::boost::detail::empty_base<T> >                 \
 struct NAME##1 : B                                                            \
 {                                                                             \
  friend T operator OP( const T& lhs, const T& rhs )                          \
@ -330,13 +337,13 @@ struct NAME##1 : B                                                            \
 #else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)

 #define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
-template <class T, class U, class B = ::boost::detail::empty_base>            \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >        \
 struct NAME##2 : B                                                            \
 {                                                                             \
  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; }       \
 };                                                                            \
                                                                              \
-template <class T, class B = ::boost::detail::empty_base>                     \
+template <class T, class B = ::boost::detail::empty_base<T> >                 \
 struct NAME##1 : B                                                            \
 {                                                                             \
  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
@ -349,209 +356,209 @@ BOOST_BINARY_OPERATOR( right_shiftable, >> )

 #undef BOOST_BINARY_OPERATOR

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct equivalent2 : B
 {
  friend bool operator==(const T& x, const U& y)
  {
-    return !(x < y) && !(x > y);
+    return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
  }
 };

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct equivalent1 : B
 {
  friend bool operator==(const T&x, const T&y)
  {
-    return !(x < y) && !(y < x);
+    return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
  }
 };

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct partially_ordered2 : B
 {
  friend bool operator<=(const T& x, const U& y)
-    { return (x < y) || (x == y); }
+    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
  friend bool operator>=(const T& x, const U& y)
-    { return (x > y) || (x == y); }
+    { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
  friend bool operator>(const U& x, const T& y)
    { return y < x; }
  friend bool operator<(const U& x, const T& y)
    { return y > x; }
  friend bool operator<=(const U& x, const T& y)
-    { return (y > x) || (y == x); }
+    { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
  friend bool operator>=(const U& x, const T& y)
-    { return (y < x) || (y == x); }
+    { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
 };

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct partially_ordered1 : B
 {
  friend bool operator>(const T& x, const T& y)
    { return y < x; }
  friend bool operator<=(const T& x, const T& y)
-    { return (x < y) || (x == y); }
+    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
  friend bool operator>=(const T& x, const T& y)
-    { return (y < x) || (x == y); }
+    { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
 };

 //  Combined operator classes (contributed by Daryle Walker) ----------------//

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct totally_ordered2
    : less_than_comparable2<T, U
    , equality_comparable2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct totally_ordered1
    : less_than_comparable1<T
    , equality_comparable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct additive2
    : addable2<T, U
    , subtractable2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct additive1
    : addable1<T
    , subtractable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct multiplicative2
    : multipliable2<T, U
    , dividable2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct multiplicative1
    : multipliable1<T
    , dividable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct integer_multiplicative2
    : multiplicative2<T, U
    , modable2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct integer_multiplicative1
    : multiplicative1<T
    , modable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct arithmetic2
    : additive2<T, U
    , multiplicative2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct arithmetic1
    : additive1<T
    , multiplicative1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct integer_arithmetic2
    : additive2<T, U
    , integer_multiplicative2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct integer_arithmetic1
    : additive1<T
    , integer_multiplicative1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct bitwise2
    : xorable2<T, U
    , andable2<T, U
    , orable2<T, U, B
      > > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct bitwise1
    : xorable1<T
    , andable1<T
    , orable1<T, B
      > > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct unit_steppable
    : incrementable<T
    , decrementable<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct shiftable2
    : left_shiftable2<T, U
    , right_shiftable2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct shiftable1
    : left_shiftable1<T
    , right_shiftable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct ring_operators2
    : additive2<T, U
    , subtractable2_left<T, U
    , multipliable2<T, U, B
      > > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct ring_operators1
    : additive1<T
    , multipliable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct ordered_ring_operators2
    : ring_operators2<T, U
    , totally_ordered2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct ordered_ring_operators1
    : ring_operators1<T
    , totally_ordered1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct field_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U, B
      > > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct field_operators1
    : ring_operators1<T
    , dividable1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct ordered_field_operators2
    : field_operators2<T, U
    , totally_ordered2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct ordered_field_operators1
    : field_operators1<T
    , totally_ordered1<T, B
      > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct euclidian_ring_operators2
    : ring_operators2<T, U
    , dividable2<T, U
@ -560,43 +567,71 @@ struct euclidian_ring_operators2
    , modable2_left<T, U, B
      > > > > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct euclidian_ring_operators1
    : ring_operators1<T
    , dividable1<T
    , modable1<T, B
      > > > {};

-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct ordered_euclidian_ring_operators2
    : totally_ordered2<T, U
    , euclidian_ring_operators2<T, U, B
      > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct ordered_euclidian_ring_operators1
    : totally_ordered1<T
    , euclidian_ring_operators1<T, B
      > > {};
-      
-template <class T, class P, class B = ::boost::detail::empty_base>
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct euclidean_ring_operators2
+    : ring_operators2<T, U
+    , dividable2<T, U
+    , dividable2_left<T, U
+    , modable2<T, U
+    , modable2_left<T, U, B
+      > > > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct euclidean_ring_operators1
+    : ring_operators1<T
+    , dividable1<T
+    , modable1<T, B
+      > > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidean_ring_operators2
+    : totally_ordered2<T, U
+    , euclidean_ring_operators2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidean_ring_operators1
+    : totally_ordered1<T
+    , euclidean_ring_operators1<T, B
+      > > {};
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct input_iteratable
    : equality_comparable1<T
    , incrementable<T
    , dereferenceable<T, P, B
      > > > {};

-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct output_iteratable
    : incrementable<T, B
      > {};

-template <class T, class P, class B = ::boost::detail::empty_base>
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct forward_iteratable
    : input_iteratable<T, P, B
      > {};

-template <class T, class P, class B = ::boost::detail::empty_base>
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct bidirectional_iteratable
    : forward_iteratable<T, P
    , decrementable<T, B
@ -606,7 +641,7 @@ struct bidirectional_iteratable
 //  which is an indirect base class of bidirectional_iterable,
 //  random_access_iteratable must not be derived from totally_ordered1
 //  but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001)
-template <class T, class P, class D, class R, class B = ::boost::detail::empty_base>
+template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
 struct random_access_iteratable
    : bidirectional_iteratable<T, P
    , less_than_comparable1<T
@ -650,20 +685,20 @@ struct random_access_iteratable

     // Otherwise, because a Borland C++ 5.5 bug prevents a using declaration
     // from working, we are forced to use inheritance for that compiler.
-#    define BOOST_IMPORT_TEMPLATE4(template_name)                                          \
-     template <class T, class U, class V, class W, class B = ::boost::detail::empty_base>  \
+#    define BOOST_IMPORT_TEMPLATE4(template_name)                                             \
+     template <class T, class U, class V, class W, class B = ::boost::detail::empty_base<T> > \
     struct template_name : ::template_name<T, U, V, W, B> {};

-#    define BOOST_IMPORT_TEMPLATE3(template_name)                                 \
-     template <class T, class U, class V, class B = ::boost::detail::empty_base>  \
+#    define BOOST_IMPORT_TEMPLATE3(template_name)                                    \
+     template <class T, class U, class V, class B = ::boost::detail::empty_base<T> > \
     struct template_name : ::template_name<T, U, V, B> {};

-#    define BOOST_IMPORT_TEMPLATE2(template_name)                              \
-     template <class T, class U, class B = ::boost::detail::empty_base>        \
+#    define BOOST_IMPORT_TEMPLATE2(template_name)                           \
+     template <class T, class U, class B = ::boost::detail::empty_base<T> > \
     struct template_name : ::template_name<T, U, B> {};

-#    define BOOST_IMPORT_TEMPLATE1(template_name)                              \
-     template <class T, class B = ::boost::detail::empty_base>                 \
+#    define BOOST_IMPORT_TEMPLATE1(template_name)                  \
+     template <class T, class B = ::boost::detail::empty_base<T> > \
     struct template_name : ::template_name<T, B> {};

 #  endif // BOOST_NO_USING_TEMPLATE
@ -752,7 +787,7 @@ template<class T> struct is_chained_base {
 # define BOOST_OPERATOR_TEMPLATE(template_name)                    \
 template <class T                                                  \
         ,class U = T                                              \
-         ,class B = ::boost::detail::empty_base                    \
+         ,class B = ::boost::detail::empty_base<T>                 \
         ,class O = typename is_chained_base<U>::value             \
         >                                                         \
 struct template_name : template_name##2<T, U, B> {};               \
@ -788,7 +823,7 @@ BOOST_OPERATOR_TEMPLATE1(template_name##1)
   // In this case we can only assume that template_name<> is equivalent to the
   // more commonly needed template_name1<> form.
 #  define BOOST_OPERATOR_TEMPLATE(template_name)                   \
-   template <class T, class B = ::boost::detail::empty_base>       \
+   template <class T, class B = ::boost::detail::empty_base<T> >   \
   struct template_name : template_name##1<T, B> {};

 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@ -835,6 +870,8 @@ BOOST_OPERATOR_TEMPLATE(field_operators)
 BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
 BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
 BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
+BOOST_OPERATOR_TEMPLATE(euclidean_ring_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_euclidean_ring_operators)
 BOOST_OPERATOR_TEMPLATE2(input_iteratable)
 BOOST_OPERATOR_TEMPLATE1(output_iteratable)
 BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
--- a/include/boost/ref.hpp
+++ b/include/boost/ref.hpp
@ -10,11 +10,12 @@
 #include <boost/config.hpp>
 #include <boost/utility/addressof.hpp>
 #include <boost/mpl/bool.hpp>
+#include <boost/detail/workaround.hpp>

 //
 //  ref.hpp - ref/cref, useful helper functions
 //
-//  Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+//  Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //  Copyright (C) 2001, 2002 Peter Dimov
 //  Copyright (C) 2002 David Abrahams
 //
@ -33,7 +34,7 @@ template<class T> class reference_wrapper
 public:
    typedef T type;

-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1300 )

    explicit reference_wrapper(T& t): t_(&t) {}

@ -54,7 +55,7 @@ private:
    T* t_;
 };

-# if defined(__BORLANDC__) && (__BORLANDC__ <= 0x570)
+# if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
 #  define BOOST_REF_CONST
 # else
 #  define BOOST_REF_CONST const
@ -172,6 +173,17 @@ class unwrap_reference

 # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

+template <class T> inline typename unwrap_reference<T>::type&
+unwrap_ref(T& t)
+{
+    return t;
+}
+
+template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
+{
+    return r.get_pointer();
+}
+
 } // namespace boost

 #endif // #ifndef BOOST_REF_HPP_INCLUDED
--- a/include/boost/swap.hpp
+++ b/include/boost/swap.hpp
@ -0,0 +1,12 @@
+// Copyright (C) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_SWAP_HPP
+#define BOOST_SWAP_HPP
+
+#include "boost/utility/swap.hpp"
+
+#endif
--- a/include/boost/utility.hpp
+++ b/include/boost/utility.hpp
@ -10,7 +10,8 @@
 #define BOOST_UTILITY_HPP

 #include <boost/utility/addressof.hpp>
-#include <boost/utility/base_from_member.hpp>  
+#include <boost/utility/base_from_member.hpp>
+#include <boost/utility/binary.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/next_prior.hpp>
--- a/include/boost/utility/addressof.hpp
+++ b/include/boost/utility/addressof.hpp
@ -1,6 +1,7 @@
 // Copyright (C) 2002 Brad King (brad.king@kitware.com) 
 //                    Douglas Gregor (gregod@cs.rpi.edu)
-//                    Peter Dimov
+//
+// Copyright (C) 2002, 2008 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@ -14,32 +15,75 @@
 # include <boost/config.hpp>
 # include <boost/detail/workaround.hpp>

-namespace boost {
+namespace boost
+{

-// Do not make addressof() inline. Breaks MSVC 7. (Peter Dimov)
+namespace detail
+{

-// VC7 strips const from nested classes unless we add indirection here
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+template<class T> struct addr_impl_ref
+{
+    T & v_;

-template<class T> struct _addp
+    inline addr_impl_ref( T & v ): v_( v ) {}
+    inline operator T& () const { return v_; }
+
+private:
+    addr_impl_ref & operator=(const addr_impl_ref &);
+};
+
+template<class T> struct addressof_impl
+{
+    static inline T * f( T & v, long )
+    {
+        return reinterpret_cast<T*>(
+            &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+    }
+
+    static inline T * f( T * v, int )
+    {
+        return v;
+    }
+};
+
+} // namespace detail
+
+template<class T> T * addressof( T & v )
+{
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) )
+
+    return boost::detail::addressof_impl<T>::f( v, 0 );
+
+#else
+
+    return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
+
+#endif
+}
+
+#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) )
+
+namespace detail
+{
+
+template<class T> struct addressof_addp
 {
    typedef T * type;
 };
-    
-template <typename T> typename _addp<T>::type

-# else
-template <typename T> T*
-# endif
-addressof(T& v)
+} // namespace detail
+
+template< class T, std::size_t N >
+typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] )
 {
-  return reinterpret_cast<T*>(
-       &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+    return &t;
 }

+#endif
+
 // Borland doesn't like casting an array reference to a char reference
 // but these overloads work around the problem.
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 template<typename T,std::size_t N>
 T (*addressof(T (&t)[N]))[N]
 {
@ -51,8 +95,8 @@ const T (*addressof(const T (&t)[N]))[N]
 {
   return reinterpret_cast<const T(*)[N]>(&t);
 }
-# endif
+#endif

-}
+} // namespace boost

 #endif // BOOST_UTILITY_ADDRESSOF_HPP
--- a/include/boost/utility/binary.hpp
+++ b/include/boost/utility/binary.hpp
@ -0,0 +1,708 @@
+/*=============================================================================
+    Copyright (c) 2005 Matthew Calabrese
+
+    Use, modification and distribution is subject to the Boost Software
+    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#ifndef BOOST_UTILITY_BINARY_HPP
+#define BOOST_UTILITY_BINARY_HPP
+
+/*=============================================================================
+
+    Binary Literal Utility
+    ______________________
+
+
+    The following code works by converting the input bit pattern into a
+    Boost.Preprocessor sequence, then converting groupings of 3 bits each into
+    the corresponding octal digit, and finally concatenating all of the digits
+    together along with a leading zero. This yields a standard octal literal
+    with the desired value as specified in bits.
+
+==============================================================================*/
+
+#include <boost/preprocessor/control/deduce_d.hpp>
+#include <boost/preprocessor/facilities/identity.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/seq/cat.hpp>
+#include <boost/preprocessor/seq/transform.hpp>
+#include <boost/preprocessor/arithmetic/mod.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
+#include <boost/preprocessor/control/while.hpp>
+
+#define BOOST_BINARY( bit_groupings )                                          \
+  BOOST_BINARY_LITERAL_D( BOOST_PP_DEDUCE_D(), bit_groupings ) 
+
+#define BOOST_BINARY_U( bit_groupings )                                        \
+  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, U ) 
+
+#define BOOST_BINARY_L( bit_groupings )                                        \
+  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, L ) 
+
+#define BOOST_BINARY_UL( bit_groupings )                                       \
+  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, UL ) 
+
+#define BOOST_BINARY_LU( bit_groupings )                                       \
+  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LU ) 
+
+#define BOOST_BINARY_LL( bit_groupings )                                       \
+  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LL ) 
+
+#define BOOST_BINARY_ULL( bit_groupings )                                      \
+  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, ULL ) 
+
+#define BOOST_BINARY_LLU( bit_groupings )                                      \
+  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LLU ) 
+
+#define BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, suffix )                 \
+  BOOST_SUFFIXED_BINARY_LITERAL_D( BOOST_PP_DEDUCE_D(), bit_groupings, suffix ) 
+
+#define BOOST_SUFFIXED_BINARY_LITERAL_D( d, bit_groupings, suffix )            \
+  BOOST_PP_CAT( BOOST_BINARY_LITERAL_D( d, bit_groupings ), suffix ) 
+
+#define BOOST_BINARY_LITERAL_D( d, bit_groupings )                             \
+  BOOST_PP_SEQ_CAT                                                             \
+  ( (0) BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE( d, bit_groupings )  \
+  ) 
+
+#define BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE( d, bit_groupings )  \
+  BOOST_PP_SEQ_TRANSFORM                                                       \
+  ( BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION                                     \
+  , BOOST_PP_NIL                                                               \
+  , BOOST_PP_IDENTITY( BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE )()\
+    ( BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE                                    \
+      (                                                                        \
+        d                                                                      \
+      , BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE( d, bit_groupings )    \
+      )                                                                        \
+    )                                                                          \
+  ) 
+
+#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE( bit_sequence )   \
+  BOOST_PP_CAT                                                                 \
+  ( BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1 bit_sequence      \
+  , END_BIT                                                                    \
+  ) 
+
+#define BOOST_DETAIL_BITS_PER_OCTIT 3
+
+#define BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE( d, incomplete_nibble_sequence ) \
+  BOOST_PP_CAT                                                                 \
+  ( BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_                            \
+  , BOOST_PP_MOD_D( d                                                          \
+                  , BOOST_PP_SEQ_SIZE( incomplete_nibble_sequence )            \
+                  , BOOST_DETAIL_BITS_PER_OCTIT                                \
+                  )                                                            \
+  )                                                                            \
+  incomplete_nibble_sequence 
+
+#define BOOST_DETAIL_FIXED_COMPL( bit )                                        \
+  BOOST_PP_CAT( BOOST_DETAIL_FIXED_COMPL_, bit )
+
+#define BOOST_DETAIL_FIXED_COMPL_0 1 
+
+#define BOOST_DETAIL_FIXED_COMPL_1 0 
+
+#define BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE( d, bit_groupings )    \
+  BOOST_PP_EMPTY                                                               \
+  BOOST_PP_CAT( BOOST_PP_WHILE_, d )                                           \
+  ( BOOST_DETAIL_BINARY_LITERAL_PREDICATE                                      \
+  , BOOST_DETAIL_BINARY_LITERAL_OPERATION                                      \
+  , bit_groupings ()                                                           \
+  ) 
+
+#define BOOST_DETAIL_BINARY_LITERAL_PREDICATE( d, state )                      \
+  BOOST_DETAIL_FIXED_COMPL( BOOST_DETAIL_IS_NULLARY_ARGS( state ) ) 
+
+#define BOOST_DETAIL_BINARY_LITERAL_OPERATION( d, state )                      \
+  BOOST_DETAIL_SPLIT_AND_SWAP                                                  \
+  ( BOOST_PP_CAT( BOOST_DETAIL_BINARY_LITERAL_ELEMENT_, state ) ) 
+
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION( s, dummy_param, tuple )        \
+  BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL tuple 
+
+#define BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL( bit2, bit1, bit0 )               \
+  BOOST_DETAIL_TRIPLE_TO_OCTAL_ ## bit2 ## bit1 ## bit0 
+
+#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_1 (0)(0)
+#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_2 (0)
+#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_0  
+
+#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1END_BIT  
+
+#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1( bit )        \
+  ( ( bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2 
+
+#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2( bit )        \
+  bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3 
+
+#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3( bit )        \
+  bit ) ) BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1 
+
+#define BOOST_DETAIL_SPLIT_AND_SWAP( params )                                  \
+  BOOST_PP_IDENTITY( BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS )()( params )
+
+#define BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS( first_param, second_param )        \
+  second_param first_param 
+
+#define BOOST_DETAIL_LEFT_OF_COMMA( params )                                   \
+  BOOST_PP_IDENTITY( BOOST_DETAIL_FIRST_MACRO_PARAM )()( params ) 
+
+#define BOOST_DETAIL_FIRST_MACRO_PARAM( first_param, second_param )            \
+  first_param 
+
+/* Begin derived concepts from Chaos by Paul Mensonides */
+
+#define BOOST_DETAIL_IS_NULLARY_ARGS( param )                                  \
+  BOOST_DETAIL_LEFT_OF_COMMA                                                   \
+  ( BOOST_PP_CAT( BOOST_DETAIL_IS_NULLARY_ARGS_R_                              \
+                , BOOST_DETAIL_IS_NULLARY_ARGS_C param                         \
+                )                                                              \
+  ) 
+
+#define BOOST_DETAIL_IS_NULLARY_ARGS_C()                                       \
+  1 
+
+#define BOOST_DETAIL_IS_NULLARY_ARGS_R_1                                       \
+  1, BOOST_PP_NIL 
+
+#define BOOST_DETAIL_IS_NULLARY_ARGS_R_BOOST_DETAIL_IS_NULLARY_ARGS_C          \
+  0, BOOST_PP_NIL 
+
+/* End derived concepts from Chaos by Paul Mensonides */
+
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_000 0 
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_001 1 
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_010 2 
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_011 3 
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_100 4 
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_101 5 
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_110 6 
+#define BOOST_DETAIL_TRIPLE_TO_OCTAL_111 7 
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0 (0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1 (1), 
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10 (1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11 (1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10 (1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11 (1)(1), 
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000 (0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001 (0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010 (0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011 (0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100 (1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101 (1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110 (1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111 (1)(1)(1), 
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000 (0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001 (0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010 (0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011 (0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100 (0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101 (0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110 (0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111 (0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000 (1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001 (1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010 (1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011 (1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100 (1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101 (1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110 (1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111 (1)(1)(1)(1), 
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000 (0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001 (0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010 (0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011 (0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100 (0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101 (0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110 (0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111 (0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000 (0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001 (0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010 (0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011 (0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100 (0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101 (0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110 (0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111 (0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000 (1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001 (1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010 (1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011 (1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100 (1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101 (1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110 (1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111 (1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000 (1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001 (1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010 (1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011 (1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100 (1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101 (1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110 (1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111 (1)(1)(1)(1)(1), 
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000000 (0)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000001 (0)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000010 (0)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000011 (0)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000100 (0)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000101 (0)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000110 (0)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000111 (0)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001000 (0)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001001 (0)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001010 (0)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001011 (0)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001100 (0)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001101 (0)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001110 (0)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001111 (0)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010000 (0)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010001 (0)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010010 (0)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010011 (0)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010100 (0)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010101 (0)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010110 (0)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010111 (0)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011000 (0)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011001 (0)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011010 (0)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011011 (0)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011100 (0)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011101 (0)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011110 (0)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011111 (0)(1)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100000 (1)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100001 (1)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100010 (1)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100011 (1)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100100 (1)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100101 (1)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100110 (1)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100111 (1)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101000 (1)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101001 (1)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101010 (1)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101011 (1)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101100 (1)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101101 (1)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101110 (1)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101111 (1)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110000 (1)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110001 (1)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110010 (1)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110011 (1)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110100 (1)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110101 (1)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110110 (1)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110111 (1)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111000 (1)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111001 (1)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111010 (1)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111011 (1)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111100 (1)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111101 (1)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111110 (1)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111111 (1)(1)(1)(1)(1)(1), 
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000000 (0)(0)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000001 (0)(0)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000010 (0)(0)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000011 (0)(0)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000100 (0)(0)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000101 (0)(0)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000110 (0)(0)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000111 (0)(0)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001000 (0)(0)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001001 (0)(0)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001010 (0)(0)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001011 (0)(0)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001100 (0)(0)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001101 (0)(0)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001110 (0)(0)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001111 (0)(0)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010000 (0)(0)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010001 (0)(0)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010010 (0)(0)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010011 (0)(0)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010100 (0)(0)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010101 (0)(0)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010110 (0)(0)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010111 (0)(0)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011000 (0)(0)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011001 (0)(0)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011010 (0)(0)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011011 (0)(0)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011100 (0)(0)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011101 (0)(0)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011110 (0)(0)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011111 (0)(0)(1)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100000 (0)(1)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100001 (0)(1)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100010 (0)(1)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100011 (0)(1)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100100 (0)(1)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100101 (0)(1)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100110 (0)(1)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100111 (0)(1)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101000 (0)(1)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101001 (0)(1)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101010 (0)(1)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101011 (0)(1)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101100 (0)(1)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101101 (0)(1)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101110 (0)(1)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101111 (0)(1)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110000 (0)(1)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110001 (0)(1)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110010 (0)(1)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110011 (0)(1)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110100 (0)(1)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110101 (0)(1)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110110 (0)(1)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110111 (0)(1)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111000 (0)(1)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111001 (0)(1)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111010 (0)(1)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111011 (0)(1)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111100 (0)(1)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111101 (0)(1)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111110 (0)(1)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111111 (0)(1)(1)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000000 (1)(0)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000001 (1)(0)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000010 (1)(0)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000011 (1)(0)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000100 (1)(0)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000101 (1)(0)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000110 (1)(0)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000111 (1)(0)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001000 (1)(0)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001001 (1)(0)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001010 (1)(0)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001011 (1)(0)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001100 (1)(0)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001101 (1)(0)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001110 (1)(0)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001111 (1)(0)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010000 (1)(0)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010001 (1)(0)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010010 (1)(0)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010011 (1)(0)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010100 (1)(0)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010101 (1)(0)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010110 (1)(0)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010111 (1)(0)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011000 (1)(0)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011001 (1)(0)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011010 (1)(0)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011011 (1)(0)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011100 (1)(0)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011101 (1)(0)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011110 (1)(0)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011111 (1)(0)(1)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100000 (1)(1)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100001 (1)(1)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100010 (1)(1)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100011 (1)(1)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100100 (1)(1)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100101 (1)(1)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100110 (1)(1)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100111 (1)(1)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101000 (1)(1)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101001 (1)(1)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101010 (1)(1)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101011 (1)(1)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101100 (1)(1)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101101 (1)(1)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101110 (1)(1)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101111 (1)(1)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110000 (1)(1)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110001 (1)(1)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110010 (1)(1)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110011 (1)(1)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110100 (1)(1)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110101 (1)(1)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110110 (1)(1)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110111 (1)(1)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111000 (1)(1)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111001 (1)(1)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111010 (1)(1)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111011 (1)(1)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111100 (1)(1)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111101 (1)(1)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111110 (1)(1)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111111 (1)(1)(1)(1)(1)(1)(1), 
+
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000000 (0)(0)(0)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000001 (0)(0)(0)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000010 (0)(0)(0)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000011 (0)(0)(0)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000100 (0)(0)(0)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000101 (0)(0)(0)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000110 (0)(0)(0)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000111 (0)(0)(0)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001000 (0)(0)(0)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001001 (0)(0)(0)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001010 (0)(0)(0)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001011 (0)(0)(0)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001100 (0)(0)(0)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001101 (0)(0)(0)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001110 (0)(0)(0)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001111 (0)(0)(0)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010000 (0)(0)(0)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010001 (0)(0)(0)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010010 (0)(0)(0)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010011 (0)(0)(0)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010100 (0)(0)(0)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010101 (0)(0)(0)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010110 (0)(0)(0)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010111 (0)(0)(0)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011000 (0)(0)(0)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011001 (0)(0)(0)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011010 (0)(0)(0)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011011 (0)(0)(0)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011100 (0)(0)(0)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011101 (0)(0)(0)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011110 (0)(0)(0)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011111 (0)(0)(0)(1)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100000 (0)(0)(1)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100001 (0)(0)(1)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100010 (0)(0)(1)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100011 (0)(0)(1)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100100 (0)(0)(1)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100101 (0)(0)(1)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100110 (0)(0)(1)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100111 (0)(0)(1)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101000 (0)(0)(1)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101001 (0)(0)(1)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101010 (0)(0)(1)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101011 (0)(0)(1)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101100 (0)(0)(1)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101101 (0)(0)(1)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101110 (0)(0)(1)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101111 (0)(0)(1)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110000 (0)(0)(1)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110001 (0)(0)(1)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110010 (0)(0)(1)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110011 (0)(0)(1)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110100 (0)(0)(1)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110101 (0)(0)(1)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110110 (0)(0)(1)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110111 (0)(0)(1)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111000 (0)(0)(1)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111001 (0)(0)(1)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111010 (0)(0)(1)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111011 (0)(0)(1)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111100 (0)(0)(1)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111101 (0)(0)(1)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111110 (0)(0)(1)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111111 (0)(0)(1)(1)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000000 (0)(1)(0)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000001 (0)(1)(0)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000010 (0)(1)(0)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000011 (0)(1)(0)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000100 (0)(1)(0)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000101 (0)(1)(0)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000110 (0)(1)(0)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000111 (0)(1)(0)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001000 (0)(1)(0)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001001 (0)(1)(0)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001010 (0)(1)(0)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001011 (0)(1)(0)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001100 (0)(1)(0)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001101 (0)(1)(0)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001110 (0)(1)(0)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001111 (0)(1)(0)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010000 (0)(1)(0)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010001 (0)(1)(0)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010010 (0)(1)(0)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010011 (0)(1)(0)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010100 (0)(1)(0)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010101 (0)(1)(0)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010110 (0)(1)(0)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010111 (0)(1)(0)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011000 (0)(1)(0)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011001 (0)(1)(0)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011010 (0)(1)(0)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011011 (0)(1)(0)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011100 (0)(1)(0)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011101 (0)(1)(0)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011110 (0)(1)(0)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011111 (0)(1)(0)(1)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100000 (0)(1)(1)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100001 (0)(1)(1)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100010 (0)(1)(1)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100011 (0)(1)(1)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100100 (0)(1)(1)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100101 (0)(1)(1)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100110 (0)(1)(1)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100111 (0)(1)(1)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101000 (0)(1)(1)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101001 (0)(1)(1)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101010 (0)(1)(1)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101011 (0)(1)(1)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101100 (0)(1)(1)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101101 (0)(1)(1)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101110 (0)(1)(1)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101111 (0)(1)(1)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110000 (0)(1)(1)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110001 (0)(1)(1)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110010 (0)(1)(1)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110011 (0)(1)(1)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110100 (0)(1)(1)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110101 (0)(1)(1)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110110 (0)(1)(1)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110111 (0)(1)(1)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111000 (0)(1)(1)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111001 (0)(1)(1)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111010 (0)(1)(1)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111011 (0)(1)(1)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111100 (0)(1)(1)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111101 (0)(1)(1)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111110 (0)(1)(1)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111111 (0)(1)(1)(1)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000000 (1)(0)(0)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000001 (1)(0)(0)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000010 (1)(0)(0)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000011 (1)(0)(0)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000100 (1)(0)(0)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000101 (1)(0)(0)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000110 (1)(0)(0)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000111 (1)(0)(0)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001000 (1)(0)(0)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001001 (1)(0)(0)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001010 (1)(0)(0)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001011 (1)(0)(0)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001100 (1)(0)(0)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001101 (1)(0)(0)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001110 (1)(0)(0)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001111 (1)(0)(0)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010000 (1)(0)(0)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010001 (1)(0)(0)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010010 (1)(0)(0)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010011 (1)(0)(0)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010100 (1)(0)(0)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010101 (1)(0)(0)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010110 (1)(0)(0)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010111 (1)(0)(0)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011000 (1)(0)(0)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011001 (1)(0)(0)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011010 (1)(0)(0)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011011 (1)(0)(0)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011100 (1)(0)(0)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011101 (1)(0)(0)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011110 (1)(0)(0)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011111 (1)(0)(0)(1)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100000 (1)(0)(1)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100001 (1)(0)(1)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100010 (1)(0)(1)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100011 (1)(0)(1)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100100 (1)(0)(1)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100101 (1)(0)(1)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100110 (1)(0)(1)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100111 (1)(0)(1)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101000 (1)(0)(1)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101001 (1)(0)(1)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101010 (1)(0)(1)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101011 (1)(0)(1)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101100 (1)(0)(1)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101101 (1)(0)(1)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101110 (1)(0)(1)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101111 (1)(0)(1)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110000 (1)(0)(1)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110001 (1)(0)(1)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110010 (1)(0)(1)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110011 (1)(0)(1)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110100 (1)(0)(1)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110101 (1)(0)(1)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110110 (1)(0)(1)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110111 (1)(0)(1)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111000 (1)(0)(1)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111001 (1)(0)(1)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111010 (1)(0)(1)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111011 (1)(0)(1)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111100 (1)(0)(1)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111101 (1)(0)(1)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111110 (1)(0)(1)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111111 (1)(0)(1)(1)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000000 (1)(1)(0)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000001 (1)(1)(0)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000010 (1)(1)(0)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000011 (1)(1)(0)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000100 (1)(1)(0)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000101 (1)(1)(0)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000110 (1)(1)(0)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000111 (1)(1)(0)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001000 (1)(1)(0)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001001 (1)(1)(0)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001010 (1)(1)(0)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001011 (1)(1)(0)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001100 (1)(1)(0)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001101 (1)(1)(0)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001110 (1)(1)(0)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001111 (1)(1)(0)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010000 (1)(1)(0)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010001 (1)(1)(0)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010010 (1)(1)(0)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010011 (1)(1)(0)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010100 (1)(1)(0)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010101 (1)(1)(0)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010110 (1)(1)(0)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010111 (1)(1)(0)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011000 (1)(1)(0)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011001 (1)(1)(0)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011010 (1)(1)(0)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011011 (1)(1)(0)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011100 (1)(1)(0)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011101 (1)(1)(0)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011110 (1)(1)(0)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011111 (1)(1)(0)(1)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100000 (1)(1)(1)(0)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100001 (1)(1)(1)(0)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100010 (1)(1)(1)(0)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100011 (1)(1)(1)(0)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100100 (1)(1)(1)(0)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100101 (1)(1)(1)(0)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100110 (1)(1)(1)(0)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100111 (1)(1)(1)(0)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101000 (1)(1)(1)(0)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101001 (1)(1)(1)(0)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101010 (1)(1)(1)(0)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101011 (1)(1)(1)(0)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101100 (1)(1)(1)(0)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101101 (1)(1)(1)(0)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101110 (1)(1)(1)(0)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101111 (1)(1)(1)(0)(1)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110000 (1)(1)(1)(1)(0)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110001 (1)(1)(1)(1)(0)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110010 (1)(1)(1)(1)(0)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110011 (1)(1)(1)(1)(0)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110100 (1)(1)(1)(1)(0)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110101 (1)(1)(1)(1)(0)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110110 (1)(1)(1)(1)(0)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110111 (1)(1)(1)(1)(0)(1)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111000 (1)(1)(1)(1)(1)(0)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111001 (1)(1)(1)(1)(1)(0)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111010 (1)(1)(1)(1)(1)(0)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111011 (1)(1)(1)(1)(1)(0)(1)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111100 (1)(1)(1)(1)(1)(1)(0)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111101 (1)(1)(1)(1)(1)(1)(0)(1), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111110 (1)(1)(1)(1)(1)(1)(1)(0), 
+#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111111 (1)(1)(1)(1)(1)(1)(1)(1), 
+
+#endif
--- a/include/boost/utility/compare_pointees.hpp
+++ b/include/boost/utility/compare_pointees.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/utility/declval.hpp
+++ b/include/boost/utility/declval.hpp
@ -0,0 +1,44 @@
+//  common_type.hpp  ---------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP
+#define BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP
+
+#include <boost/config.hpp>
+
+//----------------------------------------------------------------------------//
+
+#include <boost/type_traits/add_rvalue_reference.hpp>
+
+//----------------------------------------------------------------------------//
+//                                                                            //
+//                           C++03 implementation of                          //
+//                          Written by Vicente J. Botet Escriba               //
+//~ 20.3.4 Function template declval [declval]
+//~ 1 The library provides the function template declval to simplify the definition of expressions which occur as
+//~ unevaluated operands.
+//~ 2 Remarks: If this function is used, the program is ill-formed.
+//~ 3 Remarks: The template parameter T of declval may be an incomplete type.
+//~ [ Example:
+
+//~ template <class To, class From>
+//~ decltype(static_cast<To>(declval<From>())) convert(From&&);
+
+//~ declares a function template convert which only participats in overloading if the type From can be
+//~ explicitly converted to type To. For another example see class template common_type (20.7.6.6). <20>end
+//~ example ]
+//                                                                            //
+//----------------------------------------------------------------------------//
+
+namespace boost {
+
+    template <typename T>
+    typename add_rvalue_reference<T>::type declval(); //noexcept; // as unevaluated operand
+
+}  // namespace boost
+
+#endif  // BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP
--- a/include/boost/utility/detail/in_place_factory_prefix.hpp
+++ b/include/boost/utility/detail/in_place_factory_prefix.hpp
@ -1,33 +1,36 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2007, Tobias Schwinger.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// 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
 //
-#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_25AGO2003_HPP
-#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_25AGO2003_HPP
+#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
+#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP

+#include <new>
+#include <cstddef>
 #include <boost/config.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/punctuation/paren.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
 #include <boost/preprocessor/repetition/enum.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/punctuation/paren.hpp>
-#include <boost/preprocessor/facilities/empty.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>

 #define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT(z,n,_) BOOST_PP_CAT(m_a,n) BOOST_PP_LPAREN() BOOST_PP_CAT(a,n) BOOST_PP_RPAREN()
 #define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL(z,n,_) BOOST_PP_CAT(A,n) const& BOOST_PP_CAT(m_a,n);
-#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_ARG(z,n,_)  BOOST_PP_CAT(m_a,n)

 #define BOOST_MAX_INPLACE_FACTORY_ARITY 10

-#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_25AGO2003_HPP
+#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP

 #endif

--- a/include/boost/utility/detail/in_place_factory_suffix.hpp
+++ b/include/boost/utility/detail/in_place_factory_suffix.hpp
@ -1,23 +1,23 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2007, Tobias Schwinger.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// 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
 //
-#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_25AGO2003_HPP
-#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_25AGO2003_HPP
+#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
+#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP

 #undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT
 #undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL
-#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_ARG
 #undef BOOST_MAX_INPLACE_FACTORY_ARITY

-#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_25AGO2003_HPP
+#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP

 #endif

--- a/include/boost/utility/detail/result_of_iterate.hpp
+++ b/include/boost/utility/detail/result_of_iterate.hpp
@ -20,67 +20,123 @@
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<F(BOOST_RESULT_OF_ARGS)>
-    : detail::result_of<F, F(BOOST_RESULT_OF_ARGS)> {};
+struct tr1_result_of<F(BOOST_RESULT_OF_ARGS)>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::tr1_result_of_impl<
+            typename remove_cv<F>::type, 
+            typename remove_cv<F>::type(BOOST_RESULT_OF_ARGS), 
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::tr1_result_of_impl<
+            F,
+            F(BOOST_RESULT_OF_ARGS), 
+            (boost::detail::has_result_type<F>::value)> >::type { };
 #endif

+#if !defined(BOOST_NO_DECLTYPE) && defined(BOOST_RESULT_OF_USE_DECLTYPE)
+
+// Uses declval following N3225 20.7.7.6 when F is not a pointer.
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , detail::tr1_result_of_impl<
+            typename remove_cv<F>::type, 
+            typename remove_cv<F>::type(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
+          >
+        , detail::cpp0x_result_of_impl<
+              F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))
+          >
+      >::type
+{};
+
+namespace detail {
+
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
+{
+  typedef decltype(
+    boost::declval<F>()(
+      BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), declval<T, >() BOOST_PP_INTERCEPT)
+    )
+  ) type;
+};
+
+} // namespace detail 
+
+#else // defined(BOOST_NO_DECLTYPE)
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of<F(BOOST_RESULT_OF_ARGS)>
+    : tr1_result_of<F(BOOST_RESULT_OF_ARGS)> { };
+#endif
+
+#endif // defined(BOOST_NO_DECLTYPE)
+
+#undef BOOST_RESULT_OF_ARGS
+
+#if BOOST_PP_ITERATION() >= 1 
+
 namespace detail {

 template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (*)(BOOST_RESULT_OF_ARGS), FArgs>
+struct tr1_result_of_impl<R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
 {
  typedef R type;
 };

 template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (&)(BOOST_RESULT_OF_ARGS), FArgs>
+struct tr1_result_of_impl<R (&)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
 {
  typedef R type;
 };

-#undef BOOST_RESULT_OF_ARGS
-
-#if BOOST_PP_ITERATION() > 1 && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (T0::*)
+struct tr1_result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T)),
-                 FArgs>
+                 FArgs, false>
 {
  typedef R type;
 };

 template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (T0::*)
+struct tr1_result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                     const,
-                 FArgs>
+                 FArgs, false>
 {
  typedef R type;
 };

 template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (T0::*)
+struct tr1_result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                     volatile,
-                 FArgs>
+                 FArgs, false>
 {
  typedef R type;
 };

 template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
-struct result_of<R (T0::*)
+struct tr1_result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
                     const volatile,
-                 FArgs>
+                 FArgs, false>
 {
  typedef R type;
 };
 #endif

 }
+#endif
--- a/include/boost/utility/enable_if.hpp
+++ b/include/boost/utility/enable_if.hpp
@ -1,12 +1,12 @@
 // Boost enable_if library

-// Copyright 2003 <EFBFBD> The Trustees of Indiana University.
+// Copyright 2003 (c) The Trustees of Indiana University.

 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-//    Authors: Jaakko J<EFBFBD>rvi (jajarvi at osl.iu.edu)
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)

--- a/include/boost/utility/in_place_factory.hpp
+++ b/include/boost/utility/in_place_factory.hpp
@ -1,58 +1,88 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2007, Tobias Schwinger.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// 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
 //
-#ifndef BOOST_UTILITY_INPLACE_FACTORY_25AGO2003_HPP
-#define BOOST_UTILITY_INPLACE_FACTORY_25AGO2003_HPP
+#ifndef BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
+#ifndef BOOST_PP_IS_ITERATING

 #include <boost/utility/detail/in_place_factory_prefix.hpp>

-#include <boost/type.hpp>
-
 namespace boost {

 class in_place_factory_base {} ;

-#define BOOST_DEFINE_INPLACE_FACTORY_CLASS(z,n,_) \
-template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \
-class BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) : public in_place_factory_base \
-{ \
-public: \
-\
-  BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A,const& a) ) \
-    : \
-    BOOST_PP_ENUM( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _ ) \
-  {} \
-\
-  template<class T> \
-  void apply ( void* address BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T) ) const \
-  { \
-    new ( address ) T ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), m_a ) ) ; \
-  } \
-\
-  BOOST_PP_REPEAT( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _) \
-} ; \
-\
-template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \
-BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) < BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \
-in_place ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A, const& a) ) \
-{ \
-  return BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) < BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \
-           ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), a ) ) ; \
-} ; \
-
-BOOST_PP_REPEAT( BOOST_MAX_INPLACE_FACTORY_ARITY, BOOST_DEFINE_INPLACE_FACTORY_CLASS, BOOST_PP_EMPTY() )
+#define  BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY)
+#define  BOOST_PP_FILENAME_1 <boost/utility/in_place_factory.hpp>
+#include BOOST_PP_ITERATE()

 } // namespace boost

 #include <boost/utility/detail/in_place_factory_suffix.hpp>

+#define BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
+#else
+#define N BOOST_PP_ITERATION()
+
+#if N
+template< BOOST_PP_ENUM_PARAMS(N, class A) >
+#endif
+class BOOST_PP_CAT(in_place_factory,N)
+  : 
+  public in_place_factory_base
+{
+public:
+
+  explicit BOOST_PP_CAT(in_place_factory,N)
+      ( BOOST_PP_ENUM_BINARY_PARAMS(N,A,const& a) )
+#if N > 0
+    : BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _)
+#endif
+  {}
+
+  template<class T>
+  void* apply(void* address
+      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) const
+  {
+    return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
+  }
+
+  template<class T>
+  void* apply(void* address, std::size_t n
+      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) const
+  {
+    for(char* next = address = this->BOOST_NESTED_TEMPLATE apply<T>(address);
+        !! --n;)
+      this->BOOST_NESTED_TEMPLATE apply<T>(next = next+sizeof(T));
+    return address; 
+  }
+
+  BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _)
+};
+
+#if N > 0
+template< BOOST_PP_ENUM_PARAMS(N, class A) >
+inline BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
+in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
+{
+  return BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
+      ( BOOST_PP_ENUM_PARAMS(N, a) );
+}
+#else
+inline in_place_factory0 in_place()
+{
+  return in_place_factory0();
+}
+#endif
+
+#undef N
+#endif
 #endif

--- a/include/boost/utility/result_of.hpp
+++ b/include/boost/utility/result_of.hpp
@ -10,11 +10,21 @@
 #define BOOST_RESULT_OF_HPP

 #include <boost/config.hpp>
-#include <boost/type_traits/ice.hpp>
-#include <boost/type.hpp>
-#include <boost/preprocessor.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp> 
+#include <boost/preprocessor/punctuation/comma_if.hpp> 
+#include <boost/preprocessor/repetition/enum_params.hpp> 
+#include <boost/preprocessor/repetition/enum_binary_params.hpp> 
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp> 
+#include <boost/preprocessor/facilities/intercept.hpp> 
 #include <boost/detail/workaround.hpp>
 #include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_member_function_pointer.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/utility/declval.hpp>

 #ifndef BOOST_RESULT_OF_NUM_ARGS
 #  define BOOST_RESULT_OF_NUM_ARGS 10
@ -23,34 +33,61 @@
 namespace boost {

 template<typename F> struct result_of;
+template<typename F> struct tr1_result_of; // a TR1-style implementation of result_of

 #if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 namespace detail {

 BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)

-template<typename F, typename FArgs, bool HasResultType> struct get_result_of;
-
-template<typename F, typename FArgs>
-struct get_result_of<F, FArgs, true>
-{
-  typedef typename F::result_type type;
-};
-
-template<typename F, typename FArgs>
-struct get_result_of<F, FArgs, false>
-{
-  typedef typename F::template result<FArgs>::type type;
-};
+template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
+template<typename F> struct cpp0x_result_of_impl;

 template<typename F>
-struct get_result_of<F, F(void), false>
+struct result_of_void_impl
 {
  typedef void type;
 };

+template<typename R>
+struct result_of_void_impl<R (*)(void)>
+{
+  typedef R type;
+};
+
+template<typename R>
+struct result_of_void_impl<R (&)(void)>
+{
+  typedef R type;
+};
+
+// Determine the return type of a function pointer or pointer to member.
 template<typename F, typename FArgs>
-struct result_of : get_result_of<F, FArgs, (has_result_type<F>::value)> {};
+struct result_of_pointer
+  : tr1_result_of_impl<typename remove_cv<F>::type, FArgs, false> { };
+
+template<typename F, typename FArgs>
+struct tr1_result_of_impl<F, FArgs, true>
+{
+  typedef typename F::result_type type;
+};
+
+template<typename FArgs>
+struct is_function_with_no_args : mpl::false_ {};
+
+template<typename F>
+struct is_function_with_no_args<F(void)> : mpl::true_ {};
+
+template<typename F, typename FArgs>
+struct result_of_nested_result : F::template result<FArgs>
+{};
+
+template<typename F, typename FArgs>
+struct tr1_result_of_impl<F, FArgs, false>
+  : mpl::if_<is_function_with_no_args<FArgs>,
+             result_of_void_impl<F>,
+             result_of_nested_result<F, FArgs> >::type
+{};

 } // end namespace detail

--- a/include/boost/utility/swap.hpp
+++ b/include/boost/utility/swap.hpp
@ -0,0 +1,55 @@
+// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// For more information, see http://www.boost.org
+
+
+#ifndef BOOST_UTILITY_SWAP_HPP
+#define BOOST_UTILITY_SWAP_HPP
+
+// Note: the implementation of this utility contains various workarounds:
+// - swap_impl is put outside the boost namespace, to avoid infinite
+// recursion (causing stack overflow) when swapping objects of a primitive
+// type.
+// - swap_impl has a using-directive, rather than a using-declaration,
+// because some compilers (including MSVC 7.1, Borland 5.9.3, and
+// Intel 8.1) don't do argument-dependent lookup when it has a
+// using-declaration instead.
+// - boost::swap has two template arguments, instead of one, to
+// avoid ambiguity when swapping objects of a Boost type that does
+// not have its own boost::swap overload.
+
+#include <algorithm> //for std::swap
+#include <cstddef> //for std::size_t
+
+namespace boost_swap_impl
+{
+  template<class T>
+  void swap_impl(T& left, T& right)
+  {
+    using namespace std;//use std::swap if argument dependent lookup fails
+    swap(left,right);
+  }
+
+  template<class T, std::size_t N>
+  void swap_impl(T (& left)[N], T (& right)[N])
+  {
+    for (std::size_t i = 0; i < N; ++i)
+    {
+      ::boost_swap_impl::swap_impl(left[i], right[i]);
+    }
+  }
+}
+
+namespace boost
+{
+  template<class T1, class T2>
+  void swap(T1& left, T2& right)
+  {
+    ::boost_swap_impl::swap_impl(left, right);
+  }
+}
+
+#endif
--- a/include/boost/utility/typed_in_place_factory.hpp
+++ b/include/boost/utility/typed_in_place_factory.hpp
@ -1,16 +1,17 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2007, Tobias Schwinger.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// 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
 //
-#ifndef BOOST_UTILITY_TYPED_INPLACE_FACTORY_25AGO2003_HPP
-#define BOOST_UTILITY_TYPED_INPLACE_FACTORY_25AGO2003_HPP
+#ifndef BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
+#ifndef BOOST_PP_IS_ITERATING

 #include <boost/utility/detail/in_place_factory_prefix.hpp>

@ -18,40 +19,59 @@ namespace boost {

 class typed_in_place_factory_base {} ;

-#define BOOST_DEFINE_TYPED_INPLACE_FACTORY_CLASS(z,n,_) \
-template< class T, BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \
-class BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) : public typed_in_place_factory_base \
-{ \
-public: \
-\
-  typedef T value_type ; \
-\
-  BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A,const& a) ) \
-    : \
-    BOOST_PP_ENUM( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _ ) \
-  {} \
-\
-  void apply ( void* address ) const \
-  { \
-    new ( address ) T ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), m_a ) ) ; \
-  } \
-\
-  BOOST_PP_REPEAT( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _) \
-} ; \
-\
-template< class T, BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \
-BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) < T , BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \
-in_place ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A, const& a) ) \
-{ \
-  return BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) < T, BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \
-           ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), a ) ) ; \
-} ; \
-
-BOOST_PP_REPEAT( BOOST_MAX_INPLACE_FACTORY_ARITY, BOOST_DEFINE_TYPED_INPLACE_FACTORY_CLASS, BOOST_PP_EMPTY() )
+#define  BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY)
+#define  BOOST_PP_FILENAME_1 <boost/utility/typed_in_place_factory.hpp>
+#include BOOST_PP_ITERATE()

 } // namespace boost

 #include <boost/utility/detail/in_place_factory_suffix.hpp>

+#define BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
+#else 
+#define N BOOST_PP_ITERATION()
+
+template< class T BOOST_PP_ENUM_TRAILING_PARAMS(N,class A) >
+class BOOST_PP_CAT(typed_in_place_factory,N) 
+  : 
+  public typed_in_place_factory_base
+{
+public:
+
+  typedef T value_type;
+
+  explicit BOOST_PP_CAT(typed_in_place_factory,N) 
+      ( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
+#if N > 0
+    : BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _)
+#endif
+  {}
+
+  void* apply (void* address) const
+  {
+    return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
+  }
+
+  void* apply (void* address, std::size_t n) const
+  {
+    for(void* next = address = this->apply(address); !! --n;)
+      this->apply(next = static_cast<char *>(next) + sizeof(T));
+    return address; 
+  }
+
+  BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _)
+};
+
+template< class T BOOST_PP_ENUM_TRAILING_PARAMS(N, class A) >
+inline BOOST_PP_CAT(typed_in_place_factory,N)<
+    T BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >
+in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
+{
+  return BOOST_PP_CAT(typed_in_place_factory,N)< 
+      T BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >( BOOST_PP_ENUM_PARAMS(N, a) );
+}
+
+#undef N
+#endif
 #endif

--- a/include/boost/utility/value_init.hpp
+++ b/include/boost/utility/value_init.hpp
@ -1,77 +1,258 @@
-// (C) 2002, Fernando Luis Cacciola Carballal.
+// (C) Copyright 2002-2008, Fernando Luis Cacciola Carballal.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // 21 Ago 2002 (Created) Fernando Cacciola
+// 24 Dec 2007 (Refactored and worked around various compiler bugs) Fernando Cacciola, Niels Dekker
+// 23 May 2008 (Fixed operator= const issue, added initialized_value) Niels Dekker, Fernando Cacciola
+// 21 Ago 2008 (Added swap) Niels Dekker, Fernando Cacciola
+// 20 Feb 2009 (Fixed logical const-ness issues) Niels Dekker, Fernando Cacciola
+// 03 Apr 2010 (Added initialized<T>, suggested by Jeffrey Hellrung, fixing #3472) Niels Dekker
+// 30 May 2010 (Made memset call conditional, fixing #3869) Niels Dekker
 //
 #ifndef BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
 #define BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP

-#include "boost/detail/select_type.hpp"
-#include "boost/type_traits/cv_traits.hpp"
+// Note: The implementation of boost::value_initialized had to deal with the
+// fact that various compilers haven't fully implemented value-initialization.
+// The constructor of boost::value_initialized<T> works around these compiler
+// issues, by clearing the bytes of T, before constructing the T object it
+// contains. More details on these issues are at libs/utility/value_init.htm
+
+#include <boost/aligned_storage.hpp>
+#include <boost/config.hpp> // For BOOST_NO_COMPLETE_VALUE_INITIALIZATION.
+#include <boost/detail/workaround.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/cv_traits.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/swap.hpp>
+#include <cstring>
+#include <new>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#if _MSC_VER >= 1310
+// It is safe to ignore the following warning from MSVC 7.1 or higher:
+// "warning C4351: new behavior: elements of array will be default initialized"
+#pragma warning(disable: 4351)
+// It is safe to ignore the following MSVC warning, which may pop up when T is 
+// a const type: "warning C4512: assignment operator could not be generated".
+#pragma warning(disable: 4512)
+#endif
+#endif
+
+#ifdef BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+  // Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED 
+  // suggests that a workaround should be applied, because of compiler issues 
+  // regarding value-initialization.
+  #define BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
+#endif
+
+// Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND
+// switches the value-initialization workaround either on or off.
+#ifndef BOOST_DETAIL_VALUE_INIT_WORKAROUND
+  #ifdef BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
+  #define BOOST_DETAIL_VALUE_INIT_WORKAROUND 1
+  #else
+  #define BOOST_DETAIL_VALUE_INIT_WORKAROUND 0
+  #endif
+#endif

 namespace boost {

-namespace vinit_detail {
-
 template<class T>
-class const_T_base
+class initialized
 {
-  protected :
+  private :
+    struct wrapper
+    {
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+      typename
+#endif 
+      remove_const<T>::type data;

-   const_T_base() : x() {}
+      wrapper()
+      :
+      data()
+      {
+      }

-   T x ;
-} ;
+      wrapper(T const & arg)
+      :
+      data(arg)
+      {
+      }
+    };

-template<class T>
-struct non_const_T_base
-{
-  protected :
+    mutable
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+      typename
+#endif 
+      aligned_storage<sizeof(wrapper), alignment_of<wrapper>::value>::type x;

-   non_const_T_base() : x() {}
+    wrapper * wrapper_address() const
+    {
+      return static_cast<wrapper *>( static_cast<void*>(&x));
+    }

-   mutable T x ;
-} ;
-
-template<class T>
-struct select_base
-{
-  typedef typename
-    detail::if_true< ::boost::is_const<T>::value >
-      ::template then< const_T_base<T>, non_const_T_base<T> >::type type ;
-} ;
-
-} // namespace vinit_detail
-
-template<class T>
-class value_initialized : private vinit_detail::select_base<T>::type
-{
  public :

-    value_initialized() {}
+    initialized()
+    {
+#if BOOST_DETAIL_VALUE_INIT_WORKAROUND
+      std::memset(&x, 0, sizeof(x));
+#endif
+      new (wrapper_address()) wrapper();
+    }

-    operator T&() const { return this->x ; }
+    initialized(initialized const & arg)
+    {
+      new (wrapper_address()) wrapper( static_cast<wrapper const &>(*(arg.wrapper_address())));
+    }

-    T& data() const { return this->x ; }
+    explicit initialized(T const & arg)
+    {
+      new (wrapper_address()) wrapper(arg);
+    }
+
+    initialized & operator=(initialized const & arg)
+    {
+      // Assignment is only allowed when T is non-const.
+      BOOST_STATIC_ASSERT( ! is_const<T>::value );
+      *wrapper_address() = static_cast<wrapper const &>(*(arg.wrapper_address()));
+      return *this;
+    }
+
+    ~initialized()
+    {
+      wrapper_address()->wrapper::~wrapper();
+    }
+
+    T const & data() const
+    {
+      return wrapper_address()->data;
+    }
+
+    T& data()
+    {
+      return wrapper_address()->data;
+    }
+
+    void swap(initialized & arg)
+    {
+      ::boost::swap( this->data(), arg.data() );
+    }
+
+    operator T const &() const
+    {
+      return wrapper_address()->data;
+    }
+
+    operator T&()
+    {
+      return wrapper_address()->data;
+    }

 } ;

+template<class T>
+T const& get ( initialized<T> const& x )
+{
+  return x.data() ;
+}
+
+template<class T>
+T& get ( initialized<T>& x )
+{
+  return x.data() ;
+}
+
+template<class T>
+void swap ( initialized<T> & lhs, initialized<T> & rhs )
+{
+  lhs.swap(rhs) ;
+}
+
+template<class T>
+class value_initialized
+{
+  private :
+
+    // initialized<T> does value-initialization by default.
+    initialized<T> m_data;
+
+  public :
+    
+    value_initialized()
+    :
+    m_data()
+    { }
+    
+    T const & data() const
+    {
+      return m_data.data();
+    }
+
+    T& data()
+    {
+      return m_data.data();
+    }
+
+    void swap(value_initialized & arg)
+    {
+      m_data.swap(arg.m_data);
+    }
+
+    operator T const &() const
+    {
+      return m_data;
+    }
+
+    operator T&()
+    {
+      return m_data;
+    }
+} ;
+
+
 template<class T>
 T const& get ( value_initialized<T> const& x )
 {
  return x.data() ;
 }
+
 template<class T>
 T& get ( value_initialized<T>& x )
 {
  return x.data() ;
 }

+template<class T>
+void swap ( value_initialized<T> & lhs, value_initialized<T> & rhs )
+{
+  lhs.swap(rhs) ;
+}
+
+
+class initialized_value_t
+{
+  public :
+    
+    template <class T> operator T() const
+    {
+      return initialized<T>().data();
+    }
+};
+
+initialized_value_t const initialized_value = {} ;
+
+
 } // namespace boost

-
+#ifdef BOOST_MSVC
+#pragma warning(pop)
 #endif

+#endif
--- a/index.html
+++ b/index.html
@ -14,21 +14,37 @@
 		<p>But that doesn't mean there isn't useful stuff here. Take a look:</p>
 		<blockquote>
 			<p>
+				<a href="utility.htm#addressof">addressof</a><br>
 				<a href="assert.html">assert</a><br>
 				<a href="base_from_member.html">base_from_member</a><br>
+				<a href="utility.htm#BOOST_BINARY">BOOST_BINARY</a><br>
 				<a href="call_traits.htm">call_traits</a><br>
 				<a href="checked_delete.html">checked_delete</a><br>
 				<a href="compressed_pair.htm">compressed_pair</a><br>
-				<a href="enable_if.html">enable_if</a><br>
-                <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
+				<a href="current_function.html">current_function</a><br>
+            <a href="doc/html/declval.html">declval</a><br>
+            <a href="enable_if.html">enable_if</a><br>
+				<a href="in_place_factories.html">in_place_factory</a><br>
+            <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
+            <a href="generator_iterator.htm">generator iterator adaptors</a><br>
+				<a href="utility.htm#functions_next_prior">next/prior</a><br>
+				<a href="utility.htm#Class_noncopyable">noncopyable</a><br>
 				<a href="operators.htm">operators</a><br>
+				<a href="utility.htm#result_of">result_of</a><br>
+				<a href="swap.html">swap</a><br>
 				<a href="throw_exception.html">throw_exception</a><br>
 				<a href="utility.htm">utility</a><br>
-                <a href="value_init.htm">value_init</a></p>
+            <a href="value_init.htm">value_init</a>
+         </p>
 		</blockquote>
 		<hr>
+		<p>&copy; Copyright Beman Dawes, 2001</p>
+        <p>Distributed under the Boost Software License, Version 1.0. (See 
+        accompanying file <a href="../../LICENSE_1_0.txt">
+        LICENSE_1_0.txt</a> or copy at
+        <a href="http://www.boost.org/LICENSE_1_0.txt">
+        www.boost.org/LICENSE_1_0.txt</a>)</p>
 		<p>Revised 
-			<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 September, 2003<!--webbot bot="Timestamp" endspan i-checksum="38582" --></p>
-		<p>&nbsp;</p>
-	</body>
+			<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->07 November, 2006<!--webbot bot="Timestamp" endspan i-checksum="39368" --></p>
+		</body>
 </html>
--- a/initialized_test.cpp
+++ b/initialized_test.cpp
@ -0,0 +1,116 @@
+// Copyright 2010, Niels Dekker.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Test program for boost::initialized<T>.
+//
+// 2 May 2010 (Created) Niels Dekker
+
+#include <boost/utility/value_init.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#include <string>
+
+namespace
+{
+  // Typical use case for boost::initialized<T>: A generic class that 
+  // holds a value of type T, which must be initialized by either 
+  // value-initialization or direct-initialization.
+  template <class T> class key_value_pair
+  {
+    std::string m_key;
+    boost::initialized<T> m_value;
+  public:
+ 
+    // Value-initializes the object held by m_value.
+    key_value_pair() { }
+
+    // Value-initializes the object held by m_value.
+    explicit key_value_pair(const std::string& key)
+    :
+    m_key(key)
+    {
+    }
+
+    // Direct-initializes the object held by m_value.
+    key_value_pair(const std::string& key, const T& value)
+    :
+    m_key(key), m_value(value)
+    {
+    }
+
+    const T& get_value() const
+    {
+      return m_value;
+    }
+  };
+
+
+  // Tells whether the argument is value-initialized.
+  bool is_value_initialized(const int& arg)
+  {
+    return arg == 0;
+  }
+
+
+  // Tells whether the argument is value-initialized.
+  bool is_value_initialized(const std::string& arg)
+  {
+    return arg.empty();
+  }
+
+  struct foo
+  {
+    int data;
+  };
+
+  bool operator==(const foo& lhs, const foo& rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+
+  // Tells whether the argument is value-initialized.
+  bool is_value_initialized(const foo& arg)
+  {
+    return arg.data == 0;
+  }
+
+
+  template <class T>
+  void test_key_value_pair(const T& magic_value)
+  {
+    // The value component of a default key_value_pair must be value-initialized.
+    key_value_pair<T> default_key_value_pair;
+    BOOST_TEST( is_value_initialized(default_key_value_pair.get_value() ) );
+
+    // The value component of a key_value_pair that only has its key explicitly specified
+    // must also be value-initialized.
+    BOOST_TEST( is_value_initialized(key_value_pair<T>("key").get_value()) );
+
+    // However, the value component of the following key_value_pair must be 
+    // "magic_value", as it must be direct-initialized.
+    BOOST_TEST( key_value_pair<T>("key", magic_value).get_value() == magic_value );
+  }
+}
+
+
+// Tests boost::initialize for a fundamental type, a type with a
+// user-defined constructor, and a user-defined type without 
+// a user-defined constructor.
+int main()
+{
+
+  const int magic_number = 42;
+  test_key_value_pair(magic_number);
+
+  const std::string magic_string = "magic value";
+  test_key_value_pair(magic_string);
+
+  const foo magic_foo = { 42 };
+  test_key_value_pair(magic_foo);
+
+  return boost::report_errors();
+}
--- a/initialized_test_fail1.cpp
+++ b/initialized_test_fail1.cpp
@ -0,0 +1,33 @@
+// Copyright 2010, Niels Dekker.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Test program for boost::initialized<T>. Must fail to compile.
+//
+// Initial: 2 May 2010
+
+#include <boost/utility/value_init.hpp>
+
+namespace
+{
+  void direct_initialize_from_int()
+  {
+    // Okay: initialized<T> supports direct-initialization from T.
+    boost::initialized<int> direct_initialized_int(1);
+  }
+
+  void copy_initialize_from_int()
+  {
+    // The following line should not compile, because initialized<T> 
+    // was not intended to supports copy-initialization from T.
+    boost::initialized<int> copy_initialized_int = 1;
+  }
+}
+
+int main()
+{
+  // This should fail to compile, so there is no need to call any function.
+  return 0;
+}
--- a/initialized_test_fail2.cpp
+++ b/initialized_test_fail2.cpp
@ -0,0 +1,37 @@
+// Copyright 2010, Niels Dekker.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Test program for boost::initialized<T>. Must fail to compile.
+//
+// Initial: 2 May 2010
+
+#include <boost/utility/value_init.hpp>
+
+namespace
+{
+  void from_value_initialized_to_initialized()
+  {
+    boost::value_initialized<int> value_initialized_int;
+
+    // Okay: initialized<T> can be initialized by value_initialized<T>.
+    boost::initialized<int> initialized_int(value_initialized_int);
+  }
+
+  void from_initialized_to_value_initialized()
+  {
+    boost::initialized<int> initialized_int(13);
+
+    // The following line should not compile, because initialized<T>
+    // should not be convertible to value_initialized<T>.
+    boost::value_initialized<int> value_initialized_int(initialized_int);
+  }
+}
+
+int main()
+{
+  // This should fail to compile, so there is no need to call any function.
+  return 0;
+}
--- a/operators.htm
+++ b/operators.htm
@ -132,18 +132,18 @@
 class MyInt
    : boost::operators&lt;MyInt&gt;
 {
-    bool operator&lt;(const MyInt&amp; x) const; 
+    bool operator&lt;(const MyInt&amp; x) const;
    bool operator==(const MyInt&amp; x) const;
-    MyInt&amp; operator+=(const MyInt&amp; x);    
-    MyInt&amp; operator-=(const MyInt&amp; x);    
-    MyInt&amp; operator*=(const MyInt&amp; x);    
-    MyInt&amp; operator/=(const MyInt&amp; x);    
-    MyInt&amp; operator%=(const MyInt&amp; x);    
-    MyInt&amp; operator|=(const MyInt&amp; x);    
-    MyInt&amp; operator&amp;=(const MyInt&amp; x);    
-    MyInt&amp; operator^=(const MyInt&amp; x);    
-    MyInt&amp; operator++();    
-    MyInt&amp; operator--();    
+    MyInt&amp; operator+=(const MyInt&amp; x);
+    MyInt&amp; operator-=(const MyInt&amp; x);
+    MyInt&amp; operator*=(const MyInt&amp; x);
+    MyInt&amp; operator/=(const MyInt&amp; x);
+    MyInt&amp; operator%=(const MyInt&amp; x);
+    MyInt&amp; operator|=(const MyInt&amp; x);
+    MyInt&amp; operator&amp;=(const MyInt&amp; x);
+    MyInt&amp; operator^=(const MyInt&amp; x);
+    MyInt&amp; operator++();
+    MyInt&amp; operator--();
 };
 </pre>
    </blockquote>
@ -345,7 +345,7 @@ class MyInt
    </ul>

    <p>As Daniel Kr&uuml;gler pointed out, this technique violates 14.6.5/2
-    and is thus non-portable. The reasoning is, that the operators injected 
+    and is thus non-portable. The reasoning is, that the operators injected
    by the instantiation of e.g.
    <code>less_than_comparable&lt;myclass&gt;</code> can not be found
    by ADL according to the rules given by 3.4.2/2, since myclass is
@ -445,6 +445,9 @@ const point&lt;float&gt; pi_over_4_normalized = pi_over_4 / length(pi_over_4);
    optional template parameter <code>B</code>, which is not shown, for the
    <a href="#chaining">base class chaining</a> technique.</p>

+    <p>The primary operand type <code>T</code> needs to be of class type,
+    built-in types are not supported.</p>
+
    <table cellpadding="5" border="1" align="center">
      <caption>
        Simple Arithmetic Operator Template Classes
@ -917,7 +920,7 @@ T operator+( const T&amp; lhs, const T&amp; rhs )
    created, <code>operator+=</code> is called on it and it is copied to the
    function return value (which is another unnamed object of type
    <code>T</code>). The standard doesn't generally allow the intermediate
-    object to be optimized away: 
+    object to be optimized away:

    <blockquote>
      3.7.2/2: Automatic storage duration<br>
@ -928,7 +931,7 @@ T operator+( const T&amp; lhs, const T&amp; rhs )
      unused, except that a class object or its copy may be eliminated as
      specified in 12.8.
    </blockquote>
-    The reference to 12.8 is important for us: 
+    The reference to 12.8 is important for us:

    <blockquote>
      12.8/15: Copying class objects<br>
@ -942,7 +945,7 @@ T operator+( const T&amp; lhs, const T&amp; rhs )
    </blockquote>
    This optimization is known as the named return value optimization (NRVO),
    which leads us to the following implementation for
-    <code>operator+</code>: 
+    <code>operator+</code>:
 <pre>
 T operator+( const T&amp; lhs, const T&amp; rhs )
 {
@ -956,7 +959,7 @@ T operator+( const T&amp; lhs, const T&amp; rhs )
    even implement it in an incorrect way which makes it useless here.
    Without the NRVO, the NRVO-friendly code is no worse than the original
    code showed above, but there is another possible implementation, which
-    has some very special properties: 
+    has some very special properties:
 <pre>
 T operator+( T lhs, const T&amp; rhs )
 {
@ -982,7 +985,7 @@ T operator+( T lhs, const T&amp; rhs )
    will force the NRVO-friendly implementation to be used even for compilers
    that don't implement the NRVO. <br>
     <br>
-     
+
    <h3><a name="grpd_oprs">Grouped Arithmetic Operators</a></h3>

    <p>The following templates provide common groups of related operations.
@ -1420,9 +1423,9 @@ T operator+( T lhs, const T&amp; rhs )

      <tr>
        <td><code><a name=
-        "euclidian_ring_operators1">euclidian_ring_operators&lt;T&gt;</a></code><br>
+        "euclidean_ring_operators1">euclidean_ring_operators&lt;T&gt;</a></code><br>

-         <code>euclidian_ring_operators1&lt;T&gt;</code></td>
+         <code>euclidean_ring_operators1&lt;T&gt;</code></td>

        <td>
          <ul>
@ -1439,9 +1442,9 @@ T operator+( T lhs, const T&amp; rhs )

      <tr>
        <td><code><a name=
-        "euclidian_ring_operators2">euclidian_ring_operators&lt;T,
+        "euclidean_ring_operators2">euclidean_ring_operators&lt;T,
        U&gt;</a></code><br>
-         <code>euclidian_ring_operators2&lt;T, U&gt;</code></td>
+         <code>euclidean_ring_operators2&lt;T, U&gt;</code></td>

        <td>
          <ul>
@ -1464,14 +1467,14 @@ T operator+( T lhs, const T&amp; rhs )

      <tr>
        <td><code><a name=
-        "ordered_euclidian_ring_operators1">ordered_euclidian_ring_operators&lt;T&gt;</a></code><br>
+        "ordered_euclidean_ring_operators1">ordered_euclidean_ring_operators&lt;T&gt;</a></code><br>

-         <code>ordered_euclidian_ring_operators1&lt;T&gt;</code></td>
+         <code>ordered_euclidean_ring_operators1&lt;T&gt;</code></td>

        <td>
          <ul>
            <li><code><a href=
-            "#euclidian_ring_operators1">euclidian_ring_operators&lt;T&gt;</a></code></li>
+            "#euclidean_ring_operators1">euclidean_ring_operators&lt;T&gt;</a></code></li>

            <li><code><a href=
            "#totally_ordered1">totally_ordered&lt;T&gt;</a></code></li>
@ -1481,14 +1484,14 @@ T operator+( T lhs, const T&amp; rhs )

      <tr>
        <td><code><a name=
-        "ordered_euclidian_ring_operators2">ordered_euclidian_ring_operators&lt;T,
+        "ordered_euclidean_ring_operators2">ordered_euclidean_ring_operators&lt;T,
        U&gt;</a></code><br>
-         <code>ordered_euclidian_ring_operators2&lt;T, U&gt;</code></td>
+         <code>ordered_euclidean_ring_operators2&lt;T, U&gt;</code></td>

        <td>
          <ul>
            <li><code><a href=
-            "#euclidian_ring_operators2">euclidian_ring_operators&lt;T,
+            "#euclidean_ring_operators2">euclidean_ring_operators&lt;T,
            U&gt;</a></code></li>

            <li><code><a href="#totally_ordered2">totally_ordered&lt;T,
@ -1498,6 +1501,15 @@ T operator+( T lhs, const T&amp; rhs )
      </tr>
    </table>

+    <h4>Spelling: euclidean vs. euclidian</h4>
+
+    <p>Older versions of the Boost.Operators library used
+    &quot;<code>euclidian</code>&quot;, but it was pointed out that
+    &quot;<code>euclidean</code>&quot; is the more common spelling.
+    To be compatible with older version, the library now supports
+    both spellings.
+    </p>
+
    <h3><a name="ex_oprs">Example</a> Templates</h3>

    <p>The arithmetic operator class templates <code><a href=
@ -1576,9 +1588,8 @@ T operator+( T lhs, const T&amp; rhs )

    <p>The <cite><a href="operators_test.cpp">operators_test.cpp</a></cite>
    program demonstrates the use of the arithmetic operator templates, and
-    can also be used to verify correct operation. Check the <a href=
-    "../../status/compiler_status.html">compiler status report</a> for the
-    test results with selected platforms.</p>
+    can also be used to verify correct operation. Check the compiler status
+    report for the test results with selected platforms.</p>

    <h2><a name="deref">Dereference</a> Operators and Iterator Helpers</h2>

@ -1856,7 +1867,7 @@ T operator+( T lhs, const T&amp; rhs )
        V, D, P, R&gt;</a></code></td>

        <td>
-          Supports the operations and has the requirements of 
+          Supports the operations and has the requirements of

          <ul>
            <li><code><a href="#input_iteratable">input_iteratable&lt;T,
@ -1870,7 +1881,7 @@ T operator+( T lhs, const T&amp; rhs )
        "output_iterator_helper">output_iterator_helper&lt;T&gt;</a></code></td>

        <td>
-          Supports the operations and has the requirements of 
+          Supports the operations and has the requirements of

          <ul>
            <li><code><a href=
@ -1886,7 +1897,7 @@ T operator+( T lhs, const T&amp; rhs )
        R&gt;</a></code></td>

        <td>
-          Supports the operations and has the requirements of 
+          Supports the operations and has the requirements of

          <ul>
            <li><code><a href="#forward_iteratable">forward_iteratable&lt;T,
@ -1901,7 +1912,7 @@ T operator+( T lhs, const T&amp; rhs )
        V, D, P, R&gt;</a></code></td>

        <td>
-          Supports the operations and has the requirements of 
+          Supports the operations and has the requirements of

          <ul>
            <li><code><a href=
@ -1917,7 +1928,7 @@ T operator+( T lhs, const T&amp; rhs )
        V, D, P, R&gt;</a></code></td>

        <td>
-          Supports the operations and has the requirements of 
+          Supports the operations and has the requirements of

          <ul>
            <li><code><a href=
@ -1968,8 +1979,8 @@ struct function_output_iterator
    template&lt;typename T&gt;
    function_output_iterator&amp; operator=(T const&amp; value)
    {
-        this-&gt;func(value); 
-        return *this; 
+        this-&gt;func(value);
+        return *this;
    }

 private:
@ -2022,20 +2033,20 @@ public:
 </pre>
    </blockquote>

-    <p>Check the <a href="../../status/compiler_status.html">compiler status
+    <p>Check the <a href="http://www.boost.org/development/testing.html">compiler status
    report</a> for the test results with selected platforms.</p>
    <hr>

    <h2><a name="contributors">Contributors</a></h2>

    <dl>
-      <dt><a href="../../people/dave_abrahams.htm">Dave Abrahams</a></dt>
+      <dt><a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a></dt>

      <dd>Started the library and contributed the arithmetic operators in
      <cite><a href=
      "../../boost/operators.hpp">boost/operators.hpp</a></cite>.</dd>

-      <dt><a href="../../people/jeremy_siek.htm">Jeremy Siek</a></dt>
+      <dt><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a></dt>

      <dd>Contributed the <a href="#deref">dereference operators and iterator
      helpers</a> in <cite><a href=
@ -2043,19 +2054,19 @@ public:
      contributed <cite><a href=
      "iterators_test.cpp">iterators_test.cpp</a></cite>.</dd>

-      <dt><a href="../../people/aleksey_gurtovoy.htm">Aleksey
+      <dt><a href="http://www.boost.org/people/aleksey_gurtovoy.htm">Aleksey
      Gurtovoy</a></dt>

      <dd>Contributed the code to support <a href="#chaining">base class
      chaining</a> while remaining backward-compatible with old versions of
      the library.</dd>

-      <dt><a href="../../people/beman_dawes.html">Beman Dawes</a></dt>
+      <dt><a href="http://www.boost.org/people/beman_dawes.html">Beman Dawes</a></dt>

      <dd>Contributed <cite><a href=
      "operators_test.cpp">operators_test.cpp</a></cite>.</dd>

-      <dt><a href="../../people/daryle_walker.html">Daryle Walker</a></dt>
+      <dt><a href="http://www.boost.org/people/daryle_walker.html">Daryle Walker</a></dt>

      <dd>Contributed classes for the shift operators, equivalence, partial
      ordering, and arithmetic conversions. Added the grouped operator
@ -2119,11 +2130,11 @@ public:
    backward-compatible.</p>
    <hr>

-    <p>Revised: 29 Oct 2004</p>
+    <p>Revised: 7 Aug 2008</p>

    <p>Copyright &copy; Beman Dawes, David Abrahams, 1999-2001.</p>
-    <p>Copyright &copy; Daniel Frey, 2002-2004.</p>
-    <p>Use, modification, and distribution is subject to the Boost Software 
+    <p>Copyright &copy; Daniel Frey, 2002-2009.</p>
+    <p>Use, modification, and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file
    <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at
    <a href="http://www.boost.org/LICENSE_1_0.txt">
--- a/operators_test.cpp
+++ b/operators_test.cpp
@ -7,6 +7,7 @@
 //  See http://www.boost.org/libs/utility for documentation.

 //  Revision History
+//  03 Apr 08 Added convertible_to_bool (Daniel Frey)
 //  01 Oct 01 Added tests for "left" operators
 //            and new grouped operators. (Helmut Zeisel)
 //  20 May 01 Output progress messages.  Added tests for new operator
@ -43,6 +44,23 @@ namespace
    unsigned char true_value(unsigned char x) { return x; }
    unsigned short true_value(unsigned short x) { return x; }

+    // verify the minimum requirements for some operators
+    class convertible_to_bool
+    {
+    private:
+        bool _value;
+
+        typedef bool convertible_to_bool::*unspecified_bool_type;
+
+        void operator!() const;
+
+    public:
+        convertible_to_bool( const bool value ) : _value( value ) {}
+
+        operator unspecified_bool_type() const
+          { return _value ? &convertible_to_bool::_value : 0; }
+    };
+
    // The use of operators<> here tended to obscure
    // interactions with certain compiler bugs
    template <class T>
@ -54,8 +72,10 @@ namespace
        explicit Wrapped1( T v = T() ) : _value(v) {}
        T value() const { return _value; }

-        bool operator<(const Wrapped1& x) const { return _value < x._value; }
-        bool operator==(const Wrapped1& x) const { return _value == x._value; }
+        convertible_to_bool operator<(const Wrapped1& x) const
+          { return _value < x._value; }
+        convertible_to_bool operator==(const Wrapped1& x) const
+          { return _value == x._value; }
        
        Wrapped1& operator+=(const Wrapped1& x)
          { _value += x._value; return *this; }
@ -97,8 +117,10 @@ namespace
        explicit Wrapped2( T v = T() ) : _value(v) {}
        T value() const { return _value; }

-        bool operator<(const Wrapped2& x) const { return _value < x._value; }
-        bool operator==(const Wrapped2& x) const { return _value == x._value; }
+        convertible_to_bool operator<(const Wrapped2& x) const
+          { return _value < x._value; }
+        convertible_to_bool operator==(const Wrapped2& x) const
+          { return _value == x._value; }
        
        Wrapped2& operator+=(const Wrapped2& x)
          { _value += x._value; return *this; }
@ -123,9 +145,13 @@ namespace
        Wrapped2& operator++()                { ++_value; return *this; }
        Wrapped2& operator--()                { --_value; return *this; }
         
-        bool operator<(U u) const { return _value < u; }
-        bool operator>(U u) const { return _value > u; }
-        bool operator==(U u) const { return _value == u; }
+        convertible_to_bool operator<(U u) const
+          { return _value < u; }
+        convertible_to_bool operator>(U u) const
+          { return _value > u; }
+        convertible_to_bool operator==(U u) const
+          { return _value == u; }
+
        Wrapped2& operator+=(U u) { _value += u; return *this; }
        Wrapped2& operator-=(U u) { _value -= u; return *this; }
        Wrapped2& operator*=(U u) { _value *= u; return *this; }
@ -153,7 +179,8 @@ namespace
        explicit Wrapped3( T v = T() ) : _value(v) {}
        T value() const { return _value; }

-        bool operator<(const Wrapped3& x) const { return _value < x._value; }
+        convertible_to_bool operator<(const Wrapped3& x) const
+          { return _value < x._value; }
        
    private:
        T _value;
@ -174,10 +201,13 @@ namespace
        explicit Wrapped4( T v = T() ) : _value(v) {}
        T value() const { return _value; }

-        bool operator<(const Wrapped4& x) const { return _value < x._value; }
+        convertible_to_bool operator<(const Wrapped4& x) const
+          { return _value < x._value; }
         
-        bool operator<(U u) const { return _value < u; }
-        bool operator>(U u) const { return _value > u; }
+        convertible_to_bool operator<(U u) const
+          { return _value < u; }
+        convertible_to_bool operator>(U u) const
+          { return _value > u; }

    private:
        T _value;
@ -198,11 +228,18 @@ namespace
        Wrapped5(U u) : _value(u) {}

        T value() const { return _value; }
-        bool operator<(const Wrapped5& x) const { return _value < x._value; }
-        bool operator<(U u) const { return _value < u; }
-        bool operator>(U u) const { return _value > u; }
-        bool operator==(const Wrapped5& u) const { return _value == u._value; }
-        bool operator==(U u) const { return _value == u; }
+
+        convertible_to_bool operator<(const Wrapped5& x) const
+          { return _value < x._value; }
+        convertible_to_bool operator<(U u) const
+          { return _value < u; }
+        convertible_to_bool operator>(U u) const
+          { return _value > u; }
+        convertible_to_bool operator==(const Wrapped5& u) const
+          { return _value == u._value; }
+        convertible_to_bool operator==(U u) const
+          { return _value == u; }
+
        Wrapped5& operator/=(const Wrapped5& u) { _value /= u._value; return *this;}
        Wrapped5& operator/=(U u) { _value /= u; return *this;}
        Wrapped5& operator*=(const Wrapped5& u) { _value *= u._value; return *this;}
@ -221,8 +258,8 @@ namespace
    // U must be convertible to T
    template <class T, class U>
    class Wrapped6
-        : boost::ordered_euclidian_ring_operators2<Wrapped6<T, U>, U>
-        , boost::ordered_euclidian_ring_operators1<Wrapped6<T, U> >
+        : boost::ordered_euclidean_ring_operators2<Wrapped6<T, U>, U>
+        , boost::ordered_euclidean_ring_operators1<Wrapped6<T, U> >
    {
    public:
        explicit Wrapped6( T v = T() ) : _value(v) {}
@ -231,11 +268,18 @@ namespace
        Wrapped6(U u) : _value(u) {}

        T value() const { return _value; }
-        bool operator<(const Wrapped6& x) const { return _value < x._value; }
-        bool operator<(U u) const { return _value < u; }
-        bool operator>(U u) const { return _value > u; }
-        bool operator==(const Wrapped6& u) const { return _value == u._value; }
-        bool operator==(U u) const { return _value == u; }
+
+        convertible_to_bool operator<(const Wrapped6& x) const
+          { return _value < x._value; }
+        convertible_to_bool operator<(U u) const
+          { return _value < u; }
+        convertible_to_bool operator>(U u) const
+          { return _value > u; }
+        convertible_to_bool operator==(const Wrapped6& u) const
+          { return _value == u._value; }
+        convertible_to_bool operator==(U u) const
+          { return _value == u; }
+
        Wrapped6& operator%=(const Wrapped6& u) { _value %= u._value; return *this;}
        Wrapped6& operator%=(U u) { _value %= u; return *this;}
        Wrapped6& operator/=(const Wrapped6& u) { _value /= u._value; return *this;}
@ -276,10 +320,10 @@ namespace
    template <class X1, class Y1, class X2, class Y2>
    void test_less_than_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        BOOST_CHECK( (x1 < y1) == (x2 < y2) );
-        BOOST_CHECK( (x1 <= y1) == (x2 <= y2) );
-        BOOST_CHECK( (x1 >= y1) == (x2 >= y2) );
-        BOOST_CHECK( (x1 > y1) == (x2 > y2) );
+        BOOST_CHECK( static_cast<bool>(x1 < y1) == static_cast<bool>(x2 < y2) );
+        BOOST_CHECK( static_cast<bool>(x1 <= y1) == static_cast<bool>(x2 <= y2) );
+        BOOST_CHECK( static_cast<bool>(x1 >= y1) == static_cast<bool>(x2 >= y2) );
+        BOOST_CHECK( static_cast<bool>(x1 > y1) == static_cast<bool>(x2 > y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
@ -293,8 +337,8 @@ namespace
    template <class X1, class Y1, class X2, class Y2>
    void test_equality_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        BOOST_CHECK( (x1 == y1) == (x2 == y2) );
-        BOOST_CHECK( (x1 != y1) == (x2 != y2) );
+        BOOST_CHECK( static_cast<bool>(x1 == y1) == static_cast<bool>(x2 == y2) );
+        BOOST_CHECK( static_cast<bool>(x1 != y1) == static_cast<bool>(x2 != y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
@ -614,14 +658,14 @@ test_main( int , char * [] )

    PRIVATE_EXPR_TEST( (i = i2), (i.value() == 2) );

-    BOOST_CHECK( i2 == i );
-    BOOST_CHECK( i1 != i2 );
-    BOOST_CHECK( i1 <  i2 );
-    BOOST_CHECK( i1 <= i2 );
-    BOOST_CHECK( i <= i2 );
-    BOOST_CHECK( i2 >  i1 );
-    BOOST_CHECK( i2 >= i1 );
-    BOOST_CHECK( i2 >= i );
+    BOOST_CHECK( static_cast<bool>(i2 == i) );
+    BOOST_CHECK( static_cast<bool>(i1 != i2) );
+    BOOST_CHECK( static_cast<bool>(i1 <  i2) );
+    BOOST_CHECK( static_cast<bool>(i1 <= i2) );
+    BOOST_CHECK( static_cast<bool>(i <= i2) );
+    BOOST_CHECK( static_cast<bool>(i2 >  i1) );
+    BOOST_CHECK( static_cast<bool>(i2 >= i1) );
+    BOOST_CHECK( static_cast<bool>(i2 >= i) );

    PRIVATE_EXPR_TEST( (i = i1 + i2), (i.value() == 3) );
    PRIVATE_EXPR_TEST( (i = i + i2), (i.value() == 5) );
@ -653,78 +697,78 @@ test_main( int , char * [] )

    PRIVATE_EXPR_TEST( (j = j2), (j.value() == 2) );
    
-    BOOST_CHECK( j2 == j );
-    BOOST_CHECK( 2 == j );
-    BOOST_CHECK( j2 == 2 );    
-    BOOST_CHECK( j == j2 );
-    BOOST_CHECK( j1 != j2 );
-    BOOST_CHECK( j1 != 2 );
-    BOOST_CHECK( 1 != j2 );
-    BOOST_CHECK( j1 <  j2 );
-    BOOST_CHECK( 1 <  j2 );
-    BOOST_CHECK( j1 <  2 );
-    BOOST_CHECK( j1 <= j2 );
-    BOOST_CHECK( 1 <= j2 );
-    BOOST_CHECK( j1 <= j );
-    BOOST_CHECK( j <= j2 );
-    BOOST_CHECK( 2 <= j2 );
-    BOOST_CHECK( j <= 2 );
-    BOOST_CHECK( j2 >  j1 );
-    BOOST_CHECK( 2 >  j1 );
-    BOOST_CHECK( j2 >  1 );
-    BOOST_CHECK( j2 >= j1 );
-    BOOST_CHECK( 2 >= j1 );
-    BOOST_CHECK( j2 >= 1 );
-    BOOST_CHECK( j2 >= j );
-    BOOST_CHECK( 2 >= j );
-    BOOST_CHECK( j2 >= 2 );
+    BOOST_CHECK( static_cast<bool>(j2 == j) );
+    BOOST_CHECK( static_cast<bool>(2 == j) );
+    BOOST_CHECK( static_cast<bool>(j2 == 2) );
+    BOOST_CHECK( static_cast<bool>(j == j2) );
+    BOOST_CHECK( static_cast<bool>(j1 != j2) );
+    BOOST_CHECK( static_cast<bool>(j1 != 2) );
+    BOOST_CHECK( static_cast<bool>(1 != j2) );
+    BOOST_CHECK( static_cast<bool>(j1 <  j2) );
+    BOOST_CHECK( static_cast<bool>(1 <  j2) );
+    BOOST_CHECK( static_cast<bool>(j1 <  2) );
+    BOOST_CHECK( static_cast<bool>(j1 <= j2) );
+    BOOST_CHECK( static_cast<bool>(1 <= j2) );
+    BOOST_CHECK( static_cast<bool>(j1 <= j) );
+    BOOST_CHECK( static_cast<bool>(j <= j2) );
+    BOOST_CHECK( static_cast<bool>(2 <= j2) );
+    BOOST_CHECK( static_cast<bool>(j <= 2) );
+    BOOST_CHECK( static_cast<bool>(j2 >  j1) );
+    BOOST_CHECK( static_cast<bool>(2 >  j1) );
+    BOOST_CHECK( static_cast<bool>(j2 >  1) );
+    BOOST_CHECK( static_cast<bool>(j2 >= j1) );
+    BOOST_CHECK( static_cast<bool>(2 >= j1) );
+    BOOST_CHECK( static_cast<bool>(j2 >= 1) );
+    BOOST_CHECK( static_cast<bool>(j2 >= j) );
+    BOOST_CHECK( static_cast<bool>(2 >= j) );
+    BOOST_CHECK( static_cast<bool>(j2 >= 2) );

-    BOOST_CHECK( (j1 + 2) == 3 );
-    BOOST_CHECK( (1 + j2) == 3 );
+    BOOST_CHECK( static_cast<bool>((j1 + 2) == 3) );
+    BOOST_CHECK( static_cast<bool>((1 + j2) == 3) );
    PRIVATE_EXPR_TEST( (j = j1 + j2), (j.value() == 3) );
    
-    BOOST_CHECK( (j + 2) == 5 );
-    BOOST_CHECK( (3 + j2) == 5 );
+    BOOST_CHECK( static_cast<bool>((j + 2) == 5) );
+    BOOST_CHECK( static_cast<bool>((3 + j2) == 5) );
    PRIVATE_EXPR_TEST( (j = j + j2), (j.value() == 5) );
    
-    BOOST_CHECK( (j - 1) == 4 );
+    BOOST_CHECK( static_cast<bool>((j - 1) == 4) );
    PRIVATE_EXPR_TEST( (j = j - j1), (j.value() == 4) );
    
-    BOOST_CHECK( (j * 2) == 8 );
-    BOOST_CHECK( (4 * j2) == 8 );
+    BOOST_CHECK( static_cast<bool>((j * 2) == 8) );
+    BOOST_CHECK( static_cast<bool>((4 * j2) == 8) );
    PRIVATE_EXPR_TEST( (j = j * j2), (j.value() == 8) );
    
-    BOOST_CHECK( (j / 2) == 4 );
+    BOOST_CHECK( static_cast<bool>((j / 2) == 4) );
    PRIVATE_EXPR_TEST( (j = j / j2), (j.value() == 4) );
    
-    BOOST_CHECK( (j % 3) == 1 );
+    BOOST_CHECK( static_cast<bool>((j % 3) == 1) );
    PRIVATE_EXPR_TEST( (j = j % ( j - j1 )), (j.value() == 1) );
    
    PRIVATE_EXPR_TEST( (j = j2 + j2), (j.value() == 4) );
    
-    BOOST_CHECK( (1 | j2 | j) == 7 );
-    BOOST_CHECK( (j1 | 2 | j) == 7 );
-    BOOST_CHECK( (j1 | j2 | 4) == 7 );
+    BOOST_CHECK( static_cast<bool>((1 | j2 | j) == 7) );
+    BOOST_CHECK( static_cast<bool>((j1 | 2 | j) == 7) );
+    BOOST_CHECK( static_cast<bool>((j1 | j2 | 4) == 7) );
    PRIVATE_EXPR_TEST( (j = j1 | j2 | j), (j.value() == 7) );
    
-    BOOST_CHECK( (7 & j2) == 2 );
-    BOOST_CHECK( (j & 2) == 2 );
+    BOOST_CHECK( static_cast<bool>((7 & j2) == 2) );
+    BOOST_CHECK( static_cast<bool>((j & 2) == 2) );
    PRIVATE_EXPR_TEST( (j = j & j2), (j.value() == 2) );
    
    PRIVATE_EXPR_TEST( (j = j | j1), (j.value() == 3) );
    
-    BOOST_CHECK( (3 ^ j1) == 2 );
-    BOOST_CHECK( (j ^ 1) == 2 );
+    BOOST_CHECK( static_cast<bool>((3 ^ j1) == 2) );
+    BOOST_CHECK( static_cast<bool>((j ^ 1) == 2) );
    PRIVATE_EXPR_TEST( (j = j ^ j1), (j.value() == 2) );
    
    PRIVATE_EXPR_TEST( (j = ( j + j1 ) * ( j2 | j1 )), (j.value() == 9) );

-    BOOST_CHECK( (j1 << 2) == 4 );
-    BOOST_CHECK( (j2 << 1) == 4 );
+    BOOST_CHECK( static_cast<bool>((j1 << 2) == 4) );
+    BOOST_CHECK( static_cast<bool>((j2 << 1) == 4) );
    PRIVATE_EXPR_TEST( (j = j1 << j2), (j.value() == 4) );

-    BOOST_CHECK( (j >> 2) == 1 );
-    BOOST_CHECK( (j2 >> 1) == 1 );
+    BOOST_CHECK( static_cast<bool>((j >> 2) == 1) );
+    BOOST_CHECK( static_cast<bool>((j2 >> 1) == 1) );
    PRIVATE_EXPR_TEST( (j = j2 >> j1), (j.value() == 1) );
    
    cout << "Performed tests on MyLong objects.\n";
@ -741,14 +785,14 @@ test_main( int , char * [] )

    PRIVATE_EXPR_TEST( (k = k2), (k.value() == 2) );

-    BOOST_CHECK( k2 == k );
-    BOOST_CHECK( k1 != k2 );
-    BOOST_CHECK( k1 <  k2 );
-    BOOST_CHECK( k1 <= k2 );
-    BOOST_CHECK( k <= k2 );
-    BOOST_CHECK( k2 >  k1 );
-    BOOST_CHECK( k2 >= k1 );
-    BOOST_CHECK( k2 >= k );
+    BOOST_CHECK( static_cast<bool>(k2 == k) );
+    BOOST_CHECK( static_cast<bool>(k1 != k2) );
+    BOOST_CHECK( static_cast<bool>(k1 <  k2) );
+    BOOST_CHECK( static_cast<bool>(k1 <= k2) );
+    BOOST_CHECK( static_cast<bool>(k <= k2) );
+    BOOST_CHECK( static_cast<bool>(k2 >  k1) );
+    BOOST_CHECK( static_cast<bool>(k2 >= k1) );
+    BOOST_CHECK( static_cast<bool>(k2 >= k) );
    
    cout << "Performed tests on MyChar objects.\n";

@ -764,31 +808,31 @@ test_main( int , char * [] )

    PRIVATE_EXPR_TEST( (l = l2), (l.value() == 2) );
    
-    BOOST_CHECK( l2 == l );
-    BOOST_CHECK( 2 == l );
-    BOOST_CHECK( l2 == 2 );    
-    BOOST_CHECK( l == l2 );
-    BOOST_CHECK( l1 != l2 );
-    BOOST_CHECK( l1 != 2 );
-    BOOST_CHECK( 1 != l2 );
-    BOOST_CHECK( l1 <  l2 );
-    BOOST_CHECK( 1 <  l2 );
-    BOOST_CHECK( l1 <  2 );
-    BOOST_CHECK( l1 <= l2 );
-    BOOST_CHECK( 1 <= l2 );
-    BOOST_CHECK( l1 <= l );
-    BOOST_CHECK( l <= l2 );
-    BOOST_CHECK( 2 <= l2 );
-    BOOST_CHECK( l <= 2 );
-    BOOST_CHECK( l2 >  l1 );
-    BOOST_CHECK( 2 >  l1 );
-    BOOST_CHECK( l2 >  1 );
-    BOOST_CHECK( l2 >= l1 );
-    BOOST_CHECK( 2 >= l1 );
-    BOOST_CHECK( l2 >= 1 );
-    BOOST_CHECK( l2 >= l );
-    BOOST_CHECK( 2 >= l );
-    BOOST_CHECK( l2 >= 2 );
+    BOOST_CHECK( static_cast<bool>(l2 == l) );
+    BOOST_CHECK( static_cast<bool>(2 == l) );
+    BOOST_CHECK( static_cast<bool>(l2 == 2) );
+    BOOST_CHECK( static_cast<bool>(l == l2) );
+    BOOST_CHECK( static_cast<bool>(l1 != l2) );
+    BOOST_CHECK( static_cast<bool>(l1 != 2) );
+    BOOST_CHECK( static_cast<bool>(1 != l2) );
+    BOOST_CHECK( static_cast<bool>(l1 <  l2) );
+    BOOST_CHECK( static_cast<bool>(1 <  l2) );
+    BOOST_CHECK( static_cast<bool>(l1 <  2) );
+    BOOST_CHECK( static_cast<bool>(l1 <= l2) );
+    BOOST_CHECK( static_cast<bool>(1 <= l2) );
+    BOOST_CHECK( static_cast<bool>(l1 <= l) );
+    BOOST_CHECK( static_cast<bool>(l <= l2) );
+    BOOST_CHECK( static_cast<bool>(2 <= l2) );
+    BOOST_CHECK( static_cast<bool>(l <= 2) );
+    BOOST_CHECK( static_cast<bool>(l2 >  l1) );
+    BOOST_CHECK( static_cast<bool>(2 >  l1) );
+    BOOST_CHECK( static_cast<bool>(l2 >  1) );
+    BOOST_CHECK( static_cast<bool>(l2 >= l1) );
+    BOOST_CHECK( static_cast<bool>(2 >= l1) );
+    BOOST_CHECK( static_cast<bool>(l2 >= 1) );
+    BOOST_CHECK( static_cast<bool>(l2 >= l) );
+    BOOST_CHECK( static_cast<bool>(2 >= l) );
+    BOOST_CHECK( static_cast<bool>(l2 >= 2) );
    
    cout << "Performed tests on MyShort objects.\n";
    
@ -807,37 +851,37 @@ test_main( int , char * [] )

    PRIVATE_EXPR_TEST( (di = di2), (di.value() == 2) );
    
-    BOOST_CHECK( di2 == di );
-    BOOST_CHECK( 2 == di );
-    BOOST_CHECK( di == 2 );
-    BOOST_CHECK( di1 < di2 );
-    BOOST_CHECK( 1 < di2 );
-    BOOST_CHECK( di1 <= di2 );
-    BOOST_CHECK( 1 <= di2 );
-    BOOST_CHECK( di2 > di1 );
-    BOOST_CHECK( di2 > 1 );
-    BOOST_CHECK( di2 >= di1 );
-    BOOST_CHECK( di2 >= 1 );
-    BOOST_CHECK( di1 / di2 == half );
-    BOOST_CHECK( di1 / 2 == half );
-    BOOST_CHECK( 1 / di2 == half );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp/=2) == half) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp/=di2) == half) );
-    BOOST_CHECK( di1 * di2 == di2 );
-    BOOST_CHECK( di1 * 2 == di2 );
-    BOOST_CHECK( 1 * di2 == di2 );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp*=2) == di2) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp*=di2) == di2) );
-    BOOST_CHECK( di2 - di1 == di1 );
-    BOOST_CHECK( di2 - 1 == di1 );
-    BOOST_CHECK( 2 - di1 == di1 );
-    PRIVATE_EXPR_TEST( (tmp=di2), ((tmp-=1) == di1) );
-    PRIVATE_EXPR_TEST( (tmp=di2), ((tmp-=di1) == di1) );
-    BOOST_CHECK( di1 + di1 == di2 );
-    BOOST_CHECK( di1 + 1 == di2 );
-    BOOST_CHECK( 1 + di1 == di2 );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp+=1) == di2) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp+=di1) == di2) );
+    BOOST_CHECK( static_cast<bool>(di2 == di) );
+    BOOST_CHECK( static_cast<bool>(2 == di) );
+    BOOST_CHECK( static_cast<bool>(di == 2) );
+    BOOST_CHECK( static_cast<bool>(di1 < di2) );
+    BOOST_CHECK( static_cast<bool>(1 < di2) );
+    BOOST_CHECK( static_cast<bool>(di1 <= di2) );
+    BOOST_CHECK( static_cast<bool>(1 <= di2) );
+    BOOST_CHECK( static_cast<bool>(di2 > di1) );
+    BOOST_CHECK( static_cast<bool>(di2 > 1) );
+    BOOST_CHECK( static_cast<bool>(di2 >= di1) );
+    BOOST_CHECK( static_cast<bool>(di2 >= 1) );
+    BOOST_CHECK( static_cast<bool>(di1 / di2 == half) );
+    BOOST_CHECK( static_cast<bool>(di1 / 2 == half) );
+    BOOST_CHECK( static_cast<bool>(1 / di2 == half) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp/=2) == half) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp/=di2) == half) );
+    BOOST_CHECK( static_cast<bool>(di1 * di2 == di2) );
+    BOOST_CHECK( static_cast<bool>(di1 * 2 == di2) );
+    BOOST_CHECK( static_cast<bool>(1 * di2 == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp*=2) == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp*=di2) == di2) );
+    BOOST_CHECK( static_cast<bool>(di2 - di1 == di1) );
+    BOOST_CHECK( static_cast<bool>(di2 - 1 == di1) );
+    BOOST_CHECK( static_cast<bool>(2 - di1 == di1) );
+    PRIVATE_EXPR_TEST( (tmp=di2), static_cast<bool>((tmp-=1) == di1) );
+    PRIVATE_EXPR_TEST( (tmp=di2), static_cast<bool>((tmp-=di1) == di1) );
+    BOOST_CHECK( static_cast<bool>(di1 + di1 == di2) );
+    BOOST_CHECK( static_cast<bool>(di1 + 1 == di2) );
+    BOOST_CHECK( static_cast<bool>(1 + di1 == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp+=1) == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp+=di1) == di2) );

    cout << "Performed tests on MyDoubleInt objects.\n";

@ -854,42 +898,42 @@ test_main( int , char * [] )

    PRIVATE_EXPR_TEST( (li = li2), (li.value() == 2) );
    
-    BOOST_CHECK( li2 == li );
-    BOOST_CHECK( 2 == li );
-    BOOST_CHECK( li == 2 );
-    BOOST_CHECK( li1 < li2 );
-    BOOST_CHECK( 1 < li2 );
-    BOOST_CHECK( li1 <= li2 );
-    BOOST_CHECK( 1 <= li2 );
-    BOOST_CHECK( li2 > li1 );
-    BOOST_CHECK( li2 > 1 );
-    BOOST_CHECK( li2 >= li1 );
-    BOOST_CHECK( li2 >= 1 );
-    BOOST_CHECK( li1 % li2 == li1 );
-    BOOST_CHECK( li1 % 2 == li1 );
-    BOOST_CHECK( 1 % li2 == li1 );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2%=2) == li1) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2%=li2) == li1) );
-    BOOST_CHECK( li1 / li2 == 0 );
-    BOOST_CHECK( li1 / 2 == 0 );
-    BOOST_CHECK( 1 / li2 == 0 );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2/=2) == 0) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2/=li2) == 0) );
-    BOOST_CHECK( li1 * li2 == li2 );
-    BOOST_CHECK( li1 * 2 == li2 );
-    BOOST_CHECK( 1 * li2 == li2 );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2*=2) == li2) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2*=li2) == li2) );
-    BOOST_CHECK( li2 - li1 == li1 );
-    BOOST_CHECK( li2 - 1 == li1 );
-    BOOST_CHECK( 2 - li1 == li1 );
-    PRIVATE_EXPR_TEST( (tmp2=li2), ((tmp2-=1) == li1) );
-    PRIVATE_EXPR_TEST( (tmp2=li2), ((tmp2-=li1) == li1) );
-    BOOST_CHECK( li1 + li1 == li2 );
-    BOOST_CHECK( li1 + 1 == li2 );
-    BOOST_CHECK( 1 + li1 == li2 );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2+=1) == li2) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2+=li1) == li2) );
+    BOOST_CHECK( static_cast<bool>(li2 == li) );
+    BOOST_CHECK( static_cast<bool>(2 == li) );
+    BOOST_CHECK( static_cast<bool>(li == 2) );
+    BOOST_CHECK( static_cast<bool>(li1 < li2) );
+    BOOST_CHECK( static_cast<bool>(1 < li2) );
+    BOOST_CHECK( static_cast<bool>(li1 <= li2) );
+    BOOST_CHECK( static_cast<bool>(1 <= li2) );
+    BOOST_CHECK( static_cast<bool>(li2 > li1) );
+    BOOST_CHECK( static_cast<bool>(li2 > 1) );
+    BOOST_CHECK( static_cast<bool>(li2 >= li1) );
+    BOOST_CHECK( static_cast<bool>(li2 >= 1) );
+    BOOST_CHECK( static_cast<bool>(li1 % li2 == li1) );
+    BOOST_CHECK( static_cast<bool>(li1 % 2 == li1) );
+    BOOST_CHECK( static_cast<bool>(1 % li2 == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2%=2) == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2%=li2) == li1) );
+    BOOST_CHECK( static_cast<bool>(li1 / li2 == 0) );
+    BOOST_CHECK( static_cast<bool>(li1 / 2 == 0) );
+    BOOST_CHECK( static_cast<bool>(1 / li2 == 0) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2/=2) == 0) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2/=li2) == 0) );
+    BOOST_CHECK( static_cast<bool>(li1 * li2 == li2) );
+    BOOST_CHECK( static_cast<bool>(li1 * 2 == li2) );
+    BOOST_CHECK( static_cast<bool>(1 * li2 == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2*=2) == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2*=li2) == li2) );
+    BOOST_CHECK( static_cast<bool>(li2 - li1 == li1) );
+    BOOST_CHECK( static_cast<bool>(li2 - 1 == li1) );
+    BOOST_CHECK( static_cast<bool>(2 - li1 == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li2), static_cast<bool>((tmp2-=1) == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li2), static_cast<bool>((tmp2-=li1) == li1) );
+    BOOST_CHECK( static_cast<bool>(li1 + li1 == li2) );
+    BOOST_CHECK( static_cast<bool>(li1 + 1 == li2) );
+    BOOST_CHECK( static_cast<bool>(1 + li1 == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2+=1) == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2+=li1) == li2) );

    cout << "Performed tests on MyLongInt objects.\n";

--- a/ref_test.cpp
+++ b/ref_test.cpp
@ -68,11 +68,54 @@ struct ref_wrapper
    }
 };

+struct copy_counter {
+  static int count_;
+  copy_counter(copy_counter const& /*other*/) {
+    ++count_;
+  }
+  copy_counter() {}
+  static void reset() { count_ = 0; }
+  static int count() { return copy_counter::count_;  }
+};
+
+int copy_counter::count_ = 0;
+
 } // namespace unnamed

+template <class T>
+void do_unwrap(T t) {
+
+  /* typename unwrap_reference<T>::type& lt = */
+  unwrap_ref(t);
+
+}
+
+void unwrap_test() {
+
+  int i = 3;
+  const int ci = 2;
+
+  do_unwrap(i);
+  do_unwrap(ci);
+  do_unwrap(ref(i));
+  do_unwrap(cref(ci));
+  do_unwrap(ref(ci));
+
+  copy_counter cc;
+  BOOST_CHECK(cc.count() == 0);
+
+  do_unwrap(cc);
+  do_unwrap(ref(cc));
+  do_unwrap(cref(cc));
+
+  BOOST_CHECK(cc.count() == 1);
+  BOOST_CHECK(unwrap_ref(ref(cc)).count() == 1); 
+}
+
 int test_main(int, char * [])
 {
    ref_wrapper<int>::test(1);
    ref_wrapper<int const>::test(1);
+    unwrap_test();
    return 0;
 }
--- a/shared_container_iterator.html
+++ b/shared_container_iterator.html
@ -315,7 +315,7 @@ Last modified: Mon Aug 11 11:27:03 EST 2003
 <p><EFBFBD> Copyright 2003 The Trustees of Indiana University.
 Use, modification and distribution is subject to the Boost Software 
 License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http:www.boost.org/LICENSE_1_0.txt)</p>
+ http://www.boost.org/LICENSE_1_0.txt)</p>

 </body>

--- a/swap.html
+++ b/swap.html
@ -0,0 +1,98 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Boost: Swap Documentation</title>
+   </head>
+  <body>
+    <!-- Page header -->
+    <h2>
+    <img src="../../boost.png" alt="C++ Boost" align="middle" width="277" height="86"/>
+      Header &lt;<a href="../../boost/swap.hpp">boost/swap.hpp</a>&gt;
+    </h2>
+
+    <h1>Swap</h1>
+    
+    <p>
+      <tt>template&lt;class T&gt; void swap(T&amp; <em>left</em>, T&amp; <em>right</em>);</tt>
+    </p>
+     
+    <!-- Introduction -->
+    <p>
+      The template function <tt>boost::swap</tt> allows the values of two variables to be swapped, using argument dependent lookup to select a specialized swap function if available. If no specialized swap function is available, <tt>std::swap</tt> is used.
+    </p>
+    
+    <!-- Rationale -->
+    <h2>Rationale</h2>
+    <p>
+      The generic <tt>std::swap</tt> function requires that the elements to be swapped are assignable and copy constructible. It is usually implemented using one copy construction and two assignments - this is often both unnecessarily restrictive and unnecessarily slow. In addition, where the generic swap implementation provides only the basic guarantee, specialized swap functions are often able to provide the no-throw exception guarantee (and it is considered best practice to do so where possible<sup><a href="#ref1">1</a></sup>).</p>
+    <p>
+      The alternative to using argument dependent lookup in this situation is to provide a template specialization of <tt>std::swap</tt> for every type that requires a specialized swap. Although this is legal C++, no Boost libraries use this method, whereas many Boost libraries provide specialized swap functions in their own namespaces.
+    </p>
+    <p>
+      <tt>boost::swap</tt> also supports swapping built-in arrays. Note that <tt>std::swap</tt> originally did not do so, but a request to add an overload of <tt>std::swap</tt> for built-in arrays has been accepted by the C++ Standards Committee<sup><a href="#ref2">2</a></sup>.
+    </p>
+    
+    <!-- Exception Safety -->
+    <h2>Exception Safety</h2>
+    <p>
+      <tt>boost::swap</tt> provides the same exception guarantee as the underlying swap function used, with one exception; for an array of type <tt>T[n]</tt>, where <tt>n > 1</tt> and the underlying swap function for <tt>T</tt> provides the strong exception guarantee, <tt>boost::swap</tt> provides only the basic exception guarantee.
+    </p>
+    
+    <!-- Requirements -->
+    <h2>Requirements</h2>
+    <p>Either:</p>
+    <ul>      
+      <li>T must be assignable</li>
+      <li>T must be copy constructible</li>
+    </ul>
+    <p>Or:</p>
+    <ul>
+      <li>A function with the signature <tt>swap(T&amp;,T&amp;)</tt> is available via argument dependent lookup</li>
+    </ul>
+    <p>Or:</p>
+    <ul>
+      <li>A template specialization of <tt>std::swap</tt> exists for T</li>
+    </ul>
+    <p>Or:</p>
+    <ul>
+      <li>T is a built-in array of swappable elements</li>
+    </ul>
+
+    
+    <!-- Portability -->
+    <h2>Portability</h2>
+    <p>
+      Several older compilers do not support argument dependent lookup &#x2012; on these compilers <tt>boost::swap</tt> will call <tt>std::swap</tt>, ignoring any specialized swap functions that could be found as a result of argument dependent lookup.
+    </p>
+    
+    <!-- Credits -->
+    <h2>Credits</h2>
+    <ul>
+      <li>
+        <em>Niels Dekker</em> - for implementing and documenting support for built-in arrays
+      </li>
+      <li>
+        <em><a href="mailto:Joseph.Gauterin@googlemail.com">Joseph Gauterin</a></em> - for the initial idea, implementation, tests, and documentation
+      </li>
+      <li>
+        <em>Steven Watanabe</em> - for the idea to make <tt>boost::swap</tt> less specialized than <tt>std::swap</tt>, thereby allowing the function to have the name 'swap' without introducing ambiguity
+      </li>      
+    </ul>
+
+    <!-- References -->
+    <hr/>
+    <p><sup><a id="ref1"/>[1]</sup>Scott Meyers, Effective C++ Third Edition, Item 25: "Consider support for a non-throwing swap"</p>
+    <p><sup><a id="ref2"/>[2]</sup><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">LWG Defect Report 809 (std::swap should be overloaded for array types)</a></p>
+
+    <!-- Copyright info -->    
+    <hr/>
+    <p>Revised: 08 September 2009</p>
+    <p>
+      Copyright 2007 - 2009 Joseph Gauterin. Use, modification, and distribution are subject to the Boost Software License, Version 1.0.
+      (See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)
+    </p>
+    
+  </body>
+</html>
--- a/swap/test/Jamfile.v2
+++ b/swap/test/Jamfile.v2
@ -0,0 +1,37 @@
+# Copyright (c) 2007, 2008 Joseph Gauterin
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+# bring in rules for testing
+import testing ;
+
+test-suite utility/swap
+    :
+    [ compile root_header_1.cpp                                  ]
+    [ compile root_header_2.cpp                                  ]
+    [ compile lib_header_1.cpp                                   ]
+    [ compile lib_header_2.cpp                                   ]
+    [ compile mixed_headers_1.cpp                                ]
+    [ compile mixed_headers_2.cpp                                ]
+    [ run primitive.cpp ../../../test/build//boost_test_exec_monitor/<link>static                      ]
+    [ run specialized_in_boost.cpp ../../../test/build//boost_test_exec_monitor/<link>static           ]
+    [ run specialized_in_global.cpp ../../../test/build//boost_test_exec_monitor/<link>static          ]
+    [ run specialized_in_other.cpp ../../../test/build//boost_test_exec_monitor/<link>static           ]
+    [ run specialized_in_std.cpp ../../../test/build//boost_test_exec_monitor/<link>static             ]
+    [ run specialized_in_boost_and_other.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
+    [ run std_bitset.cpp ../../../test/build//boost_test_exec_monitor/<link>static                     ]
+    [ run std_dateorder.cpp ../../../test/build//boost_test_exec_monitor/<link>static                  ]
+    [ run std_string.cpp ../../../test/build//boost_test_exec_monitor/<link>static                     ]
+    [ run std_typeinfo_ptr.cpp ../../../test/build//boost_test_exec_monitor/<link>static               ]
+    [ run std_vector_of_boost.cpp ../../../test/build//boost_test_exec_monitor/<link>static            ]
+    [ run std_vector_of_global.cpp ../../../test/build//boost_test_exec_monitor/<link>static           ]
+    [ run std_vector_of_other.cpp ../../../test/build//boost_test_exec_monitor/<link>static            ]
+    [ run no_ambiguity_in_boost.cpp ../../../test/build//boost_test_exec_monitor/<link>static          ]
+    [ run array_of_array_of_class.cpp ../../../test/build//boost_test_exec_monitor/<link>static        ]
+    [ run array_of_array_of_int.cpp ../../../test/build//boost_test_exec_monitor/<link>static          ]
+    [ run array_of_class.cpp ../../../test/build//boost_test_exec_monitor/<link>static                 ]
+    [ run array_of_int.cpp ../../../test/build//boost_test_exec_monitor/<link>static                   ]
+    [ run array_of_template.cpp ../../../test/build//boost_test_exec_monitor/<link>static              ]
+    ;
--- a/swap/test/array_of_array_of_class.cpp
+++ b/swap/test/array_of_array_of_class.cpp
@ -0,0 +1,69 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests swapping an array of arrays of swap_test_class objects by means of boost::swap.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in the global namespace
+#include "./swap_test_class.hpp"
+
+#include <algorithm> //for std::copy and std::equal
+#include <cstddef> //for std::size_t
+
+//Provide swap function in both the namespace of swap_test_class
+//(which is the global namespace), and the std namespace.
+//It's common to provide a swap function for a class in both
+//namespaces. Scott Meyers recommends doing so: Effective C++,
+//Third Edition, item 25, "Consider support for a non-throwing swap".
+void swap(swap_test_class& left, swap_test_class& right)
+{
+  left.swap(right);
+}
+
+namespace std
+{
+  template <>
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+
+int test_main(int, char*[])
+{
+  const std::size_t first_dimension = 3;
+  const std::size_t second_dimension = 4;
+  const std::size_t number_of_elements = first_dimension * second_dimension;
+
+  swap_test_class array1[first_dimension][second_dimension];
+  swap_test_class array2[first_dimension][second_dimension];
+
+  swap_test_class* const ptr1 = array1[0];
+  swap_test_class* const ptr2 = array2[0];
+
+  for (std::size_t i = 0; i < number_of_elements; ++i)
+  {
+    ptr1[i].set_data( static_cast<int>(i) );
+    ptr2[i].set_data( static_cast<int>(i + number_of_elements) );
+  }
+
+  boost::swap(array1, array2);
+
+  for (std::size_t i = 0; i < number_of_elements; ++i)
+  {
+    BOOST_CHECK_EQUAL(ptr1[i].get_data(), static_cast<int>(i + number_of_elements) );
+    BOOST_CHECK_EQUAL(ptr2[i].get_data(), static_cast<int>(i) );
+  }
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), number_of_elements);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+
+  return 0;
+}
--- a/swap/test/array_of_array_of_int.cpp
+++ b/swap/test/array_of_array_of_int.cpp
@ -0,0 +1,42 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests swapping an array of arrays of integers by means of boost::swap.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+#include <algorithm> //for std::copy and std::equal
+#include <cstddef> //for std::size_t
+
+int test_main(int, char*[])
+{
+  const std::size_t first_dimension = 3;
+  const std::size_t second_dimension = 4;
+  const std::size_t number_of_elements = first_dimension * second_dimension;
+
+  int array1[first_dimension][second_dimension];
+  int array2[first_dimension][second_dimension];
+
+  int* const ptr1 = array1[0];
+  int* const ptr2 = array2[0];
+
+  for (std::size_t i = 0; i < number_of_elements; ++i)
+  {
+    ptr1[i] = static_cast<int>(i);
+    ptr2[i] = static_cast<int>(i + number_of_elements);
+  }
+
+  boost::swap(array1, array2);
+
+  for (std::size_t i = 0; i < number_of_elements; ++i)
+  {
+    BOOST_CHECK_EQUAL(ptr1[i], static_cast<int>(i + number_of_elements) );
+    BOOST_CHECK_EQUAL(ptr2[i], static_cast<int>(i) );
+  }
+  return 0;
+}
--- a/swap/test/array_of_class.cpp
+++ b/swap/test/array_of_class.cpp
@ -0,0 +1,61 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests swapping an array of arrays of swap_test_class objects by means of boost::swap.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in the global namespace
+#include "./swap_test_class.hpp"
+
+#include <algorithm> //for std::copy and std::equal
+#include <cstddef> //for std::size_t
+
+//Provide swap function in both the namespace of swap_test_class
+//(which is the global namespace), and the std namespace.
+//It's common to provide a swap function for a class in both
+//namespaces. Scott Meyers recommends doing so: Effective C++,
+//Third Edition, item 25, "Consider support for a non-throwing swap".
+void swap(swap_test_class& left, swap_test_class& right)
+{
+  left.swap(right);
+}
+
+namespace std
+{
+  template <>
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+
+int test_main(int, char*[])
+{
+  const std::size_t array_size = 2;
+  const swap_test_class initial_array1[array_size] = { swap_test_class(1), swap_test_class(2) };
+  const swap_test_class initial_array2[array_size] = { swap_test_class(3), swap_test_class(4) };
+  
+  swap_test_class array1[array_size];
+  swap_test_class array2[array_size];
+
+  std::copy(initial_array1, initial_array1 + array_size, array1);
+  std::copy(initial_array2, initial_array2 + array_size, array2);
+  
+  swap_test_class::reset();
+  boost::swap(array1, array2);
+
+  BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
+  BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), array_size);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+
+  return 0;
+}
--- a/swap/test/array_of_int.cpp
+++ b/swap/test/array_of_int.cpp
@ -0,0 +1,35 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests swapping an array of integers by means of boost::swap.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+#include <algorithm> //for std::copy and std::equal
+#include <cstddef> //for std::size_t
+
+
+int test_main(int, char*[])
+{
+  const std::size_t array_size = 3;
+  const int initial_array1[array_size] = { 1, 2, 3 };
+  const int initial_array2[array_size] = { 4, 5, 6 };
+  
+  int array1[array_size];
+  int array2[array_size];
+
+  std::copy(initial_array1, initial_array1 + array_size, array1);
+  std::copy(initial_array2, initial_array2 + array_size, array2);
+  
+  boost::swap(array1, array2);
+
+  BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
+  BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));
+
+  return 0;
+}
--- a/swap/test/array_of_template.cpp
+++ b/swap/test/array_of_template.cpp
@ -0,0 +1,71 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests swapping an array of swap_test_template<int> objects by means of boost::swap.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in the global namespace
+#include "./swap_test_class.hpp"
+
+#include <algorithm> //for std::copy and std::equal
+#include <cstddef> //for std::size_t
+
+template <class T>
+class swap_test_template
+{
+public:
+  typedef T template_argument;
+  swap_test_class swap_test_object;
+};
+
+template <class T>
+inline bool operator==(const swap_test_template<T> & lhs, const swap_test_template<T> & rhs)
+{
+  return lhs.swap_test_object == rhs.swap_test_object;
+}
+
+template <class T>
+inline bool operator!=(const swap_test_template<T> & lhs, const swap_test_template<T> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+//Provide swap function in the namespace of swap_test_template
+//(which is the global namespace).  Note that it isn't allowed to put
+//an overload of this function within the std namespace.
+template <class T>
+void swap(swap_test_template<T>& left, swap_test_template<T>& right)
+{
+  left.swap_test_object.swap(right.swap_test_object);
+}
+
+
+int test_main(int, char*[])
+{
+  const std::size_t array_size = 2;
+  const swap_test_template<int> initial_array1[array_size] = { swap_test_class(1), swap_test_class(2) };
+  const swap_test_template<int> initial_array2[array_size] = { swap_test_class(3), swap_test_class(4) };
+  
+  swap_test_template<int> array1[array_size];
+  swap_test_template<int> array2[array_size];
+
+  std::copy(initial_array1, initial_array1 + array_size, array1);
+  std::copy(initial_array2, initial_array2 + array_size, array2);
+  
+  swap_test_class::reset();
+  boost::swap(array1, array2);
+
+  BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
+  BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), array_size);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+
+  return 0;
+}
--- a/swap/test/lib_header_1.cpp
+++ b/swap/test/lib_header_1.cpp
@ -0,0 +1,10 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests that the swap header compiles as a standalone translation unit
+
+#include <boost/utility/swap.hpp>
+
--- a/swap/test/lib_header_2.cpp
+++ b/swap/test/lib_header_2.cpp
@ -0,0 +1,11 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests that the swap header include guards work correctly
+
+#include <boost/utility/swap.hpp>
+#include <boost/utility/swap.hpp>
+
--- a/swap/test/mixed_headers_1.cpp
+++ b/swap/test/mixed_headers_1.cpp
@ -0,0 +1,11 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests that the swap headers work when both are included
+
+#include <boost/swap.hpp>
+#include <boost/utility/swap.hpp>
+
--- a/swap/test/mixed_headers_2.cpp
+++ b/swap/test/mixed_headers_2.cpp
@ -0,0 +1,12 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests that the swap headers work when both are included
+
+#include <boost/utility/swap.hpp>
+#include <boost/swap.hpp>
+
+
--- a/swap/test/no_ambiguity_in_boost.cpp
+++ b/swap/test/no_ambiguity_in_boost.cpp
@ -0,0 +1,44 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// boost::swap internally does an unqualified function call to swap.
+// This could have led to ambiguity or infinite recursion, when the
+// objects to be swapped would themselves be from the boost namespace.
+// If so, boost::swap itself might be found by argument dependent lookup.
+// The implementation of boost::swap resolves this issue by giving
+// boost::swap two template argumetns, thereby making it less specialized
+// than std::swap.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in namespace boost
+namespace boost
+{
+  #include "./swap_test_class.hpp"
+}
+
+
+int test_main(int, char*[])
+{
+  const boost::swap_test_class initial_value1(1);
+  const boost::swap_test_class initial_value2(2);
+
+  boost::swap_test_class object1 = initial_value1;
+  boost::swap_test_class object2 = initial_value2;
+
+  boost::swap_test_class::reset();
+  boost::swap(object1,object2);
+
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  BOOST_CHECK_EQUAL(boost::swap_test_class::swap_count(),0);
+  BOOST_CHECK_EQUAL(boost::swap_test_class::copy_count(),3);
+
+  return 0;
+}
+
--- a/swap/test/primitive.cpp
+++ b/swap/test/primitive.cpp
@ -0,0 +1,23 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+int test_main(int, char*[])
+{
+  int object1 = 1;
+  int object2 = 2;
+
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(object1,2);
+  BOOST_CHECK_EQUAL(object2,1);
+
+  return 0;
+}
+
--- a/swap/test/root_header_1.cpp
+++ b/swap/test/root_header_1.cpp
@ -0,0 +1,10 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests that the swap header compiles as a standalone translation unit
+
+#include <boost/swap.hpp>
+
--- a/swap/test/root_header_2.cpp
+++ b/swap/test/root_header_2.cpp
@ -0,0 +1,11 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests that the swap header include guards work correctly
+
+#include <boost/swap.hpp>
+#include <boost/swap.hpp>
+
--- a/swap/test/specialized_in_boost.cpp
+++ b/swap/test/specialized_in_boost.cpp
@ -0,0 +1,45 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in namespace boost
+namespace boost
+{
+  #include "./swap_test_class.hpp"
+}
+
+//Provide swap function in namespace boost
+namespace boost
+{
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+int test_main(int, char*[])
+{
+  const boost::swap_test_class initial_value1(1);
+  const boost::swap_test_class initial_value2(2);
+
+  boost::swap_test_class object1 = initial_value1;
+  boost::swap_test_class object2 = initial_value2;
+  
+  boost::swap_test_class::reset();
+  boost::swap(object1,object2);
+
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+
+  BOOST_CHECK_EQUAL(boost::swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(boost::swap_test_class::copy_count(),0);
+
+  return 0;
+}
+
--- a/swap/test/specialized_in_boost_and_other.cpp
+++ b/swap/test/specialized_in_boost_and_other.cpp
@ -0,0 +1,64 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests whether instances of a class from a namespace other than boost are
+// properly swapped, when both boost and the other namespace have a custom
+// swap function for that class. Note that it shouldn't be necessary for a class
+// in an other namespace to have a custom swap function in boost, because the
+// boost::swap utility should find the swap function in the other namespace, by
+// argument dependent lookup (ADL). Unfortunately ADL isn't fully implemented
+// by some specific compiler versions, including Intel C++ 8.1, MSVC 7.1, and 
+// Borland 5.9.3. Users of those compilers might consider adding a swap overload
+// to the boost namespace.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in namespace other
+namespace other
+{
+  #include "./swap_test_class.hpp"
+}
+
+//Provide swap function in namespace boost
+namespace boost
+{
+  void swap(::other::swap_test_class& left, ::other::swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+//Provide swap function in namespace other
+namespace other
+{
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+int test_main(int, char*[])
+{
+  const other::swap_test_class initial_value1(1);
+  const other::swap_test_class initial_value2(2);
+
+  other::swap_test_class object1 = initial_value1;
+  other::swap_test_class object2 = initial_value2;
+  
+  other::swap_test_class::reset();
+  boost::swap(object1,object2);
+
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
+  BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);
+
+  return 0;
+}
+
--- a/swap/test/specialized_in_global.cpp
+++ b/swap/test/specialized_in_global.cpp
@ -0,0 +1,39 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in the global namespace
+#include "./swap_test_class.hpp"
+
+//Provide swap function in gloabl namespace
+void swap(swap_test_class& left, swap_test_class& right)
+{
+  left.swap(right);
+}
+
+int test_main(int, char*[])
+{
+  const swap_test_class initial_value1(1);
+  const swap_test_class initial_value2(2);
+
+  swap_test_class object1 = initial_value1;
+  swap_test_class object2 = initial_value2;
+  
+  swap_test_class::reset();
+  boost::swap(object1,object2);
+
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
+
+  return 0;
+}
+
--- a/swap/test/specialized_in_other.cpp
+++ b/swap/test/specialized_in_other.cpp
@ -0,0 +1,45 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in namespace other
+namespace other
+{
+  #include "./swap_test_class.hpp"
+}
+
+//Provide swap function in namespace other
+namespace other
+{
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+int test_main(int, char*[])
+{
+  const other::swap_test_class initial_value1(1);
+  const other::swap_test_class initial_value2(2);
+
+  other::swap_test_class object1 = initial_value1;
+  other::swap_test_class object2 = initial_value2;
+  
+  other::swap_test_class::reset();
+  boost::swap(object1,object2);
+
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
+  BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);
+
+  return 0;
+}
+
--- a/swap/test/specialized_in_std.cpp
+++ b/swap/test/specialized_in_std.cpp
@ -0,0 +1,44 @@
+// Copyright (c) 2007 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+//Put test class in the global namespace
+#include "./swap_test_class.hpp"
+
+
+//Provide swap function in namespace std
+namespace std
+{
+  template <>
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+int test_main(int, char*[])
+{
+  const swap_test_class initial_value1(1);
+  const swap_test_class initial_value2(2);
+
+  swap_test_class object1 = initial_value1;
+  swap_test_class object2 = initial_value2;
+  
+  swap_test_class::reset();
+  boost::swap(object1,object2);
+
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
+
+  return 0;
+}
+
--- a/swap/test/std_bitset.cpp
+++ b/swap/test/std_bitset.cpp
@ -0,0 +1,33 @@
+// Copyright (c) 2008 - 2010 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests swapping std::bitset<T> objects by means of boost::swap.
+// Unlike most other Standard C++ Library template classes,
+// std::bitset<T> does not have its own std::swap overload.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+#include <bitset>
+
+int test_main(int, char*[])
+{
+  typedef std::bitset<8> bitset_type;
+  const bitset_type initial_value1 = 1;
+  const bitset_type initial_value2 = 2;
+
+  bitset_type object1 = initial_value1;
+  bitset_type object2 = initial_value2;
+
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(object1,initial_value2);
+  BOOST_CHECK_EQUAL(object2,initial_value1);
+
+  return 0;
+}
+
--- a/swap/test/std_dateorder.cpp
+++ b/swap/test/std_dateorder.cpp
@ -0,0 +1,32 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests swapping std::time_base::dateorder objects by means of boost::swap.
+// std::time_base::dateorder is an enumerated type. It does not have an
+// std::swap overload or template specialization.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+#include <locale>
+
+int test_main(int, char*[])
+{
+  const std::time_base::dateorder initial_value1 = std::time_base::dmy;
+  const std::time_base::dateorder initial_value2 = std::time_base::mdy;
+
+  std::time_base::dateorder object1 = initial_value1;
+  std::time_base::dateorder object2 = initial_value2;
+
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(object1,initial_value2);
+  BOOST_CHECK_EQUAL(object2,initial_value1);
+
+  return 0;
+}
+
--- a/swap/test/std_string.cpp
+++ b/swap/test/std_string.cpp
@ -0,0 +1,31 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests swapping std::string objects by means of boost::swap.
+// std::string has its own std::swap overload.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+#include <string>
+
+int test_main(int, char*[])
+{
+  const std::string initial_value1 = "one";
+  const std::string initial_value2 = "two";
+
+  std::string object1 = initial_value1;
+  std::string object2 = initial_value2;
+
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(object1,initial_value2);
+  BOOST_CHECK_EQUAL(object2,initial_value1);
+
+  return 0;
+}
+
--- a/swap/test/std_typeinfo_ptr.cpp
+++ b/swap/test/std_typeinfo_ptr.cpp
@ -0,0 +1,32 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests swapping std::type_info pointers by means of boost::swap.
+// There is no std::swap overload or template specialization
+// for std::type_info pointers.
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+#include <typeinfo>
+
+int test_main(int, char*[])
+{
+  const std::type_info * const initial_value1 = 0;
+  const std::type_info * const initial_value2 = &typeid(double);
+  
+  const std::type_info * ptr1 = initial_value1;
+  const std::type_info * ptr2 = initial_value2;
+
+  boost::swap(ptr1,ptr2);
+
+  BOOST_CHECK_EQUAL(ptr1,initial_value2);
+  BOOST_CHECK_EQUAL(ptr2,initial_value1);
+
+  return 0;
+}
+
--- a/swap/test/std_vector_of_boost.cpp
+++ b/swap/test/std_vector_of_boost.cpp
@ -0,0 +1,60 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests swapping std::vector objects by means of boost::swap,
+// having boost::swap_test_class as vector element type. 
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+#include <vector>
+
+//Put test class in namespace boost
+namespace boost
+{
+  #include "./swap_test_class.hpp"
+}
+
+//Provide swap function in namespace boost
+namespace boost
+{
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+int test_main(int, char*[])
+{
+  typedef boost::swap_test_class swap_test_class_type;
+  typedef std::vector<swap_test_class_type> vector_type;
+
+  const vector_type::size_type initial_size1 = 1;
+  const vector_type::size_type initial_size2 = 2;
+
+  const vector_type initial_value1(initial_size1, swap_test_class_type(1));
+  const vector_type initial_value2(initial_size2, swap_test_class_type(2));
+  
+  vector_type object1 = initial_value1;
+  vector_type object2 = initial_value2;
+
+  swap_test_class_type::reset();
+  
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(object1.size(),initial_size2);
+  BOOST_CHECK_EQUAL(object2.size(),initial_size1);
+
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
+  BOOST_CHECK_EQUAL(swap_test_class_type::swap_count(),0);
+  BOOST_CHECK_EQUAL(swap_test_class_type::copy_count(),0);
+
+  return 0;
+}
+
--- a/swap/test/std_vector_of_global.cpp
+++ b/swap/test/std_vector_of_global.cpp
@ -0,0 +1,53 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests swapping std::vector objects by means of boost::swap,
+// having ::swap_test_class as vector element type. 
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+#include <vector>
+
+//Put test class in the global namespace
+#include "./swap_test_class.hpp"
+
+//Provide swap function in the global namespace 
+void swap(swap_test_class& left, swap_test_class& right)
+{
+  left.swap(right);
+}
+
+int test_main(int, char*[])
+{
+  typedef std::vector<swap_test_class> vector_type;
+
+  const vector_type::size_type initial_size1 = 1;
+  const vector_type::size_type initial_size2 = 2;
+
+  const vector_type initial_value1(initial_size1, swap_test_class(1));
+  const vector_type initial_value2(initial_size2, swap_test_class(2));
+  
+  vector_type object1 = initial_value1;
+  vector_type object2 = initial_value2;
+
+  swap_test_class::reset();
+  
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(object1.size(),initial_size2);
+  BOOST_CHECK_EQUAL(object2.size(),initial_size1);
+
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(),0);
+  BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
+
+  return 0;
+}
+
--- a/swap/test/std_vector_of_other.cpp
+++ b/swap/test/std_vector_of_other.cpp
@ -0,0 +1,60 @@
+// Copyright (c) 2008 Joseph Gauterin, Niels Dekker
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests swapping std::vector objects by means of boost::swap,
+// having other::swap_test_class as vector element type. 
+
+#include <boost/utility/swap.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+#include <vector>
+
+//Put test class in namespace other
+namespace other
+{
+  #include "./swap_test_class.hpp"
+}
+
+//Provide swap function in namespace other
+namespace other
+{
+  void swap(swap_test_class& left, swap_test_class& right)
+  {
+    left.swap(right);
+  }
+}
+
+int test_main(int, char*[])
+{
+  typedef other::swap_test_class swap_test_class_type;
+  typedef std::vector<swap_test_class_type> vector_type;
+
+  const vector_type::size_type initial_size1 = 1;
+  const vector_type::size_type initial_size2 = 2;
+
+  const vector_type initial_value1(initial_size1, swap_test_class_type(1));
+  const vector_type initial_value2(initial_size2, swap_test_class_type(2));
+  
+  vector_type object1 = initial_value1;
+  vector_type object2 = initial_value2;
+
+  swap_test_class_type::reset();
+  
+  boost::swap(object1,object2);
+
+  BOOST_CHECK_EQUAL(object1.size(),initial_size2);
+  BOOST_CHECK_EQUAL(object2.size(),initial_size1);
+
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+
+  BOOST_CHECK_EQUAL(swap_test_class_type::swap_count(),0);
+  BOOST_CHECK_EQUAL(swap_test_class_type::copy_count(),0);
+
+  return 0;
+}
+
--- a/swap/test/swap_test_class.hpp
+++ b/swap/test/swap_test_class.hpp
@ -0,0 +1,114 @@
+// Copyright (c) 2007-2008 Joseph Gauterin
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests class used by the Boost.Swap tests
+
+#ifndef BOOST_UTILITY_SWAP_TEST_CLASS_HPP
+#define BOOST_UTILITY_SWAP_TEST_CLASS_HPP
+
+
+class swap_test_class
+{
+  int m_data;
+public:
+  explicit swap_test_class(int arg = 0)
+  :
+  m_data(arg)
+  {
+    ++constructCount();
+  }
+
+  ~swap_test_class()
+  {
+    ++destructCount();
+  }
+
+  swap_test_class(const swap_test_class& arg)
+  :
+  m_data(arg.m_data)
+  {
+    ++copyCount();
+    ++destructCount();
+  }
+
+  swap_test_class& operator=(const swap_test_class& arg)
+  {
+    m_data = arg.m_data;
+    ++copyCount();
+    return *this;
+  }
+
+  void swap(swap_test_class& other)
+  {
+    const int temp = m_data;
+    m_data = other.m_data;
+    other.m_data = temp;
+
+    ++swapCount();
+  }
+
+  int get_data() const
+  {
+    return m_data;
+  }
+
+  void set_data(int arg)
+  {
+    m_data = arg;
+  }
+  
+  static unsigned int swap_count(){ return swapCount(); }
+  static unsigned int copy_count(){ return copyCount(); }
+  static unsigned int construct_count(){ return constructCount(); }
+  static unsigned int destruct_count(){ return destructCount(); }
+
+  static void reset()
+  {
+    swapCount() = 0;
+    copyCount() = 0;    
+    constructCount() = 0;
+    destructCount() = 0;
+  }
+
+private:
+  static unsigned int& swapCount()
+  {
+    static unsigned int value = 0;
+    return value;
+  }
+
+  static unsigned int& copyCount()    
+  {
+    static unsigned int value = 0;
+    return value;
+  }
+
+  static unsigned int& constructCount()    
+  {
+    static unsigned int value = 0;
+    return value;
+  }
+
+  static unsigned int& destructCount()    
+  {
+    static unsigned int value = 0;
+    return value;
+  }
+
+};
+
+
+inline bool operator==(const swap_test_class & lhs, const swap_test_class & rhs)
+{
+  return lhs.get_data() == rhs.get_data();
+}
+
+inline bool operator!=(const swap_test_class & lhs, const swap_test_class & rhs)
+{
+  return !(lhs == rhs);
+}
+
+#endif
--- a/test/Jamfile
+++ b/test/Jamfile
@ -1,43 +0,0 @@
-# Copyright David Abrahams 2003. Permission to copy, use,
-# modify, sell and distribute this software is granted provided this
-# copyright notice appears in all copies. This software is provided
-# "as is" without express or implied warranty, and with no claim as
-# to its suitability for any purpose.
-
-# For more information, see http://www.boost.org/
-
-subproject libs/utility/test ;
-
-# bring in rules for testing
-import testing ;
-
-# Make tests run by default.
-DEPENDS all : test ;
-
-local test_monitor = <lib>@boost/libs/test/build/boost_test_exec_monitor ;
-
-# Please keep the tests ordered by filename
-test-suite utility
-    :
-        [ run ../addressof_test.cpp ]
-        [ run ../assert_test.cpp ]
-        [ run ../base_from_member_test.cpp ]
-        [ run ../binary_search_test.cpp ]
-        [ run ../call_traits_test.cpp : -u ]
-        [ compile-fail ../checked_delete_test.cpp ]
-        [ run ../compressed_pair_test.cpp $(test_monitor) : -u ]
-        [ run ../current_function_test.cpp : : : <test-info>always_show_run_output ]
-        [ run ../iterators_test.cpp $(test_monitor) ]
-        [ run next_prior_test.cpp $(test_monitor) ]
-        [ compile-fail ../noncopyable_test.cpp ]
-        [ run ../numeric_traits_test.cpp ]
-        [ run ../operators_test.cpp $(test_monitor) ]
-        [ compile ../ref_ct_test.cpp  ]
-        [ run ../ref_test.cpp $(test_monitor) ]
-        [ compile result_of_test.cpp ]
-        [ run ../shared_iterator_test.cpp ]
-        [ run ../value_init_test.cpp ]
-        [ compile-fail ../value_init_test_fail1.cpp ]
-        [ compile-fail ../value_init_test_fail2.cpp ]
-        [ compile-fail ../value_init_test_fail3.cpp ]
-    ;
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -1,8 +1,7 @@
-# Copyright David Abrahams 2003. Permission to copy, use,
-# modify, sell and distribute this software is granted provided this
-# copyright notice appears in all copies. This software is provided
-# "as is" without express or implied warranty, and with no claim as
-# to its suitability for any purpose.
+# Copyright David Abrahams 2003.
+
+# Distributed under the Boost Software License, Version 1.0.
+# See http://www.boost.org/LICENSE_1_0.txt

 # For more information, see http://www.boost.org/

@ -12,25 +11,34 @@ import testing ;
 # Please keep the tests ordered by filename
 test-suite utility
    :
+        [ run ../addressof_fn_test.cpp ]
        [ run ../addressof_test.cpp ]
+        [ run ../addressof_test2.cpp ]
        [ run ../assert_test.cpp ]
        [ run ../base_from_member_test.cpp ]
        [ run ../binary_search_test.cpp ]
+        [ run ../binary_test.cpp ]
        [ run ../call_traits_test.cpp : -u ]
        [ compile-fail ../checked_delete_test.cpp ]
-        [ run ../compressed_pair_test.cpp ../../test/build//boost_test_exec_monitor : -u ]
+        [ run ../compressed_pair_test.cpp ../../test/build//boost_test_exec_monitor/<link>static : -u ]
        [ run ../current_function_test.cpp : : : <test-info>always_show_run_output ]
-        [ run ../iterators_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run next_prior_test.cpp ../../test/build//boost_test_exec_monitor ]
+        [ run ../iterators_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ]
+        [ run next_prior_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ]
        [ compile-fail ../noncopyable_test.cpp ]
        [ run ../numeric_traits_test.cpp ]
-        [ run ../operators_test.cpp ../../test/build//boost_test_exec_monitor ]
+        [ run ../operators_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ]
        [ compile ../ref_ct_test.cpp  ]
-        [ run ../ref_test.cpp ../../test/build//boost_test_exec_monitor ]
+        [ run ../ref_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ]
        [ compile result_of_test.cpp ]
        [ run ../shared_iterator_test.cpp ]
        [ run ../value_init_test.cpp ]
+        [ run ../value_init_workaround_test.cpp ]
+        [ run ../initialized_test.cpp ]
        [ compile-fail ../value_init_test_fail1.cpp ]
        [ compile-fail ../value_init_test_fail2.cpp ]
        [ compile-fail ../value_init_test_fail3.cpp ]
+        [ compile-fail ../initialized_test_fail1.cpp ]
+        [ compile-fail ../initialized_test_fail2.cpp ]
+        [ run ../verify_test.cpp ]
    ;
+
--- a/test/next_prior_test.cpp
+++ b/test/next_prior_test.cpp
--- a/test/result_of_test.cpp
+++ b/test/result_of_test.cpp
@ -5,23 +5,119 @@
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)

+#define BOOST_RESULT_OF_USE_DECLTYPE
+
 // For more information, see http://www.boost.org/libs/utility
 #include <boost/utility/result_of.hpp>
 #include <utility>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>

-struct int_result_type { typedef int result_type; };
+struct int_result_type
+{
+  typedef int result_type;
+  result_type operator()(float);
+};

 struct int_result_of
 {
  template<typename F> struct result { typedef int type; };
+  result<int_result_of(double)>::type operator()(double);
+  result<const int_result_of(double)>::type operator()(double) const;
+  result<int_result_of()>::type operator()();
+  result<volatile int_result_of()>::type operator()() volatile;
 };

-struct int_result_type_and_float_result_of
+struct int_result_type_and_float_result_of_and_char_return
 {
  typedef int result_type;
  template<typename F> struct result { typedef float type; };
+  char operator()(char);
+};
+
+template<typename T>
+struct int_result_type_template
+{
+  typedef int result_type;
+  result_type operator()(float);
+};
+
+template<typename T>
+struct int_result_of_template
+{
+  template<typename F> struct result;
+  template<typename This, typename That> struct result<This(That)> { typedef int type; };
+  typename result<int_result_of_template<T>(double)>::type operator()(double);
+  typename result<const int_result_of_template<T>(double)>::type operator()(double) const;
+  typename result<int_result_of_template<T>(double)>::type operator()();
+  typename result<volatile int_result_of_template<T>(double)>::type operator()() volatile;
+};
+
+template<typename T>
+struct int_result_type_and_float_result_of_and_char_return_template
+{
+  typedef int result_type;
+  template<typename F> struct result;
+  template<typename This, typename That> struct result<This(That)> { typedef float type; };
+  char operator()(char);
+};
+
+struct result_of_member_function_template
+{
+  template<typename F> struct result;
+
+  template<typename This, typename That> struct result<This(That)> { typedef That type; };
+  template<class T> typename result<result_of_member_function_template(T)>::type operator()(T);
+
+  template<typename This, typename That> struct result<const This(That)> { typedef const That type; };
+  template<class T> typename result<const result_of_member_function_template(T)>::type operator()(T) const;
+
+  template<typename This, typename That> struct result<volatile This(That)> { typedef volatile That type; };
+  template<class T> typename result<volatile result_of_member_function_template(T)>::type operator()(T) volatile;
+
+  template<typename This, typename That> struct result<const volatile This(That)> { typedef const volatile That type; };
+  template<class T> typename result<const volatile result_of_member_function_template(T)>::type operator()(T) const volatile;
+
+  template<typename This, typename That> struct result<This(That &, That)> { typedef That & type; };
+  template<class T> typename result<result_of_member_function_template(T &, T)>::type operator()(T &, T);
+
+  template<typename This, typename That> struct result<This(That const &, That)> { typedef That const & type; };
+  template<class T> typename result<result_of_member_function_template(T const &, T)>::type operator()(T const &, T);
+
+  template<typename This, typename That> struct result<This(That volatile &, That)> { typedef That volatile & type; };
+  template<class T> typename result<result_of_member_function_template(T volatile &, T)>::type operator()(T volatile &, T);
+
+  template<typename This, typename That> struct result<This(That const volatile &, That)> { typedef That const volatile & type; };
+  template<class T> typename result<result_of_member_function_template(T const volatile &, T)>::type operator()(T const volatile &, T);
+};
+
+struct no_result_type_or_result_of
+{
+  int operator()(double);
+  short operator()(double) const;
+  unsigned int operator()();
+  unsigned short operator()() volatile;
+  const unsigned short operator()() const volatile;
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
+  short operator()(int&&);
+  int operator()(int&);
+  long operator()(int const&);
+#endif
+};
+
+template<typename T>
+struct no_result_type_or_result_of_template
+{
+  int operator()(double);
+  short operator()(double) const;
+  unsigned int operator()();
+  unsigned short operator()() volatile;
+  const unsigned short operator()() const volatile;
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
+  short operator()(int&&);
+  int operator()(int&);
+  long operator()(int const&);
+#endif
 };

 struct X {};
@ -32,22 +128,129 @@ int main()

  typedef int (*func_ptr)(float, double);
  typedef int (&func_ref)(float, double);
+  typedef int (*func_ptr_0)();
+  typedef int (&func_ref_0)();
  typedef int (X::*mem_func_ptr)(float);
  typedef int (X::*mem_func_ptr_c)(float) const;
  typedef int (X::*mem_func_ptr_v)(float) volatile;
  typedef int (X::*mem_func_ptr_cv)(float) const volatile;
+  typedef int (X::*mem_func_ptr_0)();

  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type(float)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(double)>::type, int>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, void>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<const int_result_of(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_template<void>(float)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const int_result_of_template<void>(double)>::type, int>::value));
+
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type(float)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_of(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<const int_result_of(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_template<void>(float)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_of_template<void>(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<const int_result_of_template<void>(double)>::type, int>::value));
+
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_of(void)>::type, void>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<volatile int_result_of(void)>::type, void>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_of_template<void>(void)>::type, void>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<volatile int_result_of_template<void>(void)>::type, void>::value));
+
+  // Prior to decltype, result_of could not deduce the return type
+  // nullary function objects unless they exposed a result_type.
+#if !defined(BOOST_NO_DECLTYPE)
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(void)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of_template<void>(void)>::type, int>::value));
+#else
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, void>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, void>::value));
-  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of(char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(void)>::type, void>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of_template<void>(void)>::type, void>::value));
+#endif
+
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, int>::value));
+
+  // Prior to decltype, result_of ignored a nested result<> if
+  // result_type was defined. After decltype, result_of deduces the
+  // actual return type of the function object, ignoring both
+  // result<> and result_type.
+#if !defined(BOOST_NO_DECLTYPE)
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, char>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, char>::value));
+#else
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, int>::value));
+#endif
+
  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(char, float)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<func_ref(char, float)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr_0()>::type, int>::value)); 
+  BOOST_STATIC_ASSERT((is_same<result_of<func_ref_0()>::type, int>::value)); 
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_c(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_v(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_cv(X,char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_0(X)>::type, int>::value)); 
+  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(void)>::type, int>::value));
+
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr(char, float)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref(char, float)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr_0()>::type, int>::value)); 
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref_0()>::type, int>::value)); 
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr(X,char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_c(X,char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_v(X,char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_cv(X,char)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_0(X)>::type, int>::value)); 
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr(void)>::type, int>::value));
+
+  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(double)>::type, double>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const result_of_member_function_template(double)>::type, const double>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile result_of_member_function_template(double)>::type, volatile double>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const volatile result_of_member_function_template(double)>::type, const volatile double>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int &, int)>::type, int &>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int const &, int)>::type, int const &>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int volatile &, int)>::type, int volatile &>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int const volatile &, int)>::type, int const volatile &>::value));
+
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(double)>::type, double>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<const result_of_member_function_template(double)>::type, const double>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<volatile result_of_member_function_template(double)>::type, volatile double>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<const volatile result_of_member_function_template(double)>::type, const volatile double>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int &, int)>::type, int &>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int const &, int)>::type, int const &>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int volatile &, int)>::type, int volatile &>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int const volatile &, int)>::type, int const volatile &>::value));
+
+  typedef int (*pf_t)(int);
+  BOOST_STATIC_ASSERT((is_same<result_of<pf_t(int)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<pf_t const(int)>::type,int>::value));
+
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<pf_t(int)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<tr1_result_of<pf_t const(int)>::type,int>::value));
+
+#if !defined(BOOST_NO_DECLTYPE)
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(void)>::type, unsigned int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_of(double)>::type, short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_of(void)>::type, unsigned short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_of(void)>::type, const unsigned short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(double)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(void)>::type, unsigned int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_of_template<void>(double)>::type, short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_of_template<void>(void)>::type, unsigned short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_of_template<void>(void)>::type, const unsigned short>::value));
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(int&&)>::type, short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(int&)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of(int const&)>::type, long>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(int&&)>::type, short>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(int&)>::type, int>::value));
+  BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_of_template<void>(int const&)>::type, long>::value));
+#endif
+#endif
+
  return 0;
 }
--- a/throw_exception.html
+++ b/throw_exception.html
@ -1,59 +1,15 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
-	<head>
-		<title>Boost: throw_exception.hpp documentation</title>
-		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-	</head>
-	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
-		<table border="0" width="100%">
-			<tr>
-				<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
-				</td>
-				<td align="center">
-					<h1>throw_exception.hpp</h1>
-				</td>
-			</tr>
-			<tr>
-				<td colspan="2" height="64">&nbsp;</td>
-			</tr>
-		</table>
-		<p>
-			The header <STRONG>&lt;boost/throw_exception.hpp&gt;</STRONG> defines the 
-			helper function <STRONG>boost::throw_exception</STRONG>. It is intended to be 
-			used in Boost libraries that need to throw exceptions, but support 
-			configurations and platforms where exceptions aren't available, as indicated by 
-			the presence of the <STRONG>BOOST_NO_EXCEPTIONS</STRONG> <A href="../config/config.htm#macro_ref">
-				configuration macro</A>.
-		</p>
-		<P>When <STRONG>BOOST_NO_EXCEPTIONS</STRONG> is not defined, <tt>boost::throw_exception(e)</tt>
-			is equivalent to <tt>throw e</tt>. Otherwise, the function is left undefined, 
-			and the user is expected to supply an appropriate definition. Callers of <tt>throw_exception</tt>
-			are allowed to assume that the function never returns; therefore, if the 
-			user-defined <tt>throw_exception</tt> returns, the behavior is undefined.</P>
-		<h3><a name="Synopsis">Synopsis</a></h3>
-		<pre>
-namespace boost
-{
-
-#ifdef BOOST_NO_EXCEPTIONS
-
-void throw_exception(std::exception const &amp; e); // user defined
-
-#else
-
-template&lt;class E&gt; void throw_exception(E const &amp; e)
-{
-    throw e;
-}
-
-#endif
-
-}
-</pre>
-		<p><br>
-			<small>Copyright <20> 2002 by Peter Dimov. Permission to copy, use, modify, sell and 
-				distribute this document is granted provided this copyright notice appears in 
-				all copies. This document is provided "as is" without express or implied 
-				warranty, and with no claim as to its suitability for any purpose.</small></p>
-	</body>
+<head>
+<meta http-equiv=refresh content="0; URL=../exception/doc/throw_exception.html">
+<title>Automatic redirection</title>
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../exception/doc/throw_exception.html">throw_exception.html</a>.&nbsp;<hr>
+<p><EFBFBD> Copyright Beman Dawes, 2001</p>
+<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
+file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
+at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
 </html>
--- a/utility.htm
+++ b/utility.htm
@ -23,6 +23,9 @@
 			<li>
 				Function template <a href="#addressof">addressof()</a></li>
                        <li>Class template <a href="#result_of">result_of</a></li>
+                        <li>
+				Macro <a href="#BOOST_BINARY">BOOST_BINARY</a></li>
+                        <li><a href="index.html">Other utilities not part of <code>utility.hpp</code></a></li>
 		</ul>
 		<h2>
 			Function templates <a name="checked_delete">checked_delete</a>() and 
@ -67,7 +70,7 @@ const std::list&lt;T&gt;::iterator next = boost::next(prev, 2);</pre>
                <p>The distance from the given iterator should be supplied as an absolute value. For
 			example, the iterator four iterators prior to the given iterator <code>p</code>
 			may be obtained by <code>prior(p, 4)</code>.</p>
-		<p>Contributed by <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>.  Two-argument versions by Daniel Walker.</p>
+		<p>Contributed by <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a>.  Two-argument versions by Daniel Walker.</p>
 		<h2><a name="Class_noncopyable">Class noncopyable</a></h2>
 		<p>Class <strong>noncopyable</strong> is a base class.&nbsp; Derive your own class 
 			from <strong>noncopyable</strong> when you want to prohibit copy construction 
@ -88,7 +91,7 @@ const std::list&lt;T&gt;::iterator next = boost::next(prev, 2);</pre>
 			to verify class <b>noncopyable</b> works as expected. It has have been run 
 			successfully under GCC 2.95, Metrowerks CodeWarrior 5.0, and Microsoft Visual 
 			C++ 6.0 sp 3.</p>
-		<p>Contributed by <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>.</p>
+		<p>Contributed by <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a>.</p>
 		<h3>Example</h3>
 		<blockquote>
 			<pre>// inside one of your own headers ...
@ -148,46 +151,160 @@ void f() {
                <code>result_of&lt;F(T1, T2, ...,
                T<em>N</em>)&gt;::type</code> defines the result type
                of the expression <code>f(t1, t2,
-                ...,t<em>N</em>)</code>. The implementation permits
+                ...,t<em>N</em>)</code>. This implementation permits
                the type <code>F</code> to be a function pointer,
                function reference, member function pointer, or class
-                type. When <code>F</code> is a class type with a
+                type. By default, <em>N</em> may be any value between 0 and
+                10. To change the upper limit, define the macro
+                <code>BOOST_RESULT_OF_NUM_ARGS</code> to the maximum
+                value for <em>N</em>. Class template <code>result_of</code>
+                resides in the header <code>&lt;<a
+                href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>&gt;</code>.</p>
+
+                <p>If your compiler supports <code>decltype</code>,
+                then you can enable automatic result type deduction by
+                defining the macro <code>BOOST_RESULT_OF_USE_DECLTYPE</code>,
+                as in the following example.</p>
+
+                <blockquote>
+                <pre>#define BOOST_RESULT_OF_USE_DECLTYPE
+#include &lt;boost/utility/result_of.hpp&gt;
+
+struct functor {
+    template&lt;class T&gt;
+    T operator()(T x)
+    {
+        return x;
+    }
+};
+
+typedef boost::result_of&lt;
+    functor(int)
+&gt;::type type;</pre>
+                </blockquote>
+
+                <p>If <code>decltype</code> is not enabled,
+                then automatic result type deduction of function
+                objects is not possible. Instead, <code>result_of</code>
+                uses the following protocol to allow the programmer to
+                specify a type. When <code>F</code> is a class type with a
                member type <code>result_type</code>,
                <code>result_of&lt;F(T1, T2, ...,
                T<em>N</em>)&gt;</code> is
-                <code>F::result_type</code>. Otherwise,
+                <code>F::result_type</code>. When <code>F</code> does
+                not contain <code>result_type</code>,
                <code>result_of&lt;F(T1, T2, ...,
                T<em>N</em>)&gt;</code> is <code>F::result&lt;F(T1,
                T2, ..., T<em>N</em>)&gt;::type</code> when
                <code><em>N</em> &gt; 0</code> or <code>void</code>
-                when <code><em>N</em> = 0</code>. For additional
-                information about <code>result_of</code>, see the
-                current draft of the C++ Library TR, <a
-                href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2004/n1647.pdf">N1647</a>,
-                or the <code>result_of</code> <a
-                href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1454.html">proposal</a>.</p>
+                when <code><em>N</em> = 0</code>. Note that it is the
+                responsibility of the programmer to ensure that
+                function objects accurately advertise their result
+                type via this protocol, as in the following
+                example.</p>

-                <p>Class template <code>result_of</code> resides in
-                the header <code>&lt;<a
-                href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>&gt;</code>. By
-                default, <em>N</em> may be any value between 0 and
-                10. To change the upper limit, define the macro
-                <code>BOOST_RESULT_OF_NUM_ARGS</code> to the maximum
-                value for <em>N</em>.</p>
+                <blockquote>
+                <pre>struct functor {
+    template&lt;class&gt; struct result;
+
+    template&lt;class F, class T&gt;
+    struct result&lt;F(T)&gt; {
+        typedef T type;
+    };
+
+    template&lt;class T&gt;
+    T operator()(T x)
+    {
+        return x;
+    }
+};
+
+typedef boost::result_of&lt;
+    functor(int)
+&gt;::type type;</pre>
+                </blockquote>

                <a name="BOOST_NO_RESULT_OF"></a>
-                <p>This implementation of <code>result_of</code> requires class template partial specialization, the ability to parse function types properly, and support for SFINAE. If <code>result_of</code> is not supported by your compiler, including the header <code>boost/utility/result_of.hpp</code> will define the macro <code>BOOST_NO_RESULT_OF</code>. Contributed by Doug Gregor.</p>
+                <p>This implementation of <code>result_of</code>
+                requires class template partial specialization, the
+                ability to parse function types properly, and support
+                for SFINAE. If <code>result_of</code> is not supported
+                by your compiler, including the header 
+                <code>boost/utility/result_of.hpp</code> will
+                define the macro <code>BOOST_NO_RESULT_OF</code>.</p>
+
+                <p>For additional information
+                about <code>result_of</code>, see the C++ Library
+                Technical Report,
+                <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf">N1836</a>,
+                or, for motivation and design rationale,
+                the <code>result_of</code> <a href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1454.html">proposal</a>.</p>
+                Contributed by Doug Gregor.</p>

 		<h2>Class templates for the Base-from-Member Idiom</h2>
 		<p>See <a href="base_from_member.html">separate documentation</a>.</p>
+		<h2><a name="BOOST_BINARY">Macro BOOST_BINARY</a></h2>
+
+		<p>The macro <code>BOOST_BINARY</code> is used for the
+                representation of binary literals. It takes as an argument
+                a binary number arranged as an arbitrary amount of 1s and 0s in
+                groupings of length 1 to 8, with groups separated
+                by spaces. The type of the literal yielded is determined by
+                the same rules as those of hex and octal
+                literals (<i>2.13.1p1</i>). By implementation, this macro
+                expands directly to an octal literal during preprocessing, so
+                there is no overhead at runtime and the result is useable in
+                any place that an octal literal would be.</p>
+
+		<p>In order to directly support binary literals with suffixes,
+                additional macros of the form BOOST_BINARY_XXX are also
+                provided, where XXX is a standard integer suffix in all capital
+                letters. In addition, LL and ULL suffixes may be used for representing
+                long long and unsigned long long types in compilers which provide
+                them as an extension.</p>
+
+
+                <p>The BOOST_BINARY family of macros resides in the header
+                <a
+                href="../../boost/utility/binary.hpp">&lt;boost/utility/binary.hpp&gt;</a>
+                which is automatically included by
+                <a
+                href="../../boost/utility.hpp">&lt;boost/utility.hpp&gt;</a>.
+
+		<p>Contributed by Matt Calabrese.</p><p>
+		</p><h3>Example</h3>
+		<blockquote>
+			<pre>
+void foo( int );
+
+void foo( unsigned long );
+
+void bar()
+{
+  int value1 = BOOST_BINARY( 100 111000 01 1 110 );
+
+  unsigned long value2 = BOOST_BINARY_UL( 100 001 ); // unsigned long
+
+  long long value3 = BOOST_BINARY_LL( 11 000 ); // long long if supported
+
+  assert(    BOOST_BINARY( 10010 )
+          &  BOOST_BINARY( 11000 )
+          == BOOST_BINARY( 10000 )
+        );
+
+  foo( BOOST_BINARY( 1010 ) ); // calls the first foo
+
+  foo( BOOST_BINARY_LU( 1010 ) ); // calls the second foo
+}
+</pre></blockquote>
 		<hr>
 		<p>Revised&nbsp; <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan
-->02 May, 2004<!--webbot bot="Timestamp" endspan i-checksum="38582"
+-->04 September, 2008<!--webbot bot="Timestamp" endspan i-checksum="39369"
 -->
 		</p>
-		<p>&copy; Copyright boost.org 1999-2003. Permission to copy, use, modify, sell and distribute 
-			this document is granted provided this copyright notice appears in all copies. 
-			This document is provided &quot;as is&quot; without express or implied 
-			warranty, and with no claim as to its suitability for any purpose.</p>
+		<p>&copy; Copyright Beman Dawes 1999-2003.</p>
+<p>Distributed under the Boost Software License, Version 1.0. See
+<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
+
 	</body>
 </html>
--- a/value_init.htm
+++ b/value_init.htm
@ -17,20 +17,24 @@
 <dl>
  <dt><a href="#rationale">Rationale</a></dt>
  <dt><a href="#intro">Introduction</a></dt>
+  <dt><a href="#details">Details</a></dt>
 </dl>
                   
 <ul>
          <li><a href="#valueinit">value-initialization</a></li>
          <li><a href="#valueinitsyn">value-initialization syntax</a></li>
+          <li><a href="#compiler_issues">compiler issues</a></li>
                   
 </ul>
                   
 <dl class="page-index">
-  <dt><a href="#types">Types</a></dt>
+  <dt><a href="#types">Types and objects</a></dt>
 </dl>
                   
 <ul>
-          <li><a href="#val_init"><code>value_initialized&lt;&gt;</code></a></li>
+          <li><a href="#val_init"><code>template class value_initialized&lt;T&gt;</code></a></li>
+          <li><a href="#initialized"><code>template class initialized&lt;T&gt;</code></a></li>
+          <li><a href="#initialized_value"><code>initialized_value</code></a></li>
                   
 </ul>
              <a href="#acknowledgements">Acknowledgements</a><br>
@ -44,24 +48,110 @@
 for    initialization. Depending on the type, the value of a newly constructed
  object  can be zero-initialized (logically 0), default-constructed (using
  the default constructor), or indeterminate. When writing generic code,
-this   problem must be addressed. <code>value_initialized</code> provides
+this  problem must be addressed. The template <code>value_initialized</code> provides
 a solution   with consistent syntax for value   initialization of scalar,
-union and class   types. <br>
+union and class   types.
+Moreover, <code>value_initialized</code> offers a workaround to various
+compiler issues regarding value-initialization.
+
+Furthermore, a <code>const</code> object, <code>initialized_value</code> is provided,
+to avoid repeating the type name when retrieving the value from a
+<code>value_initialized&lt;T&gt;</code> object.
+<br>
  </p>
        
 <h2><a name="intro"></a>Introduction</h2>
     
-<p>The C++ standard [<a href="#references">1</a>] contains the definitions 
+<p>
+There are various ways to initialize a variable, in C++. The following
+declarations all <em>may</em> have a local variable initialized to its default
+value:
+<pre>
+  T1 var1;
+  T2 var2 = 0;
+  T3 var3 = {};
+  T4 var4 = T4();
+</pre> 
+Unfortunately, whether or not any of those declarations correctly
+initialize the variable very much depends on its type. The first
+declaration is valid for any <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">
+DefaultConstructible</a> type (by definition).
+However, it does not always do an initialization!
+It correctly initializes the variable when it's an instance of a
+class, and the author of the class has provided a proper default
+constructor. On the other hand, the value of <code>var1</code> is <em>indeterminate</em> when
+its type is an arithmetic type, like <code>int</code>, <code>float</code>, or <code>char</code>.
+An arithmetic variable
+is of course initialized properly by the second declaration, <code>T2
+var2 = 0</code>. But this initialization form usually won't work for a
+class type (unless the class was especially written to support being
+initialized that way). The third form,  <code>T3 var3 = {}</code>
+initializes an aggregate, typically a "C-style" <code>struct</code> or a "C-style" array.
+However, the syntax is not allowed for a class that has an explicitly declared
+constructor.  (But watch out for an upcoming C++ language change, 
+by Bjarne Stroustrup et al [<a href="#references">1</a>]!)
+The fourth form is the most generic form of them, as it
+can be used to initialize arithmetic types, class types, aggregates, pointers, and
+other types. The declaration,  <code>T4 var4 = T4()</code>, should be read
+as follows: First a temporary object is created, by <code>T4()</code>.
+This object is <a href="#valueinit">value-initialized</a>. Next the temporary
+object is copied to the named variable, <code>var4</code>. Afterwards, the temporary
+is destroyed. While the copying and the destruction are likely to
+be optimized away, C++ still requires the type <code>T4</code> to be
+<a href="CopyConstructible.html">CopyConstructible</a>.
+(So <code>T4</code> needs to be <em>both</em> DefaultConstructible <em>and</em> CopyConstructible.) 
+A class may not be CopyConstructible, for example because it may have a
+private and undefined copy constructor,
+or because it may be derived from <a href="utility.htm#Class_noncopyable">boost::noncopyable</a>.
+Scott Meyers [<a href="#references">2</a>] explains why a class would be defined like that.
+</p>
+<p>
+There is another, less obvious disadvantage to the fourth form, <code>T4 var4 = T4()</code>:
+It suffers from various  <a href="#compiler_issues">compiler issues</a>, causing
+a variable to be left uninitialized in some compiler specific cases.
+</p>
+<p>
+The template <a href="#val_init"><code>value_initialized</code></a>
+offers a generic way to initialize
+an object, like <code>T4 var4 = T4()</code>, but without requiring its type
+to be CopyConstructible. And it offers a workaround to those compiler issues
+regarding value-initialization as well! It allows getting an initialized
+variable of any type; it <em>only</em> requires the type to be DefaultConstructible.
+A properly <em>value-initialized</em> object of type <code>T</code> is
+constructed by the following declaration:
+<pre>
+  value_initialized&lt;T&gt; var;
+</pre>
+</p>
+<p>
+The template <a href="#initialized"><code>initialized</code></a>
+offers both value-initialization and direct-initialization.
+It is especially useful as a data member type, allowing the very same object
+to be either direct-initialized or value-initialized.
+</p>
+<p>
+The <code>const</code> object <a href="#initialized_value"><code>initialized_value</code></a>
+allows value-initializing a variable as follows:
+<pre>
+  T var = initialized_value ;
+</pre>
+This form of initialization is semantically equivalent to <code>T4 var4 = T4()</code>,
+but robust against the aforementioned compiler issues.
+
+</p>
+
+<h2><a name="details"></a>Details</h2>
+<p>The C++ standard [<a href="#references">3</a>] contains the definitions 
    of <code>zero-initialization</code> and <code>default-initialization</code>.
     Informally, zero-initialization means that the object is given the initial
     value 0 (converted to the type) and default-initialization means that
- POD   [<a href="#references">2</a>] types are zero-initialized, while class
+ POD   [<a href="#references">4</a>] types are zero-initialized, while non-POD class
 types   are initialized with their corresponding default constructors. A
 <i>declaration</i>   can contain an <i>initializer</i>, which specifies the
 object's initial value.  The initializer can be just '()', which states that
-the object shall be default-initialized  (but see below). However, if a <i>declaration</i> 
+the object shall be value-initialized  (but see below). However, if a <i>declaration</i> 
  has no <i>initializer</i>  and it is of a non-<code>const</code>, non-<code>static</code> 
-   POD type, the initial value is indeterminate:<cite>(see &sect;8.5 for the
+   POD type, the initial value is indeterminate: <cite>(see &sect;8.5, [dcl.init], for the
   accurate definitions).</cite></p>
                   
 <pre>int x ; // no initializer. x value is indeterminate.<br>std::string s ; // no initializer, s is default-constructed.<br><br>int y = int() ; <br>// y is initialized using copy-initialization<br>// but the temporary uses an empty set of parentheses as the initializer,<br>// so it is default-constructed.<br>// A default constructed POD type is zero-initialized,<br>// therefore, y == 0.<br><br>void foo ( std::string ) ;<br>foo ( std::string() ) ; <br>// the temporary string is default constructed <br>// as indicated by the initializer ()  </pre>
@ -87,14 +177,11 @@ the object shall be default-initialized  (but see below). However, if a <i>decla
 <p>In order to specify value-initialization of an object we need to use the
     empty-set initializer: (). </p>
                   
-<p><i>(but recall that the current C++ Standard states that '()' invokes default-initialization,
-not value-initialization)</i></p>
-                   
 <p>As before, a declaration with no intializer specifies default-initialization, 
    and a declaration with a non-empty initializer specifies copy (=xxx) or
  direct  (xxx) initialization. </p>
                   
-<pre>template&lt;class T&gt; void eat(T);<br>int x ; // indeterminate initial value.<br>std::string s; // default-initialized.<br>eat ( int() ) ; // value-initialized<br>eat ( std::string() ) ; // value-initialied</pre>
+<pre>template&lt;class T&gt; void eat(T);<br>int x ; // indeterminate initial value.<br>std::string s; // default-initialized.<br>eat ( int() ) ; // value-initialized<br>eat ( std::string() ) ; // value-initialized</pre>
                    
 <h4><a name="valueinitsyn">value-initialization</a> syntax</h4>
                   
@ -102,7 +189,7 @@ not value-initialization)</i></p>
 parentheses is not permitted by the syntax of initializers because it is
 parsed as the declaration of a function taking no arguments: </p>
                   
-<pre>int x() ; // declares function int(*)()<br>int y ( int() ) ; // decalares function int(*)( int(*)() )</pre>
+<pre>int x() ; // declares function int(*)()</pre>
                    
 <p>Thus, the empty () must be put in some other initialization context.</p>
                   
@ -124,14 +211,110 @@ data member:</p>
                   
 <pre>template&lt;class T&gt; <br>struct W <br>{<br>  // value-initialization of 'data' here.<br>  W() : data() {}<br>  T data ;<br>} ;<br>W&lt;int&gt; w ;<br>// w.data is value-initialized for any type. </pre>
                    
-<p><code>This is the solution supplied by the value_initialized&lt;&gt; template
-     class.</code></p>
+<p>This is the solution as it was supplied by earlier versions of the
+<code>value_initialized&lt;T&gt;</code> template
+     class. Unfortunately this approach suffered from various compiler issues.</p>
+		 
+<h4><a name="compiler_issues">compiler issues</a> </h4>
+
+Various compilers haven't yet fully implemented value-initialization.
+So when an object should be <em>value-initialized</em> (according to the C++ Standard),
+it <em>may</em> in practice still be left uninitialized, because of those
+compiler issues! It's hard to make a general statement on what those issues
+are like, because they depend on the compiler you are using, its version number,
+and the type of object you would like to have value-initialized.
+All compilers we have tested so far support value-initialization for arithmetic types properly.
+However, various compilers may leave some types of <em>aggregates</em> uninitialized, when they 
+should be value-initialized. Value-initialization of objects of a pointer-to-member type may also
+go wrong on various compilers. 
+</p>
+<p>
+At the moment of writing, May 2010, the following reported issues regarding 
+value-initialization are still there in current compiler releases:
+<ul>
+<li>
+<a href="https://connect.microsoft.com/VisualStudio/feedback/details/100744">
+Microsoft Visual Studio Feedback ID 100744, Value-initialization in new-expression</a>
+<br>Reported by Pavel Kuznetsov (MetaCommunications Engineering), 2005
+</li><li>
+<a href="http://connect.microsoft.com/VisualStudio/feedback/details/484295">
+Microsoft Visual Studio Feedback ID 484295, VC++ does not value-initialize members of derived classes without user-declared constructor</a>
+<br>Reported by Sylvester Hesp, 2009
+</li><li>
+<a href="https://connect.microsoft.com/VisualStudio/feedback/details/499606">
+Microsoft Visual Studio Feedback ID 499606, Presence of copy constructor breaks member class initialization</a>
+<br>Reported by Alex Vakulenko, 2009
+</li><li>
+<a href="http://qc.embarcadero.com/wc/qcmain.aspx?d=83751">
+Embarcadero/C++Builder Report 83751, Value-initialization: arrays should have each element value-initialized</a>
+<br>Reported by Niels Dekker (LKEB), 2010
+</li><li>
+<a href="http://qc.embarcadero.com/wc/qcmain.aspx?d=83851">
+Embarcadero/C++Builder Report 83851, Value-initialized temporary triggers internal backend error C1798</a>
+<br>Reported by Niels Dekker, 2010
+</li><li>
+<a href="http://qc.embarcadero.com/wc/qcmain.aspx?d=84279">
+Embarcadero/C++Builder Report 84279, Internal compiler error (F1004), value-initializing member function pointer by "new T()"</a>
+<br>Reported by Niels Dekker, 2010
+</li><li>
+Sun CR 6947016, Sun 5.10 may fail to value-initialize an object of a non-POD aggregate.
+<br>Reported to Steve Clamage by Niels Dekker, 2010
+</li><li>
+IBM's XL V10.1 and V11.1 may fail to value-initialize a temporary of a non-POD aggregate.
+<br>Reported to Michael Wong by Niels Dekker, 2010
+</li><li>
+Intel support issue 589832, Attempt to value-initialize pointer-to-member triggers internal error
+on Intel 11.1.
+<br>Reported by John Maddock, 2010
+</li>
+</ul>
+Note that all known GCC issues regarding value-initialization are
+fixed with GCC version 4.4, including
+<a href="http://gcc.gnu.org/bugzilla/show_bug.cgi?id=30111">GCC Bug 30111</a>.
+Clang also has completely implemented value-initialization, as far as we know,
+now that <a href="http://llvm.org/bugs/show_bug.cgi?id=7139">Clang Bug 7139</a> is fixed. 
+</p><p>
+
+New versions of <code>value_initialized</code>
+(Boost release version 1.35 or higher)
+offer a workaround to these issues: <code>value_initialized</code> may now clear
+its internal data, prior to constructing the object that it contains. It will do
+so for those compilers that need to have such a workaround, based on the
+<a href="../config/doc/html/boost_config/boost_macro_reference.html#boost_config.boost_macro_reference.macros_that_describe_defects"
+>compiler defect macro</a> BOOST_NO_COMPLETE_VALUE_INITIALIZATION.
+</p>
                   
-<h2><a name="types"></a>Types</h2>
+<h2><a name="types"></a>Types and objects</h2>
                   
 <h2><a name="val_init"><code>template class value_initialized&lt;T&gt;</code></a></h2>
                   
-<pre>namespace boost {<br><br>template&lt;class T&gt;<br>class value_initialized<br>{<br>  public :<br>    value_initialized() : x() {}<br>    operator T&amp;() const { return x ; }<br>    T&amp; data() const { return x ; }<br><br>  private :<br>    <i>unspecified</i> x ;<br>} ;<br><br>template&lt;class T&gt;<br>T const&amp; get ( value_initialized&lt;T&gt; const&amp; x )<br>{<br>  return x.data() ;<br>}<br><br>template&lt;class T&gt;<br>T&amp; get ( value_initialized&lt;T&gt;&amp; x )<br>{<br>  return x.data() ;<br>}<br><br>} // namespace boost<br></pre>
+<pre>namespace boost {<br><br>template&lt;class T&gt;<br>class value_initialized<br>{
+<br>  public :
+<br>    value_initialized() : x() {}
+<br>    operator T const &amp;() const { return x ; }
+<br>    operator T&amp;() { return x ; }
+<br>    T const &amp;data() const { return x ; }
+<br>    T&amp; data() { return x ; }
+<br>    void swap( value_initialized&lt;T&gt;&amp; );
+<br>
+<br>  private :
+<br>    <i>unspecified</i> x ;
+<br>} ;
+<br>
+<br>template&lt;class T&gt;
+<br>T const&amp; get ( value_initialized&lt;T&gt; const&amp; x )
+<br>{
+<br>  return x.data() ;
+<br>}
+<br>
+<br>template&lt;class T&gt;
+<br>T&amp; get ( value_initialized&lt;T&gt;&amp; x )
+<br>{
+<br>  return x.data() ;
+<br>}
+<br>
+<br>} // namespace boost
+<br></pre>
                    
 <p>An object of this template class is a <code>T</code>-wrapper convertible 
    to <code>'T&amp;'</code> whose wrapped object (data member of type <code>T</code>) 
@ -149,69 +332,172 @@ data member:</p>
     <code>T&amp;</code>, the member function <code>data()</code>, or the
 non-member    function <code>get()</code>:  </p>
                   
-<pre>void watch(int);<br>value_initialized&lt;int&gt; x;<br><br>watch(x) ; // operator T&amp; used.<br>watch(x.data());<br>watch( get(x) ) // function get() used</pre>
+<pre>void watch(int);<br>value_initialized&lt;int&gt; x;
+<br><br>watch(x) ; // operator T&amp; used.<br>watch(x.data());<br>watch( get(x) ) // function get() used</pre>
                    
 <p>Both <code>const</code> and non-<code>const</code> objects can be wrapped. 
    Mutable objects can be modified directly from within the wrapper but constant
    objects cannot:</p>
+
+<p>When <code>T</code> is a <em>Swappable</em> type, <code>value_initialized&lt;T&gt;</code>
+    is swappable as well, by calling its <code>swap</code> member function
+    as well as by calling <code>boost::swap</code>.</p>
                   
-<pre>value_initialized&lt;int&gt; x ; <br>static_cast&lt;int&amp;&gt;(x) = 1 ; // OK<br>get(x) = 1 ; // OK<br><br>value_initialized&lt;int const&gt; y ; <br>static_cast&lt;int&amp;&gt;(y) = 1 ; // ERROR: cannot cast to int&amp;<br>static_cast&lt;int const&amp;&gt;(y) = 1 ; // ERROR: cannot modify a const value<br>get(y) = 1 ; // ERROR: cannot modify a const value</pre>
+<pre>value_initialized&lt;int&gt; x ; <br>static_cast&lt;int&amp;&gt;(x) = 1 ; // OK<br>get(x) = 1 ; // OK
+<br><br>value_initialized&lt;int const&gt; y ; <br>static_cast&lt;int&amp;&gt;(y) = 1 ; // ERROR: cannot cast to int&amp;<br>static_cast&lt;int const&amp;&gt;(y) = 1 ; // ERROR: cannot modify a const value<br>get(y) = 1 ; // ERROR: cannot modify a const value</pre>
                    
 <h3>Warning:</h3>
                   
-<p>Both the conversion operator and the <code>data()</code> member function 
-    are <code>const</code> in order to allow access to the wrapped object 
-from    a constant wrapper:</p>
+<p>The <code>value_initialized</code> implementation of Boost version 1.40.0 and older
+allowed <i>non-const</i> access to the wrapped object, from a constant wrapper,
+both by its conversion operator and its <code>data()</code> member function. For example:</p>
                   
-<pre>void foo(int);<br>value_initialized&lt;int&gt; const x ;<br>foo(x);<br></pre>
+<pre>value_initialized&lt;int&gt; const x_c ;<br>int&amp; xr = x_c ; // OK, conversion to int&amp; available even though x_c is itself const.
+<br>xr = 2 ; </pre>
                    
-<p>But notice that this conversion operator is to <code>T&amp;</code> although 
-    it is itself <code>const</code>. As a consequence, if <code>T</code> is
-  a  non-<code>const</code> type, you can modify the wrapped object even from
-   within a constant wrapper:</p>
-                   
-<pre>value_initialized&lt;int&gt; const x_c ;<br>int&amp; xr = x_c ; // OK, conversion to int&amp; available even though x_c is itself const.<br>xr = 2 ; </pre>
-                    
-<p>The reason for this obscure behavior is that some commonly used compilers
-     just don't accept the following valid code:</p>
+<p>The reason for this obscure behavior was that some compilers 
+     didn't accept the following valid code:</p>
                   
 <pre>struct X<br>{<br>  operator int&amp;() ;<br>  operator int const&amp;() const ;   <br>};<br>X x ;<br>(x == 1 ) ; // ERROR HERE!</pre>
                    
-<p>These compilers complain about ambiguity between the conversion operators. 
-    This complaint is incorrect, but the only workaround that I know of is 
- to   provide only one of them, which leads to the obscure behavior just explained.<br>
+<p>The current version of <code>value_initialized</code> no longer has this obscure behavior.
+As compilers nowadays widely support overloading the conversion operator by having a <code>const</code> and a <code>non-const</code> version, we have decided to fix the issue accordingly. So the current version supports the idea of logical constness.
+<br>
          </p>
                   
 <h3>Recommended practice: The non-member get() idiom</h3>
                   
 <p>The obscure behavior of being able to modify a non-<code>const</code>
-wrapped object from within a constant wrapper can be avoided if access to
+wrapped object from within a constant wrapper (as was supported by previous
+versions of <code>value_initialized</code>)
+can be avoided if access to
 the wrapped object is always performed with the <code>get()</code> idiom:</p>
                   
 <pre>value_initialized&lt;int&gt; x ;<br>get(x) = 1 ; // OK<br><br>value_initialized&lt;int const&gt; cx ;<br>get(x) = 1 ; // ERROR: Cannot modify a const object<br><br>value_initialized&lt;int&gt; const x_c ;<br>get(x_c) = 1 ; // ERROR: Cannot modify a const object<br><br>value_initialized&lt;int const&gt; const cx_c ;<br>get(cx_c) = 1 ; // ERROR: Cannot modify a const object<br></pre>
+
+<h2><a name="initialized"><code>template class initialized&lt;T&gt;</code></a></h2>
+                   
+<pre>namespace boost {<br><br>template&lt;class T&gt;<br>class initialized<br>{
+<br>  public :
+<br>    initialized() : x() {}
+<br>    explicit initialized(T const &amp; arg) : x(arg) {}
+<br>    operator T const &amp;() const;
+<br>    operator T&amp;();
+<br>    T const &amp;data() const;
+<br>    T&amp; data();
+<br>    void swap( value_initialized&lt;T&gt;&amp; );
+<br>
+<br>  private :
+<br>    <i>unspecified</i> x ;
+<br>} ;
+<br>
+<br>template&lt;class T&gt;
+<br>T const&amp; get ( initialized&lt;T&gt; const&amp; x );
+<br>
+<br>template&lt;class T&gt;
+<br>T&amp; get ( initialized&lt;T&gt;&amp; x );
+<br>
+<br>} // namespace boost
+<br></pre>
+
+The template class <code>boost::initialized&lt;T&gt;</code> supports both value-initialization
+and direct-initialization, so its interface is a superset of the interface
+of <code>value_initialized&lt;T&gt;</code>: Its default-constructor 
+value-initializes the wrapped object just like the default-constructor of
+<code>value_initialized&lt;T&gt;</code>, but <code>boost::initialized&lt;T&gt;</code>
+also offers an extra <code>explicit</code>
+constructor, which direct-initializes the wrapped object by the specified value.
+<p>
+
+<code>initialized&lt;T&gt;</code> is especially useful when the wrapped
+object must be either value-initialized or direct-initialized, depending on
+runtime conditions. For example, <code>initialized&lt;T&gt;</code> could
+hold the value of a data member that may be value-initialized by some
+constructors, and direct-initialized by others.
+On the other hand, if it is known beforehand that the
+object must <i>always</i> be value-initialized, <code>value_initialized&lt;T&gt;</code>
+may be preferable. And if the object must always be
+direct-initialized, none of the two wrappers really needs to be used.
+</p>
+ 
+
+<h2><a name="initialized_value"><code>initialized_value</code></a></h2>
+
+<pre>
+namespace boost {
+class initialized_value_t
+{
+  public :
+    template &lt;class T&gt; operator T() const ;
+};
+
+initialized_value_t const initialized_value = {} ;
+
+} // namespace boost
+</pre>
+
+<code>initialized_value</code> provides a convenient way to get
+an initialized value: its conversion operator provides an appropriate
+<em>value-initialized</em> object for any CopyConstructible type.
+
+Suppose you need to have an initialized variable of type <code>T</code>.
+You could do it as follows:
+<pre>
+  T var = T();
+</pre>
+But as mentioned before, this form suffers from various compiler issues.
+The template <code>value_initialized</code> offers a workaround:
+<pre>
+  T var = get( value_initialized&lt;T&gt;() );
+</pre>
+Unfortunately both forms repeat the type name, which
+is rather short now (<code>T</code>), but could of course be 
+more like <code>Namespace::Template&lt;Arg&gt;::Type</code>.
+Instead, one could use <code>initialized_value</code> as follows:
+<pre>
+  T var = initialized_value ;
+</pre>
                    
 <h3><a name="references">References</a></h3>
-          [1] The C++ Standard, ISO/IEC 14882:98 <br>
-          [2] Plain Old Data           
+          [1] Bjarne Stroustrup, Gabriel Dos Reis, and J. Stephen Adamczyk wrote
+          various papers, proposing to extend the support for brace-enclosed <em>initializer lists</em>
+          in the next version of C++.
+          This would allow a variable <code>var</code> of any DefaultConstructible type
+          <code>T</code> to be <em>value-initialized</em> by doing <code>T var = {}</code>.
+          The papers are listed at Bjarne's web page,
+          <a href="http://www.research.att.com/~bs/WG21.html">My C++ Standards committee papers</a>  <br> 
+          [2] Scott Meyers, Effective C++, Third Edition, item 6,
+          <em>Explicitly disallow the use of compiler-generated functions you do not want</em>, 
+          <a href="http://www.aristeia.com/books.html">Scott Meyers: Books and CDs</a>  <br>
+          [3] The C++ Standard, Second edition (2003), ISO/IEC 14882:2003 <br>
+          [4] POD stands for "Plain Old Data"
+
 <h3><a name="acknowledgements"></a>Acknowledgements</h3>
     value_initialized was developed by Fernando Cacciola, with help and
 suggestions from David Abrahams and Darin Adler.<br>
-Special thanks to Bj<EFBFBD>rn Karlsson who carefully edited and completed this documentation.
-<pre>&nbsp;</pre>
-                    
-<hr>          
-<p>Revised 19 September 2002</p>
-                   
-<p>&copy; Copyright boost.org 2002. Permission to copy, use, modify, sell 
-and distribute this document is granted provided this copyright notice  appears 
-in all copies. This document is provided "as is" without express or implied 
-warranty, and with no claim as to its suitability for any purpose.</p>
-                   
+Special thanks to Bj&ouml;rn Karlsson who carefully edited and completed this documentation.
+                 
+<p>value_initialized was reimplemented by Fernando Cacciola and Niels Dekker
+for Boost release version 1.35 (2008), offering a workaround to various compiler issues.
+     </p>
+<p><code>boost::initialized</code> was very much inspired by feedback from Edward Diener and 
+  Jeffrey Hellrung.
+     </p>
+<p>initialized_value was written by Niels Dekker, and added to Boost release version 1.36 (2008).
+     </p>
 <p>Developed by <a href="mailto:fernando_cacciola@hotmail.com">Fernando Cacciola</a>,
     the latest version of this file can be found at <a
- href="http://www.boost.org">www.boost.org</a>, and the boost discussion list
-at <a href="http://www.yahoogroups.com/list/boost">www.yahoogroups.com/list/boost</a>.
+ href="http://www.boost.org">www.boost.org</a>.
     </p>
+                    
+<hr>          
+<p>Revised 30 May 2010</p>
+                   
+<p>&copy; Copyright Fernando Cacciola, 2002 - 2010.</p>
+                   
+<p>Distributed under the Boost Software License, Version 1.0. See
+<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
+
 <br>
 <br>
    
--- a/value_init_test.cpp
+++ b/value_init_test.cpp
@ -1,4 +1,4 @@
-// (C) 2002, Fernando Luis Cacciola Carballal.
+// Copyright 2002-2008, Fernando Luis Cacciola Carballal.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@ -6,27 +6,32 @@
 //
 // Test program for "boost/utility/value_init.hpp"
 //
-// Initial: 21 Agu 2002
+// 21 Ago 2002 (Created) Fernando Cacciola
+// 15 Jan 2008 (Added tests regarding compiler issues) Fernando Cacciola, Niels Dekker
+// 23 May 2008 (Added tests regarding initialized_value) Niels Dekker
+// 21 Ago 2008 (Added swap test) Niels Dekker

+#include <cstring>  // For memcmp.
 #include <iostream>
 #include <string>

 #include "boost/utility/value_init.hpp"
+#include <boost/shared_ptr.hpp>

 #ifdef __BORLANDC__
 #pragma hdrstop
 #endif

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

 //
 // Sample POD type
 //
 struct POD
 {
-  POD () : c(0), i(0), f(0) {}
+  POD () : f(0), c(0), i(0){}

-  POD ( char c_, int i_, float f_ ) : c(c_), i(i_), f(f_) {}
+  POD ( char c_, int i_, float f_ ) : f(f_), c(c_), i(i_) {}

  friend std::ostream& operator << ( std::ostream& os, POD const& pod )
    { return os << '(' << pod.c << ',' << pod.i << ',' << pod.f << ')' ; }
@ -49,7 +54,7 @@ struct NonPODBase
 struct NonPOD : NonPODBase
 {
  NonPOD () : id() {}
-  NonPOD ( std::string const& id_) : id(id_) {}
+  explicit NonPOD ( std::string const& id_) : id(id_) {}

  friend std::ostream& operator << ( std::ostream& os, NonPOD const& npod )
    { return os << '(' << npod.id << ')' ; }
@ -60,48 +65,305 @@ struct NonPOD : NonPODBase
  std::string id ;
 } ;

-template<class T>
-void test ( T const& y, T const& z )
+//
+// Sample aggregate POD struct type
+// Some compilers do not correctly value-initialize such a struct, for example:
+// Borland C++ Report #51854, "Value-initialization: POD struct should be zero-initialized "
+// http://qc.codegear.com/wc/qcmain.aspx?d=51854
+//
+struct AggregatePODStruct
 {
+  float f;
+  char  c;
+  int   i;
+};
+
+bool operator == ( AggregatePODStruct const& lhs, AggregatePODStruct const& rhs )
+{ return lhs.f == rhs.f && lhs.c == rhs.c && lhs.i == rhs.i ; }
+
+//
+// An aggregate struct that contains an std::string and an int.
+// Pavel Kuznetsov (MetaCommunications Engineering) used a struct like
+// this to reproduce the Microsoft Visual C++ compiler bug, reported as
+// Feedback ID 100744, "Value-initialization in new-expression"
+// https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100744
+//
+struct StringAndInt
+{
+  std::string s;
+  int i;
+};
+
+bool operator == ( StringAndInt const& lhs, StringAndInt const& rhs )
+{ return lhs.s == rhs.s && lhs.i == rhs.i ; }
+
+
+//
+// A struct that has an explicit (user defined) destructor.
+// Some compilers do not correctly value-initialize such a struct, for example:
+// Microsoft Visual C++, Feedback ID 100744, "Value-initialization in new-expression"
+// https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100744
+//
+struct StructWithDestructor
+{
+  int i;
+  ~StructWithDestructor() {}
+};
+
+bool operator == ( StructWithDestructor const& lhs, StructWithDestructor const& rhs )
+{ return lhs.i == rhs.i ; }
+
+
+//
+// A struct that has a virtual function.
+// Some compilers do not correctly value-initialize such a struct either, for example:
+// Microsoft Visual C++, Feedback ID 100744, "Value-initialization in new-expression"
+// https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100744
+//
+struct StructWithVirtualFunction
+{
+  int i;
+  virtual void VirtualFunction(); 
+};
+
+void StructWithVirtualFunction::VirtualFunction()
+{
+}
+
+bool operator == ( StructWithVirtualFunction const& lhs, StructWithVirtualFunction const& rhs )
+{ return lhs.i == rhs.i ; }
+
+
+//
+// A struct that is derived from an aggregate POD struct.
+// Some compilers do not correctly value-initialize such a struct, for example:
+// GCC Bugzilla Bug 30111,  "Value-initialization of POD base class doesn't initialize members",
+// reported by Jonathan Wakely, http://gcc.gnu.org/bugzilla/show_bug.cgi?id=30111
+//
+struct DerivedFromAggregatePODStruct : AggregatePODStruct
+{
+  DerivedFromAggregatePODStruct() : AggregatePODStruct() {}
+};
+
+//
+// A struct that wraps an aggregate POD struct as data member.
+//
+struct AggregatePODStructWrapper
+{
+  AggregatePODStructWrapper() : dataMember() {}
+  AggregatePODStruct dataMember;
+};
+
+bool operator == ( AggregatePODStructWrapper const& lhs, AggregatePODStructWrapper const& rhs )
+{ return lhs.dataMember == rhs.dataMember ; }
+
+typedef unsigned char ArrayOfBytes[256];
+
+
+//
+// A struct that allows testing whether the appropriate copy functions are called.
+//
+struct CopyFunctionCallTester
+{
+  bool is_copy_constructed;
+  bool is_assignment_called;
+
+  CopyFunctionCallTester()
+  : is_copy_constructed(false), is_assignment_called(false) {}
+
+  CopyFunctionCallTester(const CopyFunctionCallTester & )
+  : is_copy_constructed(true), is_assignment_called(false) {}
+
+  CopyFunctionCallTester & operator=(const CopyFunctionCallTester & )
+  {
+    is_assignment_called = true ;
+    return *this ;
+  }
+};
+
+
+//
+// A struct that allows testing whether its customized swap function is called.
+//
+struct SwapFunctionCallTester
+{
+  bool is_custom_swap_called;
+  int data;
+
+  SwapFunctionCallTester()
+  : is_custom_swap_called(false), data(0) {}
+
+  SwapFunctionCallTester(const SwapFunctionCallTester & arg)
+  : is_custom_swap_called(false), data(arg.data) {}
+
+  void swap(SwapFunctionCallTester & arg)
+  {
+    std::swap(data, arg.data);
+    is_custom_swap_called = true;
+    arg.is_custom_swap_called = true;
+  }
+};
+
+void swap(SwapFunctionCallTester & lhs, SwapFunctionCallTester & rhs)
+{
+  lhs.swap(rhs);
+}
+
+
+
+template<class T>
+void check_initialized_value ( T const& y )
+{
+  T initializedValue = boost::initialized_value ;
+  BOOST_TEST ( y == initializedValue ) ;
+}
+
+#ifdef  __BORLANDC__
+#if __BORLANDC__ == 0x582
+void check_initialized_value( NonPOD const& )
+{
+  // The initialized_value check is skipped for Borland 5.82
+  // and this type (NonPOD), because the following statement
+  // won't compile on this particular compiler version:
+  //   NonPOD initializedValue = boost::initialized_value() ;
+  //
+  // This is caused by a compiler bug, that is fixed with a newer version
+  // of the Borland compiler.  The Release Notes for Delphi(R) 2007 for
+  // Win32(R) and C++Builder(R) 2007 (http://dn.codegear.com/article/36575)
+  // say about similar statements:
+  //   both of these statements now compile but under 5.82 got the error:
+  //   Error E2015: Ambiguity between 'V::V(const A &)' and 'V::V(const V &)'
+}
+#endif
+#endif
+
+//
+// This test function tests boost::value_initialized<T> for a specific type T.
+// The first argument (y) is assumed have the value of a value-initialized object.
+// Returns true on success.
+//
+template<class T>
+bool test ( T const& y, T const& z )
+{
+  const int errors_before_test = boost::detail::test_errors();
+
+  check_initialized_value(y);
+
  boost::value_initialized<T> x ;
-  BOOST_CHECK ( y == x ) ;
-  BOOST_CHECK ( y == boost::get(x) ) ;
+  BOOST_TEST ( y == x ) ;
+  BOOST_TEST ( y == boost::get(x) ) ;
+
  static_cast<T&>(x) = z ;
  boost::get(x) = z ;
-  BOOST_CHECK ( x == z ) ;
+  BOOST_TEST ( x == z ) ;

  boost::value_initialized<T> const x_c ;
-  BOOST_CHECK ( y == x_c ) ;
-  BOOST_CHECK ( y == boost::get(x_c) ) ;
-  T& x_c_ref = x_c ;
+  BOOST_TEST ( y == x_c ) ;
+  BOOST_TEST ( y == boost::get(x_c) ) ;
+  T& x_c_ref = const_cast<T&>( boost::get(x_c) ) ;
  x_c_ref = z ;
-  BOOST_CHECK ( x_c == z ) ;
+  BOOST_TEST ( x_c == z ) ;
+
+  boost::value_initialized<T> const copy1 = x;
+  BOOST_TEST ( boost::get(copy1) == boost::get(x) ) ;
+
+  boost::value_initialized<T> copy2;
+  copy2 = x;
+  BOOST_TEST ( boost::get(copy2) == boost::get(x) ) ;
+  
+  boost::shared_ptr<boost::value_initialized<T> > ptr( new boost::value_initialized<T> );
+  BOOST_TEST ( y == *ptr ) ;

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

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

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

-  return 0;
+  NonPOD NonPOD_object( std::string("NonPOD_object") );
+  BOOST_TEST ( test<NonPOD *>( 0, &NonPOD_object ) ) ;
+
+  AggregatePODStruct zeroInitializedAggregatePODStruct = { 0.0f, '\0', 0 };
+  AggregatePODStruct nonZeroInitializedAggregatePODStruct = { 1.25f, 'a', -1 };
+  BOOST_TEST ( test(zeroInitializedAggregatePODStruct, nonZeroInitializedAggregatePODStruct) );
+
+  StringAndInt stringAndInt0;
+  StringAndInt stringAndInt1;
+  stringAndInt0.i = 0;
+  stringAndInt1.i = 1;
+  stringAndInt1.s = std::string("1");
+  BOOST_TEST ( test(stringAndInt0, stringAndInt1) );
+
+  StructWithDestructor structWithDestructor0;
+  StructWithDestructor structWithDestructor1;
+  structWithDestructor0.i = 0;
+  structWithDestructor1.i = 1;
+  BOOST_TEST ( test(structWithDestructor0, structWithDestructor1) );
+
+  StructWithVirtualFunction structWithVirtualFunction0;
+  StructWithVirtualFunction structWithVirtualFunction1;
+  structWithVirtualFunction0.i = 0;
+  structWithVirtualFunction1.i = 1;
+  BOOST_TEST ( test(structWithVirtualFunction0, structWithVirtualFunction1) );
+
+  DerivedFromAggregatePODStruct derivedFromAggregatePODStruct0;
+  DerivedFromAggregatePODStruct derivedFromAggregatePODStruct1;
+  static_cast<AggregatePODStruct &>(derivedFromAggregatePODStruct0) = zeroInitializedAggregatePODStruct;
+  static_cast<AggregatePODStruct &>(derivedFromAggregatePODStruct1) = nonZeroInitializedAggregatePODStruct;
+  BOOST_TEST ( test(derivedFromAggregatePODStruct0, derivedFromAggregatePODStruct1) );
+
+  AggregatePODStructWrapper aggregatePODStructWrapper0;
+  AggregatePODStructWrapper aggregatePODStructWrapper1;
+  aggregatePODStructWrapper0.dataMember = zeroInitializedAggregatePODStruct;
+  aggregatePODStructWrapper1.dataMember = nonZeroInitializedAggregatePODStruct;
+  BOOST_TEST ( test(aggregatePODStructWrapper0, aggregatePODStructWrapper1) );
+
+  ArrayOfBytes zeroInitializedArrayOfBytes = { 0 };
+  boost::value_initialized<ArrayOfBytes> valueInitializedArrayOfBytes;
+  BOOST_TEST (std::memcmp(get(valueInitializedArrayOfBytes), zeroInitializedArrayOfBytes, sizeof(ArrayOfBytes)) == 0);
+
+  boost::value_initialized<ArrayOfBytes> valueInitializedArrayOfBytes2;
+  valueInitializedArrayOfBytes2 = valueInitializedArrayOfBytes;
+  BOOST_TEST (std::memcmp(get(valueInitializedArrayOfBytes), get(valueInitializedArrayOfBytes2), sizeof(ArrayOfBytes)) == 0);
+
+  boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester1;
+  BOOST_TEST ( ! get(copyFunctionCallTester1).is_copy_constructed);
+  BOOST_TEST ( ! get(copyFunctionCallTester1).is_assignment_called);
+
+  boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester2 = boost::value_initialized<CopyFunctionCallTester>(copyFunctionCallTester1);
+  BOOST_TEST ( get(copyFunctionCallTester2).is_copy_constructed);
+  BOOST_TEST ( ! get(copyFunctionCallTester2).is_assignment_called);
+
+  boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester3;
+  copyFunctionCallTester3 = boost::value_initialized<CopyFunctionCallTester>(copyFunctionCallTester1);
+  BOOST_TEST ( ! get(copyFunctionCallTester3).is_copy_constructed);
+  BOOST_TEST ( get(copyFunctionCallTester3).is_assignment_called);
+
+  boost::value_initialized<SwapFunctionCallTester> swapFunctionCallTester1;
+  boost::value_initialized<SwapFunctionCallTester> swapFunctionCallTester2;
+  get(swapFunctionCallTester1).data = 1;
+  get(swapFunctionCallTester2).data = 2;
+  boost::swap(swapFunctionCallTester1, swapFunctionCallTester2);
+  BOOST_TEST( get(swapFunctionCallTester1).data == 2 );
+  BOOST_TEST( get(swapFunctionCallTester2).data == 1 );
+  BOOST_TEST( get(swapFunctionCallTester1).is_custom_swap_called );
+  BOOST_TEST( get(swapFunctionCallTester2).is_custom_swap_called );
+
+  return boost::report_errors();
 }


-unsigned int expected_failures = 0;
-
-
-
-
-
--- a/value_init_test_fail1.cpp
+++ b/value_init_test_fail1.cpp
@ -1,4 +1,4 @@
-// (C) 2002, Fernando Luis Cacciola Carballal.
+// Copyright 2002, Fernando Luis Cacciola Carballal.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
--- a/Show More
+++ b/Show More