Branch at revision 46530

[SVN r46531]
Fixed value_init test + doc, according to change of boost::initialized_value, revision [45685]
2008-06-19 18:57:10 +00:00 · 2008-05-23 16:48:10 +00:00 · 2008-05-23 16:46:43 +00:00 · 2008-05-09 22:08:46 +00:00 · 2008-04-27 07:39:49 +00:00 · 2008-04-21 21:42:29 +00:00
87 changed files with 3996 additions and 3433 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="../../c++boost.gif" 
-     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=
+  "http://www.w3.org/Icons/valid-html401" 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="../../c++boost.gif" 
-     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=
+  "http://www.w3.org/Icons/valid-html401" 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="../../c++boost.gif" 
-     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=
+  "http://www.w3.org/Icons/valid-html401" 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="../../c++boost.gif" 
-     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.hmtl">Forward Iterator</a>. The
-only difference is that a <a
-href="http://www.sgi.com/tech/stl/ForwardIterator.hmtl">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=
+  "http://www.w3.org/Icons/valid-html401" 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
@ -4,7 +4,7 @@
 </HEAD>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
        ALINK="#ff0000"> 
-<IMG SRC="../../c++boost.gif" 
+<IMG SRC="../../boost.png" 
     ALT="C++ Boost" width="277" height="86"> 
 <!--end header-->
 <BR Clear>
@ -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_test.cpp
+++ b/addressof_test.cpp
@ -1,46 +1,94 @@
 // Copyright (C) 2002 Brad King (brad.king@kitware.com) 
-//                    Doug Gregor (gregod@cs.rpi.edu)
+//                    Douglas Gregor (gregod@cs.rpi.edu)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+// 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

-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/utility.hpp>
+
+#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 );
+}
+
+struct addressable
+{
+    addressable( int = 0 )
+    {
+    }
+};

 struct useless_type {};

 class nonaddressable {
 public:
-  void dummy(); // Silence GCC warning: all member of class are private
+
+    nonaddressable( int = 0 )
+    {
+    }
+
+    void dummy(); // Silence GCC warning: all member of class are private

 private:
-  useless_type operator&() const;
+
+    useless_type operator&() const;
 };

-int test_main(int, char*[])
+int main()
 {
-  nonaddressable* px = new nonaddressable();
+    scalar_test<char>();
+    scalar_test<int>();
+    scalar_test<addressable>();
+    scalar_test<nonaddressable>();

-  nonaddressable& x = *px;
-  BOOST_TEST(boost::addressof(x) == px);
+    array_test<char>();
+    array_test<int>();
+    array_test<addressable>();
+    array_test<nonaddressable>();

-  const nonaddressable& cx = *px;
-  BOOST_TEST(boost::addressof(cx) == static_cast<const nonaddressable*>(px));
-
-  volatile nonaddressable& vx = *px;
-  BOOST_TEST(boost::addressof(vx) == static_cast<volatile nonaddressable*>(px));
-
-  const volatile nonaddressable& cvx = *px;
-  BOOST_TEST(boost::addressof(cvx) == static_cast<const volatile nonaddressable*>(px));
-  
-  return 0;
+    return boost::report_errors();
 }
--- a/assert.html
+++ b/assert.html
@ -7,10 +7,9 @@
 	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
 		<table border="0" width="100%">
 			<tr>
-				<td width="277">
-					<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
+				<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="middle">
+				<td align="center">
 					<h1>assert.hpp</h1>
 				</td>
 			</tr>
@ -48,10 +47,15 @@ void assertion_failed(char const * expr, char const * function, char const * fil
 		<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>
+		<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. 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/assert_test.cpp
+++ b/assert_test.cpp
@ -3,10 +3,9 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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/detail/lightweight_test.hpp>
@ -52,13 +51,18 @@ void test_disabled()

 #define BOOST_ENABLE_ASSERT_HANDLER
 #include <boost/assert.hpp>
+#include <boost/config.hpp>
 #include <cstdio>

 int handler_invoked = 0;

 void boost::assertion_failed(char const * expr, char const * function, char const * file, long line)
 {
-    std::printf("Expression: %s\nFunction: %s\nFile: %s\nLine: %ld\n\n", expr, function, file, line);
+#if !defined(BOOST_NO_STDC_NAMESPACE)
+    using std::printf;
+#endif
+
+    printf("Expression: %s\nFunction: %s\nFile: %s\nLine: %ld\n\n", expr, function, file, line);
    ++handler_invoked;
 }

--- a/base_from_member.html
+++ b/base_from_member.html
@ -5,15 +5,14 @@
 </head>

 <body bgcolor="white" link="blue" text="black" vlink="purple" alink="red"> 
-<h1><img src="../../c++boost.gif" alt="C++ Boost" align="middle"
+<h1><img src="../../boost.png" alt="C++ Boost" align="middle"
 width="277" height="86">Base-from-Member Idiom</h1>

 <p>The class template <code>boost::base_from_member</code> provides
 a workaround for a class that needs to initialize a base class with a
 member.  The class template is in <cite><a
 href="../../boost/utility/base_from_member.hpp">boost/utility/base_from_member.hpp</a></cite>
-which is included in <i><a href="../../boost/utility.hpp">boost/utility.hpp</a></i>.
-The class template is forward declared in <i><a href="../../boost/utility_fwd.hpp">boost/utility_fwd.hpp</a></i>.</p>
+which is included in <i><a href="../../boost/utility.hpp">boost/utility.hpp</a></i>.</p>

 <p>There is test/example code in <cite><a
 href="base_from_member_test.cpp">base_from_member_test.cpp</a></cite>.</p>
@ -130,6 +129,10 @@ particular member type does not need to concern itself with the integer.</p>
 <h2><a name="synopsis">Synopsis</a></h2>

 <blockquote><pre>
+#ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY
+#define BOOST_BASE_FROM_MEMBER_MAX_ARITY  10
+#endif
+
 template &lt; typename MemberType, int UniqueID = 0 &gt;
 class boost::base_from_member
 {
@ -171,6 +174,14 @@ the template parameters of a templated constructor, make sure that
 the arguments are already close as possible to the actual type used in
 the data member's desired constructor.</p>

+<p>The <var>BOOST_BASE_FROM_MEMBER_MAX_ARITY</var> macro constant specifies
+the maximum argument length for the constructor templates.  The constant
+may be overridden if more (or less) argument configurations are needed.  The
+constant may be read for code that is expandable like the class template and
+needs to maintain the same maximum size.  (Example code would be a class that
+uses this class template as a base class for a member with a flexible set of
+constructors.)</p>
+
 <h2><a name="usage">Usage</a></h2>

 <p>With the starting example, the <code>fdoutbuf</code> sub-object needs
@ -323,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
@ -332,21 +343,26 @@ 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>.

-	<dt><a href="../../people/daryle_walker.html">Daryle Walker</a>
+	<dt>Jonathan Turkanis
+	<dd>Supplied an implementation of generating the constructor templates that
+		can be controlled and automated with macros.  The implementation uses
+		the <a href="../preprocessor/index.html">Preprocessor library</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>

 <hr>

-<p>Revised: 14 June 2003</p>
+<p>Revised: 28 August 2004</p>

-<p>Copyright 2001, 2003 Daryle Walker.  Use, modification, and distribution
+<p>Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and distribution
 are subject to the Boost Software License, Version 1.0.  (See accompanying
 file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
 href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
--- a/binary_search_test.cpp
+++ b/binary_search_test.cpp
@ -1,8 +1,7 @@
-// (C) Copyright David Abrahams 2000. 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.
+// (C) Copyright David Abrahams 2000.
+// 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 <vector>
 #include <string>
@ -15,6 +14,7 @@
 #include <algorithm>
 #include <boost/detail/binary_search.hpp>
 #include <boost/detail/workaround.hpp>
+#include <cstddef>

 #if defined(__SGI_STL_PORT) ? defined(__SGI_STL_OWN_IOSTREAMS) : (!defined(__GNUC__) || __GNUC__ > 2)
 # define USE_SSTREAM
--- a/call_traits.htm
+++ b/call_traits.htm
@ -12,7 +12,7 @@ content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
 <body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
 vlink="#800080">

-<h1><img src="../../c++boost.gif" width="276" height="86">Header
+<h1><img src="../../boost.png" width="276" height="86">Header
 &lt;<a href="../../boost/detail/call_traits.hpp">boost/call_traits.hpp</a>&gt;</h1>

 <p>All of the contents of &lt;boost/call_traits.hpp&gt; are
@ -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,14 +12,14 @@
 // 03 Oct 2000:
 //    Enabled extra tests for VC6.

-#include <cassert>
 #include <iostream>
 #include <iomanip>
 #include <algorithm>
 #include <typeinfo>
 #include <boost/call_traits.hpp>

-#include <boost/type_traits/type_traits_test.hpp>
+#include <libs/type_traits/test/test.hpp>
+#include <libs/type_traits/test/check_type.hpp>

 // a way prevent warnings for unused variables
 template<class T> inline void unused_variable(const T&) {}
@ -121,9 +121,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;
@ -145,11 +145,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;
@ -167,7 +167,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);
 }

 //
@ -178,8 +178,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;
 }

@ -231,73 +231,67 @@ int main(int argc, char *argv[ ])
   typedef int& r_type;
   typedef const r_type cr_type;

-   type_test(comparible_UDT, boost::call_traits<comparible_UDT>::value_type)
-   type_test(comparible_UDT&, boost::call_traits<comparible_UDT>::reference)
-   type_test(const comparible_UDT&, boost::call_traits<comparible_UDT>::const_reference)
-   type_test(const comparible_UDT&, boost::call_traits<comparible_UDT>::param_type)
-   type_test(int, boost::call_traits<int>::value_type)
-   type_test(int&, boost::call_traits<int>::reference)
-   type_test(const int&, boost::call_traits<int>::const_reference)
-   type_test(const int, boost::call_traits<int>::param_type)
-   type_test(int*, boost::call_traits<int*>::value_type)
-   type_test(int*&, boost::call_traits<int*>::reference)
-   type_test(int*const&, boost::call_traits<int*>::const_reference)
-   type_test(int*const, boost::call_traits<int*>::param_type)
+   BOOST_CHECK_TYPE(comparible_UDT, boost::call_traits<comparible_UDT>::value_type);
+   BOOST_CHECK_TYPE(comparible_UDT&, boost::call_traits<comparible_UDT>::reference);
+   BOOST_CHECK_TYPE(const comparible_UDT&, boost::call_traits<comparible_UDT>::const_reference);
+   BOOST_CHECK_TYPE(const comparible_UDT&, boost::call_traits<comparible_UDT>::param_type);
+   BOOST_CHECK_TYPE(int, boost::call_traits<int>::value_type);
+   BOOST_CHECK_TYPE(int&, boost::call_traits<int>::reference);
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<int>::const_reference);
+   BOOST_CHECK_TYPE(const int, boost::call_traits<int>::param_type);
+   BOOST_CHECK_TYPE(int*, boost::call_traits<int*>::value_type);
+   BOOST_CHECK_TYPE(int*&, boost::call_traits<int*>::reference);
+   BOOST_CHECK_TYPE(int*const&, boost::call_traits<int*>::const_reference);
+   BOOST_CHECK_TYPE(int*const, boost::call_traits<int*>::param_type);
 #if defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-   type_test(int&, boost::call_traits<int&>::value_type)
-   type_test(int&, boost::call_traits<int&>::reference)
-   type_test(const int&, boost::call_traits<int&>::const_reference)
-   type_test(int&, boost::call_traits<int&>::param_type)
+   BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::value_type);
+   BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::reference);
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<int&>::const_reference);
+   BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::param_type);
 #if !(defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC__ == 3) && (__GNUC_MINOR__ < 1)))
-   type_test(int&, boost::call_traits<cr_type>::value_type)
-   type_test(int&, boost::call_traits<cr_type>::reference)
-   type_test(const int&, boost::call_traits<cr_type>::const_reference)
-   type_test(int&, boost::call_traits<cr_type>::param_type)
+   BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::value_type);
+   BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::reference);
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<cr_type>::const_reference);
+   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
-   type_test(const int&, boost::call_traits<const int&>::value_type)
-   type_test(const int&, boost::call_traits<const int&>::reference)
-   type_test(const int&, boost::call_traits<const int&>::const_reference)
-   type_test(const int&, boost::call_traits<const int&>::param_type)
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::value_type);
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::reference);
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::const_reference);
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::param_type);
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   type_test(const int*, boost::call_traits<int[3]>::value_type)
-   type_test(int(&)[3], boost::call_traits<int[3]>::reference)
-   type_test(const int(&)[3], boost::call_traits<int[3]>::const_reference)
-   type_test(const int*const, boost::call_traits<int[3]>::param_type)
-   type_test(const int*, boost::call_traits<const int[3]>::value_type)
-   type_test(const int(&)[3], boost::call_traits<const int[3]>::reference)
-   type_test(const int(&)[3], boost::call_traits<const int[3]>::const_reference)
-   type_test(const int*const, boost::call_traits<const int[3]>::param_type)
+   BOOST_CHECK_TYPE(const int*, boost::call_traits<int[3]>::value_type);
+   BOOST_CHECK_TYPE(int(&)[3], boost::call_traits<int[3]>::reference);
+   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<int[3]>::const_reference);
+   BOOST_CHECK_TYPE(const int*const, boost::call_traits<int[3]>::param_type);
+   BOOST_CHECK_TYPE(const int*, boost::call_traits<const int[3]>::value_type);
+   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<const int[3]>::reference);
+   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<const int[3]>::const_reference);
+   BOOST_CHECK_TYPE(const int*const, boost::call_traits<const int[3]>::param_type);
   // test with abstract base class:
-   type_test(test_abc1, boost::call_traits<test_abc1>::value_type)
-   type_test(test_abc1&, boost::call_traits<test_abc1>::reference)
-   type_test(const test_abc1&, boost::call_traits<test_abc1>::const_reference)
-   type_test(const test_abc1&, boost::call_traits<test_abc1>::param_type)
+   BOOST_CHECK_TYPE(test_abc1, boost::call_traits<test_abc1>::value_type);
+   BOOST_CHECK_TYPE(test_abc1&, boost::call_traits<test_abc1>::reference);
+   BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::const_reference);
+   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:
-   type_test(incomplete_type, boost::call_traits<incomplete_type>::value_type)
-   type_test(incomplete_type&, boost::call_traits<incomplete_type>::reference)
-   type_test(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference)
-   type_test(const incomplete_type&, boost::call_traits<incomplete_type>::param_type)
+   BOOST_CHECK_TYPE(incomplete_type, boost::call_traits<incomplete_type>::value_type);
+   BOOST_CHECK_TYPE(incomplete_type&, boost::call_traits<incomplete_type>::reference);
+   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference);
+   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::param_type);

-   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
@ -409,23 +403,3 @@ template struct call_traits_test<int[2], true>;
 #endif
 #endif

-#if defined(BOOST_MSVC) && _MSC_VER <= 1300
-unsigned int expected_failures = 14;
-#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
@ -7,10 +7,9 @@
 	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
 		<table border="0" width="100%">
 			<tr>
-				<td width="277">
-					<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
+				<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="middle">
+				<td align="center">
 					<h1>checked_delete.hpp</h1>
 				</td>
 			</tr>
@ -116,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/checked_delete_test.cpp
+++ b/checked_delete_test.cpp
@ -1,7 +1,8 @@
 //  Boost checked_delete test program  ---------------------------------------//

-//  Copyright Beman Dawes 2001.
-//  See accompanying license for terms and conditions of use.
+//  Copyright Beman Dawes 2001.  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)

 //  See http://www.boost.org/libs/utility for documentation.

--- a/compressed_pair.htm
+++ b/compressed_pair.htm
@ -1,30 +1,19 @@
 <html>
-
-<head>
-<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">
-<title>Header </title>
-<boost/compressed_pair.hpp>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
-vlink="#800080">
-
-<h2><img src="../../c++boost.gif" width="276" height="86">Header
-&lt;<a href="../../boost/detail/compressed_pair.hpp">boost/compressed_pair.hpp</a>&gt;</h2>
-
-<p>All of the contents of &lt;boost/compressed_pair.hpp&gt; are
-defined inside namespace boost.</p>
-
-<p>The class compressed pair is very similar to std::pair, but if
-either of the template arguments are empty classes, then the
-&quot;empty base-class optimisation&quot; is applied to compress
-the size of the pair.</p>
-
-<pre>template &lt;class T1, class T2&gt;
+   <head>
+      <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 5.0">
+      <boostcompressed_pair.hpp>
+   </head>
+   <body bgcolor="#ffffff" text="#000000" link="#0000ff" vlink="#800080">
+      <h2><img src="../../boost.png" width="276" height="86">Header &lt;<a href="../../boost/detail/compressed_pair.hpp">boost/compressed_pair.hpp</a>&gt;</h2>
+      <p>All of the contents of &lt;boost/compressed_pair.hpp&gt; are defined inside 
+         namespace boost.</p>
+      <p>The class compressed pair is very similar to std::pair, but if either of the 
+         template arguments are empty classes, then the "empty base-class optimisation" 
+         is applied to compress the size of the pair.</p>
+      <pre>template &lt;class T1, class T2&gt;
 class compressed_pair
 {
 public:
@ -52,47 +41,36 @@ public:

 	void swap(compressed_pair&amp; y);
 };</pre>
+      <p>The two members of the pair can be accessed using the member functions first() 
+         and second(). Note that not all member functions can be instantiated for all 
+         template parameter types. In particular compressed_pair can be instantiated for 
+         reference and array types, however in these cases the range of constructors 
+         that can be used are limited. If types T1 and T2 are the same type, then there 
+         is only one version of the single-argument constructor, and this constructor 
+         initialises both values in the pair to the passed value.</p>
+      <P>Note that if either member is a POD type, then that member is not 
+         zero-initialized by the compressed_pair default constructor: it's up to you to 
+         supply an initial value for these types if you want them to have a default 
+         value.</P>
+      <p>Note that compressed_pair can not be instantiated if either of the template 
+         arguments is a union type, unless there is compiler support for 
+         boost::is_union, or if boost::is_union is specialised for the union type.</p>
+      <p>Finally, a word of caution for Visual C++ 6 users: if either argument is an 
+         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>
+      <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>
+      <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>

-<p>The two members of the pair can be accessed using the member
-functions first() and second(). Note that not all member
-functions can be instantiated for all template parameter types.
-In particular compressed_pair can be instantiated for reference
-and array types, however in these cases the range of constructors
-that can be used are limited. If types T1 and T2 are the same
-type, then there is only one version of the single-argument
-constructor, and this constructor initialises both values in the
-pair to the passed value.</p>
-
-<p>Note that compressed_pair can not be instantiated if either of
-the template arguments is a union type, unless there is compiler
-support for boost::is_union, or if boost::is_union is specialised
-for the union type.</p>
-
-<p>Finally, a word of caution for Visual C++ 6 users: if either
-argument is an empty type, then assigning to that member will
-produce memory corruption, unless the empty type has a &quot;do
-nothing&quot; 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
-&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>&nbsp;</p>
-</body>
-</html>
+   </body>
+</html>
--- a/compressed_pair_test.cpp
+++ b/compressed_pair_test.cpp
@ -14,29 +14,23 @@
 #include <cassert>

 #include <boost/compressed_pair.hpp>
-#include <boost/type_traits/type_traits_test.hpp>
-#define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>

 using namespace boost;

-namespace boost {
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-template <> struct is_empty<empty_UDT>
-{ static const bool value = true; };
-template <> struct is_empty<empty_POD_UDT>
-{ static const bool value = true; };
-template <> struct is_POD<empty_POD_UDT>
-{ static const bool value = true; };
-#else
-template <> struct is_empty<empty_UDT>
-{ enum{ value = true }; };
-template <> struct is_empty<empty_POD_UDT>
-{ enum{ value = true }; };
-template <> struct is_POD<empty_POD_UDT>
-{ enum{ value = true }; };
-#endif
-}
+struct empty_UDT
+{
+   ~empty_UDT(){};
+   empty_UDT& operator=(const empty_UDT&){ return *this; }
+   bool operator==(const empty_UDT&)const
+   { return true; }
+};
+struct empty_POD_UDT
+{
+   empty_POD_UDT& operator=(const empty_POD_UDT&){ return *this; }
+   bool operator==(const empty_POD_UDT&)const
+   { return true; }
+};

 struct non_empty1
 { 
@ -85,47 +79,47 @@ void compressed_pair_tester<T1, T2>::test(first_param_type p1, second_param_type
   // first param construct:
   boost::compressed_pair<T1,T2> cp2(p1);
   cp2.second() = p2;
-   BOOST_TEST(cp2.first() == p1);
-   BOOST_TEST(cp2.second() == p2);
+   BOOST_CHECK(cp2.first() == p1);
+   BOOST_CHECK(cp2.second() == p2);
   // second param construct:
   boost::compressed_pair<T1,T2> cp3(p2);
   cp3.first() = p1;
-   BOOST_TEST(cp3.second() == p2);
-   BOOST_TEST(cp3.first() == p1);
+   BOOST_CHECK(cp3.second() == p2);
+   BOOST_CHECK(cp3.first() == p1);
   // both param construct:
   boost::compressed_pair<T1,T2> cp4(p1, p2);
-   BOOST_TEST(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
+   BOOST_CHECK(cp4.first() == p1);
+   BOOST_CHECK(cp4.second() == p2);
   boost::compressed_pair<T1,T2> cp5(p3, p4);
-   BOOST_TEST(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
+   BOOST_CHECK(cp5.first() == p3);
+   BOOST_CHECK(cp5.second() == p4);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp4;
-   BOOST_TEST(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second() == p2);
+   BOOST_CHECK(cpr1.first() == p1);
+   BOOST_CHECK(cpr1.second() == p2);

   // copy construct:
   boost::compressed_pair<T1,T2> cp6(cp4);
-   BOOST_TEST(cp6.first() == p1);
-   BOOST_TEST(cp6.second() == p2);
+   BOOST_CHECK(cp6.first() == p1);
+   BOOST_CHECK(cp6.second() == p2);
   // assignment:
   cp1 = cp4;
-   BOOST_TEST(cp1.first() == p1);
-   BOOST_TEST(cp1.second() == p2);
+   BOOST_CHECK(cp1.first() == p1);
+   BOOST_CHECK(cp1.second() == p2);
   cp1 = cp5;
-   BOOST_TEST(cp1.first() == p3);
-   BOOST_TEST(cp1.second() == p4);
+   BOOST_CHECK(cp1.first() == p3);
+   BOOST_CHECK(cp1.second() == p4);
   // swap:
   cp4.swap(cp5);
-   BOOST_TEST(cp4.first() == p3);
-   BOOST_TEST(cp4.second() == p4);
-   BOOST_TEST(cp5.first() == p1);
-   BOOST_TEST(cp5.second() == p2);
+   BOOST_CHECK(cp4.first() == p3);
+   BOOST_CHECK(cp4.second() == p4);
+   BOOST_CHECK(cp5.first() == p1);
+   BOOST_CHECK(cp5.second() == p2);
   swap(cp4,cp5);
-   BOOST_TEST(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
-   BOOST_TEST(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
+   BOOST_CHECK(cp4.first() == p1);
+   BOOST_CHECK(cp4.second() == p2);
+   BOOST_CHECK(cp5.first() == p3);
+   BOOST_CHECK(cp5.second() == p4);
 }

 //
@ -154,20 +148,20 @@ void compressed_pair_reference_tester<T1, T2>::test(first_param_type p1, second_
 #endif
   // both param construct:
   boost::compressed_pair<T1,T2> cp4(p1, p2);
-   BOOST_TEST(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
+   BOOST_CHECK(cp4.first() == p1);
+   BOOST_CHECK(cp4.second() == p2);
   boost::compressed_pair<T1,T2> cp5(p3, p4);
-   BOOST_TEST(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
+   BOOST_CHECK(cp5.first() == p3);
+   BOOST_CHECK(cp5.second() == p4);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp4;
-   BOOST_TEST(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second() == p2);
+   BOOST_CHECK(cpr1.first() == p1);
+   BOOST_CHECK(cpr1.second() == p2);

   // copy construct:
   boost::compressed_pair<T1,T2> cp6(cp4);
-   BOOST_TEST(cp6.first() == p1);
-   BOOST_TEST(cp6.second() == p2);
+   BOOST_CHECK(cp6.first() == p1);
+   BOOST_CHECK(cp6.second() == p2);
   // assignment:
   // VC6 bug:
   // When second() is an empty class, VC6 performs the
@ -180,8 +174,8 @@ void compressed_pair_reference_tester<T1, T2>::test(first_param_type p1, second_
   // settings - some generate the problem others do not.
   cp4.first() = p3;
   cp4.second() = p4;
-   BOOST_TEST(cp4.first() == p3);
-   BOOST_TEST(cp4.second() == p4);
+   BOOST_CHECK(cp4.first() == p3);
+   BOOST_CHECK(cp4.second() == p4);
 }
 //
 // supplimentary tests for case where first arg only is a reference type:
@ -205,8 +199,8 @@ void compressed_pair_reference1_tester<T1, T2>::test(first_param_type p1, second
   // first param construct:
   boost::compressed_pair<T1,T2> cp2(p1);
   cp2.second() = p2;
-   BOOST_TEST(cp2.first() == p1);
-   BOOST_TEST(cp2.second() == p2);
+   BOOST_CHECK(cp2.first() == p1);
+   BOOST_CHECK(cp2.second() == p2);
 #endif
 }
 //
@ -231,8 +225,8 @@ void compressed_pair_reference2_tester<T1, T2>::test(first_param_type p1, second
   // second param construct:
   boost::compressed_pair<T1,T2> cp3(p2);
   cp3.first() = p1;
-   BOOST_TEST(cp3.second() == p2);
-   BOOST_TEST(cp3.first() == p1);
+   BOOST_CHECK(cp3.second() == p2);
+   BOOST_CHECK(cp3.first() == p1);
 #endif
 }

@ -259,14 +253,14 @@ void compressed_pair_array1_tester<T1, T2>::test(first_param_type p1, second_par
   // second param construct:
   boost::compressed_pair<T1,T2> cp3(p2);
   cp3.first()[0] = p1[0];
-   BOOST_TEST(cp3.second() == p2);
-   BOOST_TEST(cp3.first()[0] == p1[0]);
+   BOOST_CHECK(cp3.second() == p2);
+   BOOST_CHECK(cp3.first()[0] == p1[0]);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp3;
-   BOOST_TEST(cpr1.first()[0] == p1[0]);
-   BOOST_TEST(cpr1.second() == p2);
+   BOOST_CHECK(cpr1.first()[0] == p1[0]);
+   BOOST_CHECK(cpr1.second() == p2);

-   BOOST_TEST(sizeof(T1) == sizeof(cp1.first()));
+   BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
 }

 template <class T1, class T2>
@ -289,14 +283,14 @@ void compressed_pair_array2_tester<T1, T2>::test(first_param_type p1, second_par
   // first param construct:
   boost::compressed_pair<T1,T2> cp2(p1);
   cp2.second()[0] = p2[0];
-   BOOST_TEST(cp2.first() == p1);
-   BOOST_TEST(cp2.second()[0] == p2[0]);
+   BOOST_CHECK(cp2.first() == p1);
+   BOOST_CHECK(cp2.second()[0] == p2[0]);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp2;
-   BOOST_TEST(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second()[0] == p2[0]);
+   BOOST_CHECK(cpr1.first() == p1);
+   BOOST_CHECK(cpr1.second()[0] == p2[0]);

-   BOOST_TEST(sizeof(T2) == sizeof(cp1.second()));
+   BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
 }

 template <class T1, class T2>
@ -318,15 +312,15 @@ void compressed_pair_array_tester<T1, T2>::test(first_param_type p1, second_para
   boost::compressed_pair<T1,T2> cp1;
   cp1.first()[0] = p1[0];
   cp1.second()[0] = p2[0];
-   BOOST_TEST(cp1.first()[0] == p1[0]);
-   BOOST_TEST(cp1.second()[0] == p2[0]);
+   BOOST_CHECK(cp1.first()[0] == p1[0]);
+   BOOST_CHECK(cp1.second()[0] == p2[0]);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp1;
-   BOOST_TEST(cpr1.first()[0] == p1[0]);
-   BOOST_TEST(cpr1.second()[0] == p2[0]);
+   BOOST_CHECK(cpr1.first()[0] == p1[0]);
+   BOOST_CHECK(cpr1.second()[0] == p2[0]);

-   BOOST_TEST(sizeof(T1) == sizeof(cp1.first()));
-   BOOST_TEST(sizeof(T2) == sizeof(cp1.second()));
+   BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
+   BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
 }

 int test_main(int, char *[])
--- a/counting_iterator_example.cpp
+++ b/counting_iterator_example.cpp
@ -1,60 +0,0 @@
-// (C) Copyright Jeremy Siek 2000. 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.
-
-
-#include <boost/config.hpp>
-#include <algorithm>
-#include <iostream>
-#include <iterator>
-#include <vector>
-#include <boost/iterator/counting_iterator.hpp>
-#include <boost/iterator/indirect_iterator.hpp>
-
-int main(int, char*[])
-{
-  // Example of using counting_iterator_generator
-  std::cout << "counting from 0 to 4:" << std::endl;
-  boost::counting_iterator<int> first(0), last(4);
-  std::copy(first, last, std::ostream_iterator<int>(std::cout, " "));
-  std::cout << std::endl;
-
-  // Example of using make_counting_iterator()
-  std::cout << "counting from -5 to 4:" << std::endl;
-  std::copy(boost::make_counting_iterator(-5),
-            boost::make_counting_iterator(5),
-            std::ostream_iterator<int>(std::cout, " "));
-  std::cout << std::endl;
-
-  // Example of using counting iterator to create an array of pointers.
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-  const
-#endif 
-      int N = 7;
-  std::vector<int> numbers;
-  // Fill "numbers" array with [0,N)
-  std::copy(
-      boost::make_counting_iterator(0)
-      , boost::make_counting_iterator(N)
-      , std::back_inserter(numbers));
-
-  std::vector<std::vector<int>::iterator> pointers;
-
-  // Use counting iterator to fill in the array of pointers.
-  // causes an ICE with MSVC6
-  std::copy(boost::make_counting_iterator(numbers.begin()),
-            boost::make_counting_iterator(numbers.end()),
-            std::back_inserter(pointers));
-
-  // Use indirect iterator to print out numbers by accessing
-  // them through the array of pointers.
-  std::cout << "indirectly printing out the numbers from 0 to " 
-            << N << std::endl;
-  std::copy(boost::make_indirect_iterator(pointers.begin()),
-            boost::make_indirect_iterator(pointers.end()),
-            std::ostream_iterator<int>(std::cout, " "));
-  std::cout << std::endl;
-  
-  return 0;
-}
--- a/current_function.html
+++ b/current_function.html
@ -7,10 +7,9 @@
 	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
 		<table border="0" width="100%">
 			<tr>
-				<td width="277">
-					<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
+				<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="middle">
+				<td align="center">
 					<h1>current_function.hpp</h1>
 				</td>
 			</tr>
@ -30,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/current_function_test.cpp
+++ b/current_function_test.cpp
@ -12,18 +12,22 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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/current_function.hpp>
+#include <boost/config.hpp>
 #include <cstdio>

 void message(char const * file, long line, char const * func, char const * msg)
 {
-    std::printf("%s(%ld): %s in function '%s'\n", file, line, msg, func);
+#if !defined(BOOST_NO_STDC_NAMESPACE)
+    using std::printf;
+#endif
+
+    printf("%s(%ld): %s in function '%s'\n", file, line, msg, func);
 }

 #define MESSAGE(msg) message(__FILE__, __LINE__, BOOST_CURRENT_FUNCTION, msg)
@ -31,4 +35,6 @@ void message(char const * file, long line, char const * func, char const * msg)
 int main()
 {
    MESSAGE("assertion failed");
+
+    return 0;
 }
--- a/enable_if.html
+++ b/enable_if.html
@ -17,7 +17,7 @@


 <h1>
-<img border="0" src="../../c++boost.gif" align="center" width="277" height="86">enable_if</h1>
+<img border="0" src="../../boost.png" align="center" width="277" height="86">enable_if</h1>
 <BR>
 <BR>
 Copyright 2003 Jaakko J&auml;rvi, Jeremiah Willcock, Andrew Lumsdaine.<BR>
@ -128,7 +128,7 @@ When valid, <TT>enable_if_c&lt;B, T&gt;::type</TT> equals <TT>T</TT>.
 The <TT>enable_if_c</TT> template can thus be used for controlling when functions are considered for
 overload resolution and when they are not. 
 For example, the following function is defined for all arithmetic types (according to the
-classification of the <A HREF="http://www.boost.org/libs/type_traits">Boost type_traits library</A>):
+classification of the <A HREF="../type_traits/index.html">Boost type_traits library</A>):
 <PRE>template &lt;class T&gt;
 typename enable_if_c&lt;boost::is_arithmetic&lt;T&gt;::value, T&gt;::type 
 foo(T t) { return t; }
@ -303,7 +303,7 @@ foo(T t);
 <UL><LI>
 Use an extra dummy parameter which disambiguates the functions. Use a default value for
 it to hide the parameter from the caller. For example:
-<PRE>template &lt;class T&gt; struct dummy { dummy(int) {} };
+<PRE>template &lt;int&gt; struct dummy { dummy(int) {} };

 template &lt;class T&gt;
 typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
@ -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.v2
+++ b/enable_if/test/Jamfile.v2
@ -0,0 +1,23 @@
+# 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/
+
+project
+    : requirements <library>/boost/test//boost_test_exec_monitor
+    ;
+
+test-suite utility/enable_if
+        :
+        [ run constructors.cpp ]
+        [ run dummy_arg_disambiguation.cpp ]
+        [ run lazy.cpp ]
+        [ run lazy_test.cpp ]
+        [ run member_templates.cpp ]
+        [ run namespace_disambiguation.cpp ]
+        [ run no_disambiguation.cpp ]
+        [ run partial_specializations.cpp ]
+    ;
+
--- a/enable_if/test/constructors.cpp
+++ b/enable_if/test/constructors.cpp
@ -1,6 +1,6 @@
 // Boost enable_if library

-// Copyright 2003 © 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
--- a/enable_if/test/dummy_arg_disambiguation.cpp
+++ b/enable_if/test/dummy_arg_disambiguation.cpp
@ -1,6 +1,6 @@
 // Boost enable_if library

-// Copyright 2003 © 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
--- a/enable_if/test/lazy.cpp
+++ b/enable_if/test/lazy.cpp
@ -1,6 +1,6 @@
 // Boost enable_if library

-// Copyright 2003 © 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
@ -61,7 +61,7 @@ mult(const T& x, const U& y) {return x * y;}
 #if 1
 template <class T, class U>
 typename lazy_enable_if_c<
-  is_int<T>::value && is_int<U>::value,
+  is_int<T>::value & is_int<U>::value,
  mult_traits<T, U> 
 >::type
 mult(const T& x, const U& y) {return x * y;}
--- a/enable_if/test/lazy_test.cpp
+++ b/enable_if/test/lazy_test.cpp
@ -1,6 +1,6 @@
 // Boost enable_if library

-// Copyright 2003 © 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
--- a/enable_if/test/member_templates.cpp
+++ b/enable_if/test/member_templates.cpp
@ -1,6 +1,6 @@
 // Boost enable_if library

-// Copyright 2003 © 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
--- a/enable_if/test/namespace_disambiguation.cpp
+++ b/enable_if/test/namespace_disambiguation.cpp
@ -1,6 +1,6 @@
 // Boost enable_if library

-// Copyright 2003 © 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
--- a/enable_if/test/no_disambiguation.cpp
+++ b/enable_if/test/no_disambiguation.cpp
@ -1,6 +1,6 @@
 // Boost enable_if library

-// Copyright 2003 © 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
--- a/enable_if/test/partial_specializations.cpp
+++ b/enable_if/test/partial_specializations.cpp
@ -1,6 +1,6 @@
 // Boost enable_if library

-// Copyright 2003 © 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
--- a/filter_iterator_example.cpp
+++ b/filter_iterator_example.cpp
@ -1,62 +0,0 @@
-// Example of using the filter iterator adaptor from
-// boost/iterator_adaptors.hpp.
-
-//  (C) Copyright Jeremy Siek 1999. 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.
-
-#include <boost/config.hpp>
-#include <algorithm>
-#include <functional>
-#include <iostream>
-#include <boost/iterator/filter_iterator.hpp>
-
-struct is_positive_number {
-  bool operator()(int x) { return 0 < x; }
-};
-
-int main()
-{
-  int numbers_[] = { 0, -1, 4, -3, 5, 8, -2 };
-  const int N = sizeof(numbers_)/sizeof(int);
-  
-  typedef int* base_iterator;
-  base_iterator numbers(numbers_);
-  
-  // Example using make_filter_iterator()
-  std::copy(boost::make_filter_iterator<is_positive_number>(numbers, numbers + N),
-            boost::make_filter_iterator<is_positive_number>(numbers + N, numbers + N),
-            std::ostream_iterator<int>(std::cout, " "));
-  std::cout << std::endl;
-
-  // Example using filter_iterator
-  typedef boost::filter_iterator<is_positive_number, base_iterator>
-    FilterIter;
-  
-  is_positive_number predicate;
-  FilterIter filter_iter_first(predicate, numbers, numbers + N);
-  FilterIter filter_iter_last(predicate, numbers + N, numbers + N);
-
-  std::copy(filter_iter_first, filter_iter_last, std::ostream_iterator<int>(std::cout, " "));
-  std::cout << std::endl;
-
-  // Another example using make_filter_iterator()
-  std::copy(
-      boost::make_filter_iterator(
-          std::bind2nd(std::greater<int>(), -2)
-        , numbers, numbers + N)
-            
-    , boost::make_filter_iterator(
-          std::bind2nd(std::greater<int>(), -2)
-        , numbers + N, numbers + N)
-      
-    , std::ostream_iterator<int>(std::cout, " ")
-  );
-  
-  std::cout << std::endl;
-  
-  
-  return 0;
-}
--- a/fun_out_iter_example.cpp
+++ b/fun_out_iter_example.cpp
@ -1,47 +0,0 @@
-// (C) Copyright Jeremy Siek 2001. 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.
-
-// Revision History:
-
-// 27 Feb 2001   Jeremy Siek
-//      Initial checkin.
-
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include <boost/function_output_iterator.hpp>
-
-struct string_appender
-{
-    string_appender(std::string& s)
-        : m_str(&s)
-    {}
-    
-    void operator()(const std::string& x) const
-    {
-        *m_str += x;
-    }
-
-    std::string* m_str;
-};
-
-int main(int, char*[])
-{
-  std::vector<std::string> x;
-  x.push_back("hello");
-  x.push_back(" ");
-  x.push_back("world");
-  x.push_back("!");
-
-  std::string s = "";
-  std::copy(x.begin(), x.end(), 
-            boost::make_function_output_iterator(string_appender(s)));
-  
-  std::cout << s << std::endl;
-
-  return 0;
-}
--- 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="../../c++boost.gif" alt="c++boost.gif (8819 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,87 +44,85 @@ 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:
-  typedef <a href="iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt; type; // the resulting generator iterator type 
+  typedef <i>unspecified</i> type; // the resulting generator iterator type 
 }
 </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=
+  "http://www.w3.org/Icons/valid-html401" 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/half_open_range_test.cpp
+++ b/half_open_range_test.cpp
@ -1,366 +0,0 @@
-// (C) Copyright David Abrahams 2001. 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.
-//
-//  See http://www.boost.org for most recent version including documentation.
-//
-// Revision History
-// 11 Feb 2001  Compile with Borland, re-enable failing tests (David Abrahams)
-// 29 Jan 2001  Initial revision (David Abrahams)
-
-#include <boost/half_open_range.hpp>
-#include <boost/utility.hpp>
-#include <iterator>
-#include <stdlib.h>
-#include <vector>
-#include <list>
-#include <cassert>
-#include <stdexcept>
-#ifndef BOOST_NO_LIMITS
-# include <limits>
-#endif
-#ifndef BOOST_NO_SLIST
-# include <slist>
-#endif
-
-inline unsigned unsigned_random(unsigned max)
-{
-    return (max > 0) ? (unsigned)rand() % max : 0;
-}
-
-// Special tests for ranges supporting random access
-template <class T>
-void category_test_1(
-    const boost::half_open_range<T>& r, std::random_access_iterator_tag)
-{
-    typedef boost::half_open_range<T> range;
-    typedef typename range::size_type size_type;
-    size_type size = r.size();
-
-    // pick a random offset
-    size_type offset = unsigned_random(size);
-
-    typename range::value_type x = *(r.begin() + offset);
-    // test contains(value_type)
-    assert(r.contains(r.start()) == !r.empty());
-    assert(!r.contains(r.finish()));
-    assert(r.contains(x) == (offset != size));
-
-    range::const_iterator p = r.find(x);
-    assert((p == r.end()) == (x == r.finish()));
-    assert(r.find(r.finish()) == r.end());
-
-    if (offset != size)
-    {
-        assert(x == r[offset]);
-        assert(x == r.at(offset));
-    }
-
-    bool caught_out_of_range = false;
-    try {
-        bool never_initialized = x == r.at(size);
-        (void)never_initialized;
-    }
-    catch(std::out_of_range&)
-    {
-        caught_out_of_range = true;
-    }
-    catch(...)
-    {
-    }
-    assert(caught_out_of_range);
-}
-
-// Those tests must be skipped for other ranges
-template <class T>
-void category_test_1(
-    const boost::half_open_range<T>&, std::forward_iterator_tag)
-{
-}
-
-unsigned indices[][2] = { {0,0},{0,1},{0,2},{0,3},
-                                {1,1},{1,2},{1,3},
-                                      {2,2},{2,3},
-                                            {3,3}};
-
-template <class Range>
-void category_test_2(
-    const std::vector<Range>& ranges, unsigned i, unsigned j, std::random_access_iterator_tag)
-{
-    typedef Range range;
-    const range& ri = ranges[i];
-    const range& rj = ranges[j];
-
-    if (indices[i][0] <= indices[j][0] && indices[i][1] >= indices[j][1])
-        assert(ri.contains(rj));
-
-    if (ri.contains(rj))
-        assert((ri & rj) == rj);
-    assert(boost::intersects(ri, rj) == !(ri & rj).empty());
-
-    range t1(ri);
-    t1 &= rj;
-    assert(t1 == range(indices[i][0] > indices[j][0] ? ri.start() : rj.start(),
-                       indices[i][1] < indices[j][1] ? ri.finish() : rj.finish()));
-    assert(t1 == (ri & rj));
-    
-    range t2(ri);
-    t2 |= rj;
-    
-    if (ri.empty())
-        assert(t2 == rj);
-    else if (rj.empty())
-        assert(t2 == ri);
-    else
-        assert(t2 == range(indices[i][0] < indices[j][0] ? ri.start() : rj.start(),
-                           indices[i][1] > indices[j][1] ? ri.finish() : rj.finish()));
-    assert(t2 == (ri | rj));
-    if (i == j)
-        assert(ri == rj);
-    
-    if (ri.empty() || rj.empty())
-        assert((ri == rj) == (ri.empty() && rj.empty()));
-    else
-        assert((ri == rj) == (ri.start() == rj.start() && ri.finish() == rj.finish()));
-
-    assert((ri == rj) == !(ri != rj));
-
-    bool same = ri == rj;
-    bool one_empty = ri.empty() != rj.empty();
-
-    std::less<range> less;
-    std::less_equal<range> less_equal;
-    std::greater<range> greater;
-    std::greater_equal<range> greater_equal;
-    
-    if (same)
-    {
-        assert(greater_equal(ri,rj));
-        assert(less_equal(ri,rj));
-        assert(!greater(ri,rj));
-        assert(!less(ri,rj));
-    }
-    else if (one_empty)
-    {
-        const range& empty = ri.empty() ? ri : rj;
-        const range& non_empty = rj.empty() ? ri : rj;
-        
-        assert(less(empty,non_empty));
-        assert(less_equal(empty,non_empty));
-        assert(!greater(empty,non_empty));
-        assert(!greater_equal(empty,non_empty));
-        assert(!less(non_empty,empty));
-        assert(!less_equal(non_empty,empty));
-        assert(greater(non_empty,empty));
-        assert(greater_equal(non_empty,empty));
-    }
-    else {
-        if (indices[i][0] < indices[j][0] ||
-            indices[i][0] == indices[j][0] && indices[i][1] < indices[j][1])
-        {
-            assert(!greater_equal(ri,rj));
-            assert(less(ri,rj));
-        }
-
-        if (indices[i][0] < indices[j][0] ||
-            indices[i][0] == indices[j][0] && indices[i][1] <= indices[j][1])
-        {
-            assert(!greater(ri,rj));
-            assert(less_equal(ri,rj));
-        }
-
-        if (indices[i][0] > indices[j][0] ||
-            indices[i][0] == indices[j][0] && indices[i][1] > indices[j][1])
-        {
-            assert(!less_equal(ri,rj));
-            assert(greater(ri,rj));
-        }
-
-        if (indices[i][0] > indices[j][0] ||
-            indices[i][0] == indices[j][0] && indices[i][1] >= indices[j][1])
-        {
-            assert(!less(ri,rj));
-            assert(greater_equal(ri,rj));
-        }
-    }
-}
-
-
-template <class Range>
-void category_test_2(
-    const std::vector<Range>&, unsigned, unsigned, std::forward_iterator_tag)
-{
-}
-
-template <class T>
-void category_test_2(
-    const std::vector<boost::half_open_range<T> >&, unsigned, unsigned, std::bidirectional_iterator_tag)
-{
-}
-
-template <class Range>
-void test_back(Range& x, std::bidirectional_iterator_tag)
-{
-    assert(x.back() == boost::prior(x.finish()));
-}
-
-template <class Range>
-void test_back(Range& x, std::forward_iterator_tag)
-{
-}
-
-template <class T>
-boost::half_open_range<T> range_identity(const boost::half_open_range<T>& x)
-{
-    return x;
-}
-
-template <class T>
-void test(T x0, T x1, T x2, T x3)
-{
-    std::vector<boost::half_open_range<T> > ranges;
-    typedef boost::half_open_range<T> range;
-
-    T bounds[4] = { x0, x1, x2, x3 };
-
-    const std::size_t num_ranges = sizeof(indices)/sizeof(*indices);
-    // test construction
-    for (std::size_t n = 0; n < num_ranges;++n)
-    {
-        T start = bounds[indices[n][0]];
-        T finish = bounds[indices[n][1]];
-        boost::half_open_range<T> r(start, finish);
-        ranges.push_back(r);
-    }
-    
-    // test implicit conversion from std::pair<T,T>
-    range converted = std::pair<T,T>(x0,x0);
-    (void)converted;
-
-    // test assignment, equality and inequality
-    range r00 = range(x0, x0);
-    assert(r00 == range(x0,x0));
-    assert(r00 == range(x1,x1)); // empty ranges are all equal
-    if (x3 != x0)
-        assert(r00 != range(x0, x3));
-    r00 = range(x0, x3);
-    assert(r00 == range(x0, x3));
-    if (x3 != x0)
-        assert(r00 != range(x0, x0));
-
-    typedef typename range::iterator iterator;
-    typedef typename iterator::iterator_category category;
-    
-    for (unsigned i = 0; i < num_ranges; ++i)
-    {
-        const range& r = ranges[i];
-            
-        // test begin(), end(), basic iteration.
-        unsigned count = 0;
-        for (range::const_iterator p = r.begin(), finish = r.end();
-             p != finish;
-             ++p, ++count)
-        {
-            assert(count < 2100);
-        }
-
-        // test size(), empty(), front(), back()
-        assert((unsigned)r.size() == count);
-        if (indices[i][0] == indices[i][1])
-            assert(r.empty());
-        if (r.empty())
-            assert(r.size() == 0);
-        if (!r.empty())
-        {
-            assert(r.front() == r.start());
-            test_back(r, category());
-        }
-
-            // test swap
-        range r1(r);
-        range r2(x0,x3);
-        const bool same = r1 == r2;
-        r1.swap(r2);
-        assert(r1 == range(x0,x3));
-        assert(r2 == r);
-        if (!same) {
-            assert(r1 != r);
-            assert(r2 != range(x0,x3));
-        }
-
-        // do individual tests for random-access iterators
-        category_test_1(r, category());
-    }
-
-    for (unsigned j = 0; j < num_ranges; ++j) {
-        for (unsigned k = 0; k < num_ranges; ++k) {
-            category_test_2(ranges, j, k, category());
-        }
-    }
-    
-}
-
-template <class Integer>
-void test_integer(Integer* = 0) // default arg works around MSVC bug
-{
-    Integer a = 0;
-    Integer b = a + unsigned_random(128 - a);
-    Integer c = b + unsigned_random(128 - b);
-    Integer d = c + unsigned_random(128 - c);
-
-    test(a, b, c, d);
-}
-
-template <class Container>
-void test_container(Container* = 0)  // default arg works around MSVC bug
-{
-    Container c(unsigned_random(1673));
-
-    const typename Container::size_type offset1 = unsigned_random(c.size());
-    const typename Container::size_type offset2 = unsigned_random(c.size() - offset1);
-    typename Container::iterator internal1 = c.begin();
-    std::advance(internal1, offset1);
-    typename Container::iterator internal2 = internal1;
-    std::advance(internal2, offset2);
-    
-    test(c.begin(), internal1, internal2, c.end());
-
-    typedef typename Container::const_iterator const_iterator;
-    test(const_iterator(c.begin()),
-         const_iterator(internal1),
-         const_iterator(internal2),
-         const_iterator(c.end()));
-}
-
-int main()
-{
-    // Test the built-in integer types.
-    test_integer<char>();
-    test_integer<unsigned char>();
-    test_integer<signed char>();
-    test_integer<wchar_t>();
-    test_integer<short>();
-    test_integer<unsigned short>();
-    test_integer<int>();
-    test_integer<unsigned int>();
-    test_integer<long>();
-    test_integer<unsigned long>();
-#if defined(BOOST_HAS_LONG_LONG)
-    test_integer<long long>();
-    test_integer<unsigned long long>();
-#endif
-    // Some tests on container iterators, to prove we handle a few different categories
-    test_container<std::vector<int> >();
-    test_container<std::list<int> >();
-#ifndef BOOST_NO_SLIST
-    test_container<BOOST_STD_EXTENSION_NAMESPACE::slist<int> >();
-#endif
-    // Also prove that we can handle raw pointers.
-    int array[2000];
-    const std::size_t a = 0;
-    const std::size_t b = a + unsigned_random(2000 - a);
-    const std::size_t c = b + unsigned_random(2000 - b);
-    test(array, array+b, array+c, array+2000);
-    return 0;
-}
--- a/in_place_factories.html
+++ b/in_place_factories.html
@ -0,0 +1,296 @@
+<!DOCTYPE HTML PUBLIC "-//SoftQuad Software//DTD HoTMetaL PRO 5.0::19981217::extensions to HTML 4.0//EN" "hmpro5.dtd">
+
+<HTML>
+
+<HEAD>
+<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">
+<H2 align="left"><IMG SRC="../../boost.png" WIDTH="276" HEIGHT="86"></H2>
+
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <blockquote>
+        <blockquote>
+          <blockquote>
+<H2 align="left">Header &lt;<A
+HREF="../../boost/utility/in_place_factory.hpp">boost/utility/in_place_factory.hpp</A>&gt; </H2>
+
+<H2 align="left">Header &lt;<A
+HREF="../../boost/utility/typed_in_place_factory.hpp">boost/utility/typed_in_place_factory.hpp</A>&gt; </H2>
+
+          </blockquote>
+        </blockquote>
+      </blockquote>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>&nbsp;</p>
+
+<H2>Contents</H2>
+<DL CLASS="page-index">
+  <DT><A HREF="#mot">Motivation</A></DT>
+  <DT><A HREF="#framework">Framework</A></DT>
+  <DT><A HREF="#specification">Specification</A></DT>
+  <DT><A HREF="#container-usage">Container-side Usage</A></DT>
+  <DT><A HREF="#user-usage">User-side Usage</A></DT>
+</DL>
+
+<HR>
+
+<H2><A NAME="mot"></A>Motivation</H2>
+
+<p>Suppose we have a class</p>
+<pre>struct X
+{
+  X ( int, std:::string ) ;
+} ;</pre>
+<p>And a container for it which supports an empty state (that is, which can contain zero objects):</p>
+<pre>struct C
+{
+   C() : contained_(0) {}
+  ~C() { delete contained_ ; }
+  X* contained_ ;
+} ;</pre>
+<p>A container designed to support an empty state typically doesn't require the contained type to be DefaultConstructible,
+but it typically requires it to be CopyConstructible as a mechanism to
+initialize the object to store:</p>
+<pre>struct C
+{
+   C() : contained_(0) {}
+   C ( X const& v ) : contained_ ( new X(v) ) {}
+  ~C() { delete contained_ ; }
+  X* contained_ ;
+} ;</pre>
+<p>There is a subtle problem with this: since the mechanism used to initialize the stored object is copy construction,
+there must exist a previously constructed source object to copy from. This
+object is likely to be temporary and serve no purpose besides being the source</p>
+<pre>void foo()
+{
+  // Temporary object created.
+  C c( X(123,"hello") ) ;
+}
+</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 scheme, the user supplies the arguments for the X constructor
+directly to the container:</p>
+<pre>struct C
+{
+   C() : contained_(0) {}
+   C ( X const& v ) : contained_ ( new X(v) ) {}
+   C ( int a0, std::string a1 ) : contained_ ( new X(a0,a1) ) {}
+  ~C() { delete contained_ ; }
+  X* contained_ ;
+} ;</pre>
+<pre>void foo()
+{
+  // Wrapped object constructed in-place
+  // No temporary created.
+  C c(123,"hello") ;
+}
+</pre>
+<p>Clearly, this solution doesn't scale well since the container must duplicate all the constructor overloads from the contained type
+(at least all those which are to be supported directly in 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
+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
+a fully-constructed object (as this would defeat the purpose of in-place construction)
+</p>
+<p>For this purpose, the framework provides two families of classes collectively called: InPlaceFactories and TypedInPlaceFactories.<br>
+Essentially, these classes hold a sequence of actual parameters and a method to contruct an object in place using these parameters.
+Each member of the family differs only in the number (and type) of the parameter list. The first family
+takes the type of the object to construct directly in method provided for that
+purpose, whereas the second family incorporates that type in the factory class
+itself..</p>
+<p>From the container POV, using the framework amounts to calling the factory's method to contruct the object in place.
+From the user POV, it amounts to creating the right factory object to hold the parameters and pass it to the container.<br>
+The following simplified example shows the basic idea. A complete example follows the formal specification of the framework:</p>
+<pre>struct C
+{
+   template&lt;class InPlaceFactory&gt;
+   C ( InPlaceFactory const& aFactoty )
+    :
+    contained_ ( uninitialized_storage() )
+   {
+     aFactory.template apply&lt;X&gt;(contained_);
+   }
+
+  ~C() 
+  { 
+    contained_ -> X::~X();
+    delete[] contained_ ; 
+  }
+
+  char* uninitialized_storage() { return new char[sizeof(X)] ; }
+
+  char* contained_ ;
+} ;
+
+void foo()
+{
+  C c( in_place(123,"hello") ) ;
+}
+</pre>
+
+<HR>
+
+<H2><A NAME="specification">Specification</A></H2>
+
+<p>The following is the first member of the family of 'in_place_factory' classes, along with its corresponding helper template function.
+The rest of the family varies only in the number and type of template (and constructor) parameters.</p>
+<PRE>namespace boost {
+
+struct in_place_factory_base {} ;
+
+template&lt;class A0&gt;
+class in_place_factory : public in_place_factory_base
+{
+  public:</PRE>
+
+<PRE>    in_place_factory ( A0 const& a0 ) : m_a0(a0) {}
+
+    template&lt; class T &gt;
+    void apply ( void* address ) const
+    {
+      new (address) T(m_a0);
+    }
+
+  private:</PRE>
+
+<PRE>    A0 const& m_a0 ;
+} ;
+
+template&lt;class A0&gt;
+in_place_factory&lt;A0&gt; in_place ( A0 const& a0 )
+{
+  return in_place_factory&lt;A0&gt;(a0);
+}
+</PRE>
+
+<p>Similarly, the following is the first member of the family of 'typed_in_place_factory' classes, along with its corresponding
+helper template function. The rest of the family varies only in the number and type of template (and constructor) parameters.</p>
+<PRE>namespace boost {
+
+struct typed_in_place_factory_base {} ;
+
+template&lt;class T, class A0&gt;
+class typed_in_place_factory : public typed_in_place_factory_base
+{
+  public:</PRE>
+
+<PRE>    typed_in_place_factory ( A0 const& a0 ) : m_a0(a0) {}
+
+    void apply ( void* address ) const
+    {
+      new (address) T(m_a0);
+    }
+
+  private:</PRE>
+
+<PRE>    A0 const& m_a0 ;
+} ;
+
+template&lt;class T, class A0&gt;
+typed_in_place_factory&lt;A0&gt; in_place ( A0 const& a0 )
+{
+  return typed_in_place_factory&lt;T,A0&gt;(a0);
+}</PRE>
+
+<PRE>}
+</PRE>
+
+<p>As you can see, the 'in_place_factory' and 'typed_in_place_factory' template classes varies only in the way they specify
+the target type: in the first family, the type is given as a template argument to the apply member function while in the
+second it is given directly as part of the factory class.<br>
+When the container holds a unique non-polymorphic type (such as the case of Boost.Optional), it knows the exact dynamic-type
+of the contained object and can pass it to the apply() method of a (non-typed) factory.
+In this case, end users can use an 'in_place_factory' instance which can be constructed without the type of the object to construct.<br>
+However, if the container holds heterogeneous or polymorphic objects (such as the case of Boost.Variant), the dynamic-type
+of the object to be constructed must be known by the factory itslef. In this case, end users must use a 'typed_in_place_factory'
+instead.</p>
+
+<HR>
+
+<h2><A NAME="container-usage">Container-side Usage</a></h2>
+
+<p>As shown in the introductory simplified example, the container class must
+contain methods that accept an instance of
+these factories and pass the object's storage to the factory's apply method.<br>
+However, the type of the factory class cannot be completly specified in the container class because that would
+defeat the whole purpose of the factories which is to allow the container to accept a variadic argument list
+for the constructor of its contained object.<br>
+The correct function overload must be based on the only distinctive and common
+characteristic of all the classes in each family, the base class.<br>
+Depending on the container class, you can use 'enable_if' to generate the right overload, or use the following
+dispatch technique (used in the Boost.Optional class):
+</p>
+<pre>struct C
+{
+   C() : contained_(0) {}
+   C ( X const& v ) : contained_ ( new X(v) ) {}
+
+   template&lt;class Expr&gt
+   C ( Expr const& expr )
+    :
+    contained_ ( uninitialized_storage() )
+   {
+    construct(expr,&expr)
+   }
+
+  ~C() { delete contained_ ; }
+
+  template&lt;class InPlaceFactory&gt;
+  void construct ( InPlaceFactory const& aFactory, boost::in_place_factory_base* )
+  {
+    aFactory.template apply&lt;X&gt;(contained_);
+  }
+
+  template&lt;class TypedInPlaceFactory&gt;
+  void construct ( TypedInPlaceFactory const& aFactory, boost::typed_in_place_factory_base* )
+  {
+    aFactory.apply(contained_);
+  }
+
+  X* uninitialized_storage() { return static_cast&lt;X*&gt;(new char[sizeof(X)]) ; }
+
+  X* contained_ ;
+} ;
+</pre>
+
+<hr>
+
+<h2><A NAME="user-usage">User-side Usage</a></h2>
+
+<p>End users pass to the container an instance of a factory object holding the actual parameters needed to construct the
+contained object directly within the container. For this, the helper template function 'in_place' is used.<br>
+The call 'in_place(a0,a1,a2,...,an)' constructs a (non-typed) 'in_place_factory' instance with the given argument list.<br>
+The call 'in_place&lt;T&gt;(a0,a1,a2,...,an)' constructs a 'typed_in_place_factory' instance with the given argument list for the
+type 'T'.</p>
+<pre>void foo()
+{
+  C a( in_place(123,"hello") ) ;    // in_place_factory passed
+  C b( in_place&lt;X&gt;(456,"world") ) ; // typed_in_place_factory passed
+}
+</pre>
+
+<P>Revised September 17, 2004</P>
+<p><EFBFBD> Copyright Fernando Luis Cacciola Carballal, 2004</p>
+<p> 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 copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
+www.boost.org/LICENSE_1_0.txt</a>)</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
+<A HREF="http://www.boost.org/more/mailing_lists.htm#main">discussion lists</A></P>
+</BODY>
+</HTML>
--- a/include/boost/assert.hpp
+++ b/include/boost/assert.hpp
@ -2,11 +2,11 @@
 //  boost/assert.hpp - BOOST_ASSERT(expr)
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2007 Peter Dimov
 //
-//  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.
+// 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)
 //
 //  Note: There are no include guards. This is intentional.
 //
@ -33,6 +33,18 @@ void assertion_failed(char const * expr, char const * function, char const * fil
 #define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))

 #else
-# include <assert.h>
+# include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
 # define BOOST_ASSERT(expr) assert(expr)
 #endif
+
+#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/checked_delete.hpp
+++ b/include/boost/checked_delete.hpp
@ -10,15 +10,13 @@
 //
 //  boost/checked_delete.hpp
 //
-//  Copyright (c) 1999, 2000, 2001, 2002 boost.org
 //  Copyright (c) 2002, 2003 Peter Dimov
 //  Copyright (c) 2003 Daniel Frey
 //  Copyright (c) 2003 Howard Hinnant
 //
-//  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.
+//  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)
 //
 //  See http://www.boost.org/libs/utility/checked_delete.html for documentation.
 //
--- a/include/boost/current_function.hpp
+++ b/include/boost/current_function.hpp
@ -12,10 +12,9 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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.
+// 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)
 //
 //  http://www.boost.org/libs/utility/current_function.html
 //
@ -33,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
@ -25,6 +25,7 @@

 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/type_traits/is_pointer.hpp>
+#include <boost/detail/workaround.hpp>

 namespace boost{

@ -57,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;
 };

 }
@ -75,7 +76,7 @@ public:
   // however compiler bugs prevent this - instead pass three bool's to
   // ct_imp<T,bool,bool,bool> and add an extra partial specialisation
   // of ct_imp to handle the logic. (JM)
-   typedef typename detail::ct_imp<
+   typedef typename boost::detail::ct_imp<
      T,
      ::boost::is_pointer<T>::value,
      ::boost::is_arithmetic<T>::value
@ -91,7 +92,7 @@ struct call_traits<T&>
   typedef T& param_type;  // hh removed const
 };

-#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x560)
+#if BOOST_WORKAROUND( __BORLANDC__,  BOOST_TESTED_AT( 0x581 ) )
 // 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
@ -120,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 T1
+      : 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 T2
+      : 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 T1,
-        private T2
+      : 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 T1
+      : protected ::boost::remove_cv<T1>::type
   {
   public:
      typedef T1                                                 first_type;
@ -428,7 +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,13 @@
+//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
+
+#include <boost/exception/info_tuple.hpp>
+#include <boost/exception_ptr.hpp>
+#include <boost/throw_exception.hpp>
+
+#endif
--- a/include/boost/generator_iterator.hpp
+++ b/include/boost/generator_iterator.hpp
@ -1,8 +1,7 @@
-// (C) Copyright Jens Maurer 2001. 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.
+// (C) Copyright Jens Maurer 2001.
+// 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)
 //
 // Revision History:

--- a/include/boost/next_prior.hpp
+++ b/include/boost/next_prior.hpp
@ -1,10 +1,8 @@
 //  Boost next_prior.hpp header file  ---------------------------------------//

-//  (C) Copyright Boost.org 1999-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.
+//  (C) Copyright Dave Abrahams and Daniel Walker 1999-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)

 //  See http://www.boost.org/libs/utility for documentation.

--- a/include/boost/noncopyable.hpp
+++ b/include/boost/noncopyable.hpp
@ -1,10 +1,8 @@
 //  Boost noncopyable.hpp header file  --------------------------------------//

-//  (C) Copyright Boost.org 1999-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.
+//  (C) Copyright Beman Dawes 1999-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)

 //  See http://www.boost.org/libs/utility for documentation.

@ -18,15 +16,20 @@ namespace boost {

 //  Contributed by Dave Abrahams

-class noncopyable
+namespace noncopyable_  // protection from unintended ADL
 {
- protected:
-    noncopyable() {}
-    ~noncopyable() {}
- private:  // emphasize the following members are private
-    noncopyable( const noncopyable& );
-    const noncopyable& operator=( const noncopyable& );
-};
+  class noncopyable
+  {
+   protected:
+      noncopyable() {}
+      ~noncopyable() {}
+   private:  // emphasize the following members are private
+      noncopyable( const noncopyable& );
+      const noncopyable& operator=( const noncopyable& );
+  };
+}
+
+typedef noncopyable_::noncopyable noncopyable;

 } // namespace boost

--- a/include/boost/operators.hpp
+++ b/include/boost/operators.hpp
@ -1,14 +1,17 @@
 //  Boost operators.hpp header file  ----------------------------------------//

-//  (C) Copyright David Abrahams, Jeremy Siek, and Daryle Walker 1999-2001.
-//  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.
+//  (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-2001.
+//  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)

 //  See http://www.boost.org/libs/utility/operators.htm for documentation.

 //  Revision History
+//  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)
@ -91,15 +94,15 @@
 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

@ -120,37 +123,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".
@ -166,7 +169,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 )                          \
@ -175,33 +178,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)
@ -211,35 +214,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; } \
@ -262,7 +265,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)
@ -275,7 +278,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)
@ -290,7 +293,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
@ -299,7 +302,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
@ -314,14 +317,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 )                          \
@ -331,13 +334,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; }       \
@ -350,209 +353,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
@ -561,43 +564,43 @@ 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 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
@ -607,7 +610,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
@ -651,20 +654,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
@ -675,7 +678,7 @@ struct random_access_iteratable
 // Here's where we put it all together, defining the xxxx forms of the templates
 // in namespace boost. We also define specializations of is_chained_base<> for
 // the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
-// neccessary.
+// necessary.
 //
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

@ -700,7 +703,7 @@ template<class T> struct is_chained_base {

 } // namespace boost

-// Import a 4-type-argument operator template into boost (if neccessary) and
+// Import a 4-type-argument operator template into boost (if necessary) and
 // provide a specialization of 'is_chained_base<>' for it.
 # define BOOST_OPERATOR_TEMPLATE4(template_name4)                     \
  BOOST_IMPORT_TEMPLATE4(template_name4)                              \
@ -709,7 +712,7 @@ template<class T> struct is_chained_base {
    typedef ::boost::detail::true_t value;                            \
  };

-// Import a 3-type-argument operator template into boost (if neccessary) and
+// Import a 3-type-argument operator template into boost (if necessary) and
 // provide a specialization of 'is_chained_base<>' for it.
 # define BOOST_OPERATOR_TEMPLATE3(template_name3)                     \
  BOOST_IMPORT_TEMPLATE3(template_name3)                              \
@ -718,7 +721,7 @@ template<class T> struct is_chained_base {
    typedef ::boost::detail::true_t value;                            \
  };

-// Import a 2-type-argument operator template into boost (if neccessary) and
+// Import a 2-type-argument operator template into boost (if necessary) and
 // provide a specialization of 'is_chained_base<>' for it.
 # define BOOST_OPERATOR_TEMPLATE2(template_name2)                  \
  BOOST_IMPORT_TEMPLATE2(template_name2)                           \
@ -727,7 +730,7 @@ template<class T> struct is_chained_base {
    typedef ::boost::detail::true_t value;                         \
  };

-// Import a 1-type-argument operator template into boost (if neccessary) and
+// Import a 1-type-argument operator template into boost (if necessary) and
 // provide a specialization of 'is_chained_base<>' for it.
 # define BOOST_OPERATOR_TEMPLATE1(template_name1)                  \
  BOOST_IMPORT_TEMPLATE1(template_name1)                           \
@ -753,7 +756,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> {};               \
@ -789,7 +792,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
--- a/include/boost/ref.hpp
+++ b/include/boost/ref.hpp
@ -10,6 +10,7 @@
 #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
@ -18,10 +19,9 @@
 //  Copyright (C) 2001, 2002 Peter Dimov
 //  Copyright (C) 2002 David Abrahams
 //
-//  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.
+// 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)
 //
 //  See http://www.boost.org/libs/bind/ref.html for documentation.
 //
@ -34,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) {}

@ -55,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
@ -74,18 +74,13 @@ template<class T> inline reference_wrapper<T const> BOOST_REF_CONST cref(T const
 # undef BOOST_REF_CONST

 # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
 template<typename T>
 class is_reference_wrapper
    : public mpl::false_
 {
 };

-template<typename T>
-class is_reference_wrapper<reference_wrapper<T> >
-    : public mpl::true_
-{
-};
-
 template<typename T>
 class unwrap_reference
 {
@ -93,12 +88,30 @@ class unwrap_reference
    typedef T type;
 };

-template<typename T>
-class unwrap_reference<reference_wrapper<T> >
-{
- public:
-    typedef T type;
-};
+#  define AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(X) \
+template<typename T> \
+class is_reference_wrapper< X > \
+    : public mpl::true_ \
+{ \
+}; \
+\
+template<typename T> \
+class unwrap_reference< X > \
+{ \
+ public: \
+    typedef T type; \
+}; \
+/**/
+
+AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T>)
+#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
+AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const)
+AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> volatile)
+AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const volatile)
+#endif
+
+#  undef AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF
+
 # else // no partial specialization

 } // namespace boost
--- a/include/boost/utility.hpp
+++ b/include/boost/utility.hpp
@ -1,6 +1,6 @@
 //  Boost utility.hpp header file  -------------------------------------------//

-//  Copyright 1999-2003 Boost.org.  Use, modification, and distribution are
+//  Copyright 1999-2003 Aleksey Gurtovoy.  Use, modification, and distribution are
 //  subject to the Boost Software License, Version 1.0.  (See accompanying file
 //  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)

@ -11,6 +11,7 @@

 #include <boost/utility/addressof.hpp>
 #include <boost/utility/base_from_member.hpp>  
+#include <boost/utility/enable_if.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/next_prior.hpp>
 #include <boost/noncopyable.hpp>
--- a/include/boost/utility/addressof.hpp
+++ b/include/boost/utility/addressof.hpp
@ -1,15 +1,11 @@
 // Copyright (C) 2002 Brad King (brad.king@kitware.com) 
-//                    Doug Gregor (gregod@cs.rpi.edu)
-//                    Peter Dimov
+//                    Douglas Gregor (gregod@cs.rpi.edu)
 //
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
+// Copyright (C) 2002, 2008 Peter Dimov
 //
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+// 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

@ -18,26 +14,50 @@

 # include <boost/config.hpp>
 # include <boost/detail/workaround.hpp>
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-#  include <boost/type_traits/add_pointer.hpp>
-# endif

-namespace boost {
-
-// Do not make addressof() inline. Breaks MSVC 7. (Peter Dimov)
-
-// VC7 strips const from nested classes unless we add indirection here
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-template <typename T> typename add_pointer<T>::type
-# else
-template <typename T> T*
-# endif
-addressof(T& v)
+namespace boost
 {
-  return reinterpret_cast<T*>(
-       &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+
+namespace detail
+{
+
+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 )
+{
+    return boost::detail::addressof_impl<T>::f( v, 0 );
 }

+// 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))
+template<typename T,std::size_t N>
+T (*addressof(T (&t)[N]))[N]
+{
+   return reinterpret_cast<T(*)[N]>(&t);
 }

+template<typename T,std::size_t N>
+const T (*addressof(const T (&t)[N]))[N]
+{
+   return reinterpret_cast<const T(*)[N]>(&t);
+}
+# endif
+
+} // namespace boost
+
 #endif // BOOST_UTILITY_ADDRESSOF_HPP
--- a/include/boost/utility/base_from_member.hpp
+++ b/include/boost/utility/base_from_member.hpp
@ -1,15 +1,53 @@
 //  boost utility/base_from_member.hpp header file  --------------------------//

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

 //  See <http://www.boost.org/libs/utility/> for the library's home page.

 #ifndef BOOST_UTILITY_BASE_FROM_MEMBER_HPP
 #define BOOST_UTILITY_BASE_FROM_MEMBER_HPP

-#include <boost/utility_fwd.hpp>  // required for parameter defaults
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+
+
+//  Base-from-member arity configuration macro  ------------------------------//
+
+// The following macro determines how many arguments will be in the largest
+// constructor template of base_from_member.  Constructor templates will be
+// generated from one argument to this maximum.  Code from other files can read
+// this number if they need to always match the exact maximum base_from_member
+// uses.  The maximum constructor length can be changed by overriding the
+// #defined constant.  Make sure to apply the override, if any, for all source
+// files during project compiling for consistency.
+
+// Contributed by Jonathan Turkanis
+
+#ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY
+#define BOOST_BASE_FROM_MEMBER_MAX_ARITY  10
+#endif
+
+
+//  An iteration of a constructor template for base_from_member  -------------//
+
+// A macro that should expand to:
+//     template < typename T1, ..., typename Tn >
+//     base_from_member( T1 x1, ..., Tn xn )
+//         : member( x1, ..., xn )
+//         {}
+// This macro should only persist within this file.
+
+#define BOOST_PRIVATE_CTR_DEF( z, n, data )                            \
+    template < BOOST_PP_ENUM_PARAMS(n, typename T) >                   \
+    explicit base_from_member( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) )  \
+        : member( BOOST_PP_ENUM_PARAMS(n, x) )                         \
+        {}                                                             \
+    /**/


 namespace boost
@ -24,7 +62,7 @@ namespace boost

 // Contributed by Daryle Walker

-template < typename MemberType, int UniqueID >
+template < typename MemberType, int UniqueID = 0 >
 class base_from_member
 {
 protected:
@ -34,66 +72,16 @@ protected:
        : member()
        {}

-    template< typename T1 >
-    explicit base_from_member( T1 x1 )
-        : member( x1 )
-        {}
-
-    template< typename T1, typename T2 >
-    base_from_member( T1 x1, T2 x2 )
-        : member( x1, x2 )
-        {}
-
-    template< typename T1, typename T2, typename T3 >
-    base_from_member( T1 x1, T2 x2, T3 x3 )
-        : member( x1, x2, x3 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4 )
-        : member( x1, x2, x3, x4 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4, typename T5 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5 )
-        : member( x1, x2, x3, x4, x5 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4, typename T5,
-     typename T6 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6 )
-        : member( x1, x2, x3, x4, x5, x6 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4, typename T5,
-     typename T6, typename T7 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7 )
-        : member( x1, x2, x3, x4, x5, x6, x7 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4, typename T5,
-     typename T6, typename T7, typename T8 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8 )
-        : member( x1, x2, x3, x4, x5, x6, x7, x8 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4, typename T5,
-     typename T6, typename T7, typename T8, typename T9 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8,
-     T9 x9 )
-        : member( x1, x2, x3, x4, x5, x6, x7, x8, x9 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4, typename T5,
-     typename T6, typename T7, typename T8, typename T9, typename T10 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8,
-     T9 x9, T10 x10 )
-        : member( x1, x2, x3, x4, x5, x6, x7, x8, x9, x10 ) 
-        {}
+    BOOST_PP_REPEAT_FROM_TO( 1, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
+     BOOST_PRIVATE_CTR_DEF, _ )

 };  // boost::base_from_member

 }  // namespace boost


+// Undo any private macros
+#undef BOOST_PRIVATE_CTR_DEF
+
+
 #endif  // BOOST_UTILITY_BASE_FROM_MEMBER_HPP
--- a/include/boost/utility/detail/in_place_factory_prefix.hpp
+++ b/include/boost/utility/detail/in_place_factory_prefix.hpp
@ -0,0 +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.
+//
+// You are welcome to contact the author at:
+//  fernando_cacciola@hotmail.com
+//
+#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/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_MAX_INPLACE_FACTORY_ARITY 10
+
+#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
@ -0,0 +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.
+//
+// You are welcome to contact the author at:
+//  fernando_cacciola@hotmail.com
+//
+#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_MAX_INPLACE_FACTORY_ARITY
+
+#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
@ -0,0 +1,131 @@
+// Boost result_of library
+
+//  Copyright Douglas Gregor 2004. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org/libs/utility
+#if !defined(BOOST_PP_IS_ITERATING)
+# error Boost result_of - do not include this file!
+#endif
+
+#if defined(BOOST_HAS_DECLTYPE)
+
+// As of N2588, C++0x result_of only supports function call
+// expressions of the form f(x). This precludes support for member
+// function pointers, which are invoked with expressions of the form
+// o->*f(x). This implementation supports both.
+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::result_of_impl<
+              F, F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
+          >
+        , detail::result_of_decltype_impl<
+              F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))
+          >
+      >::type
+{};
+
+namespace detail {
+
+# define BOOST_RESULT_OF_STATIC_MEMBERS(z, n, _) \
+     static T ## n t ## n; \
+  /**/
+
+template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+class result_of_decltype_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
+{
+  static F f;
+  BOOST_PP_REPEAT(BOOST_PP_ITERATION(), BOOST_RESULT_OF_STATIC_MEMBERS, _)
+public:
+  typedef decltype(f(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),t))) type;
+};
+
+} // namespace detail 
+
+#else // defined(BOOST_HAS_DECLTYPE)
+
+// CWPro8 requires an argument in a function type specialization
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3002)) && BOOST_PP_ITERATION() == 0
+# define BOOST_RESULT_OF_ARGS void
+#else
+# define BOOST_RESULT_OF_ARGS BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)
+#endif
+
+#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)>
+    : boost::detail::result_of_impl<F, F(BOOST_RESULT_OF_ARGS), (boost::detail::has_result_type<F>::value)> {};
+#endif
+
+#undef BOOST_RESULT_OF_ARGS
+
+#endif // defined(BOOST_HAS_DECLTYPE)
+
+#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_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_impl<R (&)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
+{
+  typedef R type;
+};
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
+         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
+struct result_of_impl<R (T0::*)
+                     (BOOST_PP_ENUM_SHIFTED_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_impl<R (T0::*)
+                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
+                     const,
+                 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_impl<R (T0::*)
+                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
+                     volatile,
+                 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_impl<R (T0::*)
+                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
+                     const volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+#endif
+
+}
+#endif
--- a/include/boost/utility/enable_if.hpp
+++ b/include/boost/utility/enable_if.hpp
@ -1,6 +1,6 @@
 // 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
--- a/include/boost/utility/in_place_factory.hpp
+++ b/include/boost/utility/in_place_factory.hpp
@ -0,0 +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.
+//
+// You are welcome to contact the author at:
+//  fernando_cacciola@hotmail.com
+//
+#ifndef BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
+#ifndef BOOST_PP_IS_ITERATING
+
+#include <boost/utility/detail/in_place_factory_prefix.hpp>
+
+namespace boost {
+
+class in_place_factory_base {} ;
+
+#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
@ -0,0 +1,93 @@
+// Boost result_of library
+
+//  Copyright Douglas Gregor 2004. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org/libs/utility
+#ifndef BOOST_RESULT_OF_HPP
+#define BOOST_RESULT_OF_HPP
+
+#include <boost/config.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_shifted_params.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>
+
+#ifndef BOOST_RESULT_OF_NUM_ARGS
+#  define BOOST_RESULT_OF_NUM_ARGS 10
+#endif
+
+namespace boost {
+
+template<typename F> struct 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 result_of_impl;
+template<typename F> struct result_of_decltype_impl;
+
+template<typename F>
+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;
+};
+
+template<typename F, typename FArgs>
+struct 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 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
+
+#define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,<boost/utility/detail/result_of_iterate.hpp>))
+#include BOOST_PP_ITERATE()
+
+#else
+#  define BOOST_NO_RESULT_OF 1
+#endif
+
+}
+
+#endif // BOOST_RESULT_OF_HPP
--- a/include/boost/utility/typed_in_place_factory.hpp
+++ b/include/boost/utility/typed_in_place_factory.hpp
@ -0,0 +1,77 @@
+// 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.
+//
+// You are welcome to contact the author at:
+//  fernando_cacciola@hotmail.com
+//
+#ifndef BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
+#ifndef BOOST_PP_IS_ITERATING
+
+#include <boost/utility/detail/in_place_factory_prefix.hpp>
+
+namespace boost {
+
+class typed_in_place_factory_base {} ;
+
+#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,69 +1,104 @@
-// (C) 2002, Fernando Luis Cacciola Carballal.
+// (C) Copyright 2002-2008, Fernando Luis Cacciola Carballal.
 //
-// This material is provided "as is", with absolutely no warranty expressed
-// or implied. Any use is at your own risk.
-//
-// Permission to use or copy this software for any purpose is hereby granted
-// without fee, provided the above notices are retained on all copies.
-// Permission to modify the code and to distribute modified code is granted,
-// provided the above notices are retained, and a notice that the code was
-// modified is included with the above copyright notice.
+// 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
 //
 #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/detail/workaround.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/cv_traits.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <cstring>
+#include <new>

 namespace boost {

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

-   const_T_base() : x() {}
+    mutable
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+      typename
+#endif 
+      aligned_storage<sizeof(wrapper), alignment_of<wrapper>::value>::type x;

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

-template<class T>
-struct non_const_T_base
-{
-  protected :
-
-   non_const_T_base() : 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() {}
+    value_initialized()
+    {
+      std::memset(&x, 0, sizeof(x));
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#if _MSC_VER >= 1310
+// When using MSVC 7.1 or higher, the following placement new expression may trigger warning C4345:
+// "behavior change: an object of POD type constructed with an initializer of the form ()
+// will be default-initialized".  It is safe to ignore this warning when using value_initialized.
+#pragma warning(disable: 4345)
+#endif
+#endif
+      new (wrapper_address()) wrapper();
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+    }

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

-    T& data() const { return this->x ; }
+    value_initialized & operator=(value_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;
+    }
+
+    ~value_initialized()
+    {
+      wrapper_address()->wrapper::~wrapper();
+    }
+
+    T& data() const
+    {
+      return wrapper_address()->data;
+    }
+
+    operator T&() const { return this->data(); }

 } ;

+
+
 template<class T>
 T const& get ( value_initialized<T> const& x )
 {
@ -75,8 +110,21 @@ T& get ( value_initialized<T>& x )
  return x.data() ;
 }

+
+class initialized_value_t
+{
+  public :
+    
+    template <class T> operator T() const
+    {
+      return get( value_initialized<T>() );
+    }
+};
+
+initialized_value_t const initialized_value = {} ;
+
+
 } // namespace boost


 #endif
-
--- a/include/boost/utility_fwd.hpp
+++ b/include/boost/utility_fwd.hpp
@ -1,33 +0,0 @@
-//  Boost utility_fwd.hpp header file  ---------------------------------------//
-
-//  Copyright 2001, 2003 Boost.org.  Use, modification, and distribution are
-//  subject to the Boost Software License, Version 1.0.  (See accompanying file
-//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-//  See <http://www.boost.org/libs/utility/> for the library's home page.
-
-#ifndef BOOST_UTILITY_FWD_HPP
-#define BOOST_UTILITY_FWD_HPP
-
-
-namespace boost
-{
-
-
-//  From <boost/utility/base_from_member.hpp>  -------------------------------//
-
-template < typename MemberType, int UniqueID = 0 >
-    class base_from_member;
-
-
-//  From <boost/noncopyable.hpp>  --------------------------------------------//
-
-class noncopyable;
-
-// Also has a few function templates
-
-
-}  // namespace boost
-
-
-#endif  // BOOST_UTILITY_FWD_HPP
--- a/index.html
+++ b/index.html
@ -7,7 +7,7 @@
 		<title>Boost Utility Library</title>
 	</head>
 	<body bgcolor="#FFFFFF">
-		<h1><IMG SRC="../../c++boost.gif" WIDTH="276" HEIGHT="86" align="center">Boost 
+		<h1><IMG SRC="../../boost.png" WIDTH="276" HEIGHT="86" align="center">Boost 
 			Utility Library</h1>
 		<p>The Boost Utility Library isn't really a single library at all. It is just a 
 			collection for components too small to be called libraries in their own right.</p>
@ -19,16 +19,23 @@
 				<a href="call_traits.htm">call_traits</a><br>
 				<a href="checked_delete.html">checked_delete</a><br>
 				<a href="compressed_pair.htm">compressed_pair</a><br>
+				<a href="current_function.html">current_function</a><br>
 				<a href="enable_if.html">enable_if</a><br>
-                <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
+            <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
+            <a href="generator_iterator.htm">generator iterator adaptors</a><br>
 				<a href="operators.htm">operators</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>
 		</blockquote>
 		<hr>
+		<p>© 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/indirect_iterator_example.cpp
+++ b/indirect_iterator_example.cpp
@ -1,59 +0,0 @@
-// (C) Copyright Jeremy Siek 2000. 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.
-
-#include <boost/config.hpp>
-#include <vector>
-#include <iostream>
-#include <iterator>
-#include <functional>
-#include <algorithm>
-#include <boost/iterator/indirect_iterator.hpp>
-
-int main(int, char*[])
-{
-  char characters[] = "abcdefg";
-  const int N = sizeof(characters)/sizeof(char) - 1; // -1 since characters has a null char
-  char* pointers_to_chars[N];                        // at the end.
-  for (int i = 0; i < N; ++i)
-    pointers_to_chars[i] = &characters[i];
-
-  // Example of using indirect_iterator_generator
-  
-  boost::indirect_iterator<char**, char>
-    indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);
-
-  std::copy(indirect_first, indirect_last, std::ostream_iterator<char>(std::cout, ","));
-  std::cout << std::endl;
-  
-
-  // Example of using indirect_iterator_pair_generator
-
-  char mutable_characters[N];
-  char* pointers_to_mutable_chars[N];
-  for (int j = 0; j < N; ++j)
-    pointers_to_mutable_chars[j] = &mutable_characters[j];
-
-  boost::indirect_iterator<char* const*> mutable_indirect_first(pointers_to_mutable_chars),
-    mutable_indirect_last(pointers_to_mutable_chars + N);
-  boost::indirect_iterator<char* const*, char const> const_indirect_first(pointers_to_chars),
-    const_indirect_last(pointers_to_chars + N);
-
-  std::transform(const_indirect_first, const_indirect_last,
-                 mutable_indirect_first, std::bind1st(std::plus<char>(), 1));
-
-  std::copy(mutable_indirect_first, mutable_indirect_last,
-            std::ostream_iterator<char>(std::cout, ","));
-  std::cout << std::endl;
-
-  
-  // Example of using make_indirect_iterator()
-
-  std::copy(boost::make_indirect_iterator(pointers_to_chars), 
-            boost::make_indirect_iterator(pointers_to_chars + N),
-            std::ostream_iterator<char>(std::cout, ","));
-  std::cout << std::endl;
-  
-  return 0;
-}
--- a/iterator_adaptor_examples.cpp
+++ b/iterator_adaptor_examples.cpp
@ -1,46 +0,0 @@
-// (C) Copyright Jeremy Siek 2000. 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.
-
-
-#include <functional>
-#include <algorithm>
-#include <iostream>
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/pending/integer_range.hpp>
-
-int
-main(int, char*[])
-{
-  // This is a simple example of using the transform_iterators class to
-  // generate iterators that multiply the value returned by dereferencing
-  // the iterator. In this case we are multiplying by 2.
-  // Would be cooler to use lambda library in this example.
-
-  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
-
-  typedef std::binder1st< std::multiplies<int> > Function;
-  
-  typedef boost::transform_iterator<Function, int*> doubling_iterator;
-
-  doubling_iterator i(x, std::bind1st(std::multiplies<int>(), 2)),
-    i_end(x + sizeof(x)/sizeof(int), std::bind1st(std::multiplies<int>(), 2));
-
-  std::cout << "multiplying the array by 2:" << std::endl;
-  while (i != i_end)
-    std::cout << *i++ << " ";
-  std::cout << std::endl;
-
-  // Here is an example of counting from 0 to 5 using the integer_range class.
-
-  boost::integer_range<int> r(0,5);
-
-  std::cout << "counting to from 0 to 4:" << std::endl;
-  std::copy(r.begin(), r.end(), std::ostream_iterator<int>(std::cout, " "));
-  std::cout << std::endl;
-
-  return 0;
-}
-
-
--- a/iterator_adaptors.htm
+++ b/iterator_adaptors.htm
@ -0,0 +1,11 @@
+<!-- Copyright David Abrahams 2004. 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) -->
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=../iterator/doc/index.html">
+</head>
+<body>
+This documentation moved to <a href="../iterator/doc/index.html">../iterator/doc/index.html</a>.
+</body>
+</html>
--- a/iterator_traits_test.cpp
+++ b/iterator_traits_test.cpp
@ -1,215 +0,0 @@
-//  (C) Copyright David Abrahams 2002. 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.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-//  Revision History
-//  04 Mar 2001 Patches for Intel C++ (Dave Abrahams)
-//  19 Feb 2001 Take advantage of improved iterator_traits to do more tests
-//              on MSVC. Reordered some #ifdefs for coherency.
-//              (David Abrahams)
-//  13 Feb 2001 Test new VC6 workarounds (David Abrahams)
-//  11 Feb 2001 Final fixes for Borland (David Abrahams)
-//  11 Feb 2001 Some fixes for Borland get it closer on that compiler
-//              (David Abrahams)
-//  07 Feb 2001 More comprehensive testing; factored out static tests for
-//              better reuse (David Abrahams)
-//  21 Jan 2001 Quick fix to my_iterator, which wasn't returning a
-//              reference type from operator* (David Abrahams)
-//  19 Jan 2001 Initial version with iterator operators (David Abrahams)
-
-#include <boost/detail/iterator.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/operators.hpp>
-#include <boost/static_assert.hpp>
-#include <iterator>
-#include <vector>
-#include <list>
-#include <cassert>
-#include <iostream>
-
-// A UDT for which we can specialize std::iterator_traits<element*> on
-// compilers which don't support partial specialization. There's no
-// other reasonable way to test pointers on those compilers.
-struct element {};
-
-// An iterator for which we can get traits.
-struct my_iterator1
-    : boost::forward_iterator_helper<my_iterator1, char, long, const char*, const char&>
-{
-    my_iterator1(const char* p) : m_p(p) {}
-    
-    bool operator==(const my_iterator1& rhs) const
-        { return this->m_p == rhs.m_p; }
-
-    my_iterator1& operator++() { ++this->m_p; return *this; }
-    const char& operator*() { return *m_p; }
- private:
-    const char* m_p;
-};
-
-// Used to prove that we don't require std::iterator<> in the hierarchy under
-// MSVC6, and that we can compute all the traits for a standard-conforming UDT
-// iterator.
-struct my_iterator2
-    : boost::equality_comparable<my_iterator2
-    , boost::incrementable<my_iterator2
-    , boost::dereferenceable<my_iterator2,const char*> > >
-{
-    typedef char value_type;
-    typedef long difference_type;
-    typedef const char* pointer;
-    typedef const char& reference;
-    typedef std::forward_iterator_tag iterator_category;
-    
-    my_iterator2(const char* p) : m_p(p) {}
-    
-    bool operator==(const my_iterator2& rhs) const
-        { return this->m_p == rhs.m_p; }
-
-    my_iterator2& operator++() { ++this->m_p; return *this; }
-    const char& operator*() { return *m_p; }
- private:
-    const char* m_p;
-};
-
-// Used to prove that we're not overly confused by the existence of
-// std::iterator<> in the hierarchy under MSVC6 - we should find that
-// boost::detail::iterator_traits<my_iterator3>::difference_type is int.
-struct my_iterator3 : my_iterator1
-{
-    typedef int difference_type;
-    my_iterator3(const char* p)
-        : my_iterator1(p) {}
-};
-
-//
-// Assertion tools.  Used instead of BOOST_STATIC_ASSERT because that
-// doesn't give us a nice stack backtrace
-//
-template <bool = false> struct assertion;
-
-template <> struct assertion<true>
-{
-    typedef char type;
-};
-
-template <class T, class U>
-struct assert_same
-    : assertion<(::boost::is_same<T,U>::value)>
-{
-};
-
-
-// Iterator tests
-template <class Iterator,
-    class value_type, class difference_type, class pointer, class reference, class category>
-struct non_portable_tests
-{
-    typedef typename boost::detail::iterator_traits<Iterator>::pointer test_pt;
-    typedef typename boost::detail::iterator_traits<Iterator>::reference test_rt;
-    typedef typename assert_same<test_pt, pointer>::type a1;
-    typedef typename assert_same<test_rt, reference>::type a2;
-};
-
-template <class Iterator,
-    class value_type, class difference_type, class pointer, class reference, class category>
-struct portable_tests
-{
-    typedef typename boost::detail::iterator_traits<Iterator>::difference_type test_dt;
-    typedef typename boost::detail::iterator_traits<Iterator>::iterator_category test_cat;
-    typedef typename assert_same<test_dt, difference_type>::type a1;
-    typedef typename assert_same<test_cat, category>::type a2;
-};
-
-// Test iterator_traits
-template <class Iterator,
-    class value_type, class difference_type, class pointer, class reference, class category>
-struct input_iterator_test
-    : portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
-{
-    typedef typename boost::detail::iterator_traits<Iterator>::value_type test_vt;
-    typedef typename assert_same<test_vt, value_type>::type a1;
-};
-
-template <class Iterator,
-    class value_type, class difference_type, class pointer, class reference, class category>
-struct non_pointer_test
-    : input_iterator_test<Iterator,value_type,difference_type,pointer,reference,category>
-      , non_portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
-{
-};
-
-template <class Iterator,
-    class value_type, class difference_type, class pointer, class reference, class category>
-struct maybe_pointer_test
-    : portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
-      , non_portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
-{
-};
-
-input_iterator_test<std::istream_iterator<int>, int, std::ptrdiff_t, int*, int&, std::input_iterator_tag>
-        istream_iterator_test;
-
-#if defined(__BORLANDC__) && !defined(__SGI_STL_PORT)
-typedef ::std::char_traits<char>::off_type distance;
-non_pointer_test<std::ostream_iterator<int>,int,
-    distance,int*,int&,std::output_iterator_tag> ostream_iterator_test;
-#elif defined(BOOST_MSVC_STD_ITERATOR)
-non_pointer_test<std::ostream_iterator<int>,
-    int, void, int*, int&, std::output_iterator_tag>
-        ostream_iterator_test;
-#else
-non_pointer_test<std::ostream_iterator<int>,
-    void, void, void, void, std::output_iterator_tag>
-        ostream_iterator_test;
-#endif
-
-
-#ifdef __KCC
-  typedef long std_list_diff_type;
-#else
-  typedef std::ptrdiff_t std_list_diff_type;
-#endif
-
-non_pointer_test<std::list<int>::iterator, int, std_list_diff_type, int*, int&, std::bidirectional_iterator_tag>
-        list_iterator_test;
-
-maybe_pointer_test<std::vector<int>::iterator, int, std::ptrdiff_t, int*, int&, std::random_access_iterator_tag>
-        vector_iterator_test;
-
-maybe_pointer_test<int*, int, std::ptrdiff_t, int*, int&, std::random_access_iterator_tag>
-        int_pointer_test;
-
-non_pointer_test<my_iterator1, char, long, const char*, const char&, std::forward_iterator_tag>
-       my_iterator1_test;
-                    
-non_pointer_test<my_iterator2, char, long, const char*, const char&, std::forward_iterator_tag>
-       my_iterator2_test;
-
-non_pointer_test<my_iterator3, char, int, const char*, const char&, std::forward_iterator_tag>
-       my_iterator3_test;
-
-int main()
-{
-    char chars[100];
-    int ints[100];
-
-    for (int length = 3; length < 100; length += length / 3)
-    {
-        std::list<int> l(length);
-        assert(boost::detail::distance(l.begin(), l.end()) == length);
-        
-        std::vector<int> v(length);
-        assert(boost::detail::distance(v.begin(), v.end()) == length);
-
-        assert(boost::detail::distance(&ints[0], ints + length) == length);
-        assert(boost::detail::distance(my_iterator1(chars), my_iterator1(chars + length)) == length);
-        assert(boost::detail::distance(my_iterator2(chars), my_iterator2(chars + length)) == length);
-        assert(boost::detail::distance(my_iterator3(chars), my_iterator3(chars + length)) == length);
-    }
-    return 0;
-}
--- a/iterators_test.cpp
+++ b/iterators_test.cpp
@ -1,10 +1,9 @@
 //  Demonstrate and test boost/operators.hpp on std::iterators  --------------//

-//  (C) Copyright Jeremy Siek 1999. 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.
+//  (C) Copyright Jeremy Siek 1999.
+// 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)

 //  See http://www.boost.org for most recent version including documentation.

@ -24,7 +23,7 @@
 #include <cstring>    // for std::strcmp
 #include <iostream>   // for std::cout (std::endl, ends, and flush indirectly)
 #include <string>     // for std::string
-#include <strstream>  // for std::ostrstream
+#include <sstream>    // for std::stringstream

 # ifdef BOOST_NO_STDC_NAMESPACE
    namespace std { using ::strcmp; }
@ -65,20 +64,16 @@ class test_opr_base
 protected:
    // Test data and types
    BOOST_STATIC_CONSTANT( std::size_t, fruit_length = 6u );
-    BOOST_STATIC_CONSTANT( std::size_t, scratch_length = 40u );

    typedef std::string  fruit_array_type[ fruit_length ];
-    typedef char         scratch_array_type[ scratch_length ];

    static  fruit_array_type    fruit;
-    static  scratch_array_type  scratch;

 };  // test_opr_base

 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 //  A definition is required even for integral static constants
 const std::size_t test_opr_base::fruit_length;
-const std::size_t test_opr_base::scratch_length;
 #endif

 template <typename T, typename R = T&, typename P = T*>
@ -120,9 +115,6 @@ private:
 test_opr_base::fruit_array_type
 test_opr_base::fruit = { "apple", "orange", "pear", "peach", "grape", "plum" };

-test_opr_base::scratch_array_type
- test_opr_base::scratch = "";
-
 template <typename T, typename R, typename P>
  typename test_opr<T, R, P>::iter_type const
 test_opr<T, R, P>::fruit_begin = test_iter<T,R,P>( fruit );
@ -176,15 +168,13 @@ test_opr<T, R, P>::post_increment_test
 {
    std::cout << "\tDoing post-increment test." << std::endl;

-    std::ostrstream  oss( scratch, scratch_length );
+    std::stringstream oss;
    for ( iter_type i = fruit_begin ; i != fruit_end ; )
    {
        oss << *i++ << ' ';
    }

-    oss << std::ends;
-    BOOST_TEST( std::strcmp(oss.str(), "apple orange pear peach grape plum ")
-     == 0 );
+    BOOST_CHECK( oss.str() == "apple orange pear peach grape plum ");
 }

 // Test post-decrement
@ -196,16 +186,14 @@ test_opr<T, R, P>::post_decrement_test
 {
    std::cout << "\tDoing post-decrement test." << std::endl;

-    std::ostrstream  oss( scratch, scratch_length );
+    std::stringstream oss;
    for ( iter_type i = fruit_end ; i != fruit_begin ; )
    {
        i--;
        oss << *i << ' ';
    }

-    oss << std::ends;
-    BOOST_TEST( std::strcmp(oss.str(), "plum grape peach pear orange apple ")
-     == 0 );
+    BOOST_CHECK( oss.str() == "plum grape peach pear orange apple ");
 }

 // Test indirect structure referral
@ -217,14 +205,13 @@ test_opr<T, R, P>::indirect_referral_test
 {
    std::cout << "\tDoing indirect reference test." << std::endl;

-    std::ostrstream  oss( scratch, scratch_length );
+    std::stringstream oss;
    for ( iter_type i = fruit_begin ; i != fruit_end ; ++i )
    {
        oss << i->size() << ' ';
    }

-    oss << std::ends;
-    BOOST_TEST( std::strcmp(oss.str(), "5 6 4 5 5 4 ") == 0 );
+    BOOST_CHECK( oss.str() == "5 6 4 5 5 4 ");
 }

 // Test offset addition
@ -237,14 +224,13 @@ test_opr<T, R, P>::offset_addition_test
    std::cout << "\tDoing offset addition test." << std::endl;

    std::ptrdiff_t const  two = 2;
-    std::ostrstream       oss( scratch, scratch_length );
+    std::stringstream oss;
    for ( iter_type i = fruit_begin ; i != fruit_end ; i = i + two )
    {
        oss << *i << ' ';
    }

-    oss << std::ends;
-    BOOST_TEST( std::strcmp(oss.str(), "apple pear grape ") == 0 );
+    BOOST_CHECK( oss.str() == "apple pear grape ");
 }

 // Test offset addition, in reverse order
@ -257,14 +243,13 @@ test_opr<T, R, P>::reverse_offset_addition_test
    std::cout << "\tDoing reverse offset addition test." << std::endl;

    std::ptrdiff_t const  two = 2;
-    std::ostrstream       oss( scratch, scratch_length );
+    std::stringstream oss;
    for ( iter_type i = fruit_begin ; i != fruit_end ; i = two + i )
    {
        oss << *i << ' ';
    }

-    oss << std::ends;
-    BOOST_TEST( std::strcmp(oss.str(), "apple pear grape ") == 0 );
+    BOOST_CHECK( oss.str() == "apple pear grape ");
 }

 // Test offset subtraction
@ -277,7 +262,7 @@ test_opr<T, R, P>::offset_subtraction_test
    std::cout << "\tDoing offset subtraction test." << std::endl;

    std::ptrdiff_t const  two = 2;
-    std::ostrstream       oss( scratch, scratch_length );
+    std::stringstream oss;
    for ( iter_type i = fruit_end ; fruit_begin < i ; )
    {
        i = i - two;
@ -287,8 +272,7 @@ test_opr<T, R, P>::offset_subtraction_test
        }
    }

-    oss << std::ends;
-    BOOST_TEST( std::strcmp(oss.str(), "grape pear apple ") == 0 );
+    BOOST_CHECK( oss.str() == "grape pear apple ");
 }

 // Test comparisons
@ -312,10 +296,10 @@ test_opr<T, R, P>::comparison_test
        {
            ptrdiff_t const  j_offset = j - fruit_begin;

-            BOOST_TEST( (i != j) == (i_offset != j_offset) );
-            BOOST_TEST( (i > j) == (i_offset > j_offset) );
-            BOOST_TEST( (i <= j) == (i_offset <= j_offset) );
-            BOOST_TEST( (i >= j) == (i_offset >= j_offset) );
+            BOOST_CHECK( (i != j) == (i_offset != j_offset) );
+            BOOST_CHECK( (i > j) == (i_offset > j_offset) );
+            BOOST_CHECK( (i <= j) == (i_offset <= j_offset) );
+            BOOST_CHECK( (i >= j) == (i_offset >= j_offset) );
        }
    }
    cout << std::endl;
@ -330,13 +314,11 @@ test_opr<T, R, P>::indexing_test
 {
    std::cout << "\tDoing indexing test." << std::endl;

-    std::ostrstream  oss( scratch, scratch_length );
+    std::stringstream oss;
    for ( std::size_t k = 0u ; k < fruit_length ; ++k )
    {
        oss << fruit_begin[ k ] << ' ';
    }

-    oss << std::ends;
-    BOOST_TEST( std::strcmp(oss.str(), "apple orange pear peach grape plum ")
-     == 0 );
+    BOOST_CHECK( oss.str() == "apple orange pear peach grape plum ");
 }
--- a/noncopyable_test.cpp
+++ b/noncopyable_test.cpp
@ -1,10 +1,8 @@
 //  boost class noncopyable test program  ------------------------------------//

-//  (C) Copyright boost.org 1999. 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.
+//  (C) Copyright Beman Dawes 1999. 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)

 //  See http://www.boost.org for most recent version including documentation.

--- a/numeric_traits_test.cpp
+++ b/numeric_traits_test.cpp
@ -1,8 +1,7 @@
-//  (C) Copyright David Abrahams 2001. 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.
+//  (C) Copyright David Abrahams 2001.
+// 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)

 //  See http://www.boost.org for most recent version including documentation.

@ -58,14 +57,22 @@ struct complement
    struct traits
    {
     private:
-        // indirection through complement_traits_aux neccessary to keep MSVC happy
+        // indirection through complement_traits_aux necessary to keep MSVC happy
        typedef complement_traits_aux<Number, size - 1> prev;
     public:
+#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
+      // GCC 4.0.2 ICEs on these C-style casts
+        BOOST_STATIC_CONSTANT(Number, max =
+                            Number((prev::max) << CHAR_BIT)
+                            + Number(UCHAR_MAX));
+        BOOST_STATIC_CONSTANT(Number, min = Number((prev::min) << CHAR_BIT));
+#else
        BOOST_STATIC_CONSTANT(Number, max =
                            Number(Number(prev::max) << CHAR_BIT)
                            + Number(UCHAR_MAX));
-        
        BOOST_STATIC_CONSTANT(Number, min = Number(Number(prev::min) << CHAR_BIT));
+#endif
+   
    };
 };

@ -222,10 +229,16 @@ void test_aux(unsigned_tag, Number*)
        (sizeof(Number) < sizeof(boost::intmax_t))
        | (boost::is_same<difference_type, boost::intmax_t>::value));

+#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
+    // GCC 4.0.2 ICEs on this C-style cases
+    BOOST_STATIC_ASSERT((complement_traits<Number>::max) > Number(0));
+    BOOST_STATIC_ASSERT((complement_traits<Number>::min) == Number(0));
+#else
    // Force casting to Number here to work around the fact that it's an enum on MSVC
    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::max) > Number(0));
    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::min) == Number(0));
-    
+#endif
+
    const Number max = complement_traits<Number>::max;
    const Number min = complement_traits<Number>::min;
    
@ -309,10 +322,15 @@ void test_aux(signed_tag, Number*)
        (sizeof(Number) < sizeof(boost::intmax_t))
        | (boost::is_same<difference_type, Number>::value));

+#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
+    // GCC 4.0.2 ICEs on this cast
+    BOOST_STATIC_ASSERT((complement_traits<Number>::max) > Number(0));
+    BOOST_STATIC_ASSERT((complement_traits<Number>::min) < Number(0));
+#else
    // Force casting to Number here to work around the fact that it's an enum on MSVC
    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::max) > Number(0));
    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::min) < Number(0));
-    
+#endif    
    const Number max = complement_traits<Number>::max;
    const Number min = complement_traits<Number>::min;
    
@ -375,8 +393,8 @@ int main()
    test<long>();
    test<unsigned long>();
 #if defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-    test<long long>();
-    test<unsigned long long>();
+    test< ::boost::long_long_type>();
+    test< ::boost::ulong_long_type>();
 #elif defined(BOOST_MSVC)
    // The problem of not having compile-time static class constants other than
    // enums prevents this from working, since values get truncated.
--- a/operators.htm
+++ b/operators.htm
@ -10,7 +10,7 @@
  </head>

  <body text="black" bgcolor="white" link="blue" vlink="purple" alink="red">
-    <h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align=
+    <h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align=
    "middle" width="277" height="86">Header <cite>&lt;<a href=
    "../../boost/operators.hpp">boost/operators.hpp</a>&gt;</cite></h1>

@ -1955,7 +1955,7 @@ T operator+( T lhs, const T&amp; rhs )
    output iterator to writing just two member functions - an appropriate
    constructor and a copy-assignment operator. For example, here is a
    possible implementation of <code><a href=
-    "function_output_iterator.htm">boost::function_output_iterator</a></code>
+    "../iterator/doc/function_output_iterator.html">boost::function_output_iterator</a></code>
    adaptor:</p>
 <pre>
 template&lt;class UnaryFunction&gt;
@ -2029,13 +2029,13 @@ public:
    <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 +2043,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,10 +2119,10 @@ public:
    backward-compatible.</p>
    <hr>

-    <p>Revised: 03 Dec 2003</p>
+    <p>Revised: 29 Oct 2004</p>

    <p>Copyright &copy; Beman Dawes, David Abrahams, 1999-2001.</p>
-    <p>Copyright &copy; Daniel Frey, 2002-2003.</p>
+    <p>Copyright &copy; Daniel Frey, 2002-2004.</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/operators_test.cpp
+++ b/operators_test.cpp
@ -1,11 +1,13 @@
 //  Demonstrate and test boost/operators.hpp  -------------------------------//

-//  Copyright Beman Dawes 1999.
-//  See accompanying license for terms and conditions of use.
+//  Copyright Beman Dawes 1999.  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)

 //  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
@ -42,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>
@ -53,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; }
@ -96,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; }
@ -122,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; }
@ -152,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;
@ -173,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;
@ -197,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;}
@ -230,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;}
@ -268,17 +313,17 @@ namespace
    template <class X1, class Y1, class X2, class Y2>
    void sanity_check(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        BOOST_TEST( true_value(y1) == true_value(y2) );
-        BOOST_TEST( true_value(x1) == true_value(x2) );
+        BOOST_CHECK( true_value(y1) == true_value(y2) );
+        BOOST_CHECK( true_value(x1) == true_value(x2) );
    }

    template <class X1, class Y1, class X2, class Y2>
    void test_less_than_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        BOOST_TEST( (x1 < y1) == (x2 < y2) );
-        BOOST_TEST( (x1 <= y1) == (x2 <= y2) );
-        BOOST_TEST( (x1 >= y1) == (x2 >= y2) );
-        BOOST_TEST( (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>
@ -292,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_TEST( (x1 == y1) == (x2 == y2) );
-        BOOST_TEST( (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>
@ -307,7 +352,7 @@ namespace
    template <class X1, class Y1, class X2, class Y2>
    void test_multipliable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        BOOST_TEST( (x1 * y1).value() == (x2 * y2) );
+        BOOST_CHECK( (x1 * y1).value() == (x2 * y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
@ -321,7 +366,7 @@ namespace
  template <class A, class B>
  void test_value_equality(A a, B b)
  {
-      BOOST_TEST(a.value() == b);
+      BOOST_CHECK(a.value() == b);
  }
  
 #define TEST_OP_R(op) test_value_equality(x1 op y1, x2 op y2)
@ -447,16 +492,16 @@ namespace
    void test_incrementable(X1 x1, X2 x2)
    {
        sanity_check( x1, x1, x2, x2 );
-        BOOST_TEST( (x1++).value() == x2++ );
-        BOOST_TEST( x1.value() == x2 );
+        BOOST_CHECK( (x1++).value() == x2++ );
+        BOOST_CHECK( x1.value() == x2 );
    }
    
    template <class X1, class X2>
    void test_decrementable(X1 x1, X2 x2)
    {
        sanity_check( x1, x1, x2, x2 );
-        BOOST_TEST( (x1--).value() == x2-- );
-        BOOST_TEST( x1.value() == x2 );
+        BOOST_CHECK( (x1--).value() == x2-- );
+        BOOST_CHECK( x1.value() == x2 );
    }
    
    template <class X1, class Y1, class X2, class Y2>
@ -535,7 +580,7 @@ namespace
 // inherited operator templates at the moment it must, so the following
 // explicit instantiations force it to do that.

-#if defined(BOOST_MSVC) && (_MSC_VER <= 1200)
+#if defined(BOOST_MSVC) && (_MSC_VER < 1300)
 template Wrapped1<int>;
 template Wrapped1<long>;
 template Wrapped1<unsigned int>;
@ -560,7 +605,7 @@ template Wrapped6<unsigned long, unsigned char>;
 template Wrapped6<unsigned int, unsigned char>;
 #endif

-#define PRIVATE_EXPR_TEST(e, t)  BOOST_TEST( ((e), (t)) )
+#define PRIVATE_EXPR_TEST(e, t)  BOOST_CHECK( ((e), (t)) )

 int
 test_main( int , char * [] )
@ -605,22 +650,22 @@ test_main( int , char * [] )
    MyInt i2(2);
    MyInt i;

-    BOOST_TEST( i1.value() == 1 );
-    BOOST_TEST( i2.value() == 2 );
-    BOOST_TEST( i.value() == 0 );
+    BOOST_CHECK( i1.value() == 1 );
+    BOOST_CHECK( i2.value() == 2 );
+    BOOST_CHECK( i.value() == 0 );

    cout << "Created MyInt objects.\n";

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

-    BOOST_TEST( i2 == i );
-    BOOST_TEST( i1 != i2 );
-    BOOST_TEST( i1 <  i2 );
-    BOOST_TEST( i1 <= i2 );
-    BOOST_TEST( i <= i2 );
-    BOOST_TEST( i2 >  i1 );
-    BOOST_TEST( i2 >= i1 );
-    BOOST_TEST( 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) );
@ -644,86 +689,86 @@ test_main( int , char * [] )
    MyLong j2(2);
    MyLong j;

-    BOOST_TEST( j1.value() == 1 );
-    BOOST_TEST( j2.value() == 2 );
-    BOOST_TEST( j.value() == 0 );
+    BOOST_CHECK( j1.value() == 1 );
+    BOOST_CHECK( j2.value() == 2 );
+    BOOST_CHECK( j.value() == 0 );

    cout << "Created MyLong objects.\n";

    PRIVATE_EXPR_TEST( (j = j2), (j.value() == 2) );
    
-    BOOST_TEST( j2 == j );
-    BOOST_TEST( 2 == j );
-    BOOST_TEST( j2 == 2 );    
-    BOOST_TEST( j == j2 );
-    BOOST_TEST( j1 != j2 );
-    BOOST_TEST( j1 != 2 );
-    BOOST_TEST( 1 != j2 );
-    BOOST_TEST( j1 <  j2 );
-    BOOST_TEST( 1 <  j2 );
-    BOOST_TEST( j1 <  2 );
-    BOOST_TEST( j1 <= j2 );
-    BOOST_TEST( 1 <= j2 );
-    BOOST_TEST( j1 <= j );
-    BOOST_TEST( j <= j2 );
-    BOOST_TEST( 2 <= j2 );
-    BOOST_TEST( j <= 2 );
-    BOOST_TEST( j2 >  j1 );
-    BOOST_TEST( 2 >  j1 );
-    BOOST_TEST( j2 >  1 );
-    BOOST_TEST( j2 >= j1 );
-    BOOST_TEST( 2 >= j1 );
-    BOOST_TEST( j2 >= 1 );
-    BOOST_TEST( j2 >= j );
-    BOOST_TEST( 2 >= j );
-    BOOST_TEST( 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_TEST( (j1 + 2) == 3 );
-    BOOST_TEST( (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_TEST( (j + 2) == 5 );
-    BOOST_TEST( (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_TEST( (j - 1) == 4 );
+    BOOST_CHECK( static_cast<bool>((j - 1) == 4) );
    PRIVATE_EXPR_TEST( (j = j - j1), (j.value() == 4) );
    
-    BOOST_TEST( (j * 2) == 8 );
-    BOOST_TEST( (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_TEST( (j / 2) == 4 );
+    BOOST_CHECK( static_cast<bool>((j / 2) == 4) );
    PRIVATE_EXPR_TEST( (j = j / j2), (j.value() == 4) );
    
-    BOOST_TEST( (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_TEST( (1 | j2 | j) == 7 );
-    BOOST_TEST( (j1 | 2 | j) == 7 );
-    BOOST_TEST( (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_TEST( (7 & j2) == 2 );
-    BOOST_TEST( (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_TEST( (3 ^ j1) == 2 );
-    BOOST_TEST( (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_TEST( (j1 << 2) == 4 );
-    BOOST_TEST( (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_TEST( (j >> 2) == 1 );
-    BOOST_TEST( (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";
@ -732,22 +777,22 @@ test_main( int , char * [] )
    MyChar k2(2);
    MyChar k;

-    BOOST_TEST( k1.value() == 1 );
-    BOOST_TEST( k2.value() == 2 );
-    BOOST_TEST( k.value() == 0 );
+    BOOST_CHECK( k1.value() == 1 );
+    BOOST_CHECK( k2.value() == 2 );
+    BOOST_CHECK( k.value() == 0 );

    cout << "Created MyChar objects.\n";

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

-    BOOST_TEST( k2 == k );
-    BOOST_TEST( k1 != k2 );
-    BOOST_TEST( k1 <  k2 );
-    BOOST_TEST( k1 <= k2 );
-    BOOST_TEST( k <= k2 );
-    BOOST_TEST( k2 >  k1 );
-    BOOST_TEST( k2 >= k1 );
-    BOOST_TEST( 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";

@ -755,39 +800,39 @@ test_main( int , char * [] )
    MyShort l2(2);
    MyShort l;

-    BOOST_TEST( l1.value() == 1 );
-    BOOST_TEST( l2.value() == 2 );
-    BOOST_TEST( l.value() == 0 );
+    BOOST_CHECK( l1.value() == 1 );
+    BOOST_CHECK( l2.value() == 2 );
+    BOOST_CHECK( l.value() == 0 );

    cout << "Created MyShort objects.\n";

    PRIVATE_EXPR_TEST( (l = l2), (l.value() == 2) );
    
-    BOOST_TEST( l2 == l );
-    BOOST_TEST( 2 == l );
-    BOOST_TEST( l2 == 2 );    
-    BOOST_TEST( l == l2 );
-    BOOST_TEST( l1 != l2 );
-    BOOST_TEST( l1 != 2 );
-    BOOST_TEST( 1 != l2 );
-    BOOST_TEST( l1 <  l2 );
-    BOOST_TEST( 1 <  l2 );
-    BOOST_TEST( l1 <  2 );
-    BOOST_TEST( l1 <= l2 );
-    BOOST_TEST( 1 <= l2 );
-    BOOST_TEST( l1 <= l );
-    BOOST_TEST( l <= l2 );
-    BOOST_TEST( 2 <= l2 );
-    BOOST_TEST( l <= 2 );
-    BOOST_TEST( l2 >  l1 );
-    BOOST_TEST( 2 >  l1 );
-    BOOST_TEST( l2 >  1 );
-    BOOST_TEST( l2 >= l1 );
-    BOOST_TEST( 2 >= l1 );
-    BOOST_TEST( l2 >= 1 );
-    BOOST_TEST( l2 >= l );
-    BOOST_TEST( 2 >= l );
-    BOOST_TEST( 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";
    
@ -797,46 +842,46 @@ test_main( int , char * [] )
    MyDoubleInt di;
    MyDoubleInt tmp;

-    BOOST_TEST( di1.value() == 1 );
-    BOOST_TEST( di2.value() == 2 );
-    BOOST_TEST( di2.value() == 2 );
-    BOOST_TEST( di.value() == 0 );
+    BOOST_CHECK( di1.value() == 1 );
+    BOOST_CHECK( di2.value() == 2 );
+    BOOST_CHECK( di2.value() == 2 );
+    BOOST_CHECK( di.value() == 0 );

    cout << "Created MyDoubleInt objects.\n";

    PRIVATE_EXPR_TEST( (di = di2), (di.value() == 2) );
    
-    BOOST_TEST( di2 == di );
-    BOOST_TEST( 2 == di );
-    BOOST_TEST( di == 2 );
-    BOOST_TEST( di1 < di2 );
-    BOOST_TEST( 1 < di2 );
-    BOOST_TEST( di1 <= di2 );
-    BOOST_TEST( 1 <= di2 );
-    BOOST_TEST( di2 > di1 );
-    BOOST_TEST( di2 > 1 );
-    BOOST_TEST( di2 >= di1 );
-    BOOST_TEST( di2 >= 1 );
-    BOOST_TEST( di1 / di2 == half );
-    BOOST_TEST( di1 / 2 == half );
-    BOOST_TEST( 1 / di2 == half );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp/=2) == half) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp/=di2) == half) );
-    BOOST_TEST( di1 * di2 == di2 );
-    BOOST_TEST( di1 * 2 == di2 );
-    BOOST_TEST( 1 * di2 == di2 );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp*=2) == di2) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp*=di2) == di2) );
-    BOOST_TEST( di2 - di1 == di1 );
-    BOOST_TEST( di2 - 1 == di1 );
-    BOOST_TEST( 2 - di1 == di1 );
-    PRIVATE_EXPR_TEST( (tmp=di2), ((tmp-=1) == di1) );
-    PRIVATE_EXPR_TEST( (tmp=di2), ((tmp-=di1) == di1) );
-    BOOST_TEST( di1 + di1 == di2 );
-    BOOST_TEST( di1 + 1 == di2 );
-    BOOST_TEST( 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";

@ -845,50 +890,50 @@ test_main( int , char * [] )
    MyLongInt li;
    MyLongInt tmp2;

-    BOOST_TEST( li1.value() == 1 );
-    BOOST_TEST( li2.value() == 2 );
-    BOOST_TEST( li.value() == 0 );
+    BOOST_CHECK( li1.value() == 1 );
+    BOOST_CHECK( li2.value() == 2 );
+    BOOST_CHECK( li.value() == 0 );

    cout << "Created MyLongInt objects.\n";

    PRIVATE_EXPR_TEST( (li = li2), (li.value() == 2) );
    
-    BOOST_TEST( li2 == li );
-    BOOST_TEST( 2 == li );
-    BOOST_TEST( li == 2 );
-    BOOST_TEST( li1 < li2 );
-    BOOST_TEST( 1 < li2 );
-    BOOST_TEST( li1 <= li2 );
-    BOOST_TEST( 1 <= li2 );
-    BOOST_TEST( li2 > li1 );
-    BOOST_TEST( li2 > 1 );
-    BOOST_TEST( li2 >= li1 );
-    BOOST_TEST( li2 >= 1 );
-    BOOST_TEST( li1 % li2 == li1 );
-    BOOST_TEST( li1 % 2 == li1 );
-    BOOST_TEST( 1 % li2 == li1 );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2%=2) == li1) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2%=li2) == li1) );
-    BOOST_TEST( li1 / li2 == 0 );
-    BOOST_TEST( li1 / 2 == 0 );
-    BOOST_TEST( 1 / li2 == 0 );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2/=2) == 0) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2/=li2) == 0) );
-    BOOST_TEST( li1 * li2 == li2 );
-    BOOST_TEST( li1 * 2 == li2 );
-    BOOST_TEST( 1 * li2 == li2 );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2*=2) == li2) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2*=li2) == li2) );
-    BOOST_TEST( li2 - li1 == li1 );
-    BOOST_TEST( li2 - 1 == li1 );
-    BOOST_TEST( 2 - li1 == li1 );
-    PRIVATE_EXPR_TEST( (tmp2=li2), ((tmp2-=1) == li1) );
-    PRIVATE_EXPR_TEST( (tmp2=li2), ((tmp2-=li1) == li1) );
-    BOOST_TEST( li1 + li1 == li2 );
-    BOOST_TEST( li1 + 1 == li2 );
-    BOOST_TEST( 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/projection_iterator_example.cpp
+++ b/projection_iterator_example.cpp
@ -1,103 +0,0 @@
-// (C) Copyright Jeremy Siek 2000. 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.
-
-#include <boost/config.hpp>
-#include <list>
-#include <iostream>
-#include <iterator>
-#include <algorithm>
-#include <string>
-#include <boost/iterator/transform_iterator.hpp>
-
-struct personnel_record {
-  personnel_record(std::string n, int id) : m_name(n), m_ID(id) { }
-  std::string m_name;
-  int m_ID;
-};
-
-struct select_name {
-  typedef personnel_record argument_type;
-  typedef std::string const& result_type;
-  const std::string& operator()(const personnel_record& r) const {
-    return r.m_name;
-  }
-  std::string& operator()(personnel_record& r) const {
-    return r.m_name;
-  }
-};
-
-struct select_ID {
-  typedef personnel_record argument_type;
-  typedef int& result_type;
-  const int& operator()(const personnel_record& r) const {
-    return r.m_ID;
-  }
-  int& operator()(personnel_record& r) const {
-    return r.m_ID;
-  }
-};
-
-int main(int, char*[])
-{
-  std::list<personnel_record> personnel_list;
-
-  personnel_list.push_back(personnel_record("Barney", 13423));
-  personnel_list.push_back(personnel_record("Fred", 12343));
-  personnel_list.push_back(personnel_record("Wilma", 62454));
-  personnel_list.push_back(personnel_record("Betty", 20490));
-
-  // Example of using transform_iterator to print out the names in the
-  // personnel list using a projection.
-
-  boost::transform_iterator<
-      select_name
-    , std::list<personnel_record>::iterator
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    , std::string
-#endif 
-  >
-    personnel_first(personnel_list.begin()),
-    personnel_last(personnel_list.end());
-
-  std::copy(personnel_first, personnel_last,
-            std::ostream_iterator<std::string>(std::cout, "\n"));
-  std::cout << std::endl;
-  
-  // Example of using transform_iterator with const_iterators to
-  // assign new ID numbers to the personnel.
-  
-  boost::transform_iterator<
-      select_ID, std::list<personnel_record>::iterator
- > ID_first(personnel_list.begin()),
-    ID_last(personnel_list.end());
-
-  int new_id = 0;
-  while (ID_first != ID_last) {
-    *ID_first = new_id++;
-    ++ID_first;
-  }
-
-    boost::transform_iterator<
-      select_ID, std::list<personnel_record>::const_iterator, int const&
-    >
-    const_ID_first(personnel_list.begin()),
-    const_ID_last(personnel_list.end());
-
-  std::copy(const_ID_first, const_ID_last,
-            std::ostream_iterator<int>(std::cout, " "));
-  std::cout << std::endl;
-  std::cout << std::endl;
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  // Example of using make_const_projection_iterator()
-  // to print out the names in the personnel list again.
-  std::copy(
-      boost::make_transform_iterator<select_name>(personnel_list.begin())
-    , boost::make_transform_iterator<select_name>(personnel_list.end())
-    , std::ostream_iterator<std::string>(std::cout, "\n"));
-#endif
-  
-  return 0;
-}
--- a/ref_ct_test.cpp
+++ b/ref_ct_test.cpp
@ -1,9 +1,18 @@
+// Copyright David Abrahams and Aleksey Gurtovoy
+// 2002-2004. 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)
+
 // compile-time test for "boost/ref.hpp" header content
 // see 'ref_test.cpp' for run-time part

 #include <boost/ref.hpp>
-#include <boost/type_traits/same_traits.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
 #include <boost/static_assert.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/mpl/assert.hpp>

 namespace {

@ -30,13 +39,23 @@ void is_reference_wrapper_test(T)
 template< typename R, typename Ref >
 void cxx_reference_test(Ref)
 {
+#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+    typedef typename boost::remove_const<Ref>::type ref;
+    BOOST_STATIC_ASSERT((boost::is_same<R,ref>::value));
+#else
    BOOST_STATIC_ASSERT((boost::is_same<R,Ref>::value));
+#endif
 }

 template< typename R, typename Ref >
 void unwrap_reference_test(Ref)
 {
+#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+    typedef typename boost::remove_const<Ref>::type ref;
+    typedef typename boost::unwrap_reference<ref>::type type;
+#else
    typedef typename boost::unwrap_reference<Ref>::type type;
+#endif
    BOOST_STATIC_ASSERT((boost::is_same<R,type>::value));
 }

--- a/ref_test.cpp
+++ b/ref_test.cpp
@ -1,3 +1,7 @@
+// Copyright David Abrahams and Aleksey Gurtovoy
+// 2002-2004. 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)

 // run-time test for "boost/ref.hpp" header content
 // see 'ref_ct_test.cpp' for compile-time part
@ -56,11 +60,11 @@ struct ref_wrapper

    static void test(T x)
    {
-        BOOST_TEST(passthru(ref(x)) == &x);
-        BOOST_TEST(&ref(x).get() == &x);
+        BOOST_CHECK(passthru(ref(x)) == &x);
+        BOOST_CHECK(&ref(x).get() == &x);

-        BOOST_TEST(cref_passthru(cref(x)) == &x);
-        BOOST_TEST(&cref(x).get() == &x);
+        BOOST_CHECK(cref_passthru(cref(x)) == &x);
+        BOOST_CHECK(&cref(x).get() == &x);
    }
 };

--- a/reverse_iterator_example.cpp
+++ b/reverse_iterator_example.cpp
@ -1,47 +0,0 @@
-// (C) Copyright Jeremy Siek 2000. 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.
-
-#include <boost/config.hpp>
-#include <iostream>
-#include <algorithm>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/detail/iterator.hpp>
-
-//boost::detail::iterator_traits
-int main(int, char*[])
-{
-  char letters_[] = "hello world!";
-  const int N = sizeof(letters_)/sizeof(char) - 1;
-  typedef char* base_iterator;
-  base_iterator letters(letters_);
-  
-  std::cout << "original sequence of letters:\t"
-            << letters_ << std::endl;
-
-  std::sort(letters, letters + N);
-
-  // Use reverse_iterator_generator to print a sequence
-  // of letters in reverse order.
-  
-  boost::reverse_iterator<base_iterator>
-    reverse_letters_first(letters + N),
-    reverse_letters_last(letters);
-
-  std::cout << "letters in descending order:\t";
-  std::copy(reverse_letters_first, reverse_letters_last,
-            std::ostream_iterator<char>(std::cout));
-  std::cout << std::endl;
-
-  // Use make_reverse_iterator() to print the sequence
-  // of letters in reverse-reverse order.
-
-  std::cout << "letters in ascending order:\t";
-  std::copy(boost::make_reverse_iterator(reverse_letters_last),
-            boost::make_reverse_iterator(reverse_letters_first),
-            std::ostream_iterator<char>(std::cout));
-  std::cout << std::endl;
-
-  return 0;
-}
--- a/shared_container_iterator.html
+++ b/shared_container_iterator.html
@ -9,7 +9,7 @@

 <body bgcolor="#FFFFFF" text="#000000">

-<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
+<img src="../../boost.png" alt="boost.png (6897 bytes)"
 align="center" width="277" height="86">

 <h1>Shared Container Iterator</h1>
@ -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/1
+++ b/1
@ -0,0 +1 @@
+The existance of this file tells the regression reporting programs that the directory contains sub-directories which are libraries.
--- 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/
-
-
-# Testing Jamfile autogenerated from XML source
-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 ;
-
-test-suite utility
-    : 
-        [ run ../iterator_traits_test.cpp ]
-        [ run ../iterators_test.cpp $(test_monitor) ]
-        [ compile-fail ../noncopyable_test.cpp ]
-        [ run ../numeric_traits_test.cpp ]
-        [ run ../operators_test.cpp $(test_monitor) ]
-        [ run ../binary_search_test.cpp $(test_monitor) ]
-        [ run ../call_traits_test.cpp : -u ]
-        [ compile-fail ../checked_delete_test.cpp ]
-        [ run ../compressed_pair_test.cpp $(test_monitor) : -u ]
-        [ run ../addressof_test.cpp $(test_monitor) ]
-        [ run ../ref_test.cpp $(test_monitor) ]
-        [ run ../enable_if_constructors.cpp $(test_monitor) ]
-        [ run ../enable_if_dummy_arg_disambiguation.cpp $(test_monitor) ]
-        [ run ../enable_if_lazy.cpp $(test_monitor) ]
-        [ run ../enable_if_lazy_test.cpp $(test_monitor) ]
-        [ run ../enable_if_member_templates.cpp $(test_monitor) ]
-        [ run ../enable_if_namespace_disambiguation.cpp $(test_monitor) ]
-        [ run ../enable_if_no_disambiguation.cpp $(test_monitor) ]
-        [ run ../enable_if_partial_specializations.cpp $(test_monitor) ]
-        [ run next_prior_test.cpp $(test_monitor) ]          
-    ;
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -1,33 +1,37 @@
-# 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/

 # bring in rules for testing
 import testing ;

+# Please keep the tests ordered by filename
 test-suite utility
-    : 
-        [ run ../iterator_traits_test.cpp ]
-        [ run ../iterators_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ compile-fail ../noncopyable_test.cpp ]
-        [ run ../numeric_traits_test.cpp ]
-        [ run ../operators_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../binary_search_test.cpp ../../test/build//boost_test_exec_monitor ]
+    :
+        [ 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/build//boost_test_exec_monitor : -u ]
-        [ run ../addressof_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../ref_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_constructors.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_dummy_arg_disambiguation.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_lazy.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_lazy_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_member_templates.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_namespace_disambiguation.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_no_disambiguation.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_partial_specializations.cpp ../../test/build//boost_test_exec_monitor ]
+        [ 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/<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/<link>static ]
+        [ compile ../ref_ct_test.cpp  ]
+        [ 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 ]
+        [ compile-fail ../value_init_test_fail1.cpp ]
+        [ compile-fail ../value_init_test_fail2.cpp ]
+        [ compile-fail ../value_init_test_fail3.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
@ -0,0 +1,194 @@
+// Boost result_of library
+
+//  Copyright Douglas Gregor 2003-2004. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org/libs/utility
+#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;
+  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_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;
+};
+
+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;
+};
+
+struct X {};
+
+int main()
+{
+  using namespace boost;
+
+  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<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));
+
+  // Prior to decltype, result_of could not deduce the return type
+  // nullary function objects unless they exposed a result_type.
+#if defined(BOOST_HAS_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_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
+
+  // 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_HAS_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<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));
+
+#if defined(BOOST_HAS_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));
+#endif
+
+  return 0;
+}
--- a/throw_exception.html
+++ b/throw_exception.html
@ -7,10 +7,9 @@
 	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
 		<table border="0" width="100%">
 			<tr>
-				<td width="277">
-					<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
+				<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="middle">
+				<td align="center">
 					<h1>throw_exception.hpp</h1>
 				</td>
 			</tr>
@ -52,9 +51,8 @@ template&lt;class E&gt; void throw_exception(E const &amp; e)
 }
 </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>
+			<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/transform_iterator_example.cpp
+++ b/transform_iterator_example.cpp
@ -1,76 +0,0 @@
-// (C) Copyright Jeremy Siek 2000. 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.
-
-
-#include <functional>
-#include <algorithm>
-#include <iostream>
-#include <boost/iterator/transform_iterator.hpp>
-
-// What a bummer. We can't use std::binder1st with transform iterator
-// because it does not have a default constructor. Here's a version
-// that does.
-
-namespace boost {
-
-  template <class Operation> 
-  class binder1st
-    : public std::unary_function<typename Operation::second_argument_type,
-                                 typename Operation::result_type> {
-  protected:
-    Operation op;
-    typename Operation::first_argument_type value;
-  public:
-    binder1st() { } // this had to be added!
-    binder1st(const Operation& x,
-              const typename Operation::first_argument_type& y)
-        : op(x), value(y) {}
-    typename Operation::result_type
-    operator()(const typename Operation::second_argument_type& x) const {
-      return op(value, x); 
-    }
-  };
-
-  template <class Operation, class T>
-  inline binder1st<Operation> bind1st(const Operation& op, const T& x) {
-    typedef typename Operation::first_argument_type arg1_type;
-    return binder1st<Operation>(op, arg1_type(x));
-  }
-
-} // namespace boost
-
-int
-main(int, char*[])
-{
-  // This is a simple example of using the transform_iterators class to
-  // generate iterators that multiply the value returned by dereferencing
-  // the iterator. In this case we are multiplying by 2.
-  // Would be cooler to use lambda library in this example.
-
-  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
-  const int N = sizeof(x)/sizeof(int);
-
-  typedef boost::binder1st< std::multiplies<int> > Function;
-  typedef boost::transform_iterator<Function, int*> doubling_iterator;
-
-  doubling_iterator i(x, boost::bind1st(std::multiplies<int>(), 2)),
-    i_end(x + N, boost::bind1st(std::multiplies<int>(), 2));
-
-  std::cout << "multiplying the array by 2:" << std::endl;
-  while (i != i_end)
-    std::cout << *i++ << " ";
-  std::cout << std::endl;
-
-  std::cout << "adding 4 to each element in the array:" << std::endl;
-
-  std::copy(boost::make_transform_iterator(x, boost::bind1st(std::plus<int>(), 4)),
-            boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
-            std::ostream_iterator<int>(std::cout, " "));
-  std::cout << std::endl;
-  
-  return 0;
-}
-
-
--- a/utility.htm
+++ b/utility.htm
@ -4,7 +4,7 @@
 		<title>Header boost/utility.hpp Documentation</title>
 	</head>
 	<body bgcolor="#FFFFFF" text="#000000">
-		<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" WIDTH="277" HEIGHT="86">Header
+		<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="center" WIDTH="277" HEIGHT="86">Header
 			<a href="../../boost/utility.hpp">boost/utility.hpp</a></h1>
 		<p>The entire contents of the header <code><a href="../../boost/utility.hpp">&lt;boost/utility.hpp&gt;</a></code>
 			are in <code>namespace boost</code>.</p>
@ -22,6 +22,8 @@
 				Class <a href="#Class_noncopyable">noncopyable</a></li>
 			<li>
 				Function template <a href="#addressof">addressof()</a></li>
+                        <li>Class template <a href="#result_of">result_of</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 
@ -66,7 +68,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 
@ -87,7 +89,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 ...
@ -136,16 +138,59 @@ void f() {
  // nonaddressable* xpe = &amp;x; /* error */
 }</pre>
 		</blockquote>
+                <h2><a name="result_of">Class template
+                result_of</a></h2> <p>The class template
+                <code>result_of</code> helps determine the type of a
+                call expression. Given an lvalue <code>f</code> of
+                type <code>F</code> and lvalues <code>t1</code>,
+                <code>t2</code>, ..., <code>t<em>N</em></code> of
+                types <code>T1</code>, <code>T2</code>, ...,
+                <code>T<em>N</em></code>, respectively, the type
+                <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
+                the type <code>F</code> to be a function pointer,
+                function reference, member function pointer, or class
+                type.</p> <p>If your compiler does not support
+                <code>decltype</code>, then 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>. 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
+                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>
+
+                <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>
+
+                <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>
+
 		<h2>Class templates for the Base-from-Member Idiom</h2>
 		<p>See <a href="base_from_member.html">separate documentation</a>.</p>
 		<hr>
 		<p>Revised&nbsp; <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan
-->23 December, 2003<!--webbot bot="Timestamp" endspan i-checksum="38582"
+-->07 November, 2007<!--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>
+</html>
--- a/value_init.htm
+++ b/value_init.htm
@ -8,29 +8,32 @@
 </head>
  <body vlink="#800080" link="#0000ff" text="#000000" bgcolor="#ffffff">
                   
-<h2><img src="../../c++boost.gif" width="276" height="86">
+<h2><img src="../../boost.png" width="276" height="86">
         Header &lt;<a href="../../boost/utility/value_init.hpp">boost/utility/value_init.hpp</a>&gt;
     </h2>
                   
 <h2>Contents</h2>
                   
 <dl>
-  <dt><a href="#intro">Rationale</a></dt>
-  <dt><a href="#rationale">Introduction</a></dt>
+  <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_value"><code>initialized_value</code></a></li>
                   
 </ul>
              <a href="#acknowledgements">Acknowledgements</a><br>
@ -44,24 +47,104 @@
 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="into"></a>Introduction</h2>
+<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 <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 +170,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 +182,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 +204,56 @@ 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.
+Compilers usually support value-initialization for built-in types properly.
+But objects of user-defined types that involve <em>aggregates</em> may <em>in some cases</em>
+be partially, or even entirely left uninitialized, when they should be value-initialized.
+</p>
+<p>
+We have encountered issues regarding value-initialization on compilers by
+Microsoft, Sun, Borland, and GNU. Here is a list of bug reports on those issues:
+<table summary="Compiler bug reports regarding value-initialization" border="0" cellpadding="7" cellspacing="1" >
+<tr><td>
+<a href="https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100744">
+Microsoft Feedback ID 100744 - Value-initialization in new-expression</a>
+<br>Reported by Pavel Kuznetsov (MetaCommunications Engineering), 2005-07-28
+<br>
+<a href="http://gcc.gnu.org/bugzilla/show_bug.cgi?id=30111">
+GCC Bug 30111 - Value-initialization of POD base class doesn't initialize members</a>
+<br>Reported by Jonathan Wakely, 2006-12-07 
+<br>
+<a href="http://gcc.gnu.org/bugzilla/show_bug.cgi?id=33916">
+GCC Bug 33916 - Default constructor fails to initialize array members</a>
+<br>Reported by Michael Elizabeth Chastain, 2007-10-26
+<br>
+<a href="http://qc.codegear.com/wc/qcmain.aspx?d=51854">
+Borland Report 51854 - Value-initialization: POD struct should be zero-initialized</a>
+<br>Reported by Niels Dekker (LKEB, Leiden University Medical Center), 2007-09-11
+<br>
+</td></tr></table>
+</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> will now clear
+its internal data, prior to constructing the object that it contains.
+</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>impll-defined</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&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>
                    
 <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>) 
@ -189,31 +311,83 @@ wrapped object from within a constant wrapper 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_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>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 23 May 2008</p>
+                   
+<p>&copy; Copyright Fernando Cacciola, 2002, 2008.</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>
    
 </body>
-</html>
+</html>
--- a/value_init_test.cpp
+++ b/value_init_test.cpp
@ -1,29 +1,27 @@
-// (C) 2002, Fernando Luis Cacciola Carballal.
+// Copyright 2002-2008, Fernando Luis Cacciola Carballal.
 //
-// This material is provided "as is", with absolutely no warranty expressed
-// or implied. Any use is at your own risk.
-//
-// Permission to use or copy this software for any purpose is hereby granted
-// without fee, provided the above notices are retained on all copies.
-// Permission to modify the code and to distribute modified code is granted,
-// provided the above notices are retained, and a notice that the code was
-// modified is included with the above copyright notice.
+// 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/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

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

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

 #ifdef __BORLANDC__
 #pragma hdrstop
 #endif

-#define BOOST_INCLUDE_MAIN
-#include "boost/test/test_tools.hpp"
+#include "boost/test/minimal.hpp"

 //
 // Sample POD type
@ -55,7 +53,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 << ')' ; }
@ -66,46 +64,264 @@ 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 ;
+  }
+};
+
+
+template<class T>
+void check_initialized_value ( T const& y )
+{
+  T initializedValue = boost::initialized_value ;
+  BOOST_CHECK ( 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 boost::unit_test::counter_t counter_before_test = boost::minimal_test::errors_counter();
+
+  check_initialized_value(y);
+
  boost::value_initialized<T> x ;
-  BOOST_TEST ( y == x ) ;
-  BOOST_TEST ( y == get(x) ) ;
+  BOOST_CHECK ( y == x ) ;
+  BOOST_CHECK ( y == boost::get(x) ) ;
+
  static_cast<T&>(x) = z ;
-  get(x) = z ;
-  BOOST_TEST ( x == z ) ;
+  boost::get(x) = z ;
+  BOOST_CHECK ( x == z ) ;

  boost::value_initialized<T> const x_c ;
-  BOOST_TEST ( y == x_c ) ;
-  BOOST_TEST ( y == get(x_c) ) ;
-  static_cast<T&>(x_c) = z ;
-  BOOST_TEST ( x_c == z ) ;
-  #ifdef PRODUCE_ERROR_1
-  get(x_c) = z ; // this should produce an ERROR
-  #endif
+  BOOST_CHECK ( y == x_c ) ;
+  BOOST_CHECK ( y == boost::get(x_c) ) ;
+  T& x_c_ref = x_c ;
+  x_c_ref = z ;
+  BOOST_CHECK ( x_c == z ) ;

+  boost::value_initialized<T> const copy1 = x;
+  BOOST_CHECK ( boost::get(copy1) == boost::get(x) ) ;
+
+  boost::value_initialized<T> copy2;
+  copy2 = x;
+  BOOST_CHECK ( boost::get(copy2) == boost::get(x) ) ;
+  
+  boost::shared_ptr<boost::value_initialized<T> > ptr( new boost::value_initialized<T> );
+  BOOST_CHECK ( y == *ptr ) ;
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
  boost::value_initialized<T const> cx ;
-  BOOST_TEST ( y == cx ) ;
-  BOOST_TEST ( y == get(cx) ) ;
-  #ifdef PRODUCE_ERROR_2
-  get(cx) = z ; // this should produce an ERROR
-  #endif
+  BOOST_CHECK ( y == cx ) ;
+  BOOST_CHECK ( y == boost::get(cx) ) ;

  boost::value_initialized<T const> const cx_c ;
-  BOOST_TEST ( y == cx_c ) ;
-  BOOST_TEST ( y == get(cx_c) ) ;
-  #ifdef PRODUCE_ERROR_3
-  get(cx_c) = z ; // this should produce an ERROR
-  #endif
+  BOOST_CHECK ( y == cx_c ) ;
+  BOOST_CHECK ( y == boost::get(cx_c) ) ;
+#endif
+
+  return boost::minimal_test::errors_counter() == counter_before_test ;
 }

 int test_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_CHECK ( test( 0,1234 ) ) ;
+  BOOST_CHECK ( test( 0.0,12.34 ) ) ;
+  BOOST_CHECK ( test( POD(0,0,0.0), POD('a',1234,56.78) ) ) ;
+  BOOST_CHECK ( test( NonPOD( std::string() ), NonPOD( std::string("something") ) ) ) ;
+
+  NonPOD NonPOD_object( std::string("NonPOD_object") );
+  BOOST_CHECK ( test<NonPOD *>( 0, &NonPOD_object ) ) ;
+
+  AggregatePODStruct zeroInitializedAggregatePODStruct = { 0.0f, '\0', 0 };
+  AggregatePODStruct nonZeroInitializedAggregatePODStruct = { 1.25f, 'a', -1 };
+  BOOST_CHECK ( test(zeroInitializedAggregatePODStruct, nonZeroInitializedAggregatePODStruct) );
+
+  StringAndInt stringAndInt0;
+  StringAndInt stringAndInt1;
+  stringAndInt0.i = 0;
+  stringAndInt1.i = 1;
+  stringAndInt1.s = std::string("1");
+  BOOST_CHECK ( test(stringAndInt0, stringAndInt1) );
+
+  StructWithDestructor structWithDestructor0;
+  StructWithDestructor structWithDestructor1;
+  structWithDestructor0.i = 0;
+  structWithDestructor1.i = 1;
+  BOOST_CHECK ( test(structWithDestructor0, structWithDestructor1) );
+
+  StructWithVirtualFunction structWithVirtualFunction0;
+  StructWithVirtualFunction structWithVirtualFunction1;
+  structWithVirtualFunction0.i = 0;
+  structWithVirtualFunction1.i = 1;
+  BOOST_CHECK ( test(structWithVirtualFunction0, structWithVirtualFunction1) );
+
+  DerivedFromAggregatePODStruct derivedFromAggregatePODStruct0;
+  DerivedFromAggregatePODStruct derivedFromAggregatePODStruct1;
+  static_cast<AggregatePODStruct &>(derivedFromAggregatePODStruct0) = zeroInitializedAggregatePODStruct;
+  static_cast<AggregatePODStruct &>(derivedFromAggregatePODStruct1) = nonZeroInitializedAggregatePODStruct;
+  BOOST_CHECK ( test(derivedFromAggregatePODStruct0, derivedFromAggregatePODStruct1) );
+
+  AggregatePODStructWrapper aggregatePODStructWrapper0;
+  AggregatePODStructWrapper aggregatePODStructWrapper1;
+  aggregatePODStructWrapper0.dataMember = zeroInitializedAggregatePODStruct;
+  aggregatePODStructWrapper1.dataMember = nonZeroInitializedAggregatePODStruct;
+  BOOST_CHECK ( test(aggregatePODStructWrapper0, aggregatePODStructWrapper1) );
+
+  ArrayOfBytes zeroInitializedArrayOfBytes = { 0 };
+  boost::value_initialized<ArrayOfBytes> valueInitializedArrayOfBytes;
+  BOOST_CHECK (std::memcmp(get(valueInitializedArrayOfBytes), zeroInitializedArrayOfBytes, sizeof(ArrayOfBytes)) == 0);
+
+  boost::value_initialized<ArrayOfBytes> valueInitializedArrayOfBytes2;
+  valueInitializedArrayOfBytes2 = valueInitializedArrayOfBytes;
+  BOOST_CHECK (std::memcmp(get(valueInitializedArrayOfBytes), get(valueInitializedArrayOfBytes2), sizeof(ArrayOfBytes)) == 0);
+
+  boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester1;
+  BOOST_CHECK ( ! get(copyFunctionCallTester1).is_copy_constructed);
+  BOOST_CHECK ( ! get(copyFunctionCallTester1).is_assignment_called);
+
+  boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester2 = boost::value_initialized<CopyFunctionCallTester>(copyFunctionCallTester1);
+  BOOST_CHECK ( get(copyFunctionCallTester2).is_copy_constructed);
+  BOOST_CHECK ( ! get(copyFunctionCallTester2).is_assignment_called);
+
+  boost::value_initialized<CopyFunctionCallTester> copyFunctionCallTester3;
+  copyFunctionCallTester3 = boost::value_initialized<CopyFunctionCallTester>(copyFunctionCallTester1);
+  BOOST_CHECK ( ! get(copyFunctionCallTester3).is_copy_constructed);
+  BOOST_CHECK ( get(copyFunctionCallTester3).is_assignment_called);

  return 0;
 }
@ -113,7 +329,3 @@ int test_main(int, char **)

 unsigned int expected_failures = 0;

-
-
-
-
--- a/value_init_test_fail1.cpp
+++ b/value_init_test_fail1.cpp
@ -0,0 +1,37 @@
+// 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
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Test program for "boost/utility/value_init.hpp"
+//
+// Initial: 21 Agu 2002
+
+#include <iostream>
+#include <string>
+
+#include "boost/utility/value_init.hpp"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/test/minimal.hpp"
+
+int test_main(int, char **)
+{
+  boost::value_initialized<int> const x_c ;
+
+  get(x_c) = 1234 ; // this should produce an ERROR
+
+  return 0;
+}
+
+
+unsigned int expected_failures = 0;
+
+
+
+
+
--- a/value_init_test_fail2.cpp
+++ b/value_init_test_fail2.cpp
@ -0,0 +1,36 @@
+// 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
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Test program for "boost/utility/value_init.hpp"
+//
+// Initial: 21 Agu 2002
+
+#include <iostream>
+#include <string>
+
+#include "boost/utility/value_init.hpp"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/test/minimal.hpp"
+
+int test_main(int, char **)
+{
+  boost::value_initialized<int const> cx ;
+
+  get(cx) = 1234 ; // this should produce an ERROR
+
+  return 0;
+}
+
+unsigned int expected_failures = 0;
+
+
+
+
+
--- a/value_init_test_fail3.cpp
+++ b/value_init_test_fail3.cpp
@ -0,0 +1,37 @@
+// 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
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Test program for "boost/utility/value_init.hpp"
+//
+// Initial: 21 Agu 2002
+
+#include <iostream>
+#include <string>
+
+#include "boost/utility/value_init.hpp"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "boost/test/minimal.hpp"
+
+int test_main(int, char **)
+{
+  boost::value_initialized<int const> const cx_c ;
+
+  get(cx_c) = 1234 ; // this should produce an ERROR
+
+  return 0;
+}
+
+
+unsigned int expected_failures = 0;
+
+
+
+
+
--- a/verify_test.cpp
+++ b/verify_test.cpp
@ -0,0 +1,126 @@
+//
+//  verify_test.cpp - a test for BOOST_VERIFY
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2007 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/detail/lightweight_test.hpp>
+
+#include <boost/assert.hpp>
+
+int f( int & x )
+{
+    return ++x;
+}
+
+void test_default()
+{
+    int x = 1;
+
+    BOOST_VERIFY( 1 );
+    BOOST_VERIFY( x == 1 );
+    BOOST_VERIFY( ++x );
+    BOOST_VERIFY( f(x) );
+    BOOST_VERIFY( &x );
+
+    BOOST_TEST( x == 3 );
+}
+
+#define BOOST_DISABLE_ASSERTS
+#include <boost/assert.hpp>
+
+void test_disabled()
+{
+    int x = 1;
+
+    BOOST_VERIFY( 1 );
+    BOOST_VERIFY( x == 1 );
+    BOOST_VERIFY( ++x );
+    BOOST_VERIFY( f(x) );
+    BOOST_VERIFY( &x );
+
+    BOOST_TEST( x == 3 );
+
+    BOOST_VERIFY( 0 );
+    BOOST_VERIFY( !x );
+    BOOST_VERIFY( x == 0 );
+    BOOST_VERIFY( !++x );
+    BOOST_VERIFY( !f(x) );
+
+    BOOST_TEST( x == 5 );
+
+    void * p = 0;
+    BOOST_VERIFY( p );
+}
+
+#undef BOOST_DISABLE_ASSERTS
+
+#define BOOST_ENABLE_ASSERT_HANDLER
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <cstdio>
+
+int handler_invoked = 0;
+
+void boost::assertion_failed(char const * expr, char const * function, char const * file, long line)
+{
+#if !defined(BOOST_NO_STDC_NAMESPACE)
+    using std::printf;
+#endif
+
+    printf("Expression: %s\nFunction: %s\nFile: %s\nLine: %ld\n\n", expr, function, file, line);
+    ++handler_invoked;
+}
+
+struct X
+{
+    static bool f()
+    {
+        BOOST_VERIFY( 0 );
+        return false;
+    }
+};
+
+void test_handler()
+{
+    int x = 1;
+
+    BOOST_VERIFY( 1 );
+    BOOST_VERIFY( x == 1 );
+    BOOST_VERIFY( ++x );
+    BOOST_VERIFY( f(x) );
+    BOOST_VERIFY( &x );
+
+    BOOST_TEST( x == 3 );
+
+    BOOST_VERIFY( 0 );
+    BOOST_VERIFY( !x );
+    BOOST_VERIFY( x == 0 );
+    BOOST_VERIFY( !++x );
+    BOOST_VERIFY( !f(x) );
+
+    BOOST_TEST( x == 5 );
+
+    void * p = 0;
+    BOOST_VERIFY( p );
+
+    BOOST_VERIFY( X::f() );
+
+    BOOST_TEST( handler_invoked == 8 );
+}
+
+#undef BOOST_ENABLE_ASSERT_HANDLER
+
+int main()
+{
+    test_default();
+    test_disabled();
+    test_handler();
+
+    return boost::report_errors();
+}
				`@ -0,0 +1 @@`
				`The existance of this file tells the regression reporting programs that the directory contains sub-directories which are libraries.`